From 34f0461a68b3a55399b69f7f7392c64a3ff3735a Mon Sep 17 00:00:00 2001
From: tqcq <99722391+tqcq@users.noreply.github.com>
Date: Wed, 14 Aug 2024 21:40:13 +0800
Subject: [PATCH 01/25] feat udpate config to configuration

---
 CMakeLists.txt                                |   6 +-
 .../config/{config.cc => configuration.cc}    |  33 ++---
 .../base/config/{config.h => configuration.h} |  20 +--
 ...le_config.cc => ini_file_configuration.cc} |  28 ++--
 ...file_config.h => ini_file_configuration.h} |  10 +-
 ...test.cc => ini_file_configuration_test.cc} |  11 +-
 tile/base/config/layered_config.cc            | 129 -----------------
 tile/base/config/layered_config.h             |  57 --------
 tile/base/config/layered_configuration.cc     | 133 ++++++++++++++++++
 tile/base/config/layered_configuration.h      |  57 ++++++++
 tile/base/configuration.h                     |  11 ++
 tile/tile.h                                   |   6 +-
 12 files changed, 258 insertions(+), 243 deletions(-)
 rename tile/base/config/{config.cc => configuration.cc} (75%)
 rename tile/base/config/{config.h => configuration.h} (89%)
 rename tile/base/config/{ini_file_config.cc => ini_file_configuration.cc} (77%)
 rename tile/base/config/{ini_file_config.h => ini_file_configuration.h} (81%)
 rename tile/base/config/{ini_file_config_test.cc => ini_file_configuration_test.cc} (72%)
 delete mode 100644 tile/base/config/layered_config.cc
 delete mode 100644 tile/base/config/layered_config.h
 create mode 100644 tile/base/config/layered_configuration.cc
 create mode 100644 tile/base/config/layered_configuration.h
 create mode 100644 tile/base/configuration.h

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 7631cc6..bbf65c9 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -207,9 +207,9 @@ set(TILE_SRCS
     "tile/rpc/protocol/http/buffer_io.cc"
     "tile/rpc/protocol/message.cc"
     # "tile/rpc/server.cc"
-    "tile/base/config/config.cc"
-    "tile/base/config/ini_file_config.cc"
-    "tile/base/config/layered_config.cc"
+    "tile/base/config/configuration.cc"
+    "tile/base/config/ini_file_configuration.cc"
+    "tile/base/config/layered_configuration.cc"
 )
 
 if((NOT TILE_HAVE_GETIFADDRS) OR (NOT TILE_HAVE_FREEIFADDRS))
diff --git a/tile/base/config/config.cc b/tile/base/config/configuration.cc
similarity index 75%
rename from tile/base/config/config.cc
rename to tile/base/config/configuration.cc
index e56cf21..482a93b 100644
--- a/tile/base/config/config.cc
+++ b/tile/base/config/configuration.cc
@@ -1,26 +1,26 @@
-#include "tile/base/config/config.h"
+#include "tile/base/config/configuration.h"
 #include "tile/base/thread/unique_lock.h"
 
 namespace tile {
 namespace util {
-bool Config::Has(const Slice &key) const {
+bool Configuration::Has(const Slice &key) const {
   UniqueLock<tile::Mutex> lock(mutex_);
   std::string value;
   return GetRaw(key, &value);
 }
 
-void Config::Remove(const Slice &key) {}
+void Configuration::Remove(const Slice &key) {}
 
-void Config::EnableEvents(bool enable) { events_enabled_ = enable; }
-bool Config::EventsEnabled() const { return events_enabled_; }
+void Configuration::EnableEvents(bool enable) { events_enabled_ = enable; }
+bool Configuration::EventsEnabled() const { return events_enabled_; }
 
-Config::Keys Config::keys(const Slice &root) const {
+Configuration::Keys Configuration::keys(const Slice &root) const {
   UniqueLock<tile::Mutex> lock(mutex_);
   return Enumerate(root);
 }
 
 #define TILE_DEFINE_CONFIG_GETTER(type, name)                                  \
-  std::optional<type> Config::Get##name(const Slice &key) const {              \
+  std::optional<type> Configuration::Get##name(const Slice &key) const {       \
     std::string value;                                                         \
     if (GetRaw(key, &value)) {                                                 \
       auto opt = TryParseTraits<type>::TryParse(value);                        \
@@ -33,7 +33,7 @@ Config::Keys Config::keys(const Slice &root) const {
       return std::nullopt;                                                     \
     }                                                                          \
   }                                                                            \
-  type Config::Get##name(const Slice &key, type default_value) const {         \
+  type Configuration::Get##name(const Slice &key, type default_value) const {  \
     auto opt = Get##name(key);                                                 \
     if (opt.has_value()) {                                                     \
       return *opt;                                                             \
@@ -43,11 +43,11 @@ Config::Keys Config::keys(const Slice &root) const {
   }
 
 #define TILE_DEFINE_CONFIG_SETTER(type, name)                                  \
-  void Config::Set##name(const Slice &key, type value) {                       \
+  void Configuration::Set##name(const Slice &key, type value) {                \
     SetRawWithEvent(key, Format("{}", value));                                 \
   }
 
-std::optional<std::string> Config::GetString(const Slice &key) const {
+std::optional<std::string> Configuration::GetString(const Slice &key) const {
   std::string value;
   UniqueLock<tile::Mutex> lock(mutex_);
   if (GetRaw(key, &value)) {
@@ -57,16 +57,16 @@ std::optional<std::string> Config::GetString(const Slice &key) const {
   }
 }
 
-std::string Config::GetString(const Slice &key,
-                              std::string default_value) const {
+std::string Configuration::GetString(const Slice &key,
+                                     std::string default_value) const {
   auto opt = GetString(key);
   return opt.has_value() ? *opt : default_value;
 }
 
-void Config::SetString(const Slice &key, const std::string &value) {
+void Configuration::SetString(const Slice &key, const std::string &value) {
   SetRawWithEvent(key, value);
 }
-void Config::SetBool(const Slice &key, bool value) {
+void Configuration::SetBool(const Slice &key, bool value) {
   SetRawWithEvent(key, value ? "true" : "false");
 }
 
@@ -91,7 +91,8 @@ TILE_DEFINE_CONFIG_SETTER(uint32_t, UInt32)
 TILE_DEFINE_CONFIG_SETTER(uint64_t, UInt64)
 TILE_DEFINE_CONFIG_SETTER(double, Double)
 
-void Config::SetRawWithEvent(const Slice &key, const std::string &value) {
+void Configuration::SetRawWithEvent(const Slice &key,
+                                    const std::string &value) {
   if (events_enabled_) {
     OnChanging(key, value);
   }
@@ -106,7 +107,7 @@ void Config::SetRawWithEvent(const Slice &key, const std::string &value) {
   }
 }
 
-Config::~Config() {}
+Configuration::~Configuration() {}
 
 } // namespace util
 
diff --git a/tile/base/config/config.h b/tile/base/config/configuration.h
similarity index 89%
rename from tile/base/config/config.h
rename to tile/base/config/configuration.h
index 32e3204..2365340 100644
--- a/tile/base/config/config.h
+++ b/tile/base/config/configuration.h
@@ -1,5 +1,5 @@
-#ifndef TILE_BASE_CONFIG_CONFIG_H
-#define TILE_BASE_CONFIG_CONFIG_H
+#ifndef TILE_BASE_CONFIG_CONFIGURATION_H
+#define TILE_BASE_CONFIG_CONFIGURATION_H
 
 #pragma once
 #include "tile/base/optional.h"
@@ -12,10 +12,10 @@
 
 namespace tile {
 namespace util {
-class Config : public RefCounted<Config> {
+class Configuration : public RefCounted<Configuration> {
 public:
   using Keys = std::vector<std::string>;
-  using Ptr = RefPtr<Config>;
+  using Ptr = RefPtr<Configuration>;
 
   // events
   // Key, Value
@@ -98,13 +98,13 @@ protected:
 protected:
   class ScopedLock {
   public:
-    explicit ScopedLock(const Config &config) : config_(config) {
+    explicit ScopedLock(const Configuration &config) : config_(config) {
       config_.mutex_.Lock();
     }
     ~ScopedLock() { config_.mutex_.Unlock(); }
 
   private:
-    const Config &config_;
+    const Configuration &config_;
   };
 
   virtual bool GetRaw(const Slice &key, std::string *value) const = 0;
@@ -112,10 +112,10 @@ protected:
   virtual void RemoveRaw(const Slice &key) = 0;
   virtual Keys Enumerate(const Slice &range) const = 0;
   void SetRawWithEvent(const Slice &key, const std::string &value);
-  virtual ~Config();
+  virtual ~Configuration();
 
-  friend class std::default_delete<Config>;
-  friend class LayeredConfig;
+  friend class std::default_delete<Configuration>;
+  friend class LayeredConfiguration;
 
 private:
   mutable Mutex mutex_;
@@ -124,4 +124,4 @@ private:
 } // namespace util
 } // namespace tile
 
-#endif // TILE_BASE_CONFIG_CONFIG_H
+#endif // TILE_BASE_CONFIG_CONFIGURATION_H
diff --git a/tile/base/config/ini_file_config.cc b/tile/base/config/ini_file_configuration.cc
similarity index 77%
rename from tile/base/config/ini_file_config.cc
rename to tile/base/config/ini_file_configuration.cc
index c3838c5..cb2c9bc 100644
--- a/tile/base/config/ini_file_config.cc
+++ b/tile/base/config/ini_file_configuration.cc
@@ -1,16 +1,16 @@
-#include "tile/base/config/ini_file_config.h"
+#include "tile/base/config/ini_file_configuration.h"
 #include "tile/base/thread/scoped_lock.h"
 
 namespace tile {
 namespace util {
 
-IniFileConfig::IniFileConfig() {}
+IniFileConfiguration::IniFileConfiguration() {}
 // IniFileConfig::IniFileConfig(std::istream &istr) { load(istr); }
 // IniFileConfig::IniFileConfig(const std::string &path) { load(path); }
-IniFileConfig::~IniFileConfig() {}
+IniFileConfiguration::~IniFileConfiguration() {}
 
-bool IniFileConfig::load(std::istream &istr) {
-  Config::ScopedLock lock(*this);
+bool IniFileConfiguration::load(std::istream &istr) {
+  Configuration::ScopedLock lock(*this);
   map_.clear();
   section_key_.clear();
   while (!istr.eof()) {
@@ -18,7 +18,7 @@ bool IniFileConfig::load(std::istream &istr) {
   }
   return true;
 }
-bool IniFileConfig::load(const std::string &path) {
+bool IniFileConfiguration::load(const std::string &path) {
   std::ifstream istr(path);
   if (istr.good()) {
     return load(istr);
@@ -26,7 +26,7 @@ bool IniFileConfig::load(const std::string &path) {
     return false;
   }
 }
-bool IniFileConfig::GetRaw(const Slice &key, std::string *value) const {
+bool IniFileConfiguration::GetRaw(const Slice &key, std::string *value) const {
   auto iter = map_.find(key.ToString());
   if (iter != map_.end()) {
     *value = iter->second;
@@ -35,12 +35,12 @@ bool IniFileConfig::GetRaw(const Slice &key, std::string *value) const {
     return false;
   }
 }
-bool IniFileConfig::SetRaw(const Slice &key, const Slice &value) {
+bool IniFileConfiguration::SetRaw(const Slice &key, const Slice &value) {
   map_[key] = value;
   return true;
 }
 
-void IniFileConfig::RemoveRaw(const Slice &key) {
+void IniFileConfiguration::RemoveRaw(const Slice &key) {
   std::string prefix = key;
   if (!prefix.empty()) {
     prefix.push_back('.');
@@ -57,8 +57,8 @@ void IniFileConfig::RemoveRaw(const Slice &key) {
   }
 }
 
-Config::Keys IniFileConfig::Enumerate(const Slice &key) const {
-  Config::Keys range;
+Configuration::Keys IniFileConfiguration::Enumerate(const Slice &key) const {
+  Configuration::Keys range;
   std::set<Slice> keys;
   std::string prefix = key.ToString();
   if (prefix.empty()) {
@@ -86,7 +86,7 @@ Config::Keys IniFileConfig::Enumerate(const Slice &key) const {
   return range;
 }
 
-void IniFileConfig::ParseLine(std::istream &istr) {
+void IniFileConfiguration::ParseLine(std::istream &istr) {
   static const int eof = std::char_traits<char>::eof();
   auto ReadLine = [&](std::string *line) {
     line->clear();
@@ -135,8 +135,8 @@ void IniFileConfig::ParseLine(std::istream &istr) {
     }
   }
 }
-bool IniFileConfig::ICompare::operator()(const std::string &s1,
-                                         const std::string &s2) const {
+bool IniFileConfiguration::ICompare::operator()(const std::string &s1,
+                                                const std::string &s2) const {
   auto len = std::min(s1.size(), s2.size());
   return strncmp(s1.c_str(), s2.c_str(), len) < 0;
 }
diff --git a/tile/base/config/ini_file_config.h b/tile/base/config/ini_file_configuration.h
similarity index 81%
rename from tile/base/config/ini_file_config.h
rename to tile/base/config/ini_file_configuration.h
index fe3e1a9..f9a1b08 100644
--- a/tile/base/config/ini_file_config.h
+++ b/tile/base/config/ini_file_configuration.h
@@ -3,17 +3,17 @@
 
 #pragma once
 
-#include "tile/base/config/config.h"
+#include "tile/base/config/configuration.h"
 #include <map>
 
 namespace tile {
 namespace util {
-class IniFileConfig : public Config {
+class IniFileConfiguration : public Configuration {
 public:
-  using Ptr = RefPtr<IniFileConfig>;
+  using Ptr = RefPtr<IniFileConfiguration>;
 
-  IniFileConfig();
-  ~IniFileConfig() override;
+  IniFileConfiguration();
+  ~IniFileConfiguration() override;
   // IniFileConfig(std::istream &istr);
   // IniFileConfig(const std::string &path);
   bool load(std::istream &istr);
diff --git a/tile/base/config/ini_file_config_test.cc b/tile/base/config/ini_file_configuration_test.cc
similarity index 72%
rename from tile/base/config/ini_file_config_test.cc
rename to tile/base/config/ini_file_configuration_test.cc
index e110933..ffd1de2 100644
--- a/tile/base/config/ini_file_config_test.cc
+++ b/tile/base/config/ini_file_configuration_test.cc
@@ -1,4 +1,4 @@
-#include "tile/base/config/ini_file_config.h"
+#include "tile/base/config/ini_file_configuration.h"
 #include "gtest/gtest.h"
 
 const char *kIniFileConfig = R"(
@@ -18,16 +18,17 @@ a=4
 namespace tile {
 namespace util {
 
-static_assert(!detail::HasClassofImpl<IniFileConfig, Config>::value, "");
+static_assert(
+    !detail::HasClassofImpl<IniFileConfiguration, Configuration>::value, "");
 
 TEST(IniFileConfig, LoadFromIStream) {
   std::stringstream ss(kIniFileConfig);
-  Config::Ptr config = MakeRefCounted<IniFileConfig>();
+  Configuration::Ptr config = MakeRefCounted<IniFileConfiguration>();
   ASSERT_FALSE(config->Has("a"));
   ASSERT_FALSE(config->Has("sec1.a"));
   ASSERT_FALSE(config->Has("sec3.a"));
-  if (config.Is<IniFileConfig>()) {
-    IniFileConfig::Ptr ini = config.As<IniFileConfig>();
+  if (config.Is<IniFileConfiguration>()) {
+    IniFileConfiguration::Ptr ini = config.As<IniFileConfiguration>();
     ASSERT_TRUE(ini->load(ss));
   }
   ASSERT_TRUE(config->Has("a"));
diff --git a/tile/base/config/layered_config.cc b/tile/base/config/layered_config.cc
deleted file mode 100644
index 3b90173..0000000
--- a/tile/base/config/layered_config.cc
+++ /dev/null
@@ -1,129 +0,0 @@
-#include "tile/base/config/layered_config.h"
-
-namespace tile {
-namespace util {
-
-LayeredConfig::LayeredConfig() {}
-LayeredConfig::~LayeredConfig() {}
-
-void LayeredConfig::Add(Config::Ptr cfg) { Add(cfg, highest(), false); }
-
-void LayeredConfig::Add(Config::Ptr cfg, int priority) {
-  Add(cfg, priority, false);
-}
-
-void LayeredConfig::Add(Config::Ptr cfg, const std::string &label) {
-  Add(cfg, label, highest(), false);
-}
-
-void LayeredConfig::Add(Config::Ptr cfg, const std::string &label,
-                        int priority) {
-  Add(cfg, label, priority, false);
-}
-
-void LayeredConfig::Add(Config::Ptr cfg, const std::string &label,
-                        bool writeable) {
-  Add(cfg, label, highest(), writeable);
-}
-
-void LayeredConfig::Add(Config::Ptr cfg, const std::string &label, int priority,
-                        bool writeable) {
-  Config::ScopedLock lock(*this);
-  ConfigItem item;
-  item.cfg = cfg;
-  item.priority = priority;
-  item.writeable = writeable;
-  item.label = label;
-  auto it = configs_.begin();
-  while (it != configs_.end() && it->priority < priority) {
-    ++it;
-  }
-  configs_.insert(it, item);
-}
-
-void LayeredConfig::Add(Config::Ptr cfg, int priority, bool writeable) {
-  Add(cfg, std::string(), priority, writeable);
-}
-void LayeredConfig::AddWriteable(Config::Ptr cfg, int priority) {
-  Add(cfg, priority, true);
-}
-
-Config::Ptr LayeredConfig::Find(const Slice &label) const {
-  Config::ScopedLock lock(*this);
-
-  for (const auto &conf : configs_) {
-    if (conf.label == label) {
-      return conf.cfg;
-    }
-  }
-  return 0;
-}
-
-void LayeredConfig::RemoveConfig(Config::Ptr cfg) {
-  Config::ScopedLock lock(*this);
-  for (auto it = configs_.begin(); it != configs_.end();) {
-    if (it->cfg == cfg) {
-      it = configs_.erase(it);
-    } else {
-      ++it;
-    }
-  }
-}
-
-bool LayeredConfig::GetRaw(const Slice &key, std::string *value) const {
-  for (const auto &conf : configs_) {
-    if (conf.cfg->GetRaw(key, value)) {
-      return true;
-    }
-  }
-  return false;
-}
-
-bool LayeredConfig::SetRaw(const Slice &key, const Slice &value) {
-  for (const auto &conf : configs_) {
-    if (conf.writeable && conf.cfg->SetRaw(key, value)) {
-      return true;
-    }
-  }
-  return false;
-}
-
-Config::Keys LayeredConfig::Enumerate(const Slice &key) const {
-  Config::Keys keys;
-  std::set<Slice> key_set;
-  for (const auto &conf : configs_) {
-    auto conf_keys = conf.cfg->Enumerate(key);
-    for (const auto &k : conf_keys) {
-      if (key_set.insert(k).second) {
-        keys.push_back(k);
-      }
-    }
-  }
-  return keys;
-}
-
-void LayeredConfig::RemoveRaw(const std::string &key) {
-  for (auto &conf : configs_) {
-    if (conf.writeable) {
-      conf.cfg->RemoveRaw(key);
-    }
-  }
-}
-
-int LayeredConfig::lowest() const {
-  if (configs_.empty()) {
-    return 0;
-  } else {
-    return configs_.front().priority - 1;
-  }
-}
-int LayeredConfig::highest() const {
-  if (configs_.empty()) {
-    return 0;
-  } else {
-    return configs_.back().priority + 1;
-  }
-}
-
-} // namespace util
-} // namespace tile
diff --git a/tile/base/config/layered_config.h b/tile/base/config/layered_config.h
deleted file mode 100644
index e481515..0000000
--- a/tile/base/config/layered_config.h
+++ /dev/null
@@ -1,57 +0,0 @@
-#ifndef TILE_BASE_CONFIG_LAYERED_CONFIG_H
-#define TILE_BASE_CONFIG_LAYERED_CONFIG_H
-
-#pragma once
-
-#include "tile/base/config/config.h"
-#include <list>
-
-namespace tile {
-namespace util {
-class LayeredConfig : public Config {
-public:
-  using Ptr = RefPtr<LayeredConfig>;
-  LayeredConfig();
-  LayeredConfig(const LayeredConfig &) = delete;
-  LayeredConfig &operator=(const LayeredConfig &) = delete;
-
-  void Add(Config::Ptr cfg);
-  void Add(Config::Ptr cfg, int priority);
-  void Add(Config::Ptr cfg, const std::string &label);
-  void Add(Config::Ptr cfg, const std::string &label, int priority);
-  void Add(Config::Ptr cfg, const std::string &label, bool writeable);
-  void Add(Config::Ptr cfg, const std::string &label, int priority,
-           bool writeable);
-  void Add(Config::Ptr cfg, int priority, bool writeable);
-  void AddWriteable(Config::Ptr cfg, int priority);
-  Config::Ptr Find(const Slice &label) const;
-  void RemoveConfig(Config::Ptr cfg);
-
-protected:
-  struct ConfigItem {
-    Config::Ptr cfg;
-    // ... > -2 > -1 > 0 > 1 > 2 > 3 > 4 ...
-    int priority;
-    // can remove or set new?
-    bool writeable;
-    std::string label;
-  };
-
-  bool GetRaw(const Slice &key, std::string *value) const override;
-  bool SetRaw(const Slice &key, const Slice &value) override;
-  Config::Keys Enumerate(const Slice &key) const override;
-  void RemoveRaw(const std::string &key);
-
-  int lowest() const;
-  int highest() const;
-
-  ~LayeredConfig();
-
-private:
-  using ConfigList = std::list<ConfigItem>;
-  ConfigList configs_;
-};
-} // namespace util
-} // namespace tile
-
-#endif // TILE_BASE_CONFIG_LAYERED_CONFIG_H
diff --git a/tile/base/config/layered_configuration.cc b/tile/base/config/layered_configuration.cc
new file mode 100644
index 0000000..80910ed
--- /dev/null
+++ b/tile/base/config/layered_configuration.cc
@@ -0,0 +1,133 @@
+#include "tile/base/config/layered_configuration.h"
+
+namespace tile {
+namespace util {
+
+LayeredConfiguration::LayeredConfiguration() {}
+LayeredConfiguration::~LayeredConfiguration() {}
+
+void LayeredConfiguration::Add(Configuration::Ptr cfg) {
+  Add(cfg, highest(), false);
+}
+
+void LayeredConfiguration::Add(Configuration::Ptr cfg, int priority) {
+  Add(cfg, priority, false);
+}
+
+void LayeredConfiguration::Add(Configuration::Ptr cfg,
+                               const std::string &label) {
+  Add(cfg, label, highest(), false);
+}
+
+void LayeredConfiguration::Add(Configuration::Ptr cfg, const std::string &label,
+                               int priority) {
+  Add(cfg, label, priority, false);
+}
+
+void LayeredConfiguration::Add(Configuration::Ptr cfg, const std::string &label,
+                               bool writeable) {
+  Add(cfg, label, highest(), writeable);
+}
+
+void LayeredConfiguration::Add(Configuration::Ptr cfg, const std::string &label,
+                               int priority, bool writeable) {
+  Configuration::ScopedLock lock(*this);
+  ConfigItem item;
+  item.cfg = cfg;
+  item.priority = priority;
+  item.writeable = writeable;
+  item.label = label;
+  auto it = configs_.begin();
+  while (it != configs_.end() && it->priority < priority) {
+    ++it;
+  }
+  configs_.insert(it, item);
+}
+
+void LayeredConfiguration::Add(Configuration::Ptr cfg, int priority,
+                               bool writeable) {
+  Add(cfg, std::string(), priority, writeable);
+}
+void LayeredConfiguration::AddWriteable(Configuration::Ptr cfg, int priority) {
+  Add(cfg, priority, true);
+}
+
+Configuration::Ptr LayeredConfiguration::Find(const Slice &label) const {
+  Configuration::ScopedLock lock(*this);
+
+  for (const auto &conf : configs_) {
+    if (conf.label == label) {
+      return conf.cfg;
+    }
+  }
+  return 0;
+}
+
+void LayeredConfiguration::RemoveConfig(Configuration::Ptr cfg) {
+  Configuration::ScopedLock lock(*this);
+  for (auto it = configs_.begin(); it != configs_.end();) {
+    if (it->cfg == cfg) {
+      it = configs_.erase(it);
+    } else {
+      ++it;
+    }
+  }
+}
+
+bool LayeredConfiguration::GetRaw(const Slice &key, std::string *value) const {
+  for (const auto &conf : configs_) {
+    if (conf.cfg->GetRaw(key, value)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+bool LayeredConfiguration::SetRaw(const Slice &key, const Slice &value) {
+  for (const auto &conf : configs_) {
+    if (conf.writeable && conf.cfg->SetRaw(key, value)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+Configuration::Keys LayeredConfiguration::Enumerate(const Slice &key) const {
+  Configuration::Keys keys;
+  std::set<Slice> key_set;
+  for (const auto &conf : configs_) {
+    auto conf_keys = conf.cfg->Enumerate(key);
+    for (const auto &k : conf_keys) {
+      if (key_set.insert(k).second) {
+        keys.push_back(k);
+      }
+    }
+  }
+  return keys;
+}
+
+void LayeredConfiguration::RemoveRaw(const std::string &key) {
+  for (auto &conf : configs_) {
+    if (conf.writeable) {
+      conf.cfg->RemoveRaw(key);
+    }
+  }
+}
+
+int LayeredConfiguration::lowest() const {
+  if (configs_.empty()) {
+    return 0;
+  } else {
+    return configs_.front().priority - 1;
+  }
+}
+int LayeredConfiguration::highest() const {
+  if (configs_.empty()) {
+    return 0;
+  } else {
+    return configs_.back().priority + 1;
+  }
+}
+
+} // namespace util
+} // namespace tile
diff --git a/tile/base/config/layered_configuration.h b/tile/base/config/layered_configuration.h
new file mode 100644
index 0000000..db498ff
--- /dev/null
+++ b/tile/base/config/layered_configuration.h
@@ -0,0 +1,57 @@
+#ifndef TILE_BASE_CONFIG_LAYERED_CONFIGURATION_H
+#define TILE_BASE_CONFIG_LAYERED_CONFIGURATION_H
+
+#pragma once
+
+#include "tile/base/config/configuration.h"
+#include <list>
+
+namespace tile {
+namespace util {
+class LayeredConfiguration : public Configuration {
+public:
+  using Ptr = RefPtr<LayeredConfiguration>;
+  LayeredConfiguration();
+  LayeredConfiguration(const LayeredConfiguration &) = delete;
+  LayeredConfiguration &operator=(const LayeredConfiguration &) = delete;
+
+  void Add(Configuration::Ptr cfg);
+  void Add(Configuration::Ptr cfg, int priority);
+  void Add(Configuration::Ptr cfg, const std::string &label);
+  void Add(Configuration::Ptr cfg, const std::string &label, int priority);
+  void Add(Configuration::Ptr cfg, const std::string &label, bool writeable);
+  void Add(Configuration::Ptr cfg, const std::string &label, int priority,
+           bool writeable);
+  void Add(Configuration::Ptr cfg, int priority, bool writeable);
+  void AddWriteable(Configuration::Ptr cfg, int priority);
+  Configuration::Ptr Find(const Slice &label) const;
+  void RemoveConfig(Configuration::Ptr cfg);
+
+protected:
+  struct ConfigItem {
+    Configuration::Ptr cfg;
+    // ... > -2 > -1 > 0 > 1 > 2 > 3 > 4 ...
+    int priority;
+    // can remove or set new?
+    bool writeable;
+    std::string label;
+  };
+
+  bool GetRaw(const Slice &key, std::string *value) const override;
+  bool SetRaw(const Slice &key, const Slice &value) override;
+  Configuration::Keys Enumerate(const Slice &key) const override;
+  void RemoveRaw(const std::string &key);
+
+  int lowest() const;
+  int highest() const;
+
+  ~LayeredConfiguration();
+
+private:
+  using ConfigList = std::list<ConfigItem>;
+  ConfigList configs_;
+};
+} // namespace util
+} // namespace tile
+
+#endif // TILE_BASE_CONFIG_LAYERED_CONFIGURATION_H
diff --git a/tile/base/configuration.h b/tile/base/configuration.h
new file mode 100644
index 0000000..0a980a9
--- /dev/null
+++ b/tile/base/configuration.h
@@ -0,0 +1,11 @@
+#ifndef TILE_BASE_CONFIGURATION_H
+#define TILE_BASE_CONFIGURATION_H
+
+#pragma once
+
+#include "tile/base/config/configurable.h"
+#include "tile/base/config/configuration.h"
+#include "tile/base/config/ini_file_configuration.h"
+#include "tile/base/config/layered_configuration.h"
+
+#endif // TILE_BASE_CONFIGURATION_H
diff --git a/tile/tile.h b/tile/tile.h
index 45a6cfd..288a809 100644
--- a/tile/tile.h
+++ b/tile/tile.h
@@ -9,7 +9,6 @@
 #include "tile/base/casting.h"
 #include "tile/base/chrono.h"
 #include "tile/base/compression.h"
-#include "tile/base/config/ini_file_config.h"
 #include "tile/base/data.h"
 #include "tile/base/deferred.h"
 #include "tile/base/demangle.h"
@@ -40,13 +39,12 @@
 #include "tile/base/write_mostly.h"
 
 // util
-#include "tile/util/config.h"
-#include "tile/util/ini_file_config.h"
+#include "tile/base/configuration.h"
 
 // init module
 #include "tile/init/override_flag.h"
 
-#include "sigslot/signal.h"
+#include "sigslot/sigslot.h"
 
 // Tile Init
 #include "mustache.hpp"

From 04d41aa566cfc88afedc7e442a02f7eab0737278 Mon Sep 17 00:00:00 2001
From: tqcq <99722391+tqcq@users.noreply.github.com>
Date: Wed, 14 Aug 2024 22:42:06 +0800
Subject: [PATCH 02/25] feat add json configuration

---
 CMakeLists.txt                                |   1 +
 tile/base/config/configurable.h               |   2 -
 tile/base/config/configuration.cc             |   3 -
 tile/base/config/configuration.h              |   2 -
 tile/base/config/ini_file_configuration.cc    |  12 +-
 tile/base/config/ini_file_configuration.h     |   2 -
 .../config/ini_file_configuration_test.cc     |   2 -
 tile/base/config/json_configuration.cc        | 128 ++++++++++++++++++
 tile/base/config/json_configuration.h         |  48 +++++++
 tile/base/config/layered_configuration.cc     |   2 -
 tile/base/config/layered_configuration.h      |   2 -
 tile/tile.h                                   |   1 -
 12 files changed, 182 insertions(+), 23 deletions(-)
 create mode 100644 tile/base/config/json_configuration.cc
 create mode 100644 tile/base/config/json_configuration.h

diff --git a/CMakeLists.txt b/CMakeLists.txt
index bbf65c9..23a459c 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -209,6 +209,7 @@ set(TILE_SRCS
     # "tile/rpc/server.cc"
     "tile/base/config/configuration.cc"
     "tile/base/config/ini_file_configuration.cc"
+    "tile/base/config/json_configuration.cc"
     "tile/base/config/layered_configuration.cc"
 )
 
diff --git a/tile/base/config/configurable.h b/tile/base/config/configurable.h
index 6896afd..6dc3969 100644
--- a/tile/base/config/configurable.h
+++ b/tile/base/config/configurable.h
@@ -5,7 +5,6 @@
 #include "tile/base/string.h"
 
 namespace tile {
-namespace util {
 class Configurable {
   Configurable();
   virtual ~Configurable() = default;
@@ -13,7 +12,6 @@ class Configurable {
   virtual std::string GetProperty(const Slice &name) const = 0;
 };
 
-} // namespace util
 } // namespace tile
 
 #endif // TILE_BASE_CONFIG_CONFIGURABLE_H
diff --git a/tile/base/config/configuration.cc b/tile/base/config/configuration.cc
index 482a93b..f501e78 100644
--- a/tile/base/config/configuration.cc
+++ b/tile/base/config/configuration.cc
@@ -2,7 +2,6 @@
 #include "tile/base/thread/unique_lock.h"
 
 namespace tile {
-namespace util {
 bool Configuration::Has(const Slice &key) const {
   UniqueLock<tile::Mutex> lock(mutex_);
   std::string value;
@@ -109,6 +108,4 @@ void Configuration::SetRawWithEvent(const Slice &key,
 
 Configuration::~Configuration() {}
 
-} // namespace util
-
 } // namespace tile
diff --git a/tile/base/config/configuration.h b/tile/base/config/configuration.h
index 2365340..a637de1 100644
--- a/tile/base/config/configuration.h
+++ b/tile/base/config/configuration.h
@@ -11,7 +11,6 @@
 #include <cstdint>
 
 namespace tile {
-namespace util {
 class Configuration : public RefCounted<Configuration> {
 public:
   using Keys = std::vector<std::string>;
@@ -121,7 +120,6 @@ private:
   mutable Mutex mutex_;
   bool events_enabled_{false};
 };
-} // namespace util
 } // namespace tile
 
 #endif // TILE_BASE_CONFIG_CONFIGURATION_H
diff --git a/tile/base/config/ini_file_configuration.cc b/tile/base/config/ini_file_configuration.cc
index cb2c9bc..8bb1443 100644
--- a/tile/base/config/ini_file_configuration.cc
+++ b/tile/base/config/ini_file_configuration.cc
@@ -2,7 +2,6 @@
 #include "tile/base/thread/scoped_lock.h"
 
 namespace tile {
-namespace util {
 
 IniFileConfiguration::IniFileConfiguration() {}
 // IniFileConfig::IniFileConfig(std::istream &istr) { load(istr); }
@@ -10,6 +9,10 @@ IniFileConfiguration::IniFileConfiguration() {}
 IniFileConfiguration::~IniFileConfiguration() {}
 
 bool IniFileConfiguration::load(std::istream &istr) {
+  if (!istr.good()) {
+    return false;
+  }
+
   Configuration::ScopedLock lock(*this);
   map_.clear();
   section_key_.clear();
@@ -20,11 +23,7 @@ bool IniFileConfiguration::load(std::istream &istr) {
 }
 bool IniFileConfiguration::load(const std::string &path) {
   std::ifstream istr(path);
-  if (istr.good()) {
-    return load(istr);
-  } else {
-    return false;
-  }
+  return load(istr);
 }
 bool IniFileConfiguration::GetRaw(const Slice &key, std::string *value) const {
   auto iter = map_.find(key.ToString());
@@ -141,5 +140,4 @@ bool IniFileConfiguration::ICompare::operator()(const std::string &s1,
   return strncmp(s1.c_str(), s2.c_str(), len) < 0;
 }
 
-} // namespace util
 } // namespace tile
diff --git a/tile/base/config/ini_file_configuration.h b/tile/base/config/ini_file_configuration.h
index f9a1b08..218c1ac 100644
--- a/tile/base/config/ini_file_configuration.h
+++ b/tile/base/config/ini_file_configuration.h
@@ -7,7 +7,6 @@
 #include <map>
 
 namespace tile {
-namespace util {
 class IniFileConfiguration : public Configuration {
 public:
   using Ptr = RefPtr<IniFileConfiguration>;
@@ -34,7 +33,6 @@ private:
   IStringMap map_;
   std::string section_key_;
 };
-} // namespace util
 } // namespace tile
 
 #endif // TILE_BASE_CONFIG_INI_FILE_CONFIG_H
diff --git a/tile/base/config/ini_file_configuration_test.cc b/tile/base/config/ini_file_configuration_test.cc
index ffd1de2..c8039c5 100644
--- a/tile/base/config/ini_file_configuration_test.cc
+++ b/tile/base/config/ini_file_configuration_test.cc
@@ -16,7 +16,6 @@ a=4
 )";
 
 namespace tile {
-namespace util {
 
 static_assert(
     !detail::HasClassofImpl<IniFileConfiguration, Configuration>::value, "");
@@ -43,5 +42,4 @@ TEST(IniFileConfig, LoadFromIStream) {
   ASSERT_EQ(3, *config->GetInt("sec3.a"));
   ASSERT_EQ(4, *config->GetInt("sec2.kk.a"));
 }
-} // namespace util
 } // namespace tile
diff --git a/tile/base/config/json_configuration.cc b/tile/base/config/json_configuration.cc
new file mode 100644
index 0000000..918f3ff
--- /dev/null
+++ b/tile/base/config/json_configuration.cc
@@ -0,0 +1,128 @@
+#include "tile/base/config/json_configuration.h"
+#include "tile/base/logging.h"
+
+namespace tile {
+JSONConfiguration::JSONConfiguration() : object_() {}
+JSONConfiguration::~JSONConfiguration() {}
+
+bool JSONConfiguration::load(const std::string &path) {
+  std::ifstream istr(path);
+  return load(istr);
+}
+
+bool JSONConfiguration::load(std::istream &istr) {
+  if (!istr.good()) {
+    return false;
+  }
+
+  Configuration::ScopedLock _(*this);
+  object_.clear();
+  Json::Reader reader;
+  return reader.parse(istr, object_, true);
+}
+
+void JSONConfiguration::SetInt(const Slice &key, int value) {
+  SetValue(key, value);
+}
+
+void JSONConfiguration::SetBool(const Slice &key, bool value) {
+  SetValue(key, value);
+}
+
+void JSONConfiguration::SetDouble(const Slice &key, double value) {
+  SetValue(key, value);
+}
+
+void JSONConfiguration::SetString(const Slice &key, const std::string &value) {
+  SetValue(key, value);
+}
+
+void JSONConfiguration::RemoveRaw(const Slice &key) {
+  Configuration::ScopedLock _(*this);
+  Json::Value root;
+  Slice last_part;
+  if (!FindStart(key, &last_part, &root)) {
+    return;
+  }
+  root.removeMember(last_part.ToString());
+}
+
+bool JSONConfiguration::GetRaw(const Slice &key, std::string *value) const {
+  Configuration::ScopedLock _(*this);
+  auto keys = Split(key, '.');
+  auto root = object_;
+  for (std::size_t i = 0; i < keys.size(); ++i) {
+    const auto &cur_key = keys[i];
+    if (cur_key.empty()) {
+      TILE_LOG_ERROR("Invalid key: {}", key);
+      return false;
+    }
+    if (!object_.isMember(cur_key)) {
+      return false;
+    }
+    root = root[cur_key];
+  }
+
+  *value = root.asString();
+  return true;
+}
+
+bool JSONConfiguration::SetRaw(const Slice &key, const Slice &value) {
+  return SetValue(key, value.ToString());
+}
+
+Configuration::Keys JSONConfiguration::Enumerate(const Slice &range) const {
+  Configuration::ScopedLock _(*this);
+  Configuration::Keys key_set;
+
+  auto keys = Split(range, '.');
+  auto root = object_;
+  for (std::size_t i = 0; i < keys.size(); ++i) {
+    const auto &cur_key = keys[i];
+    if (cur_key.empty()) {
+      TILE_LOG_ERROR("Invalid range: {}", range);
+      return key_set;
+    }
+    if (!object_.isMember(cur_key)) {
+      return key_set;
+    }
+    root = root[cur_key];
+  }
+
+  for (const auto &key : root.getMemberNames()) {
+    key_set.push_back(key);
+  }
+  return key_set;
+}
+
+bool JSONConfiguration::FindStart(const Slice &key, Slice *last_part,
+                                  Json::Value *parent_obj) {
+  auto keys = Split(key, '.');
+  if (keys.empty()) {
+    return false;
+  }
+
+  auto root = object_;
+  for (std::size_t i = 0; i < keys.size() - 1; ++i) {
+    const auto &cur_key = keys[i];
+    if (cur_key.empty()) {
+      TILE_LOG_ERROR("Invalid key: {}", key);
+      return false;
+    }
+
+    if (!root.isMember(cur_key)) {
+      root[cur_key] = Json::Value(Json::objectValue);
+    } else if (!root[cur_key].isObject()) {
+      TILE_LOG_ERROR("only leaf nodes can be set: key: {}, cur_key(idx={}): {}",
+                     key, i, cur_key);
+      return false;
+    }
+    root = root[cur_key];
+  }
+
+  *last_part = keys.back();
+  *parent_obj = root;
+  return true;
+}
+
+} // namespace tile
diff --git a/tile/base/config/json_configuration.h b/tile/base/config/json_configuration.h
new file mode 100644
index 0000000..2208300
--- /dev/null
+++ b/tile/base/config/json_configuration.h
@@ -0,0 +1,48 @@
+#ifndef TILE_BASE_CONFIG_JSON_CONFIGURATION_H
+#define TILE_BASE_CONFIG_JSON_CONFIGURATION_H
+
+#pragma once
+
+#include "tile/base/config/configuration.h"
+#include "json/json.h"
+
+namespace tile {
+class JSONConfiguration : public Configuration {
+public:
+  using Ptr = RefPtr<JSONConfiguration>;
+  JSONConfiguration();
+  ~JSONConfiguration() override;
+  bool load(const std::string &path);
+  bool load(std::istream &istr);
+
+  void SetInt(const Slice &key, int value) override;
+  void SetBool(const Slice &key, bool value) override;
+  void SetDouble(const Slice &key, double value) override;
+  void SetString(const Slice &key, const std::string &value) override;
+  void RemoveRaw(const Slice &key) override;
+
+protected:
+  bool GetRaw(const Slice &key, std::string *value) const override;
+  bool SetRaw(const Slice &key, const Slice &value) override;
+  Keys Enumerate(const Slice &range) const override;
+
+private:
+  bool FindStart(const Slice &key, Slice *last_prt, Json::Value *parent_obj);
+  template <typename T> bool SetValue(const Slice &key, T value);
+  Json::Value object_;
+};
+
+template <typename T>
+bool JSONConfiguration::SetValue(const Slice &key, T value) {
+  Slice last_part;
+  Json::Value root;
+  Configuration::ScopedLock _(*this);
+  if (!FindStart(key, &last_part, &root)) {
+    return false;
+  }
+  root[last_part] = Json::Value(value);
+  return true;
+}
+} // namespace tile
+
+#endif // TILE_BASE_CONFIG_JSON_CONFIGURATION_H
diff --git a/tile/base/config/layered_configuration.cc b/tile/base/config/layered_configuration.cc
index 80910ed..ea62c5e 100644
--- a/tile/base/config/layered_configuration.cc
+++ b/tile/base/config/layered_configuration.cc
@@ -1,7 +1,6 @@
 #include "tile/base/config/layered_configuration.h"
 
 namespace tile {
-namespace util {
 
 LayeredConfiguration::LayeredConfiguration() {}
 LayeredConfiguration::~LayeredConfiguration() {}
@@ -129,5 +128,4 @@ int LayeredConfiguration::highest() const {
   }
 }
 
-} // namespace util
 } // namespace tile
diff --git a/tile/base/config/layered_configuration.h b/tile/base/config/layered_configuration.h
index db498ff..aa8f9de 100644
--- a/tile/base/config/layered_configuration.h
+++ b/tile/base/config/layered_configuration.h
@@ -7,7 +7,6 @@
 #include <list>
 
 namespace tile {
-namespace util {
 class LayeredConfiguration : public Configuration {
 public:
   using Ptr = RefPtr<LayeredConfiguration>;
@@ -51,7 +50,6 @@ private:
   using ConfigList = std::list<ConfigItem>;
   ConfigList configs_;
 };
-} // namespace util
 } // namespace tile
 
 #endif // TILE_BASE_CONFIG_LAYERED_CONFIGURATION_H
diff --git a/tile/tile.h b/tile/tile.h
index 288a809..3d89de1 100644
--- a/tile/tile.h
+++ b/tile/tile.h
@@ -47,7 +47,6 @@
 #include "sigslot/sigslot.h"
 
 // Tile Init
-#include "mustache.hpp"
 #include "tile/init.h"
 
 #endif // TILE_TILE_H

From 5a02a4c7508b22abddcedc586565c5708b431bc4 Mon Sep 17 00:00:00 2001
From: tqcq <99722391+tqcq@users.noreply.github.com>
Date: Thu, 15 Aug 2024 11:12:06 +0800
Subject: [PATCH 03/25] fix json configuration

---
 .gitignore                                  |  1 +
 CMakeLists.txt                              |  3 +
 tile/base/config/json_configuration.cc      | 36 ++++++----
 tile/base/config/json_configuration.h       |  9 +--
 tile/base/config/json_configuration_test.cc | 76 +++++++++++++++++++++
 5 files changed, 108 insertions(+), 17 deletions(-)
 create mode 100644 tile/base/config/json_configuration_test.cc

diff --git a/.gitignore b/.gitignore
index 253e16b..6e95f64 100644
--- a/.gitignore
+++ b/.gitignore
@@ -2,3 +2,4 @@ out/
 build/
 .cache/
 compile_commands.json
+.gdb_history
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 23a459c..405b12b 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -302,6 +302,9 @@ function(add_test_group prefix group_name)
     # convert to relative path message(STATUS "${prefix} -> ${TEST_FILE}")
     file(RELATIVE_PATH TEST_NAME "${prefix}" "${SRC_FILE}")
     string(REPLACE "/" "_" TEST_NAME "${TEST_NAME}")
+    string(REPLACE ".cpp" "" TEST_NAME "${TEST_NAME}")
+    string(REPLACE ".cc" "" TEST_NAME "${TEST_NAME}")
+    string(REPLACE ".c" "" TEST_NAME "${TEST_NAME}")
     # if group_name is not empty, add suffix _
     if (NOT group_name STREQUAL "")
         set(TEST_NAME "${group_name}_${TEST_NAME}")
diff --git a/tile/base/config/json_configuration.cc b/tile/base/config/json_configuration.cc
index 918f3ff..efdc238 100644
--- a/tile/base/config/json_configuration.cc
+++ b/tile/base/config/json_configuration.cc
@@ -22,33 +22,39 @@ bool JSONConfiguration::load(std::istream &istr) {
 }
 
 void JSONConfiguration::SetInt(const Slice &key, int value) {
+  Configuration::ScopedLock _(*this);
   SetValue(key, value);
 }
 
 void JSONConfiguration::SetBool(const Slice &key, bool value) {
+  Configuration::ScopedLock _(*this);
   SetValue(key, value);
 }
 
 void JSONConfiguration::SetDouble(const Slice &key, double value) {
+  Configuration::ScopedLock _(*this);
   SetValue(key, value);
 }
 
 void JSONConfiguration::SetString(const Slice &key, const std::string &value) {
+  Configuration::ScopedLock _(*this);
   SetValue(key, value);
 }
 
 void JSONConfiguration::RemoveRaw(const Slice &key) {
-  Configuration::ScopedLock _(*this);
-  Json::Value root;
+  Json::Value *root;
   Slice last_part;
   if (!FindStart(key, &last_part, &root)) {
     return;
   }
-  root.removeMember(last_part.ToString());
+  root->removeMember(last_part.ToString());
+}
+std::string JSONConfiguration::Dump() const {
+  Configuration::ScopedLock _(*this);
+  return object_.toStyledString();
 }
 
 bool JSONConfiguration::GetRaw(const Slice &key, std::string *value) const {
-  Configuration::ScopedLock _(*this);
   auto keys = Split(key, '.');
   auto root = object_;
   for (std::size_t i = 0; i < keys.size(); ++i) {
@@ -57,13 +63,17 @@ bool JSONConfiguration::GetRaw(const Slice &key, std::string *value) const {
       TILE_LOG_ERROR("Invalid key: {}", key);
       return false;
     }
-    if (!object_.isMember(cur_key)) {
+    if (!root.isMember(cur_key)) {
       return false;
     }
     root = root[cur_key];
   }
 
-  *value = root.asString();
+  if (root.isConvertibleTo(Json::stringValue)) {
+    *value = root.asString();
+  } else {
+    *value = root.toStyledString();
+  }
   return true;
 }
 
@@ -83,7 +93,7 @@ Configuration::Keys JSONConfiguration::Enumerate(const Slice &range) const {
       TILE_LOG_ERROR("Invalid range: {}", range);
       return key_set;
     }
-    if (!object_.isMember(cur_key)) {
+    if (!root.isMember(cur_key)) {
       return key_set;
     }
     root = root[cur_key];
@@ -96,13 +106,13 @@ Configuration::Keys JSONConfiguration::Enumerate(const Slice &range) const {
 }
 
 bool JSONConfiguration::FindStart(const Slice &key, Slice *last_part,
-                                  Json::Value *parent_obj) {
+                                  Json::Value **parent_obj) {
   auto keys = Split(key, '.');
   if (keys.empty()) {
     return false;
   }
 
-  auto root = object_;
+  Json::Value *root = &object_;
   for (std::size_t i = 0; i < keys.size() - 1; ++i) {
     const auto &cur_key = keys[i];
     if (cur_key.empty()) {
@@ -110,14 +120,14 @@ bool JSONConfiguration::FindStart(const Slice &key, Slice *last_part,
       return false;
     }
 
-    if (!root.isMember(cur_key)) {
-      root[cur_key] = Json::Value(Json::objectValue);
-    } else if (!root[cur_key].isObject()) {
+    if (!root->isMember(cur_key)) {
+      (*root)[cur_key] = Json::Value(Json::objectValue);
+    } else if (!(*root)[cur_key].isObject()) {
       TILE_LOG_ERROR("only leaf nodes can be set: key: {}, cur_key(idx={}): {}",
                      key, i, cur_key);
       return false;
     }
-    root = root[cur_key];
+    root = &(*root)[cur_key];
   }
 
   *last_part = keys.back();
diff --git a/tile/base/config/json_configuration.h b/tile/base/config/json_configuration.h
index 2208300..be45c3a 100644
--- a/tile/base/config/json_configuration.h
+++ b/tile/base/config/json_configuration.h
@@ -21,13 +21,15 @@ public:
   void SetString(const Slice &key, const std::string &value) override;
   void RemoveRaw(const Slice &key) override;
 
+  std::string Dump() const;
+
 protected:
   bool GetRaw(const Slice &key, std::string *value) const override;
   bool SetRaw(const Slice &key, const Slice &value) override;
   Keys Enumerate(const Slice &range) const override;
 
 private:
-  bool FindStart(const Slice &key, Slice *last_prt, Json::Value *parent_obj);
+  bool FindStart(const Slice &key, Slice *last_prt, Json::Value **parent_obj);
   template <typename T> bool SetValue(const Slice &key, T value);
   Json::Value object_;
 };
@@ -35,12 +37,11 @@ private:
 template <typename T>
 bool JSONConfiguration::SetValue(const Slice &key, T value) {
   Slice last_part;
-  Json::Value root;
-  Configuration::ScopedLock _(*this);
+  Json::Value *root;
   if (!FindStart(key, &last_part, &root)) {
     return false;
   }
-  root[last_part] = Json::Value(value);
+  (*root)[last_part] = Json::Value(value);
   return true;
 }
 } // namespace tile
diff --git a/tile/base/config/json_configuration_test.cc b/tile/base/config/json_configuration_test.cc
new file mode 100644
index 0000000..33be658
--- /dev/null
+++ b/tile/base/config/json_configuration_test.cc
@@ -0,0 +1,76 @@
+#include "tile/base/config/json_configuration.h"
+
+#include "gtest/gtest.h"
+
+namespace tile {
+namespace {
+const char *kJsonConfig = R"(
+    {
+        "key1": "value1",
+        "key2": 2,
+        "key3": 3.0,
+        "key4": true,
+        "key5": {
+            "key51": "value51",
+            "key52": 52
+        }
+    }
+    )";
+}
+
+TEST(JSONConfiguration, Load) {
+  JSONConfiguration config;
+  std::istringstream istr(kJsonConfig);
+  ASSERT_TRUE(config.load(istr));
+}
+TEST(JSONConfiguration, Has) {
+  JSONConfiguration config;
+  std::istringstream istr(kJsonConfig);
+  ASSERT_TRUE(config.load(istr));
+
+  ASSERT_TRUE(config.Has("key1"));
+  ASSERT_TRUE(config.Has("key2"));
+  ASSERT_TRUE(config.Has("key3"));
+  ASSERT_TRUE(config.Has("key4"));
+  ASSERT_TRUE(config.Has("key5"));
+  ASSERT_TRUE(config.Has("key5.key51"));
+  ASSERT_TRUE(config.Has("key5.key52"));
+}
+
+TEST(JSONConfiguration, SampleSet) {
+  JSONConfiguration config;
+  std::istringstream istr(kJsonConfig);
+  ASSERT_TRUE(config.load(istr));
+  ASSERT_TRUE(config.GetInt32("key2"));
+  ASSERT_EQ(*config.GetInt32("key2"), 2);
+
+  config.SetInt("key2", 20);
+  ASSERT_TRUE(config.GetInt32("key2"));
+  ASSERT_EQ(20, *config.GetInt32("key2")) << config.Dump();
+
+  config.SetDouble("key3", 30.0);
+  ASSERT_TRUE(config.GetDouble("key3"));
+  ASSERT_NEAR(30.0, *config.GetDouble("key3"), 0.0001) << config.Dump();
+
+  config.SetBool("key4", false);
+  ASSERT_TRUE(config.GetBool("key4"));
+  ASSERT_FALSE(*config.GetBool("key4")) << config.Dump();
+}
+
+TEST(JSONConfiguration, LayeredSet) {
+  JSONConfiguration config;
+  std::istringstream istr(kJsonConfig);
+  ASSERT_TRUE(config.load(istr));
+
+  // ASSERT_TRUE(config.GetInt32("key5.key52"));
+  config.SetInt("key5.key52", 520);
+  ASSERT_TRUE(config.GetInt32("key5.key52")) << config.Dump();
+  ASSERT_EQ(520, *config.GetInt32("key5.key52")) << config.Dump();
+
+  // override by other type
+  config.SetBool("key5.key52", false);
+  ASSERT_TRUE(config.GetBool("key5.key52")) << config.Dump();
+  ASSERT_FALSE(*config.GetBool("key5.key52")) << config.Dump();
+}
+
+} // namespace tile

From 28c22939ce1fdc961af872de6608b80c83ab87a7 Mon Sep 17 00:00:00 2001
From: tqcq <99722391+tqcq@users.noreply.github.com>
Date: Thu, 15 Aug 2024 11:20:30 +0800
Subject: [PATCH 04/25] fix json configuration remove

---
 tile/base/config/configuration.cc           | 11 ++++++++++-
 tile/base/config/json_configuration.cc      |  9 ++++++---
 tile/base/config/json_configuration_test.cc | 22 +++++++++++++++++++++
 3 files changed, 38 insertions(+), 4 deletions(-)

diff --git a/tile/base/config/configuration.cc b/tile/base/config/configuration.cc
index f501e78..5e976e2 100644
--- a/tile/base/config/configuration.cc
+++ b/tile/base/config/configuration.cc
@@ -8,7 +8,16 @@ bool Configuration::Has(const Slice &key) const {
   return GetRaw(key, &value);
 }
 
-void Configuration::Remove(const Slice &key) {}
+void Configuration::Remove(const Slice &key) {
+  UniqueLock<tile::Mutex> lock(mutex_);
+  if (events_enabled_) {
+    OnRemoving(key);
+  }
+  RemoveRaw(key);
+  if (events_enabled_) {
+    OnRemoved(key);
+  }
+}
 
 void Configuration::EnableEvents(bool enable) { events_enabled_ = enable; }
 bool Configuration::EventsEnabled() const { return events_enabled_; }
diff --git a/tile/base/config/json_configuration.cc b/tile/base/config/json_configuration.cc
index efdc238..65f3e15 100644
--- a/tile/base/config/json_configuration.cc
+++ b/tile/base/config/json_configuration.cc
@@ -47,7 +47,7 @@ void JSONConfiguration::RemoveRaw(const Slice &key) {
   if (!FindStart(key, &last_part, &root)) {
     return;
   }
-  root->removeMember(last_part.ToString());
+  root->removeMember(last_part);
 }
 std::string JSONConfiguration::Dump() const {
   Configuration::ScopedLock _(*this);
@@ -82,8 +82,11 @@ bool JSONConfiguration::SetRaw(const Slice &key, const Slice &value) {
 }
 
 Configuration::Keys JSONConfiguration::Enumerate(const Slice &range) const {
-  Configuration::ScopedLock _(*this);
   Configuration::Keys key_set;
+  std::string prefix = range;
+  if (!prefix.empty()) {
+    prefix += ".";
+  }
 
   auto keys = Split(range, '.');
   auto root = object_;
@@ -100,7 +103,7 @@ Configuration::Keys JSONConfiguration::Enumerate(const Slice &range) const {
   }
 
   for (const auto &key : root.getMemberNames()) {
-    key_set.push_back(key);
+    key_set.push_back(prefix + key);
   }
   return key_set;
 }
diff --git a/tile/base/config/json_configuration_test.cc b/tile/base/config/json_configuration_test.cc
index 33be658..e213681 100644
--- a/tile/base/config/json_configuration_test.cc
+++ b/tile/base/config/json_configuration_test.cc
@@ -73,4 +73,26 @@ TEST(JSONConfiguration, LayeredSet) {
   ASSERT_FALSE(*config.GetBool("key5.key52")) << config.Dump();
 }
 
+TEST(json_configuration, Enumerate) {
+  JSONConfiguration config;
+  std::istringstream istr(kJsonConfig);
+  ASSERT_TRUE(config.load(istr));
+  auto keys = config.keys("");
+  ASSERT_EQ(5, keys.size());
+  ASSERT_EQ("key1", keys[0]);
+  ASSERT_EQ("key2", keys[1]);
+  ASSERT_EQ("key3", keys[2]);
+  ASSERT_EQ("key4", keys[3]);
+  ASSERT_EQ("key5", keys[4]);
+
+  keys = config.keys("key5");
+  ASSERT_EQ(2, keys.size());
+  ASSERT_EQ("key5.key51", keys[0]);
+  ASSERT_EQ("key5.key52", keys[1]);
+
+  config.Remove("key5.key51");
+  keys = config.keys("key5");
+  ASSERT_EQ("key5.key52", keys[0]);
+}
+
 } // namespace tile

From a09f8cc68bca8104f4910a0d85462586a863322b Mon Sep 17 00:00:00 2001
From: tqcq <99722391+tqcq@users.noreply.github.com>
Date: Fri, 23 Aug 2024 21:12:10 +0800
Subject: [PATCH 05/25] feat update

---
 .woodpecker/linux-aarch64-gcc.yml  | 37 ------------------------------
 .woodpecker/linux-arm-gcc.yml.stop | 30 ------------------------
 .woodpecker/linux-x64-gcc.yml      | 37 ------------------------------
 .woodpecker/linux-x86-gcc.yml.stop | 36 -----------------------------
 tile/base/config/configurable.h    |  2 +-
 tile/base/config/configuration.cc  |  2 ++
 tile/base/config/configuration.h   |  1 -
 7 files changed, 3 insertions(+), 142 deletions(-)
 delete mode 100644 .woodpecker/linux-aarch64-gcc.yml
 delete mode 100644 .woodpecker/linux-arm-gcc.yml.stop
 delete mode 100644 .woodpecker/linux-x64-gcc.yml
 delete mode 100644 .woodpecker/linux-x86-gcc.yml.stop

diff --git a/.woodpecker/linux-aarch64-gcc.yml b/.woodpecker/linux-aarch64-gcc.yml
deleted file mode 100644
index 02f22df..0000000
--- a/.woodpecker/linux-aarch64-gcc.yml
+++ /dev/null
@@ -1,37 +0,0 @@
-when:
-  - event: 
-    - push
-    - pull_request 
-  - path:
-      include:
-        - ".woodpecker/linux-aarch64-gcc.yml"
-        - "cmake/**"
-        - "third_party/**"
-        - "tile/**"
-        - "CMakeLists.txt"
-
-matrix:
-  BUILD_TYPE:
-    - Debug
-    - Release
-
-steps:
-  - name: linux-aarch64-gcc-build
-    image: art.uocat.com/docker/tqcq/cross:v1.0.1
-    commands:
-      - mkdir build 
-      - cmake -S. -Bbuild -DCMAKE_BUILD_TYPE=${BUILD_TYPE} -DTILE_BUILD_BENCHMARKS=ON -DTILE_BUILD_TESTS=ON  -DCMAKE_TOOLCHAIN_FILE=./toolchains/aarch64-linux-gnu.toolchain.cmake
-      - cmake --build build -j $(nproc)
-
-  - name: linux-aarch64-gcc-test
-    image: art.uocat.com/docker/tqcq/cross:v1.0.1
-    commands:
-      - cd build
-      - ctest --output-on-failure -j $(nproc)
-
-  # - name: linux-aarch64-gcc-benchmark
-  #   image: art.uocat.com/docker/tqcq/cross:v1.0.1
-  #   commands:
-  #     - ./build/bin/tile_bm_all
-
-
diff --git a/.woodpecker/linux-arm-gcc.yml.stop b/.woodpecker/linux-arm-gcc.yml.stop
deleted file mode 100644
index 9a167bb..0000000
--- a/.woodpecker/linux-arm-gcc.yml.stop
+++ /dev/null
@@ -1,30 +0,0 @@
-when:
-  - event:  []
-    #- push
-    #- pull_request 
-
-matrix:
-  BUILD_TYPE:
-    - Debug
-    - Release
-
-steps:
-  - name: linux-arm-gcc-build
-    image: art.uocat.com/docker/tqcq/cross:v1.0.1
-    commands:
-      - mkdir build 
-      - cmake -S. -Bbuild -DCMAKE_BUILD_TYPE=${BUILD_TYPE} -DTILE_BUILD_BENCHMARKS=ON -DTILE_BUILD_TESTS=ON  -DCMAKE_TOOLCHAIN_FILE=./toolchains/arm-linux-gnueabihf.toolchain.cmake
-      - cmake --build build -j $(nproc)
-
-  - name: linux-arm-gcc-test
-    image: art.uocat.com/docker/tqcq/cross:v1.0.1
-    commands:
-      - cd build
-      - ctest --output-on-failure -j $(nproc)
-
-  # - name: linux-arm-gcc-benchmark
-  #   image: art.uocat.com/docker/tqcq/cross:v1.0.1
-  #   commands:
-  #     - ./build/bin/tile_bm_all
-
-
diff --git a/.woodpecker/linux-x64-gcc.yml b/.woodpecker/linux-x64-gcc.yml
deleted file mode 100644
index 5b03d91..0000000
--- a/.woodpecker/linux-x64-gcc.yml
+++ /dev/null
@@ -1,37 +0,0 @@
-when:
-  - event: 
-    - push
-    - pull_request 
-  - path:
-      include:
-        - ".woodpecker/linux-x64-gcc.yml"
-        - "cmake/**"
-        - "third_party/**"
-        - "tile/**"
-        - "CMakeLists.txt"
-
-matrix:
-  BUILD_TYPE:
-    - Debug
-    - Release
-
-steps:
-  - name: linux-x64-gcc-build
-    image: art.uocat.com/docker/tqcq/cross:v1.0.1
-    commands:
-      - mkdir build 
-      - cmake -S. -Bbuild -DCMAKE_BUILD_TYPE=${BUILD_TYPE} -DTILE_BUILD_BENCHMARKS=ON -DTILE_BUILD_TESTS=ON
-      - cmake --build build -j $(nproc)
-
-  - name: linux-x64-gcc-test
-    image: art.uocat.com/docker/tqcq/cross:v1.0.1
-    commands:
-      - cd build
-      - ctest --output-on-failure -j $(nproc)
-
-  - name: linux-x64-gcc-benchmark
-    image: art.uocat.com/docker/tqcq/cross:v1.0.1
-    commands:
-      - ./build/bin/tile_bm_all
-
-
diff --git a/.woodpecker/linux-x86-gcc.yml.stop b/.woodpecker/linux-x86-gcc.yml.stop
deleted file mode 100644
index 80fbaf1..0000000
--- a/.woodpecker/linux-x86-gcc.yml.stop
+++ /dev/null
@@ -1,36 +0,0 @@
-when:
-  - event: 
-    - push
-    - pull_request 
-  - path:
-      include:
-        - ".woodpecker/linux-x86-gcc.yml"
-        - "cmake/**"
-        - "third_party/**"
-        - "tile/**"
-        - "CMakeLists.txt"
-matrix:
-  BUILD_TYPE:
-    - Debug
-    - Release
-
-steps:
-  - name: linux-x86-gcc-build
-    image: art.uocat.com/docker/tqcq/cross:v1.0.1
-    commands:
-      - mkdir build 
-      - cmake -S. -Bbuild -DCMAKE_BUILD_TYPE=${BUILD_TYPE} -DTILE_BUILD_BENCHMARKS=ON -DTILE_BUILD_TESTS=ON  -DCMAKE_TOOLCHAIN_FILE=./toolchains/host.gcc-m32.toolchain.cmake
-      - cmake --build build -j $(nproc)
-
-  - name: linux-x86-gcc-test
-    image: art.uocat.com/docker/tqcq/cross:v1.0.1
-    commands:
-      - cd build
-      - ctest --output-on-failure -j $(nproc)
-
-  - name: linux-x86-gcc-benchmark
-    image: art.uocat.com/docker/tqcq/cross:v1.0.1
-    commands:
-      - ./build/bin/tile_bm_all
-
-
diff --git a/tile/base/config/configurable.h b/tile/base/config/configurable.h
index 6dc3969..ddbca56 100644
--- a/tile/base/config/configurable.h
+++ b/tile/base/config/configurable.h
@@ -2,7 +2,7 @@
 #define TILE_BASE_CONFIG_CONFIGURABLE_H
 
 #pragma once
-#include "tile/base/string.h"
+#include "tile/base/slice.h"
 
 namespace tile {
 class Configurable {
diff --git a/tile/base/config/configuration.cc b/tile/base/config/configuration.cc
index 5e976e2..dd921b0 100644
--- a/tile/base/config/configuration.cc
+++ b/tile/base/config/configuration.cc
@@ -1,4 +1,6 @@
 #include "tile/base/config/configuration.h"
+
+#include "tile/base/string.h"
 #include "tile/base/thread/unique_lock.h"
 
 namespace tile {
diff --git a/tile/base/config/configuration.h b/tile/base/config/configuration.h
index a637de1..4484dad 100644
--- a/tile/base/config/configuration.h
+++ b/tile/base/config/configuration.h
@@ -5,7 +5,6 @@
 #include "tile/base/optional.h"
 #include "tile/base/ref_ptr.h"
 #include "tile/base/slice.h"
-#include "tile/base/string.h"
 #include "tile/base/thread/mutex.h"
 #include "tile/sigslot/sigslot.h"
 #include <cstdint>

From 0ff288d0bce2b350f82efe1f9c1228ba6d02eeea Mon Sep 17 00:00:00 2001
From: tqcq <99722391+tqcq@users.noreply.github.com>
Date: Fri, 23 Aug 2024 21:26:03 +0800
Subject: [PATCH 06/25] feat remove glog

---
 .clang-format           | 78 ++++++++++++++++++++++++++++++++
 tile/base/log/channel.h | 22 +++++++++
 tile/base/log/logger.h  | 11 +++++
 tile/base/log/message.h | 98 +++++++++++++++++++++++++++++++++++++++++
 4 files changed, 209 insertions(+)
 create mode 100644 .clang-format
 create mode 100644 tile/base/log/channel.h
 create mode 100644 tile/base/log/logger.h
 create mode 100644 tile/base/log/message.h

diff --git a/.clang-format b/.clang-format
new file mode 100644
index 0000000..6082673
--- /dev/null
+++ b/.clang-format
@@ -0,0 +1,78 @@
+# Generated from CLion C/C++ Code Style settings
+BinPackParameters: false
+BasedOnStyle: LLVM
+AccessModifierOffset: -4
+AlignArrayOfStructures: Left
+AlignAfterOpenBracket: Align
+AlignConsecutiveAssignments:
+  Enabled: true
+  AcrossEmptyLines: true
+  AcrossComments: false
+
+AlignOperands: DontAlign
+AllowAllArgumentsOnNextLine: false
+AllowAllConstructorInitializersOnNextLine: false
+AllowAllParametersOfDeclarationOnNextLine: false
+AllowShortBlocksOnASingleLine: Always
+AllowShortCaseLabelsOnASingleLine: false
+AllowShortFunctionsOnASingleLine: All
+AllowShortIfStatementsOnASingleLine: true
+AllowShortLambdasOnASingleLine: All
+AllowShortLoopsOnASingleLine: true
+AlwaysBreakTemplateDeclarations: Yes
+# 函数和返回类型分两行，方便阅读
+AlwaysBreakAfterReturnType: TopLevelDefinitions
+BreakBeforeBraces: Custom
+BraceWrapping:
+  AfterCaseLabel: false
+  AfterClass: false
+  AfterControlStatement: Never
+  AfterEnum: false
+  AfterFunction: true
+  AfterNamespace: false
+  AfterUnion: false
+  BeforeCatch: false
+  BeforeElse: false
+  IndentBraces: false
+  SplitEmptyFunction: false
+  SplitEmptyRecord: true
+BreakBeforeBinaryOperators: NonAssignment
+BreakBeforeTernaryOperators: true
+BreakConstructorInitializers: BeforeColon
+ConstructorInitializerAllOnOneLineOrOnePerLine: true
+BreakInheritanceList: BeforeColon
+ColumnLimit: 120
+CompactNamespaces: false
+ContinuationIndentWidth: 4
+EmptyLineBeforeAccessModifier: LogicalBlock
+SeparateDefinitionBlocks: Always
+IndentCaseLabels: false
+IndentPPDirectives: None
+IndentWidth: 4
+KeepEmptyLinesAtTheStartOfBlocks: true
+MaxEmptyLinesToKeep: 1
+NamespaceIndentation: None
+ObjCSpaceAfterProperty: false
+ObjCSpaceBeforeProtocolList: false
+PointerAlignment: Right
+ReflowComments: false
+SortIncludes: CaseSensitive
+SpaceAfterCStyleCast: true
+SpaceAfterLogicalNot: false
+SpaceAfterTemplateKeyword: false
+SpaceBeforeAssignmentOperators: true
+SpaceBeforeCpp11BracedList: false
+SpaceBeforeCtorInitializerColon: true
+SpaceBeforeInheritanceColon: true
+SpaceBeforeParens: ControlStatements
+SpaceBeforeRangeBasedForLoopColon: true
+SpaceInEmptyParentheses: false
+SpacesBeforeTrailingComments: 0
+SpacesInAngles: false
+SpacesInCStyleCastParentheses: false
+SpacesInContainerLiterals: false
+SpacesInParentheses: false
+SpacesInSquareBrackets: false
+TabWidth: 4
+UseTab: Never
+PenaltyIndentedWhitespace: 1
diff --git a/tile/base/log/channel.h b/tile/base/log/channel.h
new file mode 100644
index 0000000..a020502
--- /dev/null
+++ b/tile/base/log/channel.h
@@ -0,0 +1,22 @@
+#ifndef TILE_BASE_LOG_CHANNEL_H
+#define TILE_BASE_LOG_CHANNEL_H
+
+#pragma once
+
+#include "tile/base/config/configurable.h"
+#include "tile/base/ref_ptr.h"
+
+namespace tile {
+namespace log {
+class Channel : public Configurable, public RefCounted<Channel> {
+public:
+    void SetProperty(const Slice &name, const Slice &value) override;
+    std::string GetProperty(const Slice &name) const override;
+
+protected:
+    ~Channel() override;
+};
+}// namespace log
+};// namespace tile
+
+#endif// TILE_BASE_LOG_CHANNEL_H
diff --git a/tile/base/log/logger.h b/tile/base/log/logger.h
new file mode 100644
index 0000000..047d3c2
--- /dev/null
+++ b/tile/base/log/logger.h
@@ -0,0 +1,11 @@
+#ifndef TILE_BASE_LOG_LOGGER_H
+#define TILE_BASE_LOG_LOGGER_H
+
+#pragma once
+
+namespace tile {
+namespace log {
+class Logger {};
+}// namespace log
+}// namespace tile
+#endif// TILE_BASE_LOG_LOGGER_H
diff --git a/tile/base/log/message.h b/tile/base/log/message.h
new file mode 100644
index 0000000..4bd8355
--- /dev/null
+++ b/tile/base/log/message.h
@@ -0,0 +1,98 @@
+#ifndef TILE_BASE_LOG_MESSAGE_H
+#define TILE_BASE_LOG_MESSAGE_H
+
+#pragma once
+#include <cstdint>
+#include <map>
+#include <string>
+
+namespace tile {
+namespace log {
+class Message {
+public:
+    typedef std::map<std::string, std::string> StringMap;
+
+    enum Priority {
+        kTrace = 0,
+        kDebug,
+        kInfo,
+        kNotice,
+        kWarning,
+        kError,
+        kCritical,
+        kFatal,
+    };
+
+    Message();
+    Message(const Message &other);
+    Message(Message &&other) noexcept;
+    ~Message();
+
+    Message &operator=(const Message &other);
+    Message &operator=(Message &&other) noexcept;
+    void swap(Message &other);
+
+    // getter
+    inline const std::string &text() { return text_; }
+
+    inline const std::string &source() const { return source_; }
+
+    inline Priority priority() const { return priority_; }
+
+    inline const std::string &thread_name() const { return thread_name_; }
+
+    inline std::uint64_t tid() const { return tid_; }
+
+    inline std::uint64_t pid() const { return pid_; }
+
+    inline const char *source_file() const { return source_file_; }
+
+    inline int source_line() const { return source_line_; }
+
+    // setter
+    inline void set_text(const std::string &text) { text_ = text; }
+
+    inline void set_source(const std::string &source) { source_ = source; }
+
+    inline void set_priority(Priority priority) { priority_ = priority; }
+
+    inline void set_thread_name(const std::string &thread) { thread_name_ = thread; }
+
+    inline void set_tid(std::uint64_t tid) { tid_ = tid; }
+
+    inline void set_pid(std::uint64_t pid) { pid_ = pid; }
+
+    inline void set_source_file(const char *source_file) { source_file_ = source_file; }
+
+    inline void set_source_line(int source_line) { source_line_ = source_line; }
+
+    // map
+    const std::string &Get(const std::string &param) const;
+    const std::string &Get(const std::string &param, const std::string &defult_value) const;
+    const StringMap &GetAll() const;
+    void Set(const std::string &param, const std::string &value);
+    const std::string &operator[](const std::string &param) const;
+    std::string &operator[](const std::string &param);
+
+private:
+    std::string text_;
+    std::string source_;
+    Priority priority_;
+    std::string thread_name_;
+    std::uint64_t tid_;
+    std::uint64_t pid_;
+    const char *source_file_;
+    int source_line_;
+    StringMap properties_;
+};
+
+inline void
+swap(Message &lhs, Message &rhs)
+{
+    lhs.swap(rhs);
+}
+}// namespace log
+
+}// namespace tile
+
+#endif// TILE_BASE_LOG_MESSAGE_H

From dc2bb3567ba9bd0e0c23086fa6aa62b947515507 Mon Sep 17 00:00:00 2001
From: tqcq <99722391+tqcq@users.noreply.github.com>
Date: Fri, 23 Aug 2024 21:28:14 +0800
Subject: [PATCH 07/25] feat reinstall tools

---
 .gitea/workflows/linux-aarch64-gcc.yml | 12 ++++++------
 .gitea/workflows/linux-arm-gcc.yml     | 16 ++++++++--------
 .gitea/workflows/linux-mips-gcc.yml    | 12 ++++++------
 .gitea/workflows/linux-mips64-gcc.yml  | 12 ++++++------
 .gitea/workflows/linux-riscv64-gcc.yml | 12 ++++++------
 .gitea/workflows/linux-x64-clang.yml   |  8 ++++----
 .gitea/workflows/linux-x64-gcc.yml     |  8 ++++----
 7 files changed, 40 insertions(+), 40 deletions(-)

diff --git a/.gitea/workflows/linux-aarch64-gcc.yml b/.gitea/workflows/linux-aarch64-gcc.yml
index cb9514b..7102486 100644
--- a/.gitea/workflows/linux-aarch64-gcc.yml
+++ b/.gitea/workflows/linux-aarch64-gcc.yml
@@ -38,10 +38,10 @@ jobs:
       - uses: actions/checkout@v4
         with:
           submodules: recursive
-      # - name: install-tools
-      #   run: |
-      #     sudo apt-get update -y
-      #     sudo apt-get install -y g++-aarch64-linux-gnu qemu-user-binfmt
+      - name: install-tools
+        run: |
+          sudo apt-get update -y
+          sudo apt-get install -y g++-aarch64-linux-gnu qemu-user-binfmt
       - name: configure
         run: |
           mkdir build && cd build
@@ -53,6 +53,6 @@ jobs:
       - name: test
         run: |-
           cd build
-          # sudo ln -sf /usr/aarch64-linux-gnu/lib/ld-linux-aarch64.so.1 /lib/ld-linux-aarch64.so.1 
-          # export LD_LIBRARY_PATH=/usr/aarch64-linux-gnu/lib
+          sudo ln -sf /usr/aarch64-linux-gnu/lib/ld-linux-aarch64.so.1 /lib/ld-linux-aarch64.so.1 
+          export LD_LIBRARY_PATH=/usr/aarch64-linux-gnu/lib
           ctest --output-on-failure -j $(nproc)
diff --git a/.gitea/workflows/linux-arm-gcc.yml b/.gitea/workflows/linux-arm-gcc.yml
index 24506b0..3b5cc01 100644
--- a/.gitea/workflows/linux-arm-gcc.yml
+++ b/.gitea/workflows/linux-arm-gcc.yml
@@ -36,10 +36,10 @@ jobs:
         build_type: ["Debug", "Release"]
     steps:
       - uses: actions/checkout@v4
-      # - name: install-tools
-      #   run: |
-      #     sudo apt-get update -y
-      #     sudo apt-get install -y g++-arm-linux-gnueabi qemu-user-binfmt
+      - name: install-tools
+        run: |
+          sudo apt-get update -y
+          sudo apt-get install -y g++-arm-linux-gnueabi qemu-user-binfmt
       - name: configure
         run: |
           mkdir build && cd build
@@ -51,8 +51,8 @@ jobs:
       - name: test
         run: |
           cd build
-          #sudo ln -sf /usr/arm-linux-gnueabi/lib/ld-linux.so.3 /lib/ld-linux.so.3
-          #export LD_LIBRARY_PATH=/usr/arm-linux-gnueabi/lib
+          sudo ln -sf /usr/arm-linux-gnueabi/lib/ld-linux.so.3 /lib/ld-linux.so.3
+          export LD_LIBRARY_PATH=/usr/arm-linux-gnueabi/lib
           ctest --output-on-failure -j $(nproc)
 
   linux-gcc-armhf:
@@ -79,6 +79,6 @@ jobs:
       - name: test
         run: |-
           cd build
-          # sudo ln -sf /usr/arm-linux-gnueabihf/lib/ld-linux-armhf.so.3 /lib/ld-linux-armhf.so.3
-          #export LD_LIBRARY_PATH=/usr/arm-linux-gnueabihf/lib/
+          sudo ln -sf /usr/arm-linux-gnueabihf/lib/ld-linux-armhf.so.3 /lib/ld-linux-armhf.so.3
+          export LD_LIBRARY_PATH=/usr/arm-linux-gnueabihf/lib/
           ctest --output-on-failure -j $(nproc)
diff --git a/.gitea/workflows/linux-mips-gcc.yml b/.gitea/workflows/linux-mips-gcc.yml
index 3b191b3..c59edef 100644
--- a/.gitea/workflows/linux-mips-gcc.yml
+++ b/.gitea/workflows/linux-mips-gcc.yml
@@ -35,10 +35,10 @@ jobs:
       - uses: actions/checkout@v4
         with:
           submodules: recursive
-      # - name: install-tools
-      #   run: |
-      #     sudo apt-get update -y
-      #     sudo apt-get install -y g++-mipsel-linux-gnu qemu-user-binfmt
+      - name: install-tools
+        run: |
+          sudo apt-get update -y
+          sudo apt-get install -y g++-mipsel-linux-gnu qemu-user-binfmt
       - name: configure
         run: |
           mkdir build && cd build
@@ -48,6 +48,6 @@ jobs:
       - name: test
         run: |-
           cd build 
-          # sudo ln -sf /usr/mipsel-linux-gnu/lib/ld.so.1 /lib/ld.so.1
-          # export LD_LIBRARY_PATH=/usr/mipsel-linux-gnu/lib/
+          sudo ln -sf /usr/mipsel-linux-gnu/lib/ld.so.1 /lib/ld.so.1
+          export LD_LIBRARY_PATH=/usr/mipsel-linux-gnu/lib/
           ctest --output-on-failure -j $(nproc)
diff --git a/.gitea/workflows/linux-mips64-gcc.yml b/.gitea/workflows/linux-mips64-gcc.yml
index 96d82c5..a199aa9 100644
--- a/.gitea/workflows/linux-mips64-gcc.yml
+++ b/.gitea/workflows/linux-mips64-gcc.yml
@@ -36,10 +36,10 @@ jobs:
       - uses: actions/checkout@v4
         with:
           submodules: recursive
-      # - name: install-tools
-      #   run: |
-      #     sudo apt-get update -y
-      #     sudo apt-get install -y g++-mips64el-linux-gnuabi64 qemu-user-binfmt
+      - name: install-tools
+        run: |
+          sudo apt-get update -y
+          sudo apt-get install -y g++-mips64el-linux-gnuabi64 qemu-user-binfmt
       - name: configure
         run: |
           mkdir build && cd build
@@ -49,6 +49,6 @@ jobs:
       - name: test
         run: |-
           cd build 
-          # sudo ln -sf /usr/mips64el-linux-gnuabi64/lib64/ld.so.1 /lib64/ld.so.1
-          # export LD_LIBRARY_PATH=/usr/mips64el-linux-gnuabi64/lib
+          sudo ln -sf /usr/mips64el-linux-gnuabi64/lib64/ld.so.1 /lib64/ld.so.1
+          export LD_LIBRARY_PATH=/usr/mips64el-linux-gnuabi64/lib
           ctest --output-on-failure -j $(nproc)
diff --git a/.gitea/workflows/linux-riscv64-gcc.yml b/.gitea/workflows/linux-riscv64-gcc.yml
index 61a829b..9e8be76 100644
--- a/.gitea/workflows/linux-riscv64-gcc.yml
+++ b/.gitea/workflows/linux-riscv64-gcc.yml
@@ -37,10 +37,10 @@ jobs:
       - uses: actions/checkout@v4
         with:
           submodules: recursive
-      # - name: install-tools
-      #   run: |
-      #     sudo apt-get update -y
-      #     sudo apt-get install -y g++-riscv64-linux-gnu qemu-user-binfmt
+      - name: install-tools
+        run: |
+          sudo apt-get update -y
+          sudo apt-get install -y g++-riscv64-linux-gnu qemu-user-binfmt
       - name: configure
         run: |
           mkdir build && cd build
@@ -50,6 +50,6 @@ jobs:
       - name: test
         run: |-
           cd build 
-          # sudo ln -sf /usr/riscv64-linux-gnu/lib/ld-linux-riscv64-lp64d.so.1 /lib/ld-linux-riscv64-lp64d.so.1
-          # export LD_LIBRARY_PATH=/usr/riscv64-linux-gnu/lib
+          sudo ln -sf /usr/riscv64-linux-gnu/lib/ld-linux-riscv64-lp64d.so.1 /lib/ld-linux-riscv64-lp64d.so.1
+          export LD_LIBRARY_PATH=/usr/riscv64-linux-gnu/lib
           ctest --output-on-failure -j $(nproc)
diff --git a/.gitea/workflows/linux-x64-clang.yml b/.gitea/workflows/linux-x64-clang.yml
index 68373d5..0f282d0 100644
--- a/.gitea/workflows/linux-x64-clang.yml
+++ b/.gitea/workflows/linux-x64-clang.yml
@@ -29,10 +29,10 @@ jobs:
       - uses: actions/checkout@v4
         with:
           submodules: recursive
-      # - name: install-tools
-      #   run: |
-      #     sudo apt-get update -y
-      #     sudo apt-get install -y cmake make
+      - name: install-tools
+        run: |
+          sudo apt-get update -y
+          sudo apt-get install -y cmake make
       - name: configure
         env: 
           CC: clang
diff --git a/.gitea/workflows/linux-x64-gcc.yml b/.gitea/workflows/linux-x64-gcc.yml
index 0751dc1..752dcbd 100644
--- a/.gitea/workflows/linux-x64-gcc.yml
+++ b/.gitea/workflows/linux-x64-gcc.yml
@@ -33,10 +33,10 @@ jobs:
       - uses: actions/checkout@v4
         with:
           submodules: recursive
-      # - name: install-tools
-      #   run: |
-      #     sudo apt-get update -y
-      #     sudo apt-get install -y cmake make
+      - name: install-tools
+        run: |
+          sudo apt-get update -y
+          sudo apt-get install -y cmake make
       - name: configure
         run: |
           mkdir build && cd build

From 64200d42cc09ad2e017c055fa53b6f810aff6ca8 Mon Sep 17 00:00:00 2001
From: tqcq <99722391+tqcq@users.noreply.github.com>
Date: Fri, 23 Aug 2024 21:33:20 +0800
Subject: [PATCH 08/25] fix install cmake make

---
 .gitea/workflows/linux-aarch64-gcc.yml | 2 +-
 .gitea/workflows/linux-mips-gcc.yml    | 2 +-
 .gitea/workflows/linux-mips64-gcc.yml  | 2 +-
 .gitea/workflows/linux-riscv64-gcc.yml | 2 +-
 .gitea/workflows/linux-x86-gcc.yml     | 2 +-
 5 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/.gitea/workflows/linux-aarch64-gcc.yml b/.gitea/workflows/linux-aarch64-gcc.yml
index 7102486..415d7fe 100644
--- a/.gitea/workflows/linux-aarch64-gcc.yml
+++ b/.gitea/workflows/linux-aarch64-gcc.yml
@@ -41,7 +41,7 @@ jobs:
       - name: install-tools
         run: |
           sudo apt-get update -y
-          sudo apt-get install -y g++-aarch64-linux-gnu qemu-user-binfmt
+          sudo apt-get install -y cmake make g++-aarch64-linux-gnu qemu-user-binfmt
       - name: configure
         run: |
           mkdir build && cd build
diff --git a/.gitea/workflows/linux-mips-gcc.yml b/.gitea/workflows/linux-mips-gcc.yml
index c59edef..c281183 100644
--- a/.gitea/workflows/linux-mips-gcc.yml
+++ b/.gitea/workflows/linux-mips-gcc.yml
@@ -38,7 +38,7 @@ jobs:
       - name: install-tools
         run: |
           sudo apt-get update -y
-          sudo apt-get install -y g++-mipsel-linux-gnu qemu-user-binfmt
+          sudo apt-get install -y cmake make g++-mipsel-linux-gnu qemu-user-binfmt
       - name: configure
         run: |
           mkdir build && cd build
diff --git a/.gitea/workflows/linux-mips64-gcc.yml b/.gitea/workflows/linux-mips64-gcc.yml
index a199aa9..4531e39 100644
--- a/.gitea/workflows/linux-mips64-gcc.yml
+++ b/.gitea/workflows/linux-mips64-gcc.yml
@@ -39,7 +39,7 @@ jobs:
       - name: install-tools
         run: |
           sudo apt-get update -y
-          sudo apt-get install -y g++-mips64el-linux-gnuabi64 qemu-user-binfmt
+          sudo apt-get install -y cmake make g++-mips64el-linux-gnuabi64 qemu-user-binfmt
       - name: configure
         run: |
           mkdir build && cd build
diff --git a/.gitea/workflows/linux-riscv64-gcc.yml b/.gitea/workflows/linux-riscv64-gcc.yml
index 9e8be76..b7fa618 100644
--- a/.gitea/workflows/linux-riscv64-gcc.yml
+++ b/.gitea/workflows/linux-riscv64-gcc.yml
@@ -40,7 +40,7 @@ jobs:
       - name: install-tools
         run: |
           sudo apt-get update -y
-          sudo apt-get install -y g++-riscv64-linux-gnu qemu-user-binfmt
+          sudo apt-get install -y cmake make g++-riscv64-linux-gnu qemu-user-binfmt
       - name: configure
         run: |
           mkdir build && cd build
diff --git a/.gitea/workflows/linux-x86-gcc.yml b/.gitea/workflows/linux-x86-gcc.yml
index 76d1b77..19710af 100644
--- a/.gitea/workflows/linux-x86-gcc.yml
+++ b/.gitea/workflows/linux-x86-gcc.yml
@@ -38,7 +38,7 @@ jobs:
       - name: install-tools
         run: |
           sudo apt-get update -y
-          sudo apt-get install -y gcc-multilib g++-multilib
+          sudo apt-get install -y cmake make gcc-multilib g++-multilib
       - name: configure
         run: |
           mkdir build && cd build

From 481015e1c699a5f1c2fe7105404974f7bb94ba14 Mon Sep 17 00:00:00 2001
From: tqcq <99722391+tqcq@users.noreply.github.com>
Date: Fri, 23 Aug 2024 21:40:44 +0800
Subject: [PATCH 09/25] feat format file

---
 .gitea/workflows/linux-x64-clang.yml          |    2 +-
 tile/base/align.h                             |   16 +-
 tile/base/buffer.cc                           |  410 +-
 tile/base/buffer.h                            |  547 ++-
 tile/base/buffer/builtin_buffer_block.cc      |  152 +-
 tile/base/buffer/builtin_buffer_block.h       |   36 +-
 tile/base/buffer/circular_buffer.h            |   84 +-
 tile/base/buffer/compression_output_stream.cc |   63 +-
 tile/base/buffer/compression_output_stream.h  |   22 +-
 tile/base/buffer/polymorphic_buffer.cc        |   18 +-
 tile/base/buffer/polymorphic_buffer.h         |  155 +-
 tile/base/buffer_test.cc                      |  477 +-
 tile/base/byte_order.h                        |   88 +-
 tile/base/byte_order_test.cc                  |  126 +-
 tile/base/casting.h                           |  262 +-
 tile/base/casting_benchmark.cc                |   49 +-
 tile/base/casting_test.cc                     |  108 +-
 tile/base/chrono.cc                           |  206 +-
 tile/base/chrono.h                            |   37 +-
 tile/base/chrono_benchmark.cc                 |   68 +-
 tile/base/chrono_test.cc                      |   56 +-
 tile/base/compression.cc                      |  149 +-
 tile/base/compression.h                       |   25 +-
 tile/base/compression/compression.cc          |   42 +-
 tile/base/compression/compression.h           |   55 +-
 tile/base/compression/gzip.cc                 |  426 +-
 tile/base/compression/gzip.h                  |   45 +-
 tile/base/compression/util.cc                 |   54 +-
 tile/base/compression/util.h                  |    7 +-
 tile/base/compression/util_test.cc            |   25 +-
 tile/base/compression_test.cc                 |   97 +-
 tile/base/config/configurable.h               |   12 +-
 tile/base/config/configuration.cc             |  168 +-
 tile/base/config/configuration.h              |  176 +-
 tile/base/config/ini_file_configuration.cc    |  249 +-
 tile/base/config/ini_file_configuration.h     |   44 +-
 .../config/ini_file_configuration_test.cc     |   46 +-
 tile/base/config/json_configuration.cc        |  236 +-
 tile/base/config/json_configuration.h         |   57 +-
 tile/base/config/json_configuration_test.cc   |  136 +-
 tile/base/config/layered_configuration.cc     |  216 +-
 tile/base/config/layered_configuration.h      |   67 +-
 tile/base/configuration.h                     |    2 +-
 tile/base/data.h                              |    2 +-
 tile/base/data/json.h                         |   42 +-
 tile/base/deferred.h                          |   67 +-
 tile/base/deferred_test.cc                    |   78 +-
 tile/base/demangle.cc                         |   20 +-
 tile/base/demangle.h                          |   18 +-
 tile/base/demangle_test.cc                    |   18 +-
 tile/base/dependency_registry.h               |  302 +-
 tile/base/dependency_registry_test.cc         |   95 +-
 tile/base/down_cast.h                         |   26 +-
 tile/base/down_cast_test.cc                   |   25 +-
 tile/base/encoding.h                          |    2 +-
 tile/base/encoding/base64.cc                  |  241 +-
 tile/base/encoding/base64.h                   |    4 +-
 tile/base/encoding/base64_test.cc             |  125 +-
 tile/base/encoding/detail/base64_impl.h       |  425 +-
 tile/base/encoding/detail/hex_chars.cc        |  126 +-
 tile/base/encoding/detail/hex_chars.h         |   11 +-
 tile/base/encoding/hex.cc                     |   71 +-
 tile/base/encoding/hex.h                      |    4 +-
 tile/base/encoding/hex_test.cc                |   34 +-
 tile/base/encoding/percent.cc                 |  175 +-
 tile/base/encoding/percent.h                  |   32 +-
 tile/base/encoding/percent_test.cc            |  160 +-
 tile/base/encoding_benchmark.cc               |  139 +-
 tile/base/enum.h                              |   52 +-
 tile/base/erased_ptr.h                        |   97 +-
 tile/base/expected.h                          | 4305 ++++++++---------
 tile/base/exposed_var.cc                      |  419 +-
 tile/base/exposed_var.h                       |  237 +-
 tile/base/exposed_var_test.cc                 |   43 +-
 tile/base/future.h                            |    4 +-
 tile/base/future/basic.h                      |  109 +-
 tile/base/future/boxed.h                      |  226 +-
 tile/base/future/boxed_test.cc                |   93 +-
 tile/base/future/core.h                       |  127 +-
 tile/base/future/executor.h                   |  135 +-
 tile/base/future/future-impl.h                |  172 +-
 tile/base/future/future.h                     |   93 +-
 tile/base/future/future_test.cc               |  475 +-
 tile/base/future/impls.h                      |   69 +-
 tile/base/future/promise-impl.h               |   42 +-
 tile/base/future/promise.h                    |   48 +-
 tile/base/future/split.h                      |   68 +-
 tile/base/future/types.h                      |   91 +-
 tile/base/future/utils.h                      |  203 +-
 tile/base/future/when_all.h                   |  292 +-
 tile/base/future/when_any.h                   |   89 +-
 tile/base/handle.h                            |  123 +-
 tile/base/handle_test.cc                      |   36 +-
 tile/base/id_alloc.h                          |  106 +-
 tile/base/internal/background_task_host.cc    |   67 +-
 tile/base/internal/background_task_host.h     |   22 +-
 .../internal/background_task_host_test.cc     |   33 +-
 .../base/internal/case_insensitive_hash_map.h |   36 +-
 .../case_insensitive_hash_map_test.cc         |   27 +-
 tile/base/internal/curl.cc                    |  204 +-
 tile/base/internal/curl.h                     |   27 +-
 tile/base/internal/curl_test.cc               |  172 +-
 tile/base/internal/early_init.h               |   22 +-
 tile/base/internal/format.h                   |  124 +-
 tile/base/internal/format_test.cc             |   58 +-
 tile/base/internal/index_alloc.cc             |   30 +-
 tile/base/internal/index_alloc.h              |   32 +-
 tile/base/internal/lazy_init.h                |   24 +-
 tile/base/internal/logging.cc                 |  290 +-
 tile/base/internal/logging.h                  |  820 ++--
 tile/base/internal/logging_test.cc            |  143 +-
 tile/base/internal/macro.h                    |   38 +-
 tile/base/internal/macro_inl.h                |    2 +-
 tile/base/internal/meta.h                     |  154 +-
 tile/base/internal/meta/apply.h               |  121 +-
 tile/base/internal/meta/base.h                |   18 +-
 tile/base/internal/meta/index_sequence.h      |   52 +-
 tile/base/internal/meta/invoke.h              |  336 +-
 tile/base/internal/meta_test.cc               |   94 +-
 tile/base/internal/move_on_copy.h             |   87 +-
 tile/base/internal/move_on_copy_test.cc       |   77 +-
 tile/base/internal/mutex.h                    |  296 +-
 tile/base/internal/optional.h                 | 3044 ++++++------
 tile/base/internal/singly_linked_list.h       |  416 +-
 tile/base/internal/singly_linked_list_test.cc |  251 +-
 tile/base/internal/test_prod.h                |    7 +-
 tile/base/internal/thread_pool.cc             |  113 +-
 tile/base/internal/thread_pool.h              |   29 +-
 tile/base/internal/thread_pool_test.cc        |   41 +-
 tile/base/internal/time_keeper.cc             |  214 +-
 tile/base/internal/time_keeper.h              |  119 +-
 tile/base/internal/time_keeper_benchmark.cc   |   60 +-
 tile/base/internal/time_keeper_test.cc        |   66 +-
 tile/base/internal/utility.h                  |   25 +-
 tile/base/internal/variant.h                  | 3521 +++++++-------
 tile/base/likely.h                            |    2 +-
 tile/base/logging.h                           |    2 +-
 tile/base/make_unique.h                       |   65 +-
 tile/base/maybe_owning.h                      |  213 +-
 tile/base/maybe_owning_test.cc                |  296 +-
 tile/base/net/detail/android/ifaddrs.h        |    2 +-
 tile/base/net/endpoint.cc                     |  724 +--
 tile/base/net/endpoint.h                      |  175 +-
 tile/base/net/endpoint_test.cc                |  280 +-
 tile/base/net/uri.h                           |   71 +-
 tile/base/never_destroyed.h                   |   74 +-
 tile/base/object_pool.h                       |  302 +-
 tile/base/object_pool/disabled.cc             |   22 +-
 tile/base/object_pool/disabled.h              |   10 +-
 tile/base/object_pool/disabled_test.cc        |   33 +-
 tile/base/object_pool/global.cc               |   24 +-
 tile/base/object_pool/global.h                |   10 +-
 tile/base/object_pool/thread_local.cc         |  159 +-
 tile/base/object_pool/thread_local.h          |   64 +-
 tile/base/object_pool/thread_local_test.cc    |  153 +-
 tile/base/object_pool/types.h                 |  336 +-
 tile/base/object_pool/types_test.cc           |  168 +-
 tile/base/option.cc                           |   32 +-
 tile/base/option.h                            |  152 +-
 tile/base/option/dynamically_changed.h        |   38 +-
 tile/base/option/gflags_provider.cc           |   72 +-
 tile/base/option/json_parser.cc               |   22 +-
 tile/base/option/json_parser.h                |    8 +-
 tile/base/option/json_parser_test.cc          |   15 +-
 tile/base/option/key.cc                       |   95 +-
 tile/base/option/key.h                        |  161 +-
 tile/base/option/key_test.cc                  |   49 +-
 tile/base/option/option_impl.h                |  131 +-
 tile/base/option/option_provider.cc           |    3 +-
 tile/base/option/option_provider.h            |   71 +-
 tile/base/option/option_service.cc            |  294 +-
 tile/base/option/option_service.h             |  142 +-
 tile/base/option/option_service_test.cc       |   25 +-
 tile/base/optional.h                          |    3 +-
 tile/base/random.h                            |   55 +-
 tile/base/ref_ptr.h                           |  392 +-
 tile/base/ref_ptr_test.cc                     |  221 +-
 tile/base/slice.cc                            |   17 +-
 tile/base/slice.h                             |  330 +-
 tile/base/status.cc                           |   46 +-
 tile/base/status.h                            |   39 +-
 tile/base/status_test.cc                      |   47 +-
 tile/base/string.cc                           |  599 +--
 tile/base/string.h                            |   93 +-
 tile/base/string_test.cc                      |  501 +-
 tile/base/thread/cond_var.cc                  |   80 +-
 tile/base/thread/cond_var.h                   |  172 +-
 tile/base/thread/cond_var_test.cc             |  203 +-
 tile/base/thread/event.h                      |   91 +-
 tile/base/thread/latch.cc                     |   49 +-
 tile/base/thread/latch.h                      |   47 +-
 tile/base/thread/latch_test.cc                |   94 +-
 tile/base/thread/mutex.cc                     |   75 +-
 tile/base/thread/mutex.h                      |   46 +-
 tile/base/thread/mutex_benchmark.cc           |   85 +-
 tile/base/thread/rw_mutex.cc                  |  222 +-
 tile/base/thread/rw_mutex.h                   |   69 +-
 tile/base/thread/scoped_lock.cc               |  130 +-
 tile/base/thread/scoped_lock.h                |  136 +-
 tile/base/thread/scoped_lock_test.cc          |  665 +--
 tile/base/thread/spinlock.cc                  |   22 +-
 tile/base/thread/spinlock.h                   |   25 +-
 tile/base/thread/spinlock_test.cc             |   41 +-
 tile/base/thread/thread_local.h               |    2 +-
 tile/base/thread/thread_local/object_array.h  |    2 +-
 tile/base/thread/unique_lock.h                |   66 +-
 tile/base/thread/unique_lock_test.cc          |   85 +-
 tile/base/type_index.h                        |   60 +-
 tile/base/variant.h                           |    3 +-
 tile/base/write_mostly/metrics.h              |   31 +-
 tile/base/write_mostly/write_mostly.h         |    9 +-
 tile/init.cc                                  |  140 +-
 tile/init.h                                   |   11 +-
 tile/init/on_init.cc                          |  124 +-
 tile/init/on_init.h                           |   44 +-
 tile/init/on_init_test.cc                     |    8 +-
 tile/init/override_flag.cc                    |   58 +-
 tile/init/override_flag.h                     |   43 +-
 tile/init/override_flag_test.cc               |    4 +-
 tile/io/acceptor.h                            |   10 +-
 tile/io/descriptor.cc                         |  505 +-
 tile/io/descriptor.h                          |  122 +-
 tile/io/detail/eintr_safe.cc                  |   34 +-
 tile/io/detail/eintr_safe.h                   |   69 +-
 tile/io/event_loop.cc                         |   72 +-
 tile/io/event_loop.h                          |   42 +-
 tile/io/native/acceptor.cc                    |   91 +-
 tile/io/native/acceptor.h                     |   26 +-
 tile/io/util/rate_limiter.cc                  |  123 +-
 tile/io/util/rate_limiter.h                   |   63 +-
 tile/io/util/rate_limiter_test.cc             |  311 +-
 tile/net/http/http_client.cc                  |  934 ++--
 tile/net/http/http_client.h                   |  215 +-
 tile/net/http/http_client_test.cc             |   82 +-
 tile/net/http/http_headers.cc                 |  229 +-
 tile/net/http/http_headers.h                  |  118 +-
 tile/net/http/http_headers_test.cc            |   88 +-
 tile/net/http/http_message.cc                 |   20 +-
 tile/net/http/http_message.h                  |   91 +-
 tile/net/http/http_reqeust_test.cc            |  150 +-
 tile/net/http/http_request.cc                 |   44 +-
 tile/net/http/http_request.h                  |   36 +-
 tile/net/http/http_response.cc                |  251 +-
 tile/net/http/http_response.h                 |   32 +-
 tile/net/http/http_response_test.cc           |  110 +-
 tile/net/http/packet_desc.h                   |    6 +-
 tile/net/http/types.cc                        |  237 +-
 tile/net/http/types.h                         |  138 +-
 tile/net/internal/http_engine.cc              |  527 +-
 tile/net/internal/http_engine.h               |   20 +-
 tile/net/internal/http_engine_test.cc         |   46 +-
 tile/net/internal/http_task.cc                |  358 +-
 tile/net/internal/http_task.h                 |  109 +-
 tile/net/internal/http_task_test.cc           |   30 +-
 tile/rpc/protocol/http/buffer_io.cc           |  460 +-
 tile/rpc/protocol/http/buffer_io.h            |   18 +-
 tile/rpc/protocol/http/buffer_io_test.cc      |  387 +-
 tile/rpc/protocol/message.cc                  |   15 +-
 tile/rpc/protocol/message.h                   |   39 +-
 tile/rpc/server.cc                            |   45 +-
 tile/rpc/server.h                             |  151 +-
 tile/sigslot/sigslot.h                        | 2296 +++++----
 tile/testing/bm_main.h                        |   12 +-
 tile/testing/internal/random_string.cc        |    8 +-
 tile/testing/internal/random_string.h         |   79 +-
 tile/testing/main.cc                          |   18 +-
 tile/testing/main.h                           |   12 +-
 tile/tile.h                                   |    2 +-
 268 files changed, 23084 insertions(+), 22201 deletions(-)

diff --git a/.gitea/workflows/linux-x64-clang.yml b/.gitea/workflows/linux-x64-clang.yml
index 0f282d0..639234c 100644
--- a/.gitea/workflows/linux-x64-clang.yml
+++ b/.gitea/workflows/linux-x64-clang.yml
@@ -32,7 +32,7 @@ jobs:
       - name: install-tools
         run: |
           sudo apt-get update -y
-          sudo apt-get install -y cmake make
+          sudo apt-get install -y cmake make clang-tools
       - name: configure
         env: 
           CC: clang
diff --git a/tile/base/align.h b/tile/base/align.h
index 05d498c..7adbbd8 100644
--- a/tile/base/align.h
+++ b/tile/base/align.h
@@ -15,19 +15,19 @@ constexpr std::size_t max_align_v = alignof(max_align_t);
 // @sa: https://github.com/facebook/folly/blob/master/folly/lang/Align.h
 //
 // Update at 20201124: Well, AMD's Zen 3 does the same.
-constexpr std::size_t hardware_destructive_interference_size = 128;
+constexpr std::size_t hardware_destructive_interference_size  = 128;
 constexpr std::size_t hardware_constructive_interference_size = 64;
 
 #elif defined(__powerpc64__)
 
 // These values are read from
 // `/sys/devices/system/cpu/cpu0/cache/index*/coherency_line_size`
-constexpr std::size_t hardware_destructive_interference_size = 128;
+constexpr std::size_t hardware_destructive_interference_size  = 128;
 constexpr std::size_t hardware_constructive_interference_size = 128;
 
 #elif defined(__ARM_ARCH_5T__)
 
-constexpr std::size_t hardware_destructive_interference_size = 32;
+constexpr std::size_t hardware_destructive_interference_size  = 32;
 constexpr std::size_t hardware_constructive_interference_size = 32;
 
 #elif defined(__arm__)
@@ -36,7 +36,7 @@ constexpr std::size_t hardware_constructive_interference_size = 32;
 // are even implementations with cache line sizes configurable at boot
 // time.
 
-constexpr std::size_t hardware_destructive_interference_size = 64;
+constexpr std::size_t hardware_destructive_interference_size  = 64;
 constexpr std::size_t hardware_constructive_interference_size = 64;
 
 #elif defined(__aarch64__)
@@ -47,13 +47,13 @@ constexpr std::size_t hardware_constructive_interference_size = 64;
 // Let's ignore those CPUs for now.
 //
 // @sa: https://www.mono-project.com/news/2016/09/12/arm64-icache/
-constexpr std::size_t hardware_destructive_interference_size = 64;
+constexpr std::size_t hardware_destructive_interference_size  = 64;
 constexpr std::size_t hardware_constructive_interference_size = 64;
 
 #else
 
 constexpr std::size_t hardware_constructive_interference_size = max_align_v;
-constexpr std::size_t hardware_destructive_interference_size = max_align_v;
+constexpr std::size_t hardware_destructive_interference_size  = max_align_v;
 // #error Unsupported architecture.
 // #pragma message("Unsupported architecture, use max_align_v")
 
@@ -62,6 +62,6 @@ static_assert(hardware_constructive_interference_size >= max_align_v,
               "hardware constructive interference size is too small");
 static_assert(hardware_destructive_interference_size >= max_align_v,
               "hardware destructive interference size is too small");
-} // namespace tile
+}// namespace tile
 
-#endif // _TILE_BASE_ALIGN_H
+#endif// _TILE_BASE_ALIGN_H
diff --git a/tile/base/buffer.cc b/tile/base/buffer.cc
index 3eb688d..a7fbd5e 100644
--- a/tile/base/buffer.cc
+++ b/tile/base/buffer.cc
@@ -9,205 +9,214 @@
 
 namespace tile {
 namespace {
-template <typename T> class OwningBufferBlock : public PolymorphicBufferBlock {
+template<typename T>
+class OwningBufferBlock : public PolymorphicBufferBlock {
 public:
-  explicit OwningBufferBlock(T storage) : storage_(std::move(storage)) {}
-  const char *data() const noexcept override {
-    return reinterpret_cast<const char *>(storage_.data());
-  }
+    explicit OwningBufferBlock(T storage) : storage_(std::move(storage)) {}
 
-  std::size_t size() const noexcept override { return storage_.size(); }
+    const char *data() const noexcept override { return reinterpret_cast<const char *>(storage_.data()); }
+
+    std::size_t size() const noexcept override { return storage_.size(); }
 
 private:
-  T storage_;
+    T storage_;
 };
-} // namespace
+}// namespace
 
 namespace detail {
-void FlattenToSlowSlow(const NoncontiguousBuffer &nb, void *buffer,
-                       std::size_t size) {
-  TILE_CHECK_GT(nb.ByteSize(), size, "No enough data");
-  std::size_t copied = 0;
-  for (auto iter = nb.begin(); iter != nb.end() && copied != size; ++iter) {
-    auto len = std::min(size - copied, iter->size());
-    memcpy(reinterpret_cast<char *>(buffer) + copied, iter->data(), len);
-    copied += len;
-  }
+void
+FlattenToSlowSlow(const NoncontiguousBuffer &nb, void *buffer, std::size_t size)
+{
+    TILE_CHECK_GT(nb.ByteSize(), size, "No enough data");
+    std::size_t copied = 0;
+    for (auto iter = nb.begin(); iter != nb.end() && copied != size; ++iter) {
+        auto len = std::min(size - copied, iter->size());
+        memcpy(reinterpret_cast<char *>(buffer) + copied, iter->data(), len);
+        copied += len;
+    }
 }
-} // namespace detail
+}// namespace detail
 
-NoncontiguousBuffer::NoncontiguousBuffer(const NoncontiguousBuffer &other)
-    : byte_size_(other.byte_size_) {
-  for (auto &&e : other.buffers_) {
+NoncontiguousBuffer::NoncontiguousBuffer(const NoncontiguousBuffer &other) : byte_size_(other.byte_size_)
+{
+    for (auto &&e : other.buffers_) {
 
-    auto b = object_pool::Get<NoncontiguousBuffer::buffer_t>().Leak();
-    *b = e;
-    buffers_.push_back(std::move(b));
-  }
+        auto b = object_pool::Get<NoncontiguousBuffer::buffer_t>().Leak();
+        *b     = e;
+        buffers_.push_back(std::move(b));
+    }
 }
 
 NoncontiguousBuffer &
-NoncontiguousBuffer::operator=(const NoncontiguousBuffer &other) {
-  if (TILE_UNLIKELY(&other == this)) {
+NoncontiguousBuffer::operator=(const NoncontiguousBuffer &other)
+{
+    if (TILE_UNLIKELY(&other == this)) { return *this; }
+
+    Clear();
+    byte_size_ = other.byte_size_;
+    for (auto &&e : other.buffers_) {
+
+        auto b = object_pool::Get<NoncontiguousBuffer::buffer_t>().Leak();
+        *b     = e;
+        buffers_.push_back(std::move(b));
+    }
     return *this;
-  }
-
-  Clear();
-  byte_size_ = other.byte_size_;
-  for (auto &&e : other.buffers_) {
-
-    auto b = object_pool::Get<NoncontiguousBuffer::buffer_t>().Leak();
-    *b = e;
-    buffers_.push_back(std::move(b));
-  }
-  return *this;
 }
 
-void NoncontiguousBuffer::SkipSlow(std::size_t bytes) noexcept {
-  TILE_CHECK_LE(bytes, byte_size_, "Skip bytes exceed buffer size");
-  byte_size_ -= bytes;
+void
+NoncontiguousBuffer::SkipSlow(std::size_t bytes) noexcept
+{
+    TILE_CHECK_LE(bytes, byte_size_, "Skip bytes exceed buffer size");
+    byte_size_ -= bytes;
 
-  while (bytes) {
-    auto &&first = buffers_.front();
-    auto min_size = std::min(bytes, first.size());
-    if (min_size == first.size()) {
-      object_pool::Put<buffer_t>(buffers_.pop_front());
-    } else {
-      TILE_DCHECK_LT(min_size, first.size());
-      first.Skip(min_size);
+    while (bytes) {
+        auto &&first  = buffers_.front();
+        auto min_size = std::min(bytes, first.size());
+        if (min_size == first.size()) {
+            object_pool::Put<buffer_t>(buffers_.pop_front());
+        } else {
+            TILE_DCHECK_LT(min_size, first.size());
+            first.Skip(min_size);
+        }
+        bytes -= min_size;
     }
-    bytes -= min_size;
-  }
 }
 
-void NoncontiguousBuffer::ClearSlow() noexcept {
-  byte_size_ = 0;
-  while (!buffers_.empty()) {
-    object_pool::Put<buffer_t>(buffers_.pop_front());
-  }
+void
+NoncontiguousBuffer::ClearSlow() noexcept
+{
+    byte_size_ = 0;
+    while (!buffers_.empty()) { object_pool::Put<buffer_t>(buffers_.pop_front()); }
 }
 
-void NoncontiguousBufferBuilder::InitializeNextBlock() {
-  if (current_) {
-    TILE_CHECK(SizeAvailable(),
-               "You should flush current block by `FlushCurrentBlock()`");
-    return;
-  }
-
-  current_ = MakeNativeBufferBlock();
-  used_ = 0;
-}
-
-void NoncontiguousBufferBuilder::FlushCurrentBlock() {
-  if (!used_) {
-    // current block is empty
-    return;
-  }
-
-  nb_.Append(PolymorphicBuffer(std::move(current_), 0, used_));
-  used_ = 0;
-  current_ = nullptr;
-}
-
-void NoncontiguousBufferBuilder::AppendSlow(const void *ptr,
-                                            std::size_t length) {
-  while (length) {
-    auto copying = std::min(length, SizeAvailable());
-    memcpy(data(), ptr, copying);
-    MarkWritten(copying);
-    ptr = static_cast<const char *>(ptr) + copying;
-    length -= copying;
-  }
-}
-
-void NoncontiguousBufferBuilder::AppendCopy(const NoncontiguousBuffer &buffer) {
-  for (auto &&e : buffer) {
-    Append(e.data(), e.size());
-  }
-}
-
-NoncontiguousBuffer CreateBufferSlow(Slice s) {
-  NoncontiguousBufferBuilder nbb;
-  nbb.Append(s);
-  return nbb.DestructiveGet();
-}
-NoncontiguousBuffer CreateBufferSlow(const void *ptr, std::size_t size) {
-  NoncontiguousBufferBuilder nbb;
-  nbb.Append(ptr, size);
-  return nbb.DestructiveGet();
-}
-
-std::string FlattenSlow(const NoncontiguousBuffer &nb, std::size_t max_bytes) {
-  max_bytes = std::min(max_bytes, nb.ByteSize());
-  std::string rc;
-  std::size_t left = max_bytes;
-  rc.reserve(max_bytes);
-  for (auto iter = nb.begin(); iter != nb.end() && left; ++iter) {
-    auto len = std::min(left, iter->size());
-    rc.append(iter->data(), len);
-    left -= len;
-  }
-  return rc;
-}
-
-std::string FlattenSlowUntil(const NoncontiguousBuffer &nb, Slice delim,
-                             std::size_t max_bytes) {
-  if (nb.Empty()) {
-    return {};
-  }
-
-  {
-    Slice current(nb.FirstContiguous().data(), nb.FirstContiguous().size());
-    auto pos = current.find(delim);
-    if (pos != Slice::npos) {
-      auto expected_bytes = std::min(pos + delim.size(), max_bytes);
-      return std::string(nb.FirstContiguous().data(),
-                         nb.FirstContiguous().data() + expected_bytes);
+void
+NoncontiguousBufferBuilder::InitializeNextBlock()
+{
+    if (current_) {
+        TILE_CHECK(SizeAvailable(), "You should flush current block by `FlushCurrentBlock()`");
+        return;
     }
-  }
 
-  std::string rc;
-  for (auto iter = nb.begin(); iter != nb.end() && rc.size() < max_bytes;
-       ++iter) {
-    auto old_len = rc.size();
-    rc.append(iter->data(), iter->size());
-    // find delim
+    current_ = MakeNativeBufferBlock();
+    used_    = 0;
+}
+
+void
+NoncontiguousBufferBuilder::FlushCurrentBlock()
+{
+    if (!used_) {
+        // current block is empty
+        return;
+    }
+
+    nb_.Append(PolymorphicBuffer(std::move(current_), 0, used_));
+    used_    = 0;
+    current_ = nullptr;
+}
+
+void
+NoncontiguousBufferBuilder::AppendSlow(const void *ptr, std::size_t length)
+{
+    while (length) {
+        auto copying = std::min(length, SizeAvailable());
+        memcpy(data(), ptr, copying);
+        MarkWritten(copying);
+        ptr = static_cast<const char *>(ptr) + copying;
+        length -= copying;
+    }
+}
+
+void
+NoncontiguousBufferBuilder::AppendCopy(const NoncontiguousBuffer &buffer)
+{
+    for (auto &&e : buffer) { Append(e.data(), e.size()); }
+}
+
+NoncontiguousBuffer
+CreateBufferSlow(Slice s)
+{
+    NoncontiguousBufferBuilder nbb;
+    nbb.Append(s);
+    return nbb.DestructiveGet();
+}
+
+NoncontiguousBuffer
+CreateBufferSlow(const void *ptr, std::size_t size)
+{
+    NoncontiguousBufferBuilder nbb;
+    nbb.Append(ptr, size);
+    return nbb.DestructiveGet();
+}
+
+std::string
+FlattenSlow(const NoncontiguousBuffer &nb, std::size_t max_bytes)
+{
+    max_bytes = std::min(max_bytes, nb.ByteSize());
+    std::string rc;
+    std::size_t left = max_bytes;
+    rc.reserve(max_bytes);
+    for (auto iter = nb.begin(); iter != nb.end() && left; ++iter) {
+        auto len = std::min(left, iter->size());
+        rc.append(iter->data(), len);
+        left -= len;
+    }
+    return rc;
+}
+
+std::string
+FlattenSlowUntil(const NoncontiguousBuffer &nb, Slice delim, std::size_t max_bytes)
+{
+    if (nb.Empty()) { return {}; }
+
     {
-      // Avoiding the use of find_last_of
-      auto pos = rc.find(delim, old_len - std::min(old_len, delim.size()));
-      if (pos != Slice::npos) {
-        rc.erase(rc.begin() + pos + delim.size(), rc.end());
-        break;
-      }
+        Slice current(nb.FirstContiguous().data(), nb.FirstContiguous().size());
+        auto pos = current.find(delim);
+        if (pos != Slice::npos) {
+            auto expected_bytes = std::min(pos + delim.size(), max_bytes);
+            return std::string(nb.FirstContiguous().data(), nb.FirstContiguous().data() + expected_bytes);
+        }
     }
-  }
-  if (rc.size() > max_bytes) {
-    rc.erase(rc.begin() + max_bytes, rc.end());
-  }
-  return rc;
+
+    std::string rc;
+    for (auto iter = nb.begin(); iter != nb.end() && rc.size() < max_bytes; ++iter) {
+        auto old_len = rc.size();
+        rc.append(iter->data(), iter->size());
+        // find delim
+        {
+            // Avoiding the use of find_last_of
+            auto pos = rc.find(delim, old_len - std::min(old_len, delim.size()));
+            if (pos != Slice::npos) {
+                rc.erase(rc.begin() + pos + delim.size(), rc.end());
+                break;
+            }
+        }
+    }
+    if (rc.size() > max_bytes) { rc.erase(rc.begin() + max_bytes, rc.end()); }
+    return rc;
 }
 
-PolymorphicBuffer MakeReferencingBuffer(const void *ptr, std::size_t size) {
-  return MakeReferencingBuffer(ptr, size, [] {});
+PolymorphicBuffer
+MakeReferencingBuffer(const void *ptr, std::size_t size)
+{
+    return MakeReferencingBuffer(ptr, size, [] {});
 }
 
-PolymorphicBuffer MakeForeignBuffer(std::string buffer) {
-  auto size = buffer.size();
-  return PolymorphicBuffer(
-      MakeRefCounted<OwningBufferBlock<std::string>>(std::move(buffer)), 0,
-      size);
+PolymorphicBuffer
+MakeForeignBuffer(std::string buffer)
+{
+    auto size = buffer.size();
+    return PolymorphicBuffer(MakeRefCounted<OwningBufferBlock<std::string>>(std::move(buffer)), 0, size);
 }
 
-template <typename T>
-PolymorphicBuffer MakeForeignBuffer(std::vector<T> buffer) {
-  auto size = buffer.size() * sizeof(T);
-  return PolymorphicBuffer(
-      MakeRefCounted<OwningBufferBlock<std::vector<T>>>(std::move(buffer)), 0,
-      size);
+template<typename T>
+PolymorphicBuffer
+MakeForeignBuffer(std::vector<T> buffer)
+{
+    auto size = buffer.size() * sizeof(T);
+    return PolymorphicBuffer(MakeRefCounted<OwningBufferBlock<std::vector<T>>>(std::move(buffer)), 0, size);
 }
 
-#define TILE_INSTANIATE_MAKE_FOREIGN_BUFFER(type)                              \
-  template PolymorphicBuffer MakeForeignBuffer(std::vector<type> buffer)
+#define TILE_INSTANIATE_MAKE_FOREIGN_BUFFER(type) template PolymorphicBuffer MakeForeignBuffer(std::vector<type> buffer)
 
 TILE_INSTANIATE_MAKE_FOREIGN_BUFFER(char);
 TILE_INSTANIATE_MAKE_FOREIGN_BUFFER(signed char);
@@ -224,51 +233,50 @@ TILE_INSTANIATE_MAKE_FOREIGN_BUFFER(float);
 TILE_INSTANIATE_MAKE_FOREIGN_BUFFER(double);
 TILE_INSTANIATE_MAKE_FOREIGN_BUFFER(long double);
 
-bool StartsWith(NoncontiguousBuffer buffer, Slice prefix) {
-  if (buffer.ByteSize() < prefix.size()) {
-    return false;
-  }
+bool
+StartsWith(NoncontiguousBuffer buffer, Slice prefix)
+{
+    if (buffer.ByteSize() < prefix.size()) { return false; }
 
-  while (!buffer.Empty() && prefix.empty()) {
-    auto first = buffer.FirstContiguous();
-    auto min_len = std::min(first.size(), prefix.size());
-    if (memcmp(first.data(), prefix.data(), min_len) != 0) {
-      return false;
+    while (!buffer.Empty() && prefix.empty()) {
+        auto first   = buffer.FirstContiguous();
+        auto min_len = std::min(first.size(), prefix.size());
+        if (memcmp(first.data(), prefix.data(), min_len) != 0) { return false; }
+
+        buffer.Skip(min_len);
+        prefix.RemovePrefix(min_len);
     }
-
-    buffer.Skip(min_len);
-    prefix.RemovePrefix(min_len);
-  }
-  return prefix.empty();
+    return prefix.empty();
 }
 
-bool EndsWith(NoncontiguousBuffer buffer, Slice suffix) {
-  TILE_NOT_IMPLEMENTED("");
-  return false;
-}
-
-bool StartsWithIgnoreCase(NoncontiguousBuffer buffer, Slice prefix) {
-  if (buffer.ByteSize() < prefix.size()) {
+bool
+EndsWith(NoncontiguousBuffer buffer, Slice suffix)
+{
+    TILE_NOT_IMPLEMENTED("");
     return false;
-  }
+}
 
-  while (!buffer.Empty() && prefix.empty()) {
-    auto first = buffer.FirstContiguous();
-    auto min_len = std::min(first.size(), prefix.size());
+bool
+StartsWithIgnoreCase(NoncontiguousBuffer buffer, Slice prefix)
+{
+    if (buffer.ByteSize() < prefix.size()) { return false; }
 
-    if (!EqualsIgnoreCase(first.substr(0, min_len),
-                          prefix.substr(0, min_len))) {
-      return false;
+    while (!buffer.Empty() && prefix.empty()) {
+        auto first   = buffer.FirstContiguous();
+        auto min_len = std::min(first.size(), prefix.size());
+
+        if (!EqualsIgnoreCase(first.substr(0, min_len), prefix.substr(0, min_len))) { return false; }
+
+        buffer.Skip(min_len);
+        prefix.RemovePrefix(min_len);
     }
-
-    buffer.Skip(min_len);
-    prefix.RemovePrefix(min_len);
-  }
-  return prefix.empty();
+    return prefix.empty();
 }
 
-bool EndsWithIgnoreCase(NoncontiguousBuffer buffer, Slice suffix) {
-  TILE_NOT_IMPLEMENTED("");
+bool
+EndsWithIgnoreCase(NoncontiguousBuffer buffer, Slice suffix)
+{
+    TILE_NOT_IMPLEMENTED("");
 }
 
-} // namespace tile
+}// namespace tile
diff --git a/tile/base/buffer.h b/tile/base/buffer.h
index c6a3022..3bf39d3 100644
--- a/tile/base/buffer.h
+++ b/tile/base/buffer.h
@@ -19,355 +19,376 @@
 
 namespace tile {
 namespace detail {
-template <typename T>
-constexpr auto data(const T &c)
-    -> enable_if_t<std::is_convertible<decltype(c.data()), const char *>::value,
-                   const char *> {
-  return c.data();
+template<typename T>
+constexpr auto
+data(const T &c) -> enable_if_t<std::is_convertible<decltype(c.data()), const char *>::value, const char *>
+{
+    return c.data();
 }
 
-template <std::size_t N>
-constexpr auto data(const char (&c)[N]) -> decltype(c) {
-  return c;
+template<std::size_t N>
+constexpr auto
+data(const char (&c)[N]) -> decltype(c)
+{
+    return c;
 }
 
-template <typename T> constexpr std::size_t size(const T &c) {
-  return c.size();
+template<typename T>
+constexpr std::size_t
+size(const T &c)
+{
+    return c.size();
 }
 
-template <std::size_t N> struct size_impl {
-  static constexpr std::size_t size(const char (&c)[N]) {
-    return N - (c[N - 1] == '\0');
-  }
-};
-template <> struct size_impl<0> {
-  static constexpr std::size_t size(const char (&c)[0]) { return 0; }
+template<std::size_t N>
+struct size_impl {
+    static constexpr std::size_t size(const char (&c)[N]) { return N - (c[N - 1] == '\0'); }
 };
 
-template <std::size_t N> constexpr std::size_t size(const char (&c)[N]) {
-  return size_impl<N>::size(c);
+template<>
+struct size_impl<0> {
+    static constexpr std::size_t size(const char (&c)[0]) { return 0; }
+};
+
+template<std::size_t N>
+constexpr std::size_t
+size(const char (&c)[N])
+{
+    return size_impl<N>::size(c);
 }
 
-template <typename A1> constexpr std::size_t total_size(const A1 &a1) {
-  return size(a1);
+template<typename A1>
+constexpr std::size_t
+total_size(const A1 &a1)
+{
+    return size(a1);
 }
 
-template <typename A1, typename... Args>
-constexpr std::size_t total_size(const A1 &a1, const Args &...args) {
-  return size(a1) + total_size(args...);
+template<typename A1, typename... Args>
+constexpr std::size_t
+total_size(const A1 &a1, const Args &...args)
+{
+    return size(a1) + total_size(args...);
 }
 
-} // namespace detail
+}// namespace detail
 
 class NoncontiguousBuffer {
-  // <buffer_t, buffer_t::chain>
-  using LinkedBuffers =
-      internal::SinglyLinkedList<PolymorphicBuffer, &PolymorphicBuffer::chain>;
+    // <buffer_t, buffer_t::chain>
+    using LinkedBuffers = internal::SinglyLinkedList<PolymorphicBuffer, &PolymorphicBuffer::chain>;
 
 public:
-  using iterator = LinkedBuffers::iterator;
-  using const_iterator = LinkedBuffers::const_iterator;
-  using buffer_t = PolymorphicBuffer;
+    using iterator                  = LinkedBuffers::iterator;
+    using const_iterator            = LinkedBuffers::const_iterator;
+    using buffer_t                  = PolymorphicBuffer;
 
-  constexpr NoncontiguousBuffer() = default;
+    constexpr NoncontiguousBuffer() = default;
 
-  // Copyable & moveable
-  NoncontiguousBuffer(const NoncontiguousBuffer &other);
-  NoncontiguousBuffer &operator=(const NoncontiguousBuffer &other);
-  NoncontiguousBuffer(NoncontiguousBuffer &&other) noexcept
-      : byte_size_(internal::Exchange(other.byte_size_, 0)),
-        buffers_(std::move(other.buffers_)) {}
-  NoncontiguousBuffer &operator=(NoncontiguousBuffer &&other) noexcept {
-    if (TILE_UNLIKELY(&other == this)) {
-      return *this;
+    // Copyable & moveable
+    NoncontiguousBuffer(const NoncontiguousBuffer &other);
+    NoncontiguousBuffer &operator=(const NoncontiguousBuffer &other);
+
+    NoncontiguousBuffer(NoncontiguousBuffer &&other) noexcept
+        : byte_size_(internal::Exchange(other.byte_size_, 0)),
+          buffers_(std::move(other.buffers_))
+    {}
+
+    NoncontiguousBuffer &operator=(NoncontiguousBuffer &&other) noexcept
+    {
+        if (TILE_UNLIKELY(&other == this)) { return *this; }
+
+        Clear();
+        std::swap(byte_size_, other.byte_size_);
+        buffers_ = std::move(other.buffers_);
+        return *this;
     }
 
-    Clear();
-    std::swap(byte_size_, other.byte_size_);
-    buffers_ = std::move(other.buffers_);
-    return *this;
-  }
+    ~NoncontiguousBuffer() { Clear(); }
 
-  ~NoncontiguousBuffer() { Clear(); }
-
-  Slice FirstContiguous() const noexcept {
-    TILE_DCHECK(!Empty());
-    auto &&first = buffers_.front();
-    return Slice(first.data(), first.size());
-  }
-
-  void Skip(size_t bytes) noexcept {
-    TILE_DCHECK_LE(bytes, ByteSize());
-    if (TILE_UNLIKELY(bytes == 0)) {
-    } else if (bytes < buffers_.front().size()) {
-      buffers_.front().Skip(bytes);
-      byte_size_ -= bytes;
-    } else {
-      SkipSlow(bytes);
-    }
-  }
-
-  NoncontiguousBuffer Cut(std::size_t bytes) {
-    TILE_DCHECK_LE(bytes, ByteSize());
-    TILE_DCHECK_GE(bytes, 0);
-
-    NoncontiguousBuffer rc;
-    auto left = bytes;
-    while (left && left >= buffers_.front().size()) {
-      left -= buffers_.front().size();
-      rc.buffers_.push_back(buffers_.pop_front());
+    Slice FirstContiguous() const noexcept
+    {
+        TILE_DCHECK(!Empty());
+        auto &&first = buffers_.front();
+        return Slice(first.data(), first.size());
     }
 
-    if (TILE_LIKELY(left > 0)) {
-      auto ncb = object_pool::Get<PolymorphicBuffer>().Leak();
-      *ncb = buffers_.front();
-      ncb->set_size(left);
-      rc.buffers_.push_back(ncb);
-      buffers_.front().Skip(left);
-    }
-    rc.byte_size_ = bytes;
-    byte_size_ -= bytes;
-    return rc;
-  }
-
-  void Append(PolymorphicBuffer buffer) {
-    if (TILE_UNLIKELY(buffer.size() == 0)) {
-      return;
+    void Skip(size_t bytes) noexcept
+    {
+        TILE_DCHECK_LE(bytes, ByteSize());
+        if (TILE_UNLIKELY(bytes == 0)) {
+        } else if (bytes < buffers_.front().size()) {
+            buffers_.front().Skip(bytes);
+            byte_size_ -= bytes;
+        } else {
+            SkipSlow(bytes);
+        }
     }
 
-    auto block = object_pool::Get<PolymorphicBuffer>();
-    *block = std::move(buffer);
-    byte_size_ += block->size();
-    buffers_.push_back(block.Leak());
-  }
+    NoncontiguousBuffer Cut(std::size_t bytes)
+    {
+        TILE_DCHECK_LE(bytes, ByteSize());
+        TILE_DCHECK_GE(bytes, 0);
 
-  void Append(NoncontiguousBuffer buffer) {
-    byte_size_ += internal::Exchange(buffer.byte_size_, 0);
-    buffers_.splice(std::move(buffer.buffers_));
-  }
+        NoncontiguousBuffer rc;
+        auto left = bytes;
+        while (left && left >= buffers_.front().size()) {
+            left -= buffers_.front().size();
+            rc.buffers_.push_back(buffers_.pop_front());
+        }
 
-  std::size_t ByteSize() const noexcept { return byte_size_; }
-
-  bool Empty() const noexcept {
-    TILE_CHECK_EQ(buffers_.empty(), !byte_size_);
-    return !byte_size_;
-  }
-
-  void Clear() noexcept {
-    if (!Empty()) {
-      ClearSlow();
+        if (TILE_LIKELY(left > 0)) {
+            auto ncb = object_pool::Get<PolymorphicBuffer>().Leak();
+            *ncb     = buffers_.front();
+            ncb->set_size(left);
+            rc.buffers_.push_back(ncb);
+            buffers_.front().Skip(left);
+        }
+        rc.byte_size_ = bytes;
+        byte_size_ -= bytes;
+        return rc;
     }
-  }
 
-  iterator begin() noexcept { return buffers_.begin(); }
-  iterator end() noexcept { return buffers_.end(); }
-  const_iterator begin() const noexcept { return buffers_.begin(); }
-  const_iterator end() const noexcept { return buffers_.end(); }
+    void Append(PolymorphicBuffer buffer)
+    {
+        if (TILE_UNLIKELY(buffer.size() == 0)) { return; }
+
+        auto block = object_pool::Get<PolymorphicBuffer>();
+        *block     = std::move(buffer);
+        byte_size_ += block->size();
+        buffers_.push_back(block.Leak());
+    }
+
+    void Append(NoncontiguousBuffer buffer)
+    {
+        byte_size_ += internal::Exchange(buffer.byte_size_, 0);
+        buffers_.splice(std::move(buffer.buffers_));
+    }
+
+    std::size_t ByteSize() const noexcept { return byte_size_; }
+
+    bool Empty() const noexcept
+    {
+        TILE_CHECK_EQ(buffers_.empty(), !byte_size_);
+        return !byte_size_;
+    }
+
+    void Clear() noexcept
+    {
+        if (!Empty()) { ClearSlow(); }
+    }
+
+    iterator begin() noexcept { return buffers_.begin(); }
+
+    iterator end() noexcept { return buffers_.end(); }
+
+    const_iterator begin() const noexcept { return buffers_.begin(); }
+
+    const_iterator end() const noexcept { return buffers_.end(); }
 
 private:
-  void SkipSlow(size_t bytes) noexcept;
-  void ClearSlow() noexcept;
+    void SkipSlow(size_t bytes) noexcept;
+    void ClearSlow() noexcept;
 
 private:
-  std::size_t byte_size_{};
-  LinkedBuffers buffers_;
+    std::size_t byte_size_{};
+    LinkedBuffers buffers_;
 };
 
 class NoncontiguousBufferBuilder {
-  static constexpr auto kAppendViaCopyThreshold = 128;
+    static constexpr auto kAppendViaCopyThreshold = 128;
 
 public:
-  NoncontiguousBufferBuilder() { InitializeNextBlock(); }
+    NoncontiguousBufferBuilder() { InitializeNextBlock(); }
 
-  // current write ptr
-  // It's size is available at `SizeAvailable()`
-  char *data() const noexcept { return current_->mutable_data() + used_; }
+    // current write ptr
+    // It's size is available at `SizeAvailable()`
+    char *data() const noexcept { return current_->mutable_data() + used_; }
 
-  std::size_t SizeAvailable() const noexcept {
-    return current_->size() - used_;
-  }
+    std::size_t SizeAvailable() const noexcept { return current_->size() - used_; }
 
-  void MarkWritten(std::size_t bytes) {
-    TILE_DCHECK_LE(bytes, SizeAvailable(), "You're overflowing the buffer.");
-    used_ += bytes;
-    // Is fulled ?
-    if (TILE_UNLIKELY(!SizeAvailable())) {
-      FlushCurrentBlock();
-      InitializeNextBlock();
-    }
-  }
-
-  // Allocate new block
-  // return write ptr
-  char *Reserve(std::size_t bytes) {
-    static const auto kMaxBytes = 1024;
-    TILE_CHECK_LE(bytes, kMaxBytes,
-                  "At most [{}] bytes may be reserved in single call.",
-                  kMaxBytes);
-    if (SizeAvailable() < bytes) {
-      FlushCurrentBlock();
-      InitializeNextBlock();
+    void MarkWritten(std::size_t bytes)
+    {
+        TILE_DCHECK_LE(bytes, SizeAvailable(), "You're overflowing the buffer.");
+        used_ += bytes;
+        // Is fulled ?
+        if (TILE_UNLIKELY(!SizeAvailable())) {
+            FlushCurrentBlock();
+            InitializeNextBlock();
+        }
     }
 
-    auto ptr = data();
-    MarkWritten(bytes);
-    return ptr;
-  }
+    // Allocate new block
+    // return write ptr
+    char *Reserve(std::size_t bytes)
+    {
+        static const auto kMaxBytes = 1024;
+        TILE_CHECK_LE(bytes, kMaxBytes, "At most [{}] bytes may be reserved in single call.", kMaxBytes);
+        if (SizeAvailable() < bytes) {
+            FlushCurrentBlock();
+            InitializeNextBlock();
+        }
 
-  // Total number of bytes written
-  std::size_t ByteSize() const noexcept { return nb_.ByteSize() + used_; }
-
-  NoncontiguousBuffer DestructiveGet() noexcept {
-    FlushCurrentBlock();
-    return std::move(nb_);
-  }
-
-  void Append(const void *ptr, std::size_t length) {
-    auto current = data();
-    used_ += length;
-    if (TILE_LIKELY(used_ < current_->size())) {
-      memcpy(static_cast<void *>(current), ptr, length);
-      return;
-    }
-    used_ -= length;
-    AppendSlow(ptr, length);
-  }
-
-  void Append(Slice s) { return Append(s.data(), s.size()); }
-
-  void Append(const std::string &s) { Append(s.data(), s.size()); }
-
-  void Append(PolymorphicBuffer buffer) {
-    if (buffer.size() < kAppendViaCopyThreshold &&
-        SizeAvailable() >= buffer.size()) {
-      Append(buffer.data(), buffer.size());
-      return;
+        auto ptr = data();
+        MarkWritten(bytes);
+        return ptr;
     }
 
-    if (used_) {
-      FlushCurrentBlock();
-      InitializeNextBlock();
+    // Total number of bytes written
+    std::size_t ByteSize() const noexcept { return nb_.ByteSize() + used_; }
+
+    NoncontiguousBuffer DestructiveGet() noexcept
+    {
+        FlushCurrentBlock();
+        return std::move(nb_);
     }
 
-    nb_.Append(std::move(buffer));
-  }
-
-  void Append(NoncontiguousBuffer buffer) {
-    if (buffer.ByteSize() < kAppendViaCopyThreshold && SizeAvailable()) {
-      AppendCopy(buffer);
-      return;
+    void Append(const void *ptr, std::size_t length)
+    {
+        auto current = data();
+        used_ += length;
+        if (TILE_LIKELY(used_ < current_->size())) {
+            memcpy(static_cast<void *>(current), ptr, length);
+            return;
+        }
+        used_ -= length;
+        AppendSlow(ptr, length);
     }
 
-    if (used_) {
-      FlushCurrentBlock();
-      InitializeNextBlock();
+    void Append(Slice s) { return Append(s.data(), s.size()); }
+
+    void Append(const std::string &s) { Append(s.data(), s.size()); }
+
+    void Append(PolymorphicBuffer buffer)
+    {
+        if (buffer.size() < kAppendViaCopyThreshold && SizeAvailable() >= buffer.size()) {
+            Append(buffer.data(), buffer.size());
+            return;
+        }
+
+        if (used_) {
+            FlushCurrentBlock();
+            InitializeNextBlock();
+        }
+
+        nb_.Append(std::move(buffer));
     }
-    nb_.Append(std::move(buffer));
-  }
 
-  void Append(char c) { Append(static_cast<unsigned char>(c)); }
+    void Append(NoncontiguousBuffer buffer)
+    {
+        if (buffer.ByteSize() < kAppendViaCopyThreshold && SizeAvailable()) {
+            AppendCopy(buffer);
+            return;
+        }
 
-  void Append(unsigned char c) {
-    TILE_DCHECK(SizeAvailable());
-    *reinterpret_cast<unsigned char *>(data()) = c;
-    MarkWritten(1);
-  }
-
-  template <
-      typename... Ts,
-      typename =
-          internal::void_t<decltype(detail::data(std::declval<Ts &>()))...>,
-      typename =
-          internal::void_t<decltype(detail::size(std::declval<Ts &>()))...>>
-  void Append(const Ts &...buffers) {
-    auto current = data();
-    auto total = detail::total_size(buffers...);
-    used_ += total;
-    if (TILE_LIKELY(used_ < current_->size())) {
-      UncheckedAppend(current, buffers...);
-      return;
+        if (used_) {
+            FlushCurrentBlock();
+            InitializeNextBlock();
+        }
+        nb_.Append(std::move(buffer));
     }
-    used_ -= total;
-    int dummy[] = {(Append(buffers), 0)...};
-  }
 
-  template <typename T>
-  auto Append(T) -> enable_if_t<std::is_same<T, int>::value> {
-    static_assert(sizeof(T) == 0, "Please use Append(char) instead.");
-  }
+    void Append(char c) { Append(static_cast<unsigned char>(c)); }
+
+    void Append(unsigned char c)
+    {
+        TILE_DCHECK(SizeAvailable());
+        *reinterpret_cast<unsigned char *>(data()) = c;
+        MarkWritten(1);
+    }
+
+    template<typename... Ts,
+             typename = internal::void_t<decltype(detail::data(std::declval<Ts &>()))...>,
+             typename = internal::void_t<decltype(detail::size(std::declval<Ts &>()))...>>
+    void Append(const Ts &...buffers)
+    {
+        auto current = data();
+        auto total   = detail::total_size(buffers...);
+        used_ += total;
+        if (TILE_LIKELY(used_ < current_->size())) {
+            UncheckedAppend(current, buffers...);
+            return;
+        }
+        used_ -= total;
+        int dummy[] = {(Append(buffers), 0)...};
+    }
+
+    template<typename T>
+    auto Append(T) -> enable_if_t<std::is_same<T, int>::value>
+    {
+        static_assert(sizeof(T) == 0, "Please use Append(char) instead.");
+    }
 
 private:
-  // Allocate a new buffer
-  void InitializeNextBlock();
+    // Allocate a new buffer
+    void InitializeNextBlock();
 
-  void FlushCurrentBlock();
+    void FlushCurrentBlock();
 
-  void AppendSlow(const void *ptr, std::size_t length);
-  void AppendCopy(const NoncontiguousBuffer &buffer);
+    void AppendSlow(const void *ptr, std::size_t length);
+    void AppendCopy(const NoncontiguousBuffer &buffer);
 
-  template <typename T, typename...>
-  inline void UncheckedAppend(char *ptr, const T &slice) {
-    memcpy(ptr, detail::data(slice), detail::size(slice));
-  }
+    template<typename T, typename...>
+    inline void UncheckedAppend(char *ptr, const T &slice)
+    {
+        memcpy(ptr, detail::data(slice), detail::size(slice));
+    }
 
-  template <typename T, typename... Ts>
-  inline void UncheckedAppend(char *ptr, const T &slice, const Ts &...slices) {
-    memcpy(ptr, detail::data(slice), detail::size(slice));
-    UncheckedAppend(ptr + detail::size(slice), slices...);
-  }
+    template<typename T, typename... Ts>
+    inline void UncheckedAppend(char *ptr, const T &slice, const Ts &...slices)
+    {
+        memcpy(ptr, detail::data(slice), detail::size(slice));
+        UncheckedAppend(ptr + detail::size(slice), slices...);
+    }
 
 private:
-  NoncontiguousBuffer nb_;
-  std::size_t used_;
-  RefPtr<NativeBufferBlock> current_;
+    NoncontiguousBuffer nb_;
+    std::size_t used_;
+    RefPtr<NativeBufferBlock> current_;
 };
 
 namespace detail {
-void FlattenToSlowSlow(const NoncontiguousBuffer &ncb, void *buffer,
-                       std::size_t size);
+void FlattenToSlowSlow(const NoncontiguousBuffer &ncb, void *buffer, std::size_t size);
 }
 
 NoncontiguousBuffer CreateBufferSlow(Slice s);
 NoncontiguousBuffer CreateBufferSlow(const void *ptr, std::size_t size);
 
-std::string
-FlattenSlow(const NoncontiguousBuffer &nb,
-            std::size_t max_bytes = std::numeric_limits<std::size_t>::max());
-std::string FlattenSlowUntil(
-    const NoncontiguousBuffer &nb, Slice delim,
-    std::size_t max_bytes = std::numeric_limits<std::size_t>::max());
-inline void FlattenToSlow(const NoncontiguousBuffer &nb, void *buffer,
-                          std::size_t max_bytes) {
-  if (TILE_LIKELY(max_bytes <= nb.FirstContiguous().size())) {
-    std::memcpy(buffer, nb.FirstContiguous().data(), max_bytes);
-  }
-  return detail::FlattenToSlowSlow(nb, buffer, max_bytes);
+std::string FlattenSlow(const NoncontiguousBuffer &nb, std::size_t max_bytes = std::numeric_limits<std::size_t>::max());
+std::string FlattenSlowUntil(const NoncontiguousBuffer &nb,
+                             Slice delim,
+                             std::size_t max_bytes = std::numeric_limits<std::size_t>::max());
+
+inline void
+FlattenToSlow(const NoncontiguousBuffer &nb, void *buffer, std::size_t max_bytes)
+{
+    if (TILE_LIKELY(max_bytes <= nb.FirstContiguous().size())) {
+        std::memcpy(buffer, nb.FirstContiguous().data(), max_bytes);
+    }
+    return detail::FlattenToSlowSlow(nb, buffer, max_bytes);
 }
 
 PolymorphicBuffer MakeReferencingBuffer(const void *ptr, std::size_t size);
 
-template <typename F>
-PolymorphicBuffer MakeReferencingBuffer(const void *ptr, std::size_t size,
-                                        F &&completion_cb) {
-  using BufferBlock =
-      ReferencingBufferBlock<typename std::remove_reference<F>::type>;
-  return PolymorphicBuffer(
-      MakeRefCounted<BufferBlock>(
-          ptr, size,
-          std::forward<typename std::remove_reference<F>::type>(completion_cb)),
-      0, size);
+template<typename F>
+PolymorphicBuffer
+MakeReferencingBuffer(const void *ptr, std::size_t size, F &&completion_cb)
+{
+    using BufferBlock = ReferencingBufferBlock<typename std::remove_reference<F>::type>;
+    return PolymorphicBuffer(
+        MakeRefCounted<BufferBlock>(ptr, size, std::forward<typename std::remove_reference<F>::type>(completion_cb)), 0,
+        size);
 }
 
 PolymorphicBuffer MakeForeignBuffer(std::string buffer);
 
 // `T` in (`std::byte`, integral types, floating types)
-template <typename T>
+template<typename T>
 PolymorphicBuffer MakeForeignBuffer(std::vector<T> buffer);
 
 bool StartsWith(NoncontiguousBuffer buffer, Slice prefix);
 bool EndsWith(NoncontiguousBuffer buffer, Slice suffix);
 bool StartsWithIgnoreCase(NoncontiguousBuffer buffer, Slice prefix);
 bool EndsWithIgnoreCase(NoncontiguousBuffer buffer, Slice suffix);
-} // namespace tile
+}// namespace tile
 
-#endif // TILE_BASE_BUFFER_H
+#endif// TILE_BASE_BUFFER_H
diff --git a/tile/base/buffer/builtin_buffer_block.cc b/tile/base/buffer/builtin_buffer_block.cc
index 8b1054a..29c76d1 100644
--- a/tile/base/buffer/builtin_buffer_block.cc
+++ b/tile/base/buffer/builtin_buffer_block.cc
@@ -19,104 +19,108 @@ namespace tile {
 
 namespace {
 
-template <std::size_t kSize>
-struct alignas(hardware_destructive_interference_size) FixedNativeBufferBlock
-    : NativeBufferBlock {
+template<std::size_t kSize>
+struct alignas(hardware_destructive_interference_size) FixedNativeBufferBlock : NativeBufferBlock {
 public:
-  static RefPtr<FixedNativeBufferBlock> New() {
-    // WARNING: don't use adopt_ptr
-    return RefPtr<FixedNativeBufferBlock<kSize>>(
-        adopt_ptr, object_pool::Get<FixedNativeBufferBlock<kSize>>().Leak());
-  }
+    static RefPtr<FixedNativeBufferBlock> New()
+    {
+        // WARNING: don't use adopt_ptr
+        return RefPtr<FixedNativeBufferBlock<kSize>>(
+            adopt_ptr, object_pool::Get<FixedNativeBufferBlock<kSize>>().Leak());
+    }
 
-  // HACK: add ref ensure `RefCount<Base>`.
-  static void Delete(FixedNativeBufferBlock *ptr) {
-    ptr->Save();
-    object_pool::Put<FixedNativeBufferBlock<kSize>>(ptr);
-  }
+    // HACK: add ref ensure `RefCount<Base>`.
+    static void Delete(FixedNativeBufferBlock *ptr)
+    {
+        ptr->Save();
+        object_pool::Put<FixedNativeBufferBlock<kSize>>(ptr);
+    }
 
-  char *mutable_data() noexcept override { return buffer.data(); }
-  const char *data() const noexcept override { return buffer.data(); }
-  std::size_t size() const noexcept override { return buffer.size(); }
-  void Destroy() noexcept override { Delete(this); }
+    char *mutable_data() noexcept override { return buffer.data(); }
 
-  static constexpr std::size_t kBufferSize = kSize - sizeof(NativeBufferBlock);
-  std::array<char, kBufferSize> buffer;
+    const char *data() const noexcept override { return buffer.data(); }
+
+    std::size_t size() const noexcept override { return buffer.size(); }
+
+    void Destroy() noexcept override { Delete(this); }
+
+    static constexpr std::size_t kBufferSize = kSize - sizeof(NativeBufferBlock);
+    std::array<char, kBufferSize> buffer;
 };
 
-template <std::size_t kSize>
-RefPtr<NativeBufferBlock> MakeNativeBufferBlockOfBytes() {
-  return FixedNativeBufferBlock<kSize>::New();
+template<std::size_t kSize>
+RefPtr<NativeBufferBlock>
+MakeNativeBufferBlockOfBytes()
+{
+    return FixedNativeBufferBlock<kSize>::New();
 }
 
-RefPtr<NativeBufferBlock> (*make_native_buffer_block)() =
-    MakeNativeBufferBlockOfBytes<BLOCK_SIZE_4K>;
+RefPtr<NativeBufferBlock> (*make_native_buffer_block)() = MakeNativeBufferBlockOfBytes<BLOCK_SIZE_4K>;
 
-void InitializeMakeNativeBufferBlock() {
-  static const std::unordered_map<std::string, RefPtr<NativeBufferBlock> (*)()>
-      kMakers = {{"4K", MakeNativeBufferBlockOfBytes<BLOCK_SIZE_4K>},
-                 {"64K", MakeNativeBufferBlockOfBytes<BLOCK_SIZE_64K>},
-                 {"1M", MakeNativeBufferBlockOfBytes<BLOCK_SIZE_1M>}
-
-      };
-  auto iter = kMakers.find(FLAGS_tile_buffer_block_size);
-  if (iter != kMakers.end()) {
-    make_native_buffer_block = iter->second;
-  } else {
-    TILE_UNEXPECTED(
-        "Unexpected buffer block size [{}]. Only 4K/64K/1M buffer block "
-        "is supported.",
-        FLAGS_tile_buffer_block_size);
-  }
+void
+InitializeMakeNativeBufferBlock()
+{
+    static const std::unordered_map<std::string, RefPtr<NativeBufferBlock> (*)()> kMakers = {
+        {"4K",  MakeNativeBufferBlockOfBytes<BLOCK_SIZE_4K> },
+        {"64K", MakeNativeBufferBlockOfBytes<BLOCK_SIZE_64K>},
+        {"1M",  MakeNativeBufferBlockOfBytes<BLOCK_SIZE_1M> }
+    };
+    auto iter = kMakers.find(FLAGS_tile_buffer_block_size);
+    if (iter != kMakers.end()) {
+        make_native_buffer_block = iter->second;
+    } else {
+        TILE_UNEXPECTED("Unexpected buffer block size [{}]. Only 4K/64K/1M buffer block "
+                        "is supported.",
+                        FLAGS_tile_buffer_block_size);
+    }
 }
 
 TILE_ON_INIT(0, InitializeMakeNativeBufferBlock);
 
-} // namespace
+}// namespace
 
-RefPtr<NativeBufferBlock> MakeNativeBufferBlock() {
-  return make_native_buffer_block();
+RefPtr<NativeBufferBlock>
+MakeNativeBufferBlock()
+{
+    return make_native_buffer_block();
 }
 
-template <> struct PoolTraits<FixedNativeBufferBlock<BLOCK_SIZE_4K>> {
-  static constexpr auto kType = PoolType::MemoryNodeShared;
-  static constexpr auto kLowWaterMark = 16384; // 64M per node.
-  static constexpr auto kHighWaterMark =
-      std::numeric_limits<std::size_t>::max();
-  static constexpr auto kMaxIdle = std::chrono::seconds(10);
-  static constexpr auto kMinimumThreadCacheSize = 4096; // 16M per thread.
-  static constexpr auto kTransferBatchSize = 1024;      // Extra 4M.
+template<>
+struct PoolTraits<FixedNativeBufferBlock<BLOCK_SIZE_4K>> {
+    static constexpr auto kType                   = PoolType::MemoryNodeShared;
+    static constexpr auto kLowWaterMark           = 16384;// 64M per node.
+    static constexpr auto kHighWaterMark          = std::numeric_limits<std::size_t>::max();
+    static constexpr auto kMaxIdle                = std::chrono::seconds(10);
+    static constexpr auto kMinimumThreadCacheSize = 4096;// 16M per thread.
+    static constexpr auto kTransferBatchSize      = 1024;// Extra 4M.
 };
 
-template <> struct PoolTraits<FixedNativeBufferBlock<BLOCK_SIZE_64K>> {
-  static constexpr auto kType = PoolType::MemoryNodeShared;
-  static constexpr auto kLowWaterMark = 1024; // 64M per node.
-  static constexpr auto kHighWaterMark =
-      std::numeric_limits<std::size_t>::max();
-  static constexpr auto kMaxIdle = std::chrono::seconds(10);
-  static constexpr auto kMinimumThreadCacheSize = 256; // 16M per thread.
-  static constexpr auto kTransferBatchSize = 64;       // Extra 4M.
+template<>
+struct PoolTraits<FixedNativeBufferBlock<BLOCK_SIZE_64K>> {
+    static constexpr auto kType                   = PoolType::MemoryNodeShared;
+    static constexpr auto kLowWaterMark           = 1024;// 64M per node.
+    static constexpr auto kHighWaterMark          = std::numeric_limits<std::size_t>::max();
+    static constexpr auto kMaxIdle                = std::chrono::seconds(10);
+    static constexpr auto kMinimumThreadCacheSize = 256;// 16M per thread.
+    static constexpr auto kTransferBatchSize      = 64; // Extra 4M.
 };
 
-template <> struct PoolTraits<FixedNativeBufferBlock<BLOCK_SIZE_1M>> {
-  static constexpr auto kType = PoolType::MemoryNodeShared;
-  static constexpr auto kLowWaterMark = 128; // 128M per node.
-  static constexpr auto kHighWaterMark =
-      std::numeric_limits<std::size_t>::max();
-  static constexpr auto kMaxIdle = std::chrono::seconds(10);
-  static constexpr auto kMinimumThreadCacheSize = 64; // 64M per thread.
-  static constexpr auto kTransferBatchSize = 16;      // Extra 16M.
+template<>
+struct PoolTraits<FixedNativeBufferBlock<BLOCK_SIZE_1M>> {
+    static constexpr auto kType                   = PoolType::MemoryNodeShared;
+    static constexpr auto kLowWaterMark           = 128;// 128M per node.
+    static constexpr auto kHighWaterMark          = std::numeric_limits<std::size_t>::max();
+    static constexpr auto kMaxIdle                = std::chrono::seconds(10);
+    static constexpr auto kMinimumThreadCacheSize = 64;// 64M per thread.
+    static constexpr auto kTransferBatchSize      = 16;// Extra 16M.
 };
 
 constexpr PoolType PoolTraits<FixedNativeBufferBlock<BLOCK_SIZE_4K>>::kType;
 constexpr PoolType PoolTraits<FixedNativeBufferBlock<BLOCK_SIZE_64K>>::kType;
 constexpr PoolType PoolTraits<FixedNativeBufferBlock<BLOCK_SIZE_1M>>::kType;
 
-constexpr std::chrono::seconds
-    PoolTraits<FixedNativeBufferBlock<BLOCK_SIZE_4K>>::kMaxIdle;
-constexpr std::chrono::seconds
-    PoolTraits<FixedNativeBufferBlock<BLOCK_SIZE_64K>>::kMaxIdle;
-constexpr std::chrono::seconds
-    PoolTraits<FixedNativeBufferBlock<BLOCK_SIZE_1M>>::kMaxIdle;
+constexpr std::chrono::seconds PoolTraits<FixedNativeBufferBlock<BLOCK_SIZE_4K>>::kMaxIdle;
+constexpr std::chrono::seconds PoolTraits<FixedNativeBufferBlock<BLOCK_SIZE_64K>>::kMaxIdle;
+constexpr std::chrono::seconds PoolTraits<FixedNativeBufferBlock<BLOCK_SIZE_1M>>::kMaxIdle;
 
-} // namespace tile
+}// namespace tile
diff --git a/tile/base/buffer/builtin_buffer_block.h b/tile/base/buffer/builtin_buffer_block.h
index ef4480b..484b3ea 100644
--- a/tile/base/buffer/builtin_buffer_block.h
+++ b/tile/base/buffer/builtin_buffer_block.h
@@ -8,34 +8,32 @@
 #include "tile/base/ref_ptr.h"
 
 namespace tile {
-class alignas(hardware_destructive_interference_size) NativeBufferBlock
-    : public PolymorphicBufferBlock {
+class alignas(hardware_destructive_interference_size) NativeBufferBlock : public PolymorphicBufferBlock {
 public:
-  virtual char *mutable_data() noexcept = 0;
+    virtual char *mutable_data() noexcept = 0;
 };
 
 RefPtr<NativeBufferBlock> MakeNativeBufferBlock();
 
-template <typename F>
-class ReferencingBufferBlock : public PolymorphicBufferBlock,
-                               private F /* Empty Base Optimize */ {
+template<typename F>
+class ReferencingBufferBlock : public PolymorphicBufferBlock, private F /* Empty Base Optimize */ {
 public:
-  explicit ReferencingBufferBlock(const void *ptr, std::size_t size,
-                                  F &&completion_cb)
-      : F(std::move(completion_cb)), ptr_(ptr), size_(size) {}
+    explicit ReferencingBufferBlock(const void *ptr, std::size_t size, F &&completion_cb)
+        : F(std::move(completion_cb)),
+          ptr_(ptr),
+          size_(size)
+    {}
 
-  ~ReferencingBufferBlock() override { (*this)(); }
+    ~ReferencingBufferBlock() override { (*this)(); }
 
-  const char *data() const noexcept override {
-    return reinterpret_cast<const char *>(ptr_);
-  }
+    const char *data() const noexcept override { return reinterpret_cast<const char *>(ptr_); }
 
-  std::size_t size() const noexcept override { return size_; }
+    std::size_t size() const noexcept override { return size_; }
 
 private:
-  const void *ptr_;
-  std::size_t size_;
-}; // namespace tile
-} // namespace tile
+    const void *ptr_;
+    std::size_t size_;
+};// namespace tile
+}// namespace tile
 
-#endif // TILE_BASE_BUFFER_BUILTIN_BUFFER_BLOCK_H
+#endif// TILE_BASE_BUFFER_BUILTIN_BUFFER_BLOCK_H
diff --git a/tile/base/buffer/circular_buffer.h b/tile/base/buffer/circular_buffer.h
index a35746d..9a55aad 100644
--- a/tile/base/buffer/circular_buffer.h
+++ b/tile/base/buffer/circular_buffer.h
@@ -9,59 +9,63 @@
 #include <vector>
 
 namespace tile {
-template <typename T> class CircularBuffer {
-  class UninitializedObject;
+template<typename T>
+class CircularBuffer {
+    class UninitializedObject;
 
 public:
-  explicit CircularBuffer(std::size_t capacity);
+    explicit CircularBuffer(std::size_t capacity);
 
-  template <typename... Ts> bool Emplace(Ts &&...args) {
-    auto head = head_.load(std::memory_order_relaxed);
-    auto next = NormalizeIndex(head + 1);
+    template<typename... Ts>
+    bool Emplace(Ts &&...args)
+    {
+        auto head = head_.load(std::memory_order_relaxed);
+        auto next = NormalizeIndex(head + 1);
 
-    if (next == tail_.load(std::memory_order_acquire)) {
-      return false;
+        if (next == tail_.load(std::memory_order_acquire)) { return false; }
+
+        objects_[head].Initialize(std::forward<Ts>(args)...);
+        head_.store(next, std::memory_order_release);
+        return true;
     }
 
-    objects_[head].Initialize(std::forward<Ts>(args)...);
-    head_.store(next, std::memory_order_release);
-    return true;
-  }
+    void Pop(std::vector<T> *objects)
+    {
+        auto upto    = head_.load(std::memory_order_acquire);
+        auto current = tail_.load(std::memory_order_relaxed);
+        while (current != upto) {
+            objects->push_back(std::move(*objects_[current].Get()));
+            objects_[current].Destroy();
+            current = NormalizeIndex(current + 1);
+        }
 
-  void Pop(std::vector<T> *objects) {
-    auto upto = head_.load(std::memory_order_acquire);
-    auto current = tail_.load(std::memory_order_relaxed);
-    while (current != upto) {
-      objects->push_back(std::move(*objects_[current].Get()));
-      objects_[current].Destroy();
-      current = NormalizeIndex(current + 1);
+        tail_.store(current, std::memory_order_release);
     }
 
-    tail_.store(current, std::memory_order_release);
-  }
-
 private:
-  class UninitializedObject {
-  public:
-    T *Get() noexcept { return reinterpret_cast<T *>(&storage_); }
-    template <typename... Ts> void Initialize(Ts &&...args) {
-      new (Get()) T(std::forward<Ts>(args)...);
-    }
+    class UninitializedObject {
+    public:
+        T *Get() noexcept { return reinterpret_cast<T *>(&storage_); }
 
-    void Destroy() { Get()->~T(); }
+        template<typename... Ts>
+        void Initialize(Ts &&...args)
+        {
+            new (Get()) T(std::forward<Ts>(args)...);
+        }
 
-  private:
-    std::aligned_storage<sizeof(T), alignof(T)> storage_;
-  };
-  std::size_t NormalizeIndex(std::size_t x) {
-    return (x < capacity_) ? x : x - capacity_;
-  }
+        void Destroy() { Get()->~T(); }
+
+    private:
+        std::aligned_storage<sizeof(T), alignof(T)> storage_;
+    };
+
+    std::size_t NormalizeIndex(std::size_t x) { return (x < capacity_) ? x : x - capacity_; }
 
 private:
-  std::size_t capacity_;
-  std::unique_ptr<UninitializedObject[]> objects_;
-  std::atomic<std::size_t> head_{}, tail_{};
+    std::size_t capacity_;
+    std::unique_ptr<UninitializedObject[]> objects_;
+    std::atomic<std::size_t> head_{}, tail_{};
 };
-} // namespace tile
+}// namespace tile
 
-#endif // _TILE_BASE_BUFFER_CIRCULAR_BUFFER_H
+#endif// _TILE_BASE_BUFFER_CIRCULAR_BUFFER_H
diff --git a/tile/base/buffer/compression_output_stream.cc b/tile/base/buffer/compression_output_stream.cc
index 3bafc42..798aeed 100644
--- a/tile/base/buffer/compression_output_stream.cc
+++ b/tile/base/buffer/compression_output_stream.cc
@@ -2,42 +2,39 @@
 
 namespace tile {
 
-NoncontiguousBufferCompressionOutputStream::
-    NoncontiguousBufferCompressionOutputStream(
-        NoncontiguousBufferBuilder *builder)
-    : builder_(builder) {}
+NoncontiguousBufferCompressionOutputStream::NoncontiguousBufferCompressionOutputStream(
+    NoncontiguousBufferBuilder *builder)
+    : builder_(builder)
+{}
 
-NoncontiguousBufferCompressionOutputStream::
-    ~NoncontiguousBufferCompressionOutputStream() {
-  Flush();
+NoncontiguousBufferCompressionOutputStream::~NoncontiguousBufferCompressionOutputStream() { Flush(); }
+
+void
+NoncontiguousBufferCompressionOutputStream::Flush()
+{
+    if (using_bytes_ > 0) {
+        builder_->MarkWritten(using_bytes_);
+        using_bytes_ = 0;
+    }
 }
 
-void NoncontiguousBufferCompressionOutputStream::Flush() {
-  if (using_bytes_ > 0) {
-    builder_->MarkWritten(using_bytes_);
-    using_bytes_ = 0;
-  }
+bool
+NoncontiguousBufferCompressionOutputStream::Next(void **data, std::size_t *size) noexcept
+{
+    if (!builder_) { return false; }
+
+    if (using_bytes_) { builder_->MarkWritten(using_bytes_); }
+
+    *data        = builder_->data();
+    *size        = builder_->SizeAvailable();
+    using_bytes_ = *size;
+    TILE_CHECK(*size > 0);
+    return true;
 }
 
-bool NoncontiguousBufferCompressionOutputStream::Next(
-    void **data, std::size_t *size) noexcept {
-  if (!builder_) {
-    return false;
-  }
-
-  if (using_bytes_) {
-    builder_->MarkWritten(using_bytes_);
-  }
-
-  *data = builder_->data();
-  *size = builder_->SizeAvailable();
-  using_bytes_ = *size;
-  TILE_CHECK(*size > 0);
-  return true;
+void
+NoncontiguousBufferCompressionOutputStream::BackUp(std::size_t count) noexcept
+{
+    using_bytes_ -= count;
 }
-
-void NoncontiguousBufferCompressionOutputStream::BackUp(
-    std::size_t count) noexcept {
-  using_bytes_ -= count;
-}
-} // namespace tile
+}// namespace tile
diff --git a/tile/base/buffer/compression_output_stream.h b/tile/base/buffer/compression_output_stream.h
index 7a8b090..244f130 100644
--- a/tile/base/buffer/compression_output_stream.h
+++ b/tile/base/buffer/compression_output_stream.h
@@ -6,22 +6,20 @@
 #include "tile/base/compression/compression.h"
 
 namespace tile {
-class NoncontiguousBufferCompressionOutputStream
-    : public CompressionOutputStream {
+class NoncontiguousBufferCompressionOutputStream : public CompressionOutputStream {
 public:
-  explicit NoncontiguousBufferCompressionOutputStream(
-      NoncontiguousBufferBuilder *builder);
-  ~NoncontiguousBufferCompressionOutputStream() override;
+    explicit NoncontiguousBufferCompressionOutputStream(NoncontiguousBufferBuilder *builder);
+    ~NoncontiguousBufferCompressionOutputStream() override;
 
-  void Flush();
+    void Flush();
 
-  bool Next(void **data, std::size_t *size) noexcept override;
-  void BackUp(std::size_t count) noexcept override;
+    bool Next(void **data, std::size_t *size) noexcept override;
+    void BackUp(std::size_t count) noexcept override;
 
 private:
-  std::size_t using_bytes_{};
-  NoncontiguousBufferBuilder *builder_;
+    std::size_t using_bytes_{};
+    NoncontiguousBufferBuilder *builder_;
 };
-} // namespace tile
+}// namespace tile
 
-#endif // TILE_BASE_BUFFER_COMPRESSION_OUTPUT_STREAM_H
+#endif// TILE_BASE_BUFFER_COMPRESSION_OUTPUT_STREAM_H
diff --git a/tile/base/buffer/polymorphic_buffer.cc b/tile/base/buffer/polymorphic_buffer.cc
index 0476644..663f629 100644
--- a/tile/base/buffer/polymorphic_buffer.cc
+++ b/tile/base/buffer/polymorphic_buffer.cc
@@ -8,14 +8,18 @@ constexpr std::chrono::seconds PoolTraits<PolymorphicBuffer>::kMaxIdle;
 constexpr std::size_t PoolTraits<PolymorphicBuffer>::kMinimumThreadCacheSize;
 constexpr std::size_t PoolTraits<PolymorphicBuffer>::kTransferBatchSize;
 
-void PoolTraits<PolymorphicBuffer>::OnPut(PolymorphicBuffer *bb) {
-  bb->Clear();
+void
+PoolTraits<PolymorphicBuffer>::OnPut(PolymorphicBuffer *bb)
+{
+    bb->Clear();
 }
 
 namespace detail {
-void PolymorphicBufferBlockDeleter ::operator()(PolymorphicBufferBlock *p) {
-  TILE_DCHECK_EQ(p->UnsafeRefCount(), 0);
-  p->Destroy();
+void
+PolymorphicBufferBlockDeleter ::operator()(PolymorphicBufferBlock *p)
+{
+    TILE_DCHECK_EQ(p->UnsafeRefCount(), 0);
+    p->Destroy();
 }
-} // namespace detail
-} // namespace tile
+}// namespace detail
+}// namespace tile
diff --git a/tile/base/buffer/polymorphic_buffer.h b/tile/base/buffer/polymorphic_buffer.h
index ec8547e..18b3840 100644
--- a/tile/base/buffer/polymorphic_buffer.h
+++ b/tile/base/buffer/polymorphic_buffer.h
@@ -19,102 +19,111 @@ namespace detail {
 struct PolymorphicBufferBlockDeleter;
 }
 
-class PolymorphicBufferBlock
-    : public RefCounted<PolymorphicBufferBlock,
-                        detail::PolymorphicBufferBlockDeleter> {
+class PolymorphicBufferBlock : public RefCounted<PolymorphicBufferBlock, detail::PolymorphicBufferBlockDeleter> {
 public:
-  virtual ~PolymorphicBufferBlock() = default;
-  virtual const char *data() const noexcept = 0;
-  virtual std::size_t size() const noexcept = 0;
-  virtual void Destroy() noexcept { delete this; }
+    virtual ~PolymorphicBufferBlock()         = default;
+    virtual const char *data() const noexcept = 0;
+    virtual std::size_t size() const noexcept = 0;
+
+    virtual void Destroy() noexcept { delete this; }
 };
 
-static_assert(!std::is_same<detail::as_ref_counted_t<PolymorphicBufferBlock>,
-                            PolymorphicBufferBlock>::value,
-              "");
-static_assert(detail::is_default_ref_traits_safe<PolymorphicBufferBlock>::value,
-              "");
+static_assert(!std::is_same<detail::as_ref_counted_t<PolymorphicBufferBlock>, PolymorphicBufferBlock>::value, "");
+static_assert(detail::is_default_ref_traits_safe<PolymorphicBufferBlock>::value, "");
+
 class PolymorphicBuffer {
 public:
-  PolymorphicBuffer() = default;
-  PolymorphicBuffer(const PolymorphicBuffer &) = default;
-  PolymorphicBuffer &operator=(const PolymorphicBuffer &) = default;
+    PolymorphicBuffer()                                     = default;
+    PolymorphicBuffer(const PolymorphicBuffer &)            = default;
+    PolymorphicBuffer &operator=(const PolymorphicBuffer &) = default;
 
-  PolymorphicBuffer(PolymorphicBuffer &&other) noexcept
-      : ptr_(other.ptr_), size_(other.size_), ref_(std::move(other.ref_)) {
-    other.Clear();
-  }
-  PolymorphicBuffer &operator=(PolymorphicBuffer &&other) noexcept {
-    if (this != &other) {
-      ptr_ = other.ptr_;
-      size_ = other.size_;
-      ref_ = other.ref_;
-      other.Clear();
+    PolymorphicBuffer(PolymorphicBuffer &&other) noexcept
+        : ptr_(other.ptr_),
+          size_(other.size_),
+          ref_(std::move(other.ref_))
+    {
+        other.Clear();
     }
-    return *this;
-  }
 
-  PolymorphicBuffer(RefPtr<PolymorphicBufferBlock> data, std::size_t start,
-                    std::size_t size)
-      : ptr_(data->data() + start), size_(size), ref_(std::move(data)) {}
+    PolymorphicBuffer &operator=(PolymorphicBuffer &&other) noexcept
+    {
+        if (this != &other) {
+            ptr_  = other.ptr_;
+            size_ = other.size_;
+            ref_  = other.ref_;
+            other.Clear();
+        }
+        return *this;
+    }
 
-  const char *data() const noexcept { return ptr_; }
-  std::size_t size() const noexcept { return size_; }
+    PolymorphicBuffer(RefPtr<PolymorphicBufferBlock> data, std::size_t start, std::size_t size)
+        : ptr_(data->data() + start),
+          size_(size),
+          ref_(std::move(data))
+    {}
 
-  void Skip(std::size_t bytes) {
-    TILE_CHECK_LT(bytes, size_);
-    size_ -= bytes;
-    ptr_ += bytes;
-  }
+    const char *data() const noexcept { return ptr_; }
 
-  void set_size(std::size_t size) {
-    TILE_DCHECK_LE(size, size_);
-    size_ = size;
-  }
+    std::size_t size() const noexcept { return size_; }
 
-  void Reset(RefPtr<PolymorphicBufferBlock> data, std::size_t start,
-             std::size_t size) {
-    TILE_DCHECK_LE(start, size);
-    TILE_DCHECK_LE(size, data->size());
+    void Skip(std::size_t bytes)
+    {
+        TILE_CHECK_LT(bytes, size_);
+        size_ -= bytes;
+        ptr_ += bytes;
+    }
 
-    ref_ = std::move(data);
-    ptr_ = data->data() + start;
-    size_ = size;
-  }
+    void set_size(std::size_t size)
+    {
+        TILE_DCHECK_LE(size, size_);
+        size_ = size;
+    }
 
-  void Clear() {
-    ptr_ = nullptr;
-    size_ = 0;
-    ref_ = nullptr;
-  }
+    void Reset(RefPtr<PolymorphicBufferBlock> data, std::size_t start, std::size_t size)
+    {
+        TILE_DCHECK_LE(start, size);
+        TILE_DCHECK_LE(size, data->size());
+
+        ref_  = std::move(data);
+        ptr_  = data->data() + start;
+        size_ = size;
+    }
+
+    void Clear()
+    {
+        ptr_  = nullptr;
+        size_ = 0;
+        ref_  = nullptr;
+    }
 
 private:
-  friend class NoncontiguousBuffer;
+    friend class NoncontiguousBuffer;
 
-  internal::SinglyLinkedListEntry chain;
-  const char *ptr_{};
-  std::size_t size_{};
-  RefPtr<PolymorphicBufferBlock> ref_;
+    internal::SinglyLinkedListEntry chain;
+    const char *ptr_{};
+    std::size_t size_{};
+    RefPtr<PolymorphicBufferBlock> ref_;
 };
+
 namespace detail {
 struct PolymorphicBufferBlockDeleter {
-  void operator()(PolymorphicBufferBlock *p);
+    void operator()(PolymorphicBufferBlock *p);
 };
-} // namespace detail
+}// namespace detail
 
-} // namespace tile
+}// namespace tile
 
 namespace tile {
-template <> struct PoolTraits<PolymorphicBuffer> {
-  static constexpr auto kType = PoolType::MemoryNodeShared;
-  static constexpr std::size_t kLowWaterMark = 32768;
-  static constexpr std::size_t kHighWaterMark =
-      std::numeric_limits<std::size_t>::max();
-  static constexpr std::chrono::seconds kMaxIdle = std::chrono::seconds(10);
-  static constexpr std::size_t kMinimumThreadCacheSize = 8192;
-  static constexpr std::size_t kTransferBatchSize = 1024;
+template<>
+struct PoolTraits<PolymorphicBuffer> {
+    static constexpr auto kType                          = PoolType::MemoryNodeShared;
+    static constexpr std::size_t kLowWaterMark           = 32768;
+    static constexpr std::size_t kHighWaterMark          = std::numeric_limits<std::size_t>::max();
+    static constexpr std::chrono::seconds kMaxIdle       = std::chrono::seconds(10);
+    static constexpr std::size_t kMinimumThreadCacheSize = 8192;
+    static constexpr std::size_t kTransferBatchSize      = 1024;
 
-  static void OnPut(PolymorphicBuffer *bb);
+    static void OnPut(PolymorphicBuffer *bb);
 };
-} // namespace tile
-#endif // TILE_BASE_BUFFER_POLYMORPHIC_BUFFER_H
+}// namespace tile
+#endif// TILE_BASE_BUFFER_POLYMORPHIC_BUFFER_H
diff --git a/tile/base/buffer_test.cc b/tile/base/buffer_test.cc
index c972a9c..ddc1a0e 100644
--- a/tile/base/buffer_test.cc
+++ b/tile/base/buffer_test.cc
@@ -14,280 +14,308 @@ namespace tile {
 
 namespace {
 
-PolymorphicBuffer MakeNativeBuffer(Slice s) {
-  auto buffer = MakeNativeBufferBlock();
-  memcpy(buffer->mutable_data(), s.data(), s.size());
-  return PolymorphicBuffer(buffer, 0, s.size());
+PolymorphicBuffer
+MakeNativeBuffer(Slice s)
+{
+    auto buffer = MakeNativeBufferBlock();
+    memcpy(buffer->mutable_data(), s.data(), s.size());
+    return PolymorphicBuffer(buffer, 0, s.size());
 }
 
-} // namespace
+}// namespace
 
-TEST(CreateBufferSlow, All) {
-  static const auto kData = Slice("sadfas234sadf-/+8sdaf sd f~!#");
-  auto nb = CreateBufferSlow(kData);
-  ASSERT_EQ(kData, nb.FirstContiguous().data());
-  ASSERT_EQ(kData, FlattenSlow(nb));
+TEST(CreateBufferSlow, All)
+{
+    static const auto kData = Slice("sadfas234sadf-/+8sdaf sd f~!#");
+    auto nb                 = CreateBufferSlow(kData);
+    ASSERT_EQ(kData, nb.FirstContiguous().data());
+    ASSERT_EQ(kData, FlattenSlow(nb));
 }
 
-TEST(NoncontiguousBuffer, Cut) {
-  NoncontiguousBuffer nb;
-  nb.Append(CreateBufferSlow("asdf"));
-  auto r = nb.Cut(3);
-  ASSERT_EQ(1, nb.ByteSize());
-  ASSERT_EQ("f", FlattenSlow(nb));
-  ASSERT_EQ(3, r.ByteSize());
-  ASSERT_EQ("asd", FlattenSlow(r));
+TEST(NoncontiguousBuffer, Cut)
+{
+    NoncontiguousBuffer nb;
+    nb.Append(CreateBufferSlow("asdf"));
+    auto r = nb.Cut(3);
+    ASSERT_EQ(1, nb.ByteSize());
+    ASSERT_EQ("f", FlattenSlow(nb));
+    ASSERT_EQ(3, r.ByteSize());
+    ASSERT_EQ("asd", FlattenSlow(r));
 }
 
-TEST(NoncontiguousBuffer, Cut1) {
-  NoncontiguousBuffer nb;
-  nb.Append(CreateBufferSlow("asdf"));
-  auto r = nb.Cut(4);
-  ASSERT_TRUE(nb.Empty());
-  ASSERT_EQ(4, r.ByteSize());
+TEST(NoncontiguousBuffer, Cut1)
+{
+    NoncontiguousBuffer nb;
+    nb.Append(CreateBufferSlow("asdf"));
+    auto r = nb.Cut(4);
+    ASSERT_TRUE(nb.Empty());
+    ASSERT_EQ(4, r.ByteSize());
 }
 
-TEST(NoncontiguousBuffer, Cut2) {
-  NoncontiguousBuffer nb;
-  nb.Append(MakeNativeBuffer("asdf"));
-  nb.Append(MakeNativeBuffer("asdf"));
-  auto r = nb.Cut(4);
-  ASSERT_EQ(4, nb.ByteSize());
-  ASSERT_EQ(4, r.ByteSize());
+TEST(NoncontiguousBuffer, Cut2)
+{
+    NoncontiguousBuffer nb;
+    nb.Append(MakeNativeBuffer("asdf"));
+    nb.Append(MakeNativeBuffer("asdf"));
+    auto r = nb.Cut(4);
+    ASSERT_EQ(4, nb.ByteSize());
+    ASSERT_EQ(4, r.ByteSize());
 }
 
-TEST(NoncontiguousBuffer, Cut3) {
-  NoncontiguousBuffer nb;
-  nb.Append(MakeNativeBuffer("asdf"));
-  nb.Append(MakeNativeBuffer("asdf"));
-  auto r = nb.Cut(8);
-  ASSERT_TRUE(nb.Empty());
-  ASSERT_EQ(8, r.ByteSize());
+TEST(NoncontiguousBuffer, Cut3)
+{
+    NoncontiguousBuffer nb;
+    nb.Append(MakeNativeBuffer("asdf"));
+    nb.Append(MakeNativeBuffer("asdf"));
+    auto r = nb.Cut(8);
+    ASSERT_TRUE(nb.Empty());
+    ASSERT_EQ(8, r.ByteSize());
 }
 
-TEST(NoncontiguousBuffer, Cut4) {
-  auto nb = CreateBufferSlow("asdfasf2345sfsdfdf");
-  auto nb2 = nb;
-  ASSERT_EQ(FlattenSlow(nb), FlattenSlow(nb2));
-  NoncontiguousBuffer splited;
-  splited.Append(nb.Cut(1));
-  splited.Append(nb.Cut(2));
-  splited.Append(nb.Cut(3));
-  splited.Append(nb.Cut(4));
-  splited.Append(std::move(nb));
-  ASSERT_EQ(FlattenSlow(nb2), FlattenSlow(splited));
+TEST(NoncontiguousBuffer, Cut4)
+{
+    auto nb  = CreateBufferSlow("asdfasf2345sfsdfdf");
+    auto nb2 = nb;
+    ASSERT_EQ(FlattenSlow(nb), FlattenSlow(nb2));
+    NoncontiguousBuffer splited;
+    splited.Append(nb.Cut(1));
+    splited.Append(nb.Cut(2));
+    splited.Append(nb.Cut(3));
+    splited.Append(nb.Cut(4));
+    splited.Append(std::move(nb));
+    ASSERT_EQ(FlattenSlow(nb2), FlattenSlow(splited));
 }
 
-TEST(NoncontiguousBuffer, Skip) {
-  NoncontiguousBuffer splited;
-  splited.Append(CreateBufferSlow("asdf"));
-  splited.Append(CreateBufferSlow("asdf"));
-  splited.Append(CreateBufferSlow("asdf"));
-  splited.Append(CreateBufferSlow("asdf"));
-  splited.Append(CreateBufferSlow("asdf"));
-  splited.Append(CreateBufferSlow("asdf"));
-  splited.Append(CreateBufferSlow("asdf"));
-  splited.Append(CreateBufferSlow("asdf"));
-  splited.Skip(32);
-  ASSERT_EQ(0, splited.ByteSize());
+TEST(NoncontiguousBuffer, Skip)
+{
+    NoncontiguousBuffer splited;
+    splited.Append(CreateBufferSlow("asdf"));
+    splited.Append(CreateBufferSlow("asdf"));
+    splited.Append(CreateBufferSlow("asdf"));
+    splited.Append(CreateBufferSlow("asdf"));
+    splited.Append(CreateBufferSlow("asdf"));
+    splited.Append(CreateBufferSlow("asdf"));
+    splited.Append(CreateBufferSlow("asdf"));
+    splited.Append(CreateBufferSlow("asdf"));
+    splited.Skip(32);
+    ASSERT_EQ(0, splited.ByteSize());
 }
 
-TEST(NoncontiguousBuffer, Skip2) {
-  NoncontiguousBuffer buffer;
-  EXPECT_TRUE(buffer.Empty());
-  buffer.Skip(0); // Don't crash.
-  EXPECT_TRUE(buffer.Empty());
+TEST(NoncontiguousBuffer, Skip2)
+{
+    NoncontiguousBuffer buffer;
+    EXPECT_TRUE(buffer.Empty());
+    buffer.Skip(0);// Don't crash.
+    EXPECT_TRUE(buffer.Empty());
 }
 
-TEST(NoncontiguousBuffer, FlattenSlow) {
-  NoncontiguousBuffer nb;
-  nb.Append(MakeNativeBuffer("asd4234"));
-  nb.Append(MakeNativeBuffer("aXsdfsadfasdf2342"));
-  ASSERT_EQ("asd4234aXs", FlattenSlow(nb, 10));
+TEST(NoncontiguousBuffer, FlattenSlow)
+{
+    NoncontiguousBuffer nb;
+    nb.Append(MakeNativeBuffer("asd4234"));
+    nb.Append(MakeNativeBuffer("aXsdfsadfasdf2342"));
+    ASSERT_EQ("asd4234aXs", FlattenSlow(nb, 10));
 }
 
-TEST(NoncontiguousBuffer, FlattenToSlow) {
-  struct C {
-    std::uint64_t ll;
-    int i;
-    bool f;
-  };
-  NoncontiguousBuffer nb;
-  nb.Append(MakeNativeBuffer(Slice("\x12\x34\x56\x78\x9a\xbc\xde\xf0", 8)));
-  nb.Append(MakeNativeBuffer(Slice("\x12\x34\x56\x78", 4)));
-  nb.Append(MakeNativeBuffer(Slice("\x1", 1)));
-  nb.Append(MakeNativeBuffer(Slice("\x00\x00\x00", 3))); // Padding
-  C c;
-  FlattenToSlow(nb, &c, sizeof(C));
-  ASSERT_EQ(0xf0debc9a78563412, c.ll);
-  ASSERT_EQ(0x78563412, c.i);
-  ASSERT_EQ(true, c.f);
+TEST(NoncontiguousBuffer, FlattenToSlow)
+{
+    struct C {
+        std::uint64_t ll;
+        int i;
+        bool f;
+    };
+
+    NoncontiguousBuffer nb;
+    nb.Append(MakeNativeBuffer(Slice("\x12\x34\x56\x78\x9a\xbc\xde\xf0", 8)));
+    nb.Append(MakeNativeBuffer(Slice("\x12\x34\x56\x78", 4)));
+    nb.Append(MakeNativeBuffer(Slice("\x1", 1)));
+    nb.Append(MakeNativeBuffer(Slice("\x00\x00\x00", 3)));// Padding
+    C c;
+    FlattenToSlow(nb, &c, sizeof(C));
+    ASSERT_EQ(0xf0debc9a78563412, c.ll);
+    ASSERT_EQ(0x78563412, c.i);
+    ASSERT_EQ(true, c.f);
 }
 
-TEST(NoncontiguousBuffer, FlattenSlowUntil) {
-  NoncontiguousBuffer nb;
-  nb.Append(MakeNativeBuffer("asd4234"));
-  nb.Append(MakeNativeBuffer("aXsdfsadfasdf2342"));
-  ASSERT_EQ("asd4234aX", FlattenSlowUntil(nb, "aX"));
-  ASSERT_EQ("asd4", FlattenSlowUntil(nb, "4"));
-  ASSERT_EQ("asd4234aXsdfsadfasdf2342", FlattenSlowUntil(nb, "2342"));
-  ASSERT_EQ("asd42", FlattenSlowUntil(nb, "z", 5));
-  ASSERT_EQ("asd42", FlattenSlowUntil(nb, "3", 5));
-  ASSERT_EQ("asd42", FlattenSlowUntil(nb, "2", 5));
-  ASSERT_EQ("asd4", FlattenSlowUntil(nb, "4", 5));
+TEST(NoncontiguousBuffer, FlattenSlowUntil)
+{
+    NoncontiguousBuffer nb;
+    nb.Append(MakeNativeBuffer("asd4234"));
+    nb.Append(MakeNativeBuffer("aXsdfsadfasdf2342"));
+    ASSERT_EQ("asd4234aX", FlattenSlowUntil(nb, "aX"));
+    ASSERT_EQ("asd4", FlattenSlowUntil(nb, "4"));
+    ASSERT_EQ("asd4234aXsdfsadfasdf2342", FlattenSlowUntil(nb, "2342"));
+    ASSERT_EQ("asd42", FlattenSlowUntil(nb, "z", 5));
+    ASSERT_EQ("asd42", FlattenSlowUntil(nb, "3", 5));
+    ASSERT_EQ("asd42", FlattenSlowUntil(nb, "2", 5));
+    ASSERT_EQ("asd4", FlattenSlowUntil(nb, "4", 5));
 }
 
-TEST(NoncontiguousBuffer, FlattenSlowUntil2) {
-  auto nb = CreateBufferSlow(
-      "HTTP/1.1 200 OK\r\nRpc-SeqNo: 14563016719\r\nRpc-Error-Code: "
-      "0\r\nRpc-Error-Reason: The operation completed "
-      "successfully.\r\nContent-Type: "
-      "application/x-protobuf\r\nContent-Length: 0\r\n\r\nHTTP/1.1 200 "
-      "OK\r\nRpc-Seq");
-  ASSERT_EQ("HTTP/1.1 200 OK\r\nRpc-SeqNo: 14563016719\r\nRpc-Error-Code: "
-            "0\r\nRpc-Error-Reason: The operation completed "
-            "successfully.\r\nContent-Type: "
-            "application/x-protobuf\r\nContent-Length: 0\r\n\r\n",
-            FlattenSlowUntil(nb, "\r\n\r\n"));
+TEST(NoncontiguousBuffer, FlattenSlowUntil2)
+{
+    auto nb = CreateBufferSlow(
+        "HTTP/1.1 200 OK\r\nRpc-SeqNo: 14563016719\r\nRpc-Error-Code: "
+        "0\r\nRpc-Error-Reason: The operation completed "
+        "successfully.\r\nContent-Type: "
+        "application/x-protobuf\r\nContent-Length: 0\r\n\r\nHTTP/1.1 200 "
+        "OK\r\nRpc-Seq");
+    ASSERT_EQ("HTTP/1.1 200 OK\r\nRpc-SeqNo: 14563016719\r\nRpc-Error-Code: "
+              "0\r\nRpc-Error-Reason: The operation completed "
+              "successfully.\r\nContent-Type: "
+              "application/x-protobuf\r\nContent-Length: 0\r\n\r\n",
+              FlattenSlowUntil(nb, "\r\n\r\n"));
 }
 
-TEST(NoncontiguousBuffer, FlattenSlowUntil3) {
-  NoncontiguousBuffer nb;
-  nb.Append(MakeNativeBuffer("asd4234"));
-  nb.Append(MakeNativeBuffer("aXsdfsadfasdf2342"));
-  ASSERT_EQ("asd4234aX", FlattenSlowUntil(nb, "aX"));
-  ASSERT_EQ("asd4", FlattenSlowUntil(nb, "4"));
-  ASSERT_EQ("asd4234aX", FlattenSlowUntil(nb, "4aX"));
+TEST(NoncontiguousBuffer, FlattenSlowUntil3)
+{
+    NoncontiguousBuffer nb;
+    nb.Append(MakeNativeBuffer("asd4234"));
+    nb.Append(MakeNativeBuffer("aXsdfsadfasdf2342"));
+    ASSERT_EQ("asd4234aX", FlattenSlowUntil(nb, "aX"));
+    ASSERT_EQ("asd4", FlattenSlowUntil(nb, "4"));
+    ASSERT_EQ("asd4234aX", FlattenSlowUntil(nb, "4aX"));
 }
 
-TEST(NoncontiguousBuffer, FlattenSlowUntil4) {
-  NoncontiguousBuffer nb;
-  nb.Append(MakeNativeBuffer("AB"));
-  nb.Append(MakeNativeBuffer("CDEFGGGGHHHH"));
-  ASSERT_EQ("ABCDEFGGGG", FlattenSlowUntil(nb, "GGGG"));
+TEST(NoncontiguousBuffer, FlattenSlowUntil4)
+{
+    NoncontiguousBuffer nb;
+    nb.Append(MakeNativeBuffer("AB"));
+    nb.Append(MakeNativeBuffer("CDEFGGGGHHHH"));
+    ASSERT_EQ("ABCDEFGGGG", FlattenSlowUntil(nb, "GGGG"));
 }
 
-TEST(NoncontiguousBufferBuilder, Append) {
-  NoncontiguousBufferBuilder nbb;
-  nbb.Append(MakeForeignBuffer(""));
-  nbb.Append(MakeForeignBuffer("small"));
-  nbb.Append(MakeForeignBuffer(std::string(8192, 'a')));
-  nbb.Append(CreateBufferSlow(""));
-  nbb.Append(CreateBufferSlow("small"));
-  nbb.Append(CreateBufferSlow(std::string(8192, 'a')));
-  auto nb = nbb.DestructiveGet();
-  EXPECT_EQ("small" + std::string(8192, 'a') + "small" + std::string(8192, 'a'),
-            FlattenSlow(nb));
+TEST(NoncontiguousBufferBuilder, Append)
+{
+    NoncontiguousBufferBuilder nbb;
+    nbb.Append(MakeForeignBuffer(""));
+    nbb.Append(MakeForeignBuffer("small"));
+    nbb.Append(MakeForeignBuffer(std::string(8192, 'a')));
+    nbb.Append(CreateBufferSlow(""));
+    nbb.Append(CreateBufferSlow("small"));
+    nbb.Append(CreateBufferSlow(std::string(8192, 'a')));
+    auto nb = nbb.DestructiveGet();
+    EXPECT_EQ("small" + std::string(8192, 'a') + "small" + std::string(8192, 'a'), FlattenSlow(nb));
 }
 
-TEST(NoncontiguousBufferBuilder, Reserve) {
-  auto temp_block = MakeNativeBufferBlock();
-  auto max_bytes = temp_block->size();
-  NoncontiguousBufferBuilder nbb;
-  auto ptr = nbb.data();
-  auto ptr2 = nbb.Reserve(10);
-  ASSERT_EQ(ptr, ptr2);
-  ASSERT_EQ(ptr + 10, nbb.data());
-  nbb.Append(std::string(max_bytes - 10 - 1, 'a'));
-  ptr = nbb.data();
-  ptr2 = nbb.Reserve(1); // Last byte in the block.
-  ASSERT_EQ(ptr, ptr2);
-  ASSERT_EQ(max_bytes, nbb.SizeAvailable());
+TEST(NoncontiguousBufferBuilder, Reserve)
+{
+    auto temp_block = MakeNativeBufferBlock();
+    auto max_bytes  = temp_block->size();
+    NoncontiguousBufferBuilder nbb;
+    auto ptr  = nbb.data();
+    auto ptr2 = nbb.Reserve(10);
+    ASSERT_EQ(ptr, ptr2);
+    ASSERT_EQ(ptr + 10, nbb.data());
+    nbb.Append(std::string(max_bytes - 10 - 1, 'a'));
+    ptr  = nbb.data();
+    ptr2 = nbb.Reserve(1);// Last byte in the block.
+    ASSERT_EQ(ptr, ptr2);
+    ASSERT_EQ(max_bytes, nbb.SizeAvailable());
 
-  nbb.Append(std::string(max_bytes - 1, 'a'));
-  ptr = nbb.data();
-  ptr2 = nbb.Reserve(2);
-  ASSERT_NE(ptr, ptr2);
-  ASSERT_EQ(ptr2 + 2, nbb.data());
+    nbb.Append(std::string(max_bytes - 1, 'a'));
+    ptr  = nbb.data();
+    ptr2 = nbb.Reserve(2);
+    ASSERT_NE(ptr, ptr2);
+    ASSERT_EQ(ptr2 + 2, nbb.data());
 }
 
-TEST(NoncontiguousBufferBuilder, DestructiveGet1) {
-  NoncontiguousBufferBuilder nbb;
-  nbb.Append("asdf1234", 6);
-  nbb.Append("1122", 4);
-  ASSERT_EQ("asdf12"
-            "1122",
-            FlattenSlow(nbb.DestructiveGet()));
+TEST(NoncontiguousBufferBuilder, DestructiveGet1)
+{
+    NoncontiguousBufferBuilder nbb;
+    nbb.Append("asdf1234", 6);
+    nbb.Append("1122", 4);
+    ASSERT_EQ("asdf12"
+              "1122",
+              FlattenSlow(nbb.DestructiveGet()));
 }
 
-TEST(NoncontiguousBufferBuilder, DestructiveGet2) {
-  NoncontiguousBufferBuilder nbb;
-  nbb.Append("aabbccd");
-  ASSERT_EQ("aabbccd", FlattenSlow(nbb.DestructiveGet()));
+TEST(NoncontiguousBufferBuilder, DestructiveGet2)
+{
+    NoncontiguousBufferBuilder nbb;
+    nbb.Append("aabbccd");
+    ASSERT_EQ("aabbccd", FlattenSlow(nbb.DestructiveGet()));
 }
 
-TEST(NoncontiguousBufferBuilder, DestructiveGet3) {
-  NoncontiguousBufferBuilder nbb;
-  nbb.Append(std::string(1000000, 'A'));
-  ASSERT_EQ(std::string(1000000, 'A'), FlattenSlow(nbb.DestructiveGet()));
+TEST(NoncontiguousBufferBuilder, DestructiveGet3)
+{
+    NoncontiguousBufferBuilder nbb;
+    nbb.Append(std::string(1000000, 'A'));
+    ASSERT_EQ(std::string(1000000, 'A'), FlattenSlow(nbb.DestructiveGet()));
 }
 
-TEST(NoncontiguousBufferBuilder, DestructiveGet4) {
-  NoncontiguousBufferBuilder nbb;
-  nbb.Append('c');
-  ASSERT_EQ("c", FlattenSlow(nbb.DestructiveGet()));
+TEST(NoncontiguousBufferBuilder, DestructiveGet4)
+{
+    NoncontiguousBufferBuilder nbb;
+    nbb.Append('c');
+    ASSERT_EQ("c", FlattenSlow(nbb.DestructiveGet()));
 }
 
-TEST(NoncontiguousBufferBuilder, DestructiveGet5) {
-  NoncontiguousBufferBuilder nbb;
-  nbb.Append(CreateBufferSlow("c"));
-  ASSERT_EQ("c", FlattenSlow(nbb.DestructiveGet()));
+TEST(NoncontiguousBufferBuilder, DestructiveGet5)
+{
+    NoncontiguousBufferBuilder nbb;
+    nbb.Append(CreateBufferSlow("c"));
+    ASSERT_EQ("c", FlattenSlow(nbb.DestructiveGet()));
 }
 
-TEST(NoncontiguousBufferBuilder, DestructiveGet6) {
-  NoncontiguousBufferBuilder nbb;
-  nbb.Append(Slice("11"), Slice("2"), std::string("3"), std::string("45"),
-             Slice("6"));
-  nbb.Append("1122", 4);
-  ASSERT_EQ("11234561122", FlattenSlow(nbb.DestructiveGet()));
+TEST(NoncontiguousBufferBuilder, DestructiveGet6)
+{
+    NoncontiguousBufferBuilder nbb;
+    nbb.Append(Slice("11"), Slice("2"), std::string("3"), std::string("45"), Slice("6"));
+    nbb.Append("1122", 4);
+    ASSERT_EQ("11234561122", FlattenSlow(nbb.DestructiveGet()));
 }
 
-TEST(MakeReferencingBuffer, Simple) {
-  NoncontiguousBufferBuilder nbb;
-  nbb.Append(MakeReferencingBuffer("abcdefg", 7));
-  EXPECT_EQ("abcdefg", FlattenSlow(nbb.DestructiveGet()));
+TEST(MakeReferencingBuffer, Simple)
+{
+    NoncontiguousBufferBuilder nbb;
+    nbb.Append(MakeReferencingBuffer("abcdefg", 7));
+    EXPECT_EQ("abcdefg", FlattenSlow(nbb.DestructiveGet()));
 }
 
-TEST(MakeReferencingBuffer, WithCallbackSmallBufferOptimized) {
-  int x = 0;
+TEST(MakeReferencingBuffer, WithCallbackSmallBufferOptimized)
+{
+    int x = 0;
 
-  NoncontiguousBufferBuilder nbb;
-  nbb.Append("aaa", 3);
-  // Small buffers are copied by `Append` and freed immediately.
-  nbb.Append(MakeReferencingBuffer("abcdefg", 7, [&] { ++x; }));
-  // Therefore the callback should have fired on return of `Append`.
-  EXPECT_EQ(1, x);
-  auto buffer = nbb.DestructiveGet();
-  EXPECT_EQ("aaaabcdefg", FlattenSlow(buffer));
-}
-
-TEST(MakeReferencingBuffer, WithCallback) {
-  static const std::string kBuffer(12345, 'a');
-  int x = 0;
-
-  {
     NoncontiguousBufferBuilder nbb;
     nbb.Append("aaa", 3);
-    nbb.Append(MakeReferencingBuffer(kBuffer.data(), 1024, [&] { ++x; }));
-    EXPECT_EQ(0, x);
+    // Small buffers are copied by `Append` and freed immediately.
+    nbb.Append(MakeReferencingBuffer("abcdefg", 7, [&] { ++x; }));
+    // Therefore the callback should have fired on return of `Append`.
+    EXPECT_EQ(1, x);
     auto buffer = nbb.DestructiveGet();
-    EXPECT_EQ(0, x);
-    EXPECT_EQ("aaa" + kBuffer.substr(0, 1024), FlattenSlow(buffer));
-  }
-  EXPECT_EQ(1, x);
+    EXPECT_EQ("aaaabcdefg", FlattenSlow(buffer));
 }
 
-TEST(MakeForeignBuffer, String) {
-  NoncontiguousBufferBuilder nbb;
-  nbb.Append(MakeForeignBuffer(std::string("abcdefg")));
-  EXPECT_EQ("abcdefg", FlattenSlow(nbb.DestructiveGet()));
+TEST(MakeReferencingBuffer, WithCallback)
+{
+    static const std::string kBuffer(12345, 'a');
+    int x = 0;
+
+    {
+        NoncontiguousBufferBuilder nbb;
+        nbb.Append("aaa", 3);
+        nbb.Append(MakeReferencingBuffer(kBuffer.data(), 1024, [&] { ++x; }));
+        EXPECT_EQ(0, x);
+        auto buffer = nbb.DestructiveGet();
+        EXPECT_EQ(0, x);
+        EXPECT_EQ("aaa" + kBuffer.substr(0, 1024), FlattenSlow(buffer));
+    }
+    EXPECT_EQ(1, x);
 }
 
-TEST(MakeForeignBuffer, VectorOfChar) {
-  std::vector<char> data{'a', 'b', 'c', 'd', 'e', 'f', 'g'};
-  NoncontiguousBufferBuilder nbb;
-  nbb.Append(MakeForeignBuffer(std::move(data)));
-  EXPECT_EQ("abcdefg", FlattenSlow(nbb.DestructiveGet()));
+TEST(MakeForeignBuffer, String)
+{
+    NoncontiguousBufferBuilder nbb;
+    nbb.Append(MakeForeignBuffer(std::string("abcdefg")));
+    EXPECT_EQ("abcdefg", FlattenSlow(nbb.DestructiveGet()));
+}
+
+TEST(MakeForeignBuffer, VectorOfChar)
+{
+    std::vector<char> data{'a', 'b', 'c', 'd', 'e', 'f', 'g'};
+    NoncontiguousBufferBuilder nbb;
+    nbb.Append(MakeForeignBuffer(std::move(data)));
+    EXPECT_EQ("abcdefg", FlattenSlow(nbb.DestructiveGet()));
 }
 
 // TEST(MakeForeignBuffer, VectorOfBytes) {
@@ -299,13 +327,14 @@ TEST(MakeForeignBuffer, VectorOfChar) {
 //   EXPECT_EQ("abcdefg", FlattenSlow(nbb.DestructiveGet()));
 // }
 
-TEST(MakeForeignBuffer, VectorOfUInt8) {
-  std::vector<std::uint8_t> data;
-  data.resize(7);
-  memcpy(data.data(), "abcdefg", 7);
-  NoncontiguousBufferBuilder nbb;
-  nbb.Append(MakeForeignBuffer(std::move(data)));
-  EXPECT_EQ("abcdefg", FlattenSlow(nbb.DestructiveGet()));
+TEST(MakeForeignBuffer, VectorOfUInt8)
+{
+    std::vector<std::uint8_t> data;
+    data.resize(7);
+    memcpy(data.data(), "abcdefg", 7);
+    NoncontiguousBufferBuilder nbb;
+    nbb.Append(MakeForeignBuffer(std::move(data)));
+    EXPECT_EQ("abcdefg", FlattenSlow(nbb.DestructiveGet()));
 }
 
-} // namespace tile
+}// namespace tile
diff --git a/tile/base/byte_order.h b/tile/base/byte_order.h
index 7ac6fae..2fa16f1 100644
--- a/tile/base/byte_order.h
+++ b/tile/base/byte_order.h
@@ -41,86 +41,116 @@
 
 namespace tile {
 
-inline uint16_t ByteSwap16(uint16_t val) { return __builtin_bswap16(val); }
-inline uint32_t ByteSwap32(uint32_t val) { return __builtin_bswap32(val); }
-inline uint64_t ByteSwap64(uint64_t val) { return __builtin_bswap64(val); }
+inline uint16_t
+ByteSwap16(uint16_t val)
+{
+    return __builtin_bswap16(val);
+}
 
-inline bool IsHostLittleEndian() {
+inline uint32_t
+ByteSwap32(uint32_t val)
+{
+    return __builtin_bswap32(val);
+}
+
+inline uint64_t
+ByteSwap64(uint64_t val)
+{
+    return __builtin_bswap64(val);
+}
+
+inline bool
+IsHostLittleEndian()
+{
 #if TILE_LITTLE_ENDIAN == TILE_BYTE_ORDER
-  return true;
+    return true;
 #else
-  return false;
+    return false;
 #endif
 }
 
-inline bool IsHostBigEndian() {
+inline bool
+IsHostBigEndian()
+{
 #if TILE_BIG_ENDIAN == TILE_BYTE_ORDER
-  return true;
+    return true;
 #else
-  return false;
+    return false;
 #endif
 }
 
-inline uint16_t HostToNetwork16(uint16_t val_in_host) {
+inline uint16_t
+HostToNetwork16(uint16_t val_in_host)
+{
 #if TILE_BYTE_ORDER == TILE_BIG_ENDIAN
-  return val_in_host;
+    return val_in_host;
 #elif TILE_BYTE_ORDER == TILE_LITTLE_ENDIAN
-  return ByteSwap16(val_in_host);
+    return ByteSwap16(val_in_host);
 #else
 #error "Unsupported byte order"
 #endif
 }
 
-inline uint32_t HostToNetwork32(uint32_t val_in_host) {
+inline uint32_t
+HostToNetwork32(uint32_t val_in_host)
+{
 #if TILE_BYTE_ORDER == TILE_BIG_ENDIAN
-  return val_in_host;
+    return val_in_host;
 #elif TILE_BYTE_ORDER == TILE_LITTLE_ENDIAN
-  return ByteSwap32(val_in_host);
+    return ByteSwap32(val_in_host);
 #else
 #error "Unsupported byte order"
 #endif
 }
 
-inline uint64_t HostToNetwork64(uint64_t val_in_host) {
+inline uint64_t
+HostToNetwork64(uint64_t val_in_host)
+{
 #if TILE_BYTE_ORDER == TILE_BIG_ENDIAN
-  return val_in_host;
+    return val_in_host;
 #elif TILE_BYTE_ORDER == TILE_LITTLE_ENDIAN
-  return ByteSwap64(val_in_host);
+    return ByteSwap64(val_in_host);
 #else
 #error "Unsupported byte order"
 #endif
 }
 
-inline uint16_t NetworkToHost16(uint16_t val_in_network) {
+inline uint16_t
+NetworkToHost16(uint16_t val_in_network)
+{
 #if TILE_BYTE_ORDER == TILE_BIG_ENDIAN
-  return val_in_network;
+    return val_in_network;
 #elif TILE_BYTE_ORDER == TILE_LITTLE_ENDIAN
-  return ByteSwap16(val_in_network);
+    return ByteSwap16(val_in_network);
 #else
 #error "Unsupported byte order"
 #endif
 }
 
-inline uint32_t NetworkToHost32(uint32_t val_in_network) {
+inline uint32_t
+NetworkToHost32(uint32_t val_in_network)
+{
 #if TILE_BYTE_ORDER == TILE_BIG_ENDIAN
-  return val_in_network;
+    return val_in_network;
 #elif TILE_BYTE_ORDER == TILE_LITTLE_ENDIAN
-  return ByteSwap32(val_in_network);
+    return ByteSwap32(val_in_network);
 #else
 #error "Unsupported byte order"
 #endif
 }
 
-inline uint64_t NetworkToHost64(uint64_t val_in_network) {
+inline uint64_t
+NetworkToHost64(uint64_t val_in_network)
+{
 #if TILE_BYTE_ORDER == TILE_BIG_ENDIAN
-  return val_in_network;
+    return val_in_network;
 #elif TILE_BYTE_ORDER == TILE_LITTLE_ENDIAN
-  return ByteSwap64(val_in_network);
+    return ByteSwap64(val_in_network);
 #else
 #error "Unsupported byte order"
 #endif
 }
 
-} // namespace tile
+}// namespace tile
 
-#endif // TILE_BASE_BYTE_ORDER_H
+#endif// TILE_BASE_BYTE_ORDER_H
diff --git a/tile/base/byte_order_test.cc b/tile/base/byte_order_test.cc
index 8bb17bd..65f285b 100644
--- a/tile/base/byte_order_test.cc
+++ b/tile/base/byte_order_test.cc
@@ -8,109 +8,123 @@
 namespace tile {
 
 static union EndianHelper {
-  uint16_t v16;
-  uint32_t v32;
-  uint32_t v64;
-  uint8_t bytes[8];
-} endian_helper = {.bytes = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07}};
+    uint16_t v16;
+    uint32_t v32;
+    uint32_t v64;
+    uint8_t bytes[8];
+} endian_helper = {
+    .bytes = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07}
+};
 
-TEST(ByteOrder, ByteSwap16) {
-  const uint16_t val = 0x1234;
-  const uint16_t expected = 0x3412;
-  ASSERT_EQ(expected, ByteSwap16(val));
-}
-TEST(ByteOrder, ByteSwap32) {
-  const uint32_t val = 0x12345678;
-  const uint32_t expected = 0x78563412;
-  ASSERT_EQ(expected, ByteSwap32(val));
-}
-TEST(ByteOrder, ByteSwap64) {
-  const uint64_t val = 0x1234567890abcdef;
-  const uint64_t expected = 0xefcdab9078563412;
-  ASSERT_EQ(expected, ByteSwap64(val));
+TEST(ByteOrder, ByteSwap16)
+{
+    const uint16_t val      = 0x1234;
+    const uint16_t expected = 0x3412;
+    ASSERT_EQ(expected, ByteSwap16(val));
 }
 
-TEST(ByteOrder, IsHostByteOrder) {
-  ASSERT_NE(IsHostBigEndian(), IsHostLittleEndian());
+TEST(ByteOrder, ByteSwap32)
+{
+    const uint32_t val      = 0x12345678;
+    const uint32_t expected = 0x78563412;
+    ASSERT_EQ(expected, ByteSwap32(val));
+}
+
+TEST(ByteOrder, ByteSwap64)
+{
+    const uint64_t val      = 0x1234567890abcdef;
+    const uint64_t expected = 0xefcdab9078563412;
+    ASSERT_EQ(expected, ByteSwap64(val));
+}
+
+TEST(ByteOrder, IsHostByteOrder)
+{
+    ASSERT_NE(IsHostBigEndian(), IsHostLittleEndian());
 #if TILE_BYTE_ORDER == TILE_BIG_ENDIAN
-  ASSERT_TRUE(IsHostBigEndian());
-  ASSERT_FALSE(IsHostLittleEndian());
+    ASSERT_TRUE(IsHostBigEndian());
+    ASSERT_FALSE(IsHostLittleEndian());
 #else
-  ASSERT_TRUE(IsHostLittleEndian());
-  ASSERT_FALSE(IsHostBigEndian());
+    ASSERT_TRUE(IsHostLittleEndian());
+    ASSERT_FALSE(IsHostBigEndian());
 #endif
 }
 
-TEST(ByteOrder, HostToNetwork16) {
-  const uint16_t val = 0x1234;
+TEST(ByteOrder, HostToNetwork16)
+{
+    const uint16_t val = 0x1234;
 #if TILE_BYTE_ORDER == TILE_BIG_ENDIAN
-  const uint16_t expected = val;
+    const uint16_t expected = val;
 #elif TILE_BYTE_ORDER == TILE_LITTLE_ENDIAN
-  const uint16_t expected = 0x3412;
+    const uint16_t expected = 0x3412;
 #else
 #error "Unsupported byte order"
 #endif
-  ASSERT_EQ(expected, HostToNetwork16(val));
+    ASSERT_EQ(expected, HostToNetwork16(val));
 }
 
-TEST(ByteOrder, HostToNetwork32) {
-  const uint32_t val = 0x12345678;
+TEST(ByteOrder, HostToNetwork32)
+{
+    const uint32_t val = 0x12345678;
 #if TILE_BYTE_ORDER == TILE_BIG_ENDIAN
-  const uint32_t expected = val;
+    const uint32_t expected = val;
 #elif TILE_BYTE_ORDER == TILE_LITTLE_ENDIAN
-  const uint32_t expected = 0x78563412;
+    const uint32_t expected = 0x78563412;
 #else
 #error "Unsupported byte order"
 #endif
-  ASSERT_EQ(expected, HostToNetwork32(val));
+    ASSERT_EQ(expected, HostToNetwork32(val));
 }
 
-TEST(ByteOrder, HostToNetwork64) {
-  const uint64_t val = 0x1234567890abcdef;
+TEST(ByteOrder, HostToNetwork64)
+{
+    const uint64_t val = 0x1234567890abcdef;
 #if TILE_BYTE_ORDER == TILE_BIG_ENDIAN
-  const uint64_t expected = val;
+    const uint64_t expected = val;
 #elif TILE_BYTE_ORDER == TILE_LITTLE_ENDIAN
-  const uint64_t expected = 0xefcdab9078563412;
+    const uint64_t expected = 0xefcdab9078563412;
 #else
 #error "Unsupported byte order"
 #endif
-  ASSERT_EQ(expected, HostToNetwork64(val));
+    ASSERT_EQ(expected, HostToNetwork64(val));
 }
 
-TEST(ByteOrder, NetworkToHost16) {
-  const uint16_t val = 0x1234;
+TEST(ByteOrder, NetworkToHost16)
+{
+    const uint16_t val = 0x1234;
 #if TILE_BYTE_ORDER == TILE_BIG_ENDIAN
-  const uint16_t expected = val;
+    const uint16_t expected = val;
 #elif TILE_BYTE_ORDER == TILE_LITTLE_ENDIAN
-  const uint16_t expected = 0x3412;
+    const uint16_t expected = 0x3412;
 #else
 #error "Unsupported byte order"
 #endif
-  ASSERT_EQ(expected, NetworkToHost16(val));
+    ASSERT_EQ(expected, NetworkToHost16(val));
 }
 
-TEST(ByteOrder, NetworkToHost32) {
-  const uint32_t val = 0x12345678;
+TEST(ByteOrder, NetworkToHost32)
+{
+    const uint32_t val = 0x12345678;
 #if TILE_BYTE_ORDER == TILE_BIG_ENDIAN
-  const uint32_t expected = val;
+    const uint32_t expected = val;
 #elif TILE_BYTE_ORDER == TILE_LITTLE_ENDIAN
-  const uint32_t expected = 0x78563412;
+    const uint32_t expected = 0x78563412;
 #else
 #error "Unsupported byte order"
 #endif
-  ASSERT_EQ(expected, NetworkToHost32(val));
+    ASSERT_EQ(expected, NetworkToHost32(val));
 }
 
-TEST(ByteOrder, NetworkToHost64) {
-  const uint64_t val = 0x1234567890abcdef;
+TEST(ByteOrder, NetworkToHost64)
+{
+    const uint64_t val = 0x1234567890abcdef;
 #if TILE_BYTE_ORDER == TILE_BIG_ENDIAN
-  const uint64_t expected = val;
+    const uint64_t expected = val;
 #elif TILE_BYTE_ORDER == TILE_LITTLE_ENDIAN
-  const uint64_t expected = 0xefcdab9078563412;
+    const uint64_t expected = 0xefcdab9078563412;
 #else
 #error "Unsupported byte order"
 #endif
-  ASSERT_EQ(expected, NetworkToHost64(val));
+    ASSERT_EQ(expected, NetworkToHost64(val));
 }
 
-} // namespace tile
+}// namespace tile
diff --git a/tile/base/casting.h b/tile/base/casting.h
index a5ee6e1..7b1dadc 100644
--- a/tile/base/casting.h
+++ b/tile/base/casting.h
@@ -12,178 +12,200 @@
 namespace tile {
 namespace detail {
 // Has classof
-template <typename T, typename Base> struct HasClassofImpl {
-  template <
-      typename TT, typename TBase,
-      typename = enable_if_t<std::is_same<
-          decltype(TT::classof(std::declval<const TBase &>())), bool>::value>>
-  static std::true_type test(int);
-  template <typename TT, typename TBase> static std::false_type test(...);
+template<typename T, typename Base>
+struct HasClassofImpl {
+    template<typename TT,
+             typename TBase,
+             typename = enable_if_t<std::is_same<decltype(TT::classof(std::declval<const TBase &>())), bool>::value>>
+    static std::true_type test(int);
+    template<typename TT, typename TBase>
+    static std::false_type test(...);
 
-  static constexpr bool value = decltype(test<T, Base>(0))::value;
+    static constexpr bool value = decltype(test<T, Base>(0))::value;
 };
-} // namespace detail
+}// namespace detail
 
-template <typename T, typename = void> struct CastingTraits {
-  template <typename Base>
-  static auto RuntimeTypeCheck(const Base &val)
-      -> enable_if_t<detail::HasClassofImpl<T, Base>::value, bool> {
-    return T::classof(val);
-  }
+template<typename T, typename = void>
+struct CastingTraits {
+    template<typename Base>
+    static auto RuntimeTypeCheck(const Base &val) -> enable_if_t<detail::HasClassofImpl<T, Base>::value, bool>
+    {
+        return T::classof(val);
+    }
 
-  template <typename Base>
-  static auto RuntimeTypeCheck(const Base &val)
-      -> enable_if_t<!detail::HasClassofImpl<T, Base>::value, bool> {
-    return dynamic_cast<const T *>(&val) != nullptr;
-  }
+    template<typename Base>
+    static auto RuntimeTypeCheck(const Base &val) -> enable_if_t<!detail::HasClassofImpl<T, Base>::value, bool>
+    {
+        return dynamic_cast<const T *>(&val) != nullptr;
+    }
 };
 
 class Castable {
-  class Dummy {};
+    class Dummy {};
 
 public:
-  friend void SetRuntimeType(Castable *ptr, int type, Dummy = {}) {
-    ptr->type_ = type;
-  }
+    friend void SetRuntimeType(Castable *ptr, int type, Dummy = {}) { ptr->type_ = type; }
 
-  friend int GetRuntimeType(const Castable &val, Dummy = {}) {
-    return val.type_;
-  }
+    friend int GetRuntimeType(const Castable &val, Dummy = {}) { return val.type_; }
 
 protected:
-  template <typename, typename> friend struct CastingTraits;
-  ~Castable() = default;
+    template<typename, typename>
+    friend struct CastingTraits;
+    ~Castable() = default;
 
-  template <typename T> void SetRuntimeTypeTo() {
-    SetRuntimeType(this, GetRuntimeTypeId<T>());
-  }
+    template<typename T>
+    void SetRuntimeTypeTo()
+    {
+        SetRuntimeType(this, GetRuntimeTypeId<T>());
+    }
 
-  template <typename T> int GetRuntimeType() const {
-    return GetRuntimeTypeId<T>();
-  }
+    template<typename T>
+    int GetRuntimeType() const
+    {
+        return GetRuntimeTypeId<T>();
+    }
 
-  template <typename T> static int GetRuntimeTypeId() {
-    static const int value = internal::IndexAlloc::For<Castable>()->Next();
-    return value;
-  }
+    template<typename T>
+    static int GetRuntimeTypeId()
+    {
+        static const int value = internal::IndexAlloc::For<Castable>()->Next();
+        return value;
+    }
 
 private:
-  std::int_fast32_t type_ = GetRuntimeTypeId<Castable>();
+    std::int_fast32_t type_ = GetRuntimeTypeId<Castable>();
 };
 
 // ExactMatchCastable
 class ExactMatchCastable : public Castable {
 protected:
-  ~ExactMatchCastable() = default;
+    ~ExactMatchCastable() = default;
 };
 
-template <typename T>
-struct CastingTraits<
-    T, enable_if_t<std::is_base_of<ExactMatchCastable, T>::value>> {
-  static bool RuntimeTypeCheck(const ExactMatchCastable &object) {
-    return GetRuntimeType(object) == Castable::GetRuntimeTypeId<T>();
-  }
+template<typename T>
+struct CastingTraits<T, enable_if_t<std::is_base_of<ExactMatchCastable, T>::value>> {
+    static bool RuntimeTypeCheck(const ExactMatchCastable &object)
+    {
+        return GetRuntimeType(object) == Castable::GetRuntimeTypeId<T>();
+    }
 };
 
 namespace casting {
 namespace detail {
-template <typename T, typename Base,
-          typename = enable_if_t<std::is_base_of<Base, T>::value &&
-                                 !std::is_same<Base, T>::value>>
-inline bool RuntimeTypeCheck(const Base &val) {
-  return CastingTraits<T>::RuntimeTypeCheck(val);
+template<typename T,
+         typename Base,
+         typename = enable_if_t<std::is_base_of<Base, T>::value && !std::is_same<Base, T>::value>>
+inline bool
+RuntimeTypeCheck(const Base &val)
+{
+    return CastingTraits<T>::RuntimeTypeCheck(val);
 }
 
-template <typename T> inline bool RuntimeTypeCheck(const T &val) {
-  return true;
+template<typename T>
+inline bool
+RuntimeTypeCheck(const T &val)
+{
+    return true;
 }
 
-template <typename T, typename Base>
-using casted_type_t =
-    internal::conditional_t<std::is_const<Base>::value, const T *, T *>;
+template<typename T, typename Base>
+using casted_type_t = internal::conditional_t<std::is_const<Base>::value, const T *, T *>;
 
-template <typename T, typename Base>
-auto ReallyCastable(Base *ptr)
-    -> enable_if_t<std::has_virtual_destructor<T>::value, bool> {
-  return dynamic_cast<const T *>(ptr) != nullptr;
-}
-template <typename T, typename Base>
-auto ReallyCastable(Base *ptr)
-    -> enable_if_t<!std::has_virtual_destructor<T>::value, bool> {
-  return typeid(T) == typeid(*ptr);
+template<typename T, typename Base>
+auto
+ReallyCastable(Base *ptr) -> enable_if_t<std::has_virtual_destructor<T>::value, bool>
+{
+    return dynamic_cast<const T *>(ptr) != nullptr;
 }
 
-template <typename T, typename Base> void InvalidCast(Base *ptr) {
-  if (ReallyCastable<T, Base>(ptr)) {
-    TILE_LOG_FATAL(
-        "Casting to type [{}] failed. However, the C++ runtime reports that "
-        "you're indeed casting to the (right) runtime type of the object. This "
-        "can happen when either: 1) you haven't initialize object's runtime "
-        "type correctly (e.g. via `SetRuntimeTypeTo` if you're inheriting from "
-        "`ExactMatchCast`), or 2) the implementation of your `classof` is "
-        "incorrect.",
-        GetTypeName<T>());
-  } else {
-    TILE_LOG_FATAL(
-        "Invalid cast: Runtime type [{}] expected, got [{}]. If you believe "
-        "this is an error, check if your `classof` is implemented correctly",
-        GetTypeName<T>(), GetTypeName(*ptr));
-  }
-  TILE_UNREACHABLE("");
+template<typename T, typename Base>
+auto
+ReallyCastable(Base *ptr) -> enable_if_t<!std::has_virtual_destructor<T>::value, bool>
+{
+    return typeid(T) == typeid(*ptr);
 }
 
-} // namespace detail
-} // namespace casting
-
-template <typename T, typename Base,
-          typename = enable_if_t<!std::is_pointer<Base>::value>>
-inline bool isa(const Base &val) {
-  return casting::detail::RuntimeTypeCheck<T>(val);
+template<typename T, typename Base>
+void
+InvalidCast(Base *ptr)
+{
+    if (ReallyCastable<T, Base>(ptr)) {
+        TILE_LOG_FATAL("Casting to type [{}] failed. However, the C++ runtime reports that "
+                       "you're indeed casting to the (right) runtime type of the object. This "
+                       "can happen when either: 1) you haven't initialize object's runtime "
+                       "type correctly (e.g. via `SetRuntimeTypeTo` if you're inheriting from "
+                       "`ExactMatchCast`), or 2) the implementation of your `classof` is "
+                       "incorrect.",
+                       GetTypeName<T>());
+    } else {
+        TILE_LOG_FATAL("Invalid cast: Runtime type [{}] expected, got [{}]. If you believe "
+                       "this is an error, check if your `classof` is implemented correctly",
+                       GetTypeName<T>(), GetTypeName(*ptr));
+    }
+    TILE_UNREACHABLE("");
 }
 
-template <typename T, typename Base> inline bool isa(const Base *val) {
-  return isa<T>(*val);
+}// namespace detail
+}// namespace casting
+
+template<typename T, typename Base, typename = enable_if_t<!std::is_pointer<Base>::value>>
+inline bool
+isa(const Base &val)
+{
+    return casting::detail::RuntimeTypeCheck<T>(val);
 }
 
-template <typename T, typename Base,
-          typename R = casting::detail::casted_type_t<T, Base>>
-R dyn_cast(Base *ptr) {
-  return isa<T>(ptr) ? static_cast<R>(ptr) : nullptr;
+template<typename T, typename Base>
+inline bool
+isa(const Base *val)
+{
+    return isa<T>(*val);
 }
 
-template <typename T, typename Base,
-          typename = enable_if_t<!std::is_pointer<Base>::value>>
+template<typename T, typename Base, typename R = casting::detail::casted_type_t<T, Base>>
+R
+dyn_cast(Base *ptr)
+{
+    return isa<T>(ptr) ? static_cast<R>(ptr) : nullptr;
+}
+
+template<typename T, typename Base, typename = enable_if_t<!std::is_pointer<Base>::value>>
 inline auto
-dyn_cast(Base &val) -> decltype(dyn_cast<T>(std::declval<Base *>())) {
-  return dyn_cast<T>(&val);
+dyn_cast(Base &val) -> decltype(dyn_cast<T>(std::declval<Base *>()))
+{
+    return dyn_cast<T>(&val);
 }
 
-template <typename T, typename Base>
-inline auto dyn_cast_or_null(Base *ptr) -> decltype(dyn_cast<T>(ptr)) {
-  return ptr ? dyn_cast<T>(ptr) : nullptr;
+template<typename T, typename Base>
+inline auto
+dyn_cast_or_null(Base *ptr) -> decltype(dyn_cast<T>(ptr))
+{
+    return ptr ? dyn_cast<T>(ptr) : nullptr;
 }
 
-template <typename T, typename Base,
-          typename R = casting::detail::casted_type_t<T, Base>>
-inline R cast(Base *ptr) {
-  if (TILE_LIKELY(isa<T>(ptr))) {
-    return static_cast<R>(ptr);
-  }
-  casting::detail::InvalidCast<T>(ptr);
-  return nullptr;
+template<typename T, typename Base, typename R = casting::detail::casted_type_t<T, Base>>
+inline R
+cast(Base *ptr)
+{
+    if (TILE_LIKELY(isa<T>(ptr))) { return static_cast<R>(ptr); }
+    casting::detail::InvalidCast<T>(ptr);
+    return nullptr;
 }
 
-template <typename T, typename Base,
-          typename = enable_if_t<!std::is_pointer<Base>::value>>
-inline auto cast(Base &val) -> decltype(cast<T>(std::declval<Base *>())) {
-  return cast<T>(&val);
+template<typename T, typename Base, typename = enable_if_t<!std::is_pointer<Base>::value>>
+inline auto
+cast(Base &val) -> decltype(cast<T>(std::declval<Base *>()))
+{
+    return cast<T>(&val);
 }
 
-template <typename T, typename Base>
-inline auto cast_or_null(Base *ptr) -> decltype(cast<T>(ptr)) {
-  return ptr ? cast<T>(ptr) : nullptr;
+template<typename T, typename Base>
+inline auto
+cast_or_null(Base *ptr) -> decltype(cast<T>(ptr))
+{
+    return ptr ? cast<T>(ptr) : nullptr;
 }
 
-} // namespace tile
+}// namespace tile
 
-#endif // TILE_BASE_CASTING_H
+#endif// TILE_BASE_CASTING_H
diff --git a/tile/base/casting_benchmark.cc b/tile/base/casting_benchmark.cc
index 9b08b07..830e7f3 100644
--- a/tile/base/casting_benchmark.cc
+++ b/tile/base/casting_benchmark.cc
@@ -7,64 +7,63 @@
 namespace tile {
 
 struct Base {
-  virtual ~Base() = default;
-  enum { kA, kB, kC [[maybe_unused]] } type;
+    virtual ~Base() = default;
+
+    enum { kA, kB, kC [[maybe_unused]] } type;
 };
 
 struct A : Base {
-  A() { type = kA; }
+    A() { type = kA; }
 
-  static bool classof(const Base &val) {
-    return val.type == kA || val.type == kB;
-  }
+    static bool classof(const Base &val) { return val.type == kA || val.type == kB; }
 };
 
 struct B : A {
-  B() { type = kB; }
+    B() { type = kB; }
 
-  static bool classof(const Base &val) { return val.type == kB; }
+    static bool classof(const Base &val) { return val.type == kB; }
 };
 
-auto pb = make_unique<B>();
+auto pb   = make_unique<B>();
 Base *ptr = pb.get();
 volatile A *converted_ptr;
 
 struct C1 : ExactMatchCastable {};
 
 struct C2 : C1 {
-  C2() { SetRuntimeType(this, GetRuntimeTypeId<C2>()); }
+    C2() { SetRuntimeType(this, GetRuntimeTypeId<C2>()); }
 };
 
 struct C3 : C1 {
-  C3() { SetRuntimeType(this, GetRuntimeTypeId<C3>()); }
+    C3() { SetRuntimeType(this, GetRuntimeTypeId<C3>()); }
 };
 
 auto pc2 = make_unique<C2>();
-C1 *pc1 = pc2.get();
+C1 *pc1  = pc2.get();
 volatile C3 *pc3;
 
-void Benchmark_BuiltinDynamicCast(benchmark::State &state) {
-  while (state.KeepRunning()) {
-    converted_ptr = dynamic_cast<A *>(ptr);
-  }
+void
+Benchmark_BuiltinDynamicCast(benchmark::State &state)
+{
+    while (state.KeepRunning()) { converted_ptr = dynamic_cast<A *>(ptr); }
 }
 
 BENCHMARK(Benchmark_BuiltinDynamicCast);
 
-void Benchmark_DynCast(benchmark::State &state) {
-  while (state.KeepRunning()) {
-    converted_ptr = dyn_cast<A>(ptr);
-  }
+void
+Benchmark_DynCast(benchmark::State &state)
+{
+    while (state.KeepRunning()) { converted_ptr = dyn_cast<A>(ptr); }
 }
 
 BENCHMARK(Benchmark_DynCast);
 
-void Benchmark_ExactMatchCastableDynCast(benchmark::State &state) {
-  while (state.KeepRunning()) {
-    pc3 = dyn_cast<C3>(pc1);
-  }
+void
+Benchmark_ExactMatchCastableDynCast(benchmark::State &state)
+{
+    while (state.KeepRunning()) { pc3 = dyn_cast<C3>(pc1); }
 }
 
 BENCHMARK(Benchmark_ExactMatchCastableDynCast);
 
-} // namespace tile
+}// namespace tile
diff --git a/tile/base/casting_test.cc b/tile/base/casting_test.cc
index 1d9985e..9e2ce47 100644
--- a/tile/base/casting_test.cc
+++ b/tile/base/casting_test.cc
@@ -9,95 +9,99 @@
 namespace tile {
 
 struct Base {
-  enum { kA, kB, kC } type;
+    enum { kA, kB, kC } type;
 };
 
 struct A : Base {
-  A() { type = kA; }
+    A() { type = kA; }
 
-  static bool classof(const Base &val) {
-    return val.type == kA || val.type == kB;
-  }
+    static bool classof(const Base &val) { return val.type == kA || val.type == kB; }
 };
 
 struct B : A {
-  B() { type = kB; }
+    B() { type = kB; }
 
-  static bool classof(const Base &val) { return val.type == kB; }
+    static bool classof(const Base &val) { return val.type == kB; }
 };
 
 struct C : Base {
-  C() { type = kC; }
+    C() { type = kC; }
 
-  static bool classof(const Base &val) { return val.type == kC; }
+    static bool classof(const Base &val) { return val.type == kC; }
 };
 
 struct C1 : ExactMatchCastable {};
 
 struct C2 : C1 {
-  C2() { SetRuntimeType(this, GetRuntimeTypeId<C2>()); }
+    C2() { SetRuntimeType(this, GetRuntimeTypeId<C2>()); }
 };
 
 struct C3 : C1 {
-  C3() { SetRuntimeType(this, GetRuntimeTypeId<C3>()); }
+    C3() { SetRuntimeType(this, GetRuntimeTypeId<C3>()); }
 };
 
-TEST(CastingDeathTest, InvalidCast) {
-  auto pa = make_unique<A>();
-  ASSERT_DEATH(cast<B>(pa.get()), "Invalid cast");
+TEST(CastingDeathTest, InvalidCast)
+{
+    auto pa = make_unique<A>();
+    ASSERT_DEATH(cast<B>(pa.get()), "Invalid cast");
 }
 
-TEST(Casting, Nullptr) {
-  B *pb = nullptr;
-  ASSERT_EQ(nullptr, dyn_cast_or_null<A>(pb));
-  ASSERT_EQ(nullptr, cast_or_null<A>(pb));
+TEST(Casting, Nullptr)
+{
+    B *pb = nullptr;
+    ASSERT_EQ(nullptr, dyn_cast_or_null<A>(pb));
+    ASSERT_EQ(nullptr, cast_or_null<A>(pb));
 }
 
-TEST(Casting, DownCastFailure) {
-  auto pa = make_unique<A>();
-  ASSERT_EQ(nullptr, dyn_cast<B>(pa.get()));
+TEST(Casting, DownCastFailure)
+{
+    auto pa = make_unique<A>();
+    ASSERT_EQ(nullptr, dyn_cast<B>(pa.get()));
 }
 
-TEST(Casting, Cast) {
-  auto pb = make_unique<B>();
-  Base *ptr = pb.get();
+TEST(Casting, Cast)
+{
+    auto pb   = make_unique<B>();
+    Base *ptr = pb.get();
 
-  ASSERT_NE(nullptr, dyn_cast<Base>(ptr));
-  ASSERT_NE(nullptr, dyn_cast<A>(ptr));
-  ASSERT_NE(nullptr, dyn_cast<B>(ptr));
+    ASSERT_NE(nullptr, dyn_cast<Base>(ptr));
+    ASSERT_NE(nullptr, dyn_cast<A>(ptr));
+    ASSERT_NE(nullptr, dyn_cast<B>(ptr));
 
-  ASSERT_NE(nullptr, cast<A>(ptr));  // Casting pointer.
-  ASSERT_NE(nullptr, cast<B>(ptr));  // Casting pointer.
-  ASSERT_NE(nullptr, cast<A>(*ptr)); // Casting pointer.
-  ASSERT_NE(nullptr, cast<B>(*ptr)); // Casting pointer.
+    ASSERT_NE(nullptr, cast<A>(ptr)); // Casting pointer.
+    ASSERT_NE(nullptr, cast<B>(ptr)); // Casting pointer.
+    ASSERT_NE(nullptr, cast<A>(*ptr));// Casting pointer.
+    ASSERT_NE(nullptr, cast<B>(*ptr));// Casting pointer.
 
-  ASSERT_NE(nullptr, dyn_cast<B>(pb.get())); // Cast to self.
-  ASSERT_EQ(nullptr, dyn_cast<C>(ptr));      // Cast failure.
+    ASSERT_NE(nullptr, dyn_cast<B>(pb.get()));// Cast to self.
+    ASSERT_EQ(nullptr, dyn_cast<C>(ptr));     // Cast failure.
 }
 
-TEST(Casting, CastWithConst) {
-  auto pb = make_unique<const B>();
-  const Base *ptr = pb.get();
+TEST(Casting, CastWithConst)
+{
+    auto pb         = make_unique<const B>();
+    const Base *ptr = pb.get();
 
-  ASSERT_NE(nullptr, dyn_cast<Base>(ptr));
-  ASSERT_NE(nullptr, dyn_cast<A>(ptr));
-  ASSERT_NE(nullptr, dyn_cast<B>(ptr));
+    ASSERT_NE(nullptr, dyn_cast<Base>(ptr));
+    ASSERT_NE(nullptr, dyn_cast<A>(ptr));
+    ASSERT_NE(nullptr, dyn_cast<B>(ptr));
 
-  ASSERT_NE(nullptr, cast<A>(ptr));  // Casting pointer.
-  ASSERT_NE(nullptr, cast<B>(ptr));  // Casting pointer.
-  ASSERT_NE(nullptr, cast<A>(*ptr)); // Casting pointer.
-  ASSERT_NE(nullptr, cast<B>(*ptr)); // Casting pointer.
+    ASSERT_NE(nullptr, cast<A>(ptr)); // Casting pointer.
+    ASSERT_NE(nullptr, cast<B>(ptr)); // Casting pointer.
+    ASSERT_NE(nullptr, cast<A>(*ptr));// Casting pointer.
+    ASSERT_NE(nullptr, cast<B>(*ptr));// Casting pointer.
 
-  ASSERT_NE(nullptr, dyn_cast<B>(pb.get())); // Cast to self.
-  ASSERT_EQ(nullptr, dyn_cast<C>(ptr));      // Cast failure.
+    ASSERT_NE(nullptr, dyn_cast<B>(pb.get()));// Cast to self.
+    ASSERT_EQ(nullptr, dyn_cast<C>(ptr));     // Cast failure.
 }
 
-TEST(Casting, ExactMatchCastable) {
-  auto pc2 = make_unique<C2>();
-  C1 *p = pc2.get();
-  ASSERT_NE(nullptr, dyn_cast<C1>(p)); // Success.
-  ASSERT_NE(nullptr, dyn_cast<C2>(p)); // Success.
-  ASSERT_EQ(nullptr, dyn_cast<C3>(p)); // Failure.
+TEST(Casting, ExactMatchCastable)
+{
+    auto pc2 = make_unique<C2>();
+    C1 *p    = pc2.get();
+    ASSERT_NE(nullptr, dyn_cast<C1>(p));// Success.
+    ASSERT_NE(nullptr, dyn_cast<C2>(p));// Success.
+    ASSERT_EQ(nullptr, dyn_cast<C3>(p));// Failure.
 }
 
-} // namespace tile
+}// namespace tile
diff --git a/tile/base/chrono.cc b/tile/base/chrono.cc
index 1cba8f4..7e2c878 100644
--- a/tile/base/chrono.cc
+++ b/tile/base/chrono.cc
@@ -15,132 +15,150 @@
 namespace tile {
 namespace {
 
-template <typename T> struct Epoch {};
-template <> struct Epoch<std::chrono::steady_clock> {
-  static constexpr auto value =
-      std::chrono::duration_cast<std::chrono::nanoseconds>(
-          std::chrono::seconds(0));
+template<typename T>
+struct Epoch {};
+
+template<>
+struct Epoch<std::chrono::steady_clock> {
+    static constexpr auto value = std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::seconds(0));
 };
 
-template <> struct Epoch<std::chrono::system_clock> {
-  static constexpr auto value =
-      std::chrono::duration_cast<std::chrono::nanoseconds>(
-          std::chrono::seconds(1716543273));
+template<>
+struct Epoch<std::chrono::system_clock> {
+    static constexpr auto value =
+        std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::seconds(1716543273));
 };
 
-template <typename Clock>
-inline typename Clock::time_point ReadClock(clockid_t type) {
-  timespec ts;
-  clock_gettime(type, &ts);
-  const long long ns = ts.tv_sec * 1000LL * 1000LL * 1000LL + ts.tv_nsec;
-  auto duration = std::chrono::duration_cast<typename Clock::duration>(
-      std::chrono::nanoseconds(ns));
-  return typename Clock::time_point(duration);
+template<typename Clock>
+inline typename Clock::time_point
+ReadClock(clockid_t type)
+{
+    timespec ts;
+    clock_gettime(type, &ts);
+    const long long ns = ts.tv_sec * 1000LL * 1000LL * 1000LL + ts.tv_nsec;
+    auto duration      = std::chrono::duration_cast<typename Clock::duration>(std::chrono::nanoseconds(ns));
+    return typename Clock::time_point(duration);
 }
 
-void Sleep(long ns) {
-  struct timeval timeout;
-  timeout.tv_sec = 0;
-  timeout.tv_usec = (ns + 999) / 1000;
+void
+Sleep(long ns)
+{
+    struct timeval timeout;
+    timeout.tv_sec  = 0;
+    timeout.tv_usec = (ns + 999) / 1000;
 
-  select(0, NULL, NULL, NULL, &timeout);
+    select(0, NULL, NULL, NULL, &timeout);
 }
 
-} // namespace
+}// namespace
+
 namespace detail {
 namespace chrono {
-struct alignas(hardware_destructive_interference_size)
-    AsynchronouslyUpdatedTimestamps {
-  std::atomic<std::chrono::nanoseconds> steady_clock_time_since_epoch;
-  std::atomic<std::chrono::nanoseconds> system_clock_time_since_epoch;
+struct alignas(hardware_destructive_interference_size) AsynchronouslyUpdatedTimestamps {
+    std::atomic<std::chrono::nanoseconds> steady_clock_time_since_epoch;
+    std::atomic<std::chrono::nanoseconds> system_clock_time_since_epoch;
 };
+
 static AsynchronouslyUpdatedTimestamps async_updated_timestamps;
 
-void UpdateCoarseTimestamps() {
-  async_updated_timestamps.steady_clock_time_since_epoch.store(
-      ReadSteadyClock().time_since_epoch(),
-      // std::chrono::steady_clock::now().time_since_epoch(),
-      std::memory_order_relaxed);
-  async_updated_timestamps.system_clock_time_since_epoch.store(
-      ReadSystemClock().time_since_epoch(),
-      // std::chrono::system_clock::now().time_since_epoch(),
-      std::memory_order_relaxed);
+void
+UpdateCoarseTimestamps()
+{
+    async_updated_timestamps.steady_clock_time_since_epoch.store(
+        ReadSteadyClock().time_since_epoch(),
+        // std::chrono::steady_clock::now().time_since_epoch(),
+        std::memory_order_relaxed);
+    async_updated_timestamps.system_clock_time_since_epoch.store(
+        ReadSystemClock().time_since_epoch(),
+        // std::chrono::system_clock::now().time_since_epoch(),
+        std::memory_order_relaxed);
 }
+
 constexpr std::chrono::microseconds CoarseClockInitializer::kAccuracy;
-CoarseClockInitializer *CoarseClockInitializer::Instance() {
-  static NeverDestroyedSingleton<CoarseClockInitializer> cci;
-  return cci.Get();
+
+CoarseClockInitializer *
+CoarseClockInitializer::Instance()
+{
+    static NeverDestroyedSingleton<CoarseClockInitializer> cci;
+    return cci.Get();
 }
 
-void CoarseClockInitializer::Start() {
-  if (!internal::TestAndSet(running_, false, true)) {
-    TILE_LOG_WARNING("CoarseClockInitializer is already running");
-    return;
-  }
-
-  UpdateCoarseTimestamps();
-
-  worker_ = make_unique<std::thread>([this] {
-    const auto accuracy_as_ns =
-        std::chrono::duration_cast<std::chrono::nanoseconds>(kAccuracy).count();
-    TILE_CHECK_GE(accuracy_as_ns, 2000,
-                  "accuracy is too small, MUST GE 2000ns, current is {}",
-                  kAccuracy);
-
-    while (running_.load(std::memory_order_relaxed)) {
-      // std::this_thread::sleep_for(std::chrono::nanoseconds(500));
-      UpdateCoarseTimestamps();
-      // Sleep(accuracy_as_ns / 2);
-      std::this_thread::sleep_for(kAccuracy / 2);
+void
+CoarseClockInitializer::Start()
+{
+    if (!internal::TestAndSet(running_, false, true)) {
+        TILE_LOG_WARNING("CoarseClockInitializer is already running");
+        return;
     }
-  });
+
+    UpdateCoarseTimestamps();
+
+    worker_ = make_unique<std::thread>([this] {
+        const auto accuracy_as_ns = std::chrono::duration_cast<std::chrono::nanoseconds>(kAccuracy).count();
+        TILE_CHECK_GE(accuracy_as_ns, 2000, "accuracy is too small, MUST GE 2000ns, current is {}", kAccuracy);
+
+        while (running_.load(std::memory_order_relaxed)) {
+            // std::this_thread::sleep_for(std::chrono::nanoseconds(500));
+            UpdateCoarseTimestamps();
+            // Sleep(accuracy_as_ns / 2);
+            std::this_thread::sleep_for(kAccuracy / 2);
+        }
+    });
 }
 
-void CoarseClockInitializer::Stop() {
-  running_.store(false, std::memory_order_relaxed);
+void
+CoarseClockInitializer::Stop()
+{
+    running_.store(false, std::memory_order_relaxed);
 }
 
-void CoarseClockInitializer::Join() {
-  if (worker_) {
-    worker_->join();
-    worker_.reset();
-  }
+void
+CoarseClockInitializer::Join()
+{
+    if (worker_) {
+        worker_->join();
+        worker_.reset();
+    }
 }
 
 CoarseClockInitializer::CoarseClockInitializer() {}
 
 CoarseClockInitializer::~CoarseClockInitializer() {}
 
-} // namespace chrono
-} // namespace detail
+}// namespace chrono
+}// namespace detail
 
-std::chrono::steady_clock::time_point ReadSteadyClock() {
-  // return ReadClock<std::chrono::steady_clock>(CLOCK_MONOTONIC);
-  return std::chrono::steady_clock::now();
-}
-std::chrono::system_clock::time_point ReadSystemClock() {
-  // return ReadClock<std::chrono::system_clock>(CLOCK_REALTIME);
-  return std::chrono::system_clock::now();
+std::chrono::steady_clock::time_point
+ReadSteadyClock()
+{
+    // return ReadClock<std::chrono::steady_clock>(CLOCK_MONOTONIC);
+    return std::chrono::steady_clock::now();
 }
 
-std::chrono::steady_clock::time_point ReadCoarseSteadyClock() {
-  auto coarse_duration =
-      detail::chrono::async_updated_timestamps.steady_clock_time_since_epoch
-          .load(std::memory_order_relaxed);
-  auto target_duration =
-      std::chrono::duration_cast<std::chrono::steady_clock::duration>(
-          coarse_duration);
-  return std::chrono::steady_clock::time_point(target_duration);
+std::chrono::system_clock::time_point
+ReadSystemClock()
+{
+    // return ReadClock<std::chrono::system_clock>(CLOCK_REALTIME);
+    return std::chrono::system_clock::now();
 }
-std::chrono::system_clock::time_point ReadCoarseSystemClock() {
-  auto coarse_duration =
-      detail::chrono::async_updated_timestamps.system_clock_time_since_epoch
-          .load(std::memory_order_relaxed);
 
-  auto target_duration =
-      std::chrono::duration_cast<std::chrono::system_clock::duration>(
-          coarse_duration);
-
-  return std::chrono::system_clock::time_point(target_duration);
+std::chrono::steady_clock::time_point
+ReadCoarseSteadyClock()
+{
+    auto coarse_duration =
+        detail::chrono::async_updated_timestamps.steady_clock_time_since_epoch.load(std::memory_order_relaxed);
+    auto target_duration = std::chrono::duration_cast<std::chrono::steady_clock::duration>(coarse_duration);
+    return std::chrono::steady_clock::time_point(target_duration);
 }
-} // namespace tile
+
+std::chrono::system_clock::time_point
+ReadCoarseSystemClock()
+{
+    auto coarse_duration =
+        detail::chrono::async_updated_timestamps.system_clock_time_since_epoch.load(std::memory_order_relaxed);
+
+    auto target_duration = std::chrono::duration_cast<std::chrono::system_clock::duration>(coarse_duration);
+
+    return std::chrono::system_clock::time_point(target_duration);
+}
+}// namespace tile
diff --git a/tile/base/chrono.h b/tile/base/chrono.h
index 7107782..415ff10 100644
--- a/tile/base/chrono.h
+++ b/tile/base/chrono.h
@@ -17,26 +17,26 @@ namespace chrono {
 
 class CoarseClockInitializer {
 public:
-  static constexpr auto kAccuracy = std::chrono::microseconds(500);
-  static CoarseClockInitializer *Instance();
+    static constexpr auto kAccuracy = std::chrono::microseconds(500);
+    static CoarseClockInitializer *Instance();
 
-  // for `tile::Start()`
-  void Start();
-  void Stop();
-  void Join();
+    // for `tile::Start()`
+    void Start();
+    void Stop();
+    void Join();
 
 private:
-  ~CoarseClockInitializer();
-  CoarseClockInitializer();
-  friend NeverDestroyedSingleton<CoarseClockInitializer>;
+    ~CoarseClockInitializer();
+    CoarseClockInitializer();
+    friend NeverDestroyedSingleton<CoarseClockInitializer>;
 
 private:
-  std::unique_ptr<std::thread> worker_;
-  std::atomic<bool> running_{false};
+    std::unique_ptr<std::thread> worker_;
+    std::atomic<bool> running_{false};
 };
 
-} // namespace chrono
-} // namespace detail
+}// namespace chrono
+}// namespace detail
 
 std::chrono::steady_clock::time_point ReadSteadyClock();
 std::chrono::system_clock::time_point ReadSystemClock();
@@ -45,10 +45,13 @@ std::chrono::system_clock::time_point ReadSystemClock();
 std::chrono::steady_clock::time_point ReadCoarseSteadyClock();
 // accuracy: 10us
 std::chrono::system_clock::time_point ReadCoarseSystemClock();
-inline std::int64_t ReadUnixTimestamp() {
-  return ReadCoarseSystemClock().time_since_epoch() / std::chrono::seconds(1);
+
+inline std::int64_t
+ReadUnixTimestamp()
+{
+    return ReadCoarseSystemClock().time_since_epoch() / std::chrono::seconds(1);
 }
 
-} // namespace tile
+}// namespace tile
 
-#endif // _TILE_BASE_CHRONO_H
+#endif// _TILE_BASE_CHRONO_H
diff --git a/tile/base/chrono_benchmark.cc b/tile/base/chrono_benchmark.cc
index 7e04423..9b0819e 100644
--- a/tile/base/chrono_benchmark.cc
+++ b/tile/base/chrono_benchmark.cc
@@ -8,63 +8,67 @@
 
 namespace tile {
 
-void Benchmark_GetTimeOfDay(benchmark::State &state) {
-  while (state.KeepRunning()) {
-    struct timeval tv;
-    gettimeofday(&tv, nullptr);
-  }
+void
+Benchmark_GetTimeOfDay(benchmark::State &state)
+{
+    while (state.KeepRunning()) {
+        struct timeval tv;
+        gettimeofday(&tv, nullptr);
+    }
 }
 
 BENCHMARK(Benchmark_GetTimeOfDay);
 
-void Benchmark_StdSteadyClock(benchmark::State &state) {
-  while (state.KeepRunning()) {
-    (void)std::chrono::steady_clock::now();
-  }
+void
+Benchmark_StdSteadyClock(benchmark::State &state)
+{
+    while (state.KeepRunning()) { (void) std::chrono::steady_clock::now(); }
 }
 
 BENCHMARK(Benchmark_StdSteadyClock);
 
-void Benchmark_StdSystemClock(benchmark::State &state) {
-  while (state.KeepRunning()) {
-    (void)std::chrono::system_clock::now();
-  }
+void
+Benchmark_StdSystemClock(benchmark::State &state)
+{
+    while (state.KeepRunning()) { (void) std::chrono::system_clock::now(); }
 }
 
 BENCHMARK(Benchmark_StdSystemClock);
 
-void Benchmark_ReadSteadyClock(benchmark::State &state) {
-  while (state.KeepRunning()) {
-    ReadSteadyClock();
-  }
+void
+Benchmark_ReadSteadyClock(benchmark::State &state)
+{
+    while (state.KeepRunning()) { ReadSteadyClock(); }
 }
 
 BENCHMARK(Benchmark_ReadSteadyClock);
 
-void Benchmark_ReadSystemClock(benchmark::State &state) {
-  while (state.KeepRunning()) {
-    ReadSystemClock();
-  }
+void
+Benchmark_ReadSystemClock(benchmark::State &state)
+{
+    while (state.KeepRunning()) { ReadSystemClock(); }
 }
 
 BENCHMARK(Benchmark_ReadSystemClock);
 
-void Benchmark_ReadCoarseSteadyClock(benchmark::State &state) {
-  while (state.KeepRunning()) {
-    // ... <+23>: lea 0x137c5a(%rip),%rax  # `system_clock_time_since_epoch`
-    // ... <+30>: mov (%rax),%rax
-    ReadCoarseSteadyClock();
-  }
+void
+Benchmark_ReadCoarseSteadyClock(benchmark::State &state)
+{
+    while (state.KeepRunning()) {
+        // ... <+23>: lea 0x137c5a(%rip),%rax  # `system_clock_time_since_epoch`
+        // ... <+30>: mov (%rax),%rax
+        ReadCoarseSteadyClock();
+    }
 }
 
 BENCHMARK(Benchmark_ReadCoarseSteadyClock);
 
-void Benchmark_ReadCoarseSystemClock(benchmark::State &state) {
-  while (state.KeepRunning()) {
-    ReadCoarseSystemClock();
-  }
+void
+Benchmark_ReadCoarseSystemClock(benchmark::State &state)
+{
+    while (state.KeepRunning()) { ReadCoarseSystemClock(); }
 }
 
 BENCHMARK(Benchmark_ReadCoarseSystemClock);
 
-} // namespace tile
+}// namespace tile
diff --git a/tile/base/chrono_test.cc b/tile/base/chrono_test.cc
index 524fbce..6bee577 100644
--- a/tile/base/chrono_test.cc
+++ b/tile/base/chrono_test.cc
@@ -7,42 +7,38 @@ namespace tile {
 static constexpr auto one_ms = std::chrono::milliseconds(1);
 static constexpr auto kTestN = 1000;
 
-long AvageTime(std::function<long()> f, std::size_t n = kTestN) {
-  long double total = 0;
-  for (std::size_t i = 0; i != n; ++i) {
-    total += 1.0f / n * f();
-    std::this_thread::sleep_for(std::chrono::milliseconds(1));
-  }
-  return static_cast<long>(total);
+long
+AvageTime(std::function<long()> f, std::size_t n = kTestN)
+{
+    long double total = 0;
+    for (std::size_t i = 0; i != n; ++i) {
+        total += 1.0f / n * f();
+        std::this_thread::sleep_for(std::chrono::milliseconds(1));
+    }
+    return static_cast<long>(total);
 }
 
-TEST(SystemClock, Compare) {
-  auto diff = AvageTime([] {
-    return (ReadSystemClock() - std::chrono::system_clock::now()) / one_ms;
-  });
-  ASSERT_NEAR(diff, 0, 5);
+TEST(SystemClock, Compare)
+{
+    auto diff = AvageTime([] { return (ReadSystemClock() - std::chrono::system_clock::now()) / one_ms; });
+    ASSERT_NEAR(diff, 0, 5);
 }
 
-TEST(SteadyClock, Compare) {
-  auto diff = AvageTime([] {
-    return (ReadSteadyClock() - std::chrono::steady_clock::now()) / one_ms;
-  });
-  ASSERT_NEAR(diff, 0, 5);
+TEST(SteadyClock, Compare)
+{
+    auto diff = AvageTime([] { return (ReadSteadyClock() - std::chrono::steady_clock::now()) / one_ms; });
+    ASSERT_NEAR(diff, 0, 5);
 }
 
-TEST(CoarseSystemClock, Compare) {
-  auto diff = AvageTime([] {
-    return (ReadCoarseSystemClock() - std::chrono::system_clock::now()) /
-           one_ms;
-  });
-  ASSERT_NEAR(diff, 0, kTestN);
+TEST(CoarseSystemClock, Compare)
+{
+    auto diff = AvageTime([] { return (ReadCoarseSystemClock() - std::chrono::system_clock::now()) / one_ms; });
+    ASSERT_NEAR(diff, 0, kTestN);
 }
 
-TEST(CoarseSteadyClock, Compare) {
-  auto diff = AvageTime([] {
-    return (ReadCoarseSteadyClock() - std::chrono::steady_clock::now()) /
-           one_ms;
-  });
-  ASSERT_NEAR(diff, 0, kTestN);
+TEST(CoarseSteadyClock, Compare)
+{
+    auto diff = AvageTime([] { return (ReadCoarseSteadyClock() - std::chrono::steady_clock::now()) / one_ms; });
+    ASSERT_NEAR(diff, 0, kTestN);
 }
-} // namespace tile
+}// namespace tile
diff --git a/tile/base/compression.cc b/tile/base/compression.cc
index da0b1f2..54977ef 100644
--- a/tile/base/compression.cc
+++ b/tile/base/compression.cc
@@ -4,89 +4,96 @@
 
 namespace tile {
 
-std::unique_ptr<Decompressor> MakeDecompressor(Slice name) {
-  return decompressor_registry.TryNew(name);
+std::unique_ptr<Decompressor>
+MakeDecompressor(Slice name)
+{
+    return decompressor_registry.TryNew(name);
 }
 
-std::unique_ptr<Compressor> MakeCompressor(Slice name) {
-  return compressor_registry.TryNew(name);
+std::unique_ptr<Compressor>
+MakeCompressor(Slice name)
+{
+    return compressor_registry.TryNew(name);
 }
 
-std::optional<NoncontiguousBuffer> Compress(Compressor *compressor,
-                                            const NoncontiguousBuffer &body) {
-  NoncontiguousBufferBuilder builder;
-  if (!Compress(compressor, body, &builder)) {
-    return std::nullopt;
-  }
-  return builder.DestructiveGet();
-}
-std::optional<NoncontiguousBuffer> Compress(Compressor *compressor,
-                                            Slice body) {
-  NoncontiguousBufferBuilder builder;
-  if (!Compress(compressor, body, &builder)) {
-    return std::nullopt;
-  }
-  return builder.DestructiveGet();
+std::optional<NoncontiguousBuffer>
+Compress(Compressor *compressor, const NoncontiguousBuffer &body)
+{
+    NoncontiguousBufferBuilder builder;
+    if (!Compress(compressor, body, &builder)) { return std::nullopt; }
+    return builder.DestructiveGet();
 }
 
-bool Compress(Compressor *compressor, const NoncontiguousBuffer &nb,
-              NoncontiguousBufferBuilder *builder) {
-  if (!compressor) {
-    TILE_LOG_WARNING_EVERY_SECOND("Compressor nullptr");
-    return false;
-  }
-
-  NoncontiguousBufferCompressionOutputStream out(builder);
-  return compressor->Compress(nb, &out);
+std::optional<NoncontiguousBuffer>
+Compress(Compressor *compressor, Slice body)
+{
+    NoncontiguousBufferBuilder builder;
+    if (!Compress(compressor, body, &builder)) { return std::nullopt; }
+    return builder.DestructiveGet();
 }
 
-bool Compress(Compressor *compressor, Slice body,
-              NoncontiguousBufferBuilder *builder) {
-  if (!compressor) {
-    TILE_LOG_WARNING_EVERY_SECOND("Compressor nullptr");
-    return false;
-  }
+bool
+Compress(Compressor *compressor, const NoncontiguousBuffer &nb, NoncontiguousBufferBuilder *builder)
+{
+    if (!compressor) {
+        TILE_LOG_WARNING_EVERY_SECOND("Compressor nullptr");
+        return false;
+    }
 
-  NoncontiguousBufferCompressionOutputStream out(builder);
-  return compressor->Compress(body.data(), body.size(), &out);
+    NoncontiguousBufferCompressionOutputStream out(builder);
+    return compressor->Compress(nb, &out);
 }
 
-std::optional<NoncontiguousBuffer> Decompress(Decompressor *decompressor,
-                                              const NoncontiguousBuffer &body) {
-  NoncontiguousBufferBuilder builder;
-  if (!Decompress(decompressor, body, &builder)) {
-    return std::nullopt;
-  }
-  return builder.DestructiveGet();
-}
-std::optional<NoncontiguousBuffer> Decompress(Decompressor *decompressor,
-                                              Slice body) {
-  NoncontiguousBufferBuilder builder;
-  if (!Decompress(decompressor, body, &builder)) {
-    return std::nullopt;
-  }
-  return builder.DestructiveGet();
+bool
+Compress(Compressor *compressor, Slice body, NoncontiguousBufferBuilder *builder)
+{
+    if (!compressor) {
+        TILE_LOG_WARNING_EVERY_SECOND("Compressor nullptr");
+        return false;
+    }
+
+    NoncontiguousBufferCompressionOutputStream out(builder);
+    return compressor->Compress(body.data(), body.size(), &out);
 }
 
-bool Decompress(Decompressor *decompressor, const NoncontiguousBuffer &nb,
-                NoncontiguousBufferBuilder *builder) {
-  if (!decompressor) {
-    TILE_LOG_WARNING_EVERY_SECOND("Decompressor nullptr");
-    return false;
-  }
-
-  NoncontiguousBufferCompressionOutputStream out(builder);
-  return decompressor->Decompress(nb, &out);
-}
-bool Decompress(Decompressor *decompressor, Slice body,
-                NoncontiguousBufferBuilder *builder) {
-  if (!decompressor) {
-    TILE_LOG_WARNING_EVERY_SECOND("Decompressor nullptr");
-    return false;
-  }
-
-  NoncontiguousBufferCompressionOutputStream out(builder);
-  return decompressor->Decompress(body.data(), body.size(), &out);
+std::optional<NoncontiguousBuffer>
+Decompress(Decompressor *decompressor, const NoncontiguousBuffer &body)
+{
+    NoncontiguousBufferBuilder builder;
+    if (!Decompress(decompressor, body, &builder)) { return std::nullopt; }
+    return builder.DestructiveGet();
 }
 
-} // namespace tile
+std::optional<NoncontiguousBuffer>
+Decompress(Decompressor *decompressor, Slice body)
+{
+    NoncontiguousBufferBuilder builder;
+    if (!Decompress(decompressor, body, &builder)) { return std::nullopt; }
+    return builder.DestructiveGet();
+}
+
+bool
+Decompress(Decompressor *decompressor, const NoncontiguousBuffer &nb, NoncontiguousBufferBuilder *builder)
+{
+    if (!decompressor) {
+        TILE_LOG_WARNING_EVERY_SECOND("Decompressor nullptr");
+        return false;
+    }
+
+    NoncontiguousBufferCompressionOutputStream out(builder);
+    return decompressor->Decompress(nb, &out);
+}
+
+bool
+Decompress(Decompressor *decompressor, Slice body, NoncontiguousBufferBuilder *builder)
+{
+    if (!decompressor) {
+        TILE_LOG_WARNING_EVERY_SECOND("Decompressor nullptr");
+        return false;
+    }
+
+    NoncontiguousBufferCompressionOutputStream out(builder);
+    return decompressor->Decompress(body.data(), body.size(), &out);
+}
+
+}// namespace tile
diff --git a/tile/base/compression.h b/tile/base/compression.h
index e325715..cbc1c99 100644
--- a/tile/base/compression.h
+++ b/tile/base/compression.h
@@ -11,26 +11,19 @@ namespace tile {
 std::unique_ptr<Decompressor> MakeDecompressor(Slice name);
 std::unique_ptr<Compressor> MakeCompressor(Slice name);
 
-std::optional<NoncontiguousBuffer> Compress(Compressor *compressor,
-                                            const NoncontiguousBuffer &nb);
+std::optional<NoncontiguousBuffer> Compress(Compressor *compressor, const NoncontiguousBuffer &nb);
 std::optional<NoncontiguousBuffer> Compress(Compressor *compressor, Slice body);
 
-bool Compress(Compressor *compressor, const NoncontiguousBuffer &nb,
-              NoncontiguousBufferBuilder *builder);
+bool Compress(Compressor *compressor, const NoncontiguousBuffer &nb, NoncontiguousBufferBuilder *builder);
 
-bool Compress(Compressor *compressor, Slice body,
-              NoncontiguousBufferBuilder *builder);
+bool Compress(Compressor *compressor, Slice body, NoncontiguousBufferBuilder *builder);
 
-std::optional<NoncontiguousBuffer> Decompress(Decompressor *decompressor,
-                                              const NoncontiguousBuffer &body);
-std::optional<NoncontiguousBuffer> Decompress(Decompressor *decompressor,
-                                              Slice body);
+std::optional<NoncontiguousBuffer> Decompress(Decompressor *decompressor, const NoncontiguousBuffer &body);
+std::optional<NoncontiguousBuffer> Decompress(Decompressor *decompressor, Slice body);
 
-bool Decompress(Decompressor *decompressor, const NoncontiguousBuffer &nb,
-                NoncontiguousBufferBuilder *builder);
-bool Decompress(Decompressor *decompressor, Slice body,
-                NoncontiguousBufferBuilder *builder);
+bool Decompress(Decompressor *decompressor, const NoncontiguousBuffer &nb, NoncontiguousBufferBuilder *builder);
+bool Decompress(Decompressor *decompressor, Slice body, NoncontiguousBufferBuilder *builder);
 
-} // namespace tile
+}// namespace tile
 
-#endif // TILE_BASE_COMPRESSION_H
+#endif// TILE_BASE_COMPRESSION_H
diff --git a/tile/base/compression/compression.cc b/tile/base/compression/compression.cc
index 35d6702..072bc7f 100644
--- a/tile/base/compression/compression.cc
+++ b/tile/base/compression/compression.cc
@@ -4,25 +4,33 @@ namespace tile {
 TILE_DEFINE_CLASS_DEPENDENCY_REGISTRY(compressor_registry, Compressor);
 TILE_DEFINE_CLASS_DEPENDENCY_REGISTRY(decompressor_registry, Decompressor);
 
-TestCompressionOutputStream::TestCompressionOutputStream(std::string *s,
-                                                         std::size_t every_size)
-    : buffer_(s), every_size_(every_size) {}
+TestCompressionOutputStream::TestCompressionOutputStream(std::string *s, std::size_t every_size)
+    : buffer_(s),
+      every_size_(every_size)
+{}
 
-bool TestCompressionOutputStream::Next(void **data,
-                                       std::size_t *size) noexcept {
-  if (buffer_->size() < using_bytes_ + every_size_) {
-    buffer_->resize(using_bytes_ + every_size_);
-  }
+bool
+TestCompressionOutputStream::Next(void **data, std::size_t *size) noexcept
+{
+    if (buffer_->size() < using_bytes_ + every_size_) { buffer_->resize(using_bytes_ + every_size_); }
 
-  *data = internal::RemoveConstPtr(buffer_->data()) + using_bytes_;
-  *size = every_size_;
+    *data = internal::RemoveConstPtr(buffer_->data()) + using_bytes_;
+    *size = every_size_;
 
-  using_bytes_ += every_size_;
-  return true;
+    using_bytes_ += every_size_;
+    return true;
 }
-void TestCompressionOutputStream::BackUp(std::size_t count) noexcept {
-  using_bytes_ -= count;
-}
-void TestCompressionOutputStream::Flush() { buffer_->resize(using_bytes_); }
 
-} // namespace tile
+void
+TestCompressionOutputStream::BackUp(std::size_t count) noexcept
+{
+    using_bytes_ -= count;
+}
+
+void
+TestCompressionOutputStream::Flush()
+{
+    buffer_->resize(using_bytes_);
+}
+
+}// namespace tile
diff --git a/tile/base/compression/compression.h b/tile/base/compression/compression.h
index c33d5e2..1d4546d 100644
--- a/tile/base/compression/compression.h
+++ b/tile/base/compression/compression.h
@@ -9,57 +9,50 @@
 namespace tile {
 class CompressionOutputStream {
 public:
-  virtual ~CompressionOutputStream() = default;
-  // Get a buffer to write to. The buffer may be backed by multiple
-  virtual bool Next(void **data, std::size_t *size) noexcept = 0;
-  virtual void BackUp(std::size_t count) noexcept = 0;
+    virtual ~CompressionOutputStream() = default;
+    // Get a buffer to write to. The buffer may be backed by multiple
+    virtual bool Next(void **data, std::size_t *size) noexcept = 0;
+    virtual void BackUp(std::size_t count) noexcept            = 0;
 };
 
 class Compressor {
 public:
-  virtual ~Compressor() = default;
-  virtual bool Compress(const void *src, std::size_t size,
-                        CompressionOutputStream *out) = 0;
-  virtual bool Compress(const NoncontiguousBuffer &src,
-                        CompressionOutputStream *out) = 0;
+    virtual ~Compressor()                                                                  = default;
+    virtual bool Compress(const void *src, std::size_t size, CompressionOutputStream *out) = 0;
+    virtual bool Compress(const NoncontiguousBuffer &src, CompressionOutputStream *out)    = 0;
 };
 
 class Decompressor {
 public:
-  ~Decompressor() = default;
-  virtual bool Decompress(const void *src, std::size_t size,
-                          CompressionOutputStream *out) = 0;
-  virtual bool Decompress(const NoncontiguousBuffer &src,
-                          CompressionOutputStream *out) = 0;
+    ~Decompressor()                                                                          = default;
+    virtual bool Decompress(const void *src, std::size_t size, CompressionOutputStream *out) = 0;
+    virtual bool Decompress(const NoncontiguousBuffer &src, CompressionOutputStream *out)    = 0;
 };
 
 TILE_DECLARE_CLASS_DEPENDENCY_REGISTRY(compressor_registry, Compressor);
 TILE_DECLARE_CLASS_DEPENDENCY_REGISTRY(decompressor_registry, Decompressor);
 
-} // namespace tile
+}// namespace tile
 
-#define TILE_COMPRESSION_REGISTER_COMPRESSOR(Name, Implementation)             \
-  TILE_REGISTER_CLASS_DEPENDENCY(::tile::compressor_registry, Name,            \
-                                 Implementation)
-#define TILE_COMPRESSION_REGISTER_DECOMPRESSOR(Name, Implementation)           \
-  TILE_REGISTER_CLASS_DEPENDENCY(::tile::decompressor_registry, Name,          \
-                                 Implementation)
+#define TILE_COMPRESSION_REGISTER_COMPRESSOR(Name, Implementation)                                                     \
+    TILE_REGISTER_CLASS_DEPENDENCY(::tile::compressor_registry, Name, Implementation)
+#define TILE_COMPRESSION_REGISTER_DECOMPRESSOR(Name, Implementation)                                                   \
+    TILE_REGISTER_CLASS_DEPENDENCY(::tile::decompressor_registry, Name, Implementation)
 
 namespace tile {
 class TestCompressionOutputStream : public CompressionOutputStream {
 public:
-  explicit TestCompressionOutputStream(std::string *s,
-                                       std::size_t every_size = 2);
+    explicit TestCompressionOutputStream(std::string *s, std::size_t every_size = 2);
 
-  bool Next(void **data, std::size_t *size) noexcept override;
-  void BackUp(std::size_t count) noexcept override;
-  void Flush();
+    bool Next(void **data, std::size_t *size) noexcept override;
+    void BackUp(std::size_t count) noexcept override;
+    void Flush();
 
 private:
-  std::size_t using_bytes_{};
-  std::size_t every_size_;
-  std::string *buffer_;
+    std::size_t using_bytes_{};
+    std::size_t every_size_;
+    std::string *buffer_;
 };
-} // namespace tile
+}// namespace tile
 
-#endif // TILE_BASE_COMPRESSION_COMPRESSION_H
+#endif// TILE_BASE_COMPRESSION_COMPRESSION_H
diff --git a/tile/base/compression/gzip.cc b/tile/base/compression/gzip.cc
index 3041d88..3d4331f 100644
--- a/tile/base/compression/gzip.cc
+++ b/tile/base/compression/gzip.cc
@@ -11,24 +11,28 @@ TILE_COMPRESSION_REGISTER_DECOMPRESSOR("gzip", GzipDecompressor);
 
 namespace detail {
 struct ZStream {
-  z_stream stream;
+    z_stream stream;
 };
-} // namespace detail
+}// namespace detail
+
 namespace {
 
-inline double EstimateCompressionRate(const z_stream *stream,
-                                      double default_value) {
-  if (stream->total_in > 0) {
-    double rate = 1.0f * stream->total_out / stream->total_in;
-    constexpr double kMinRate = 1.1;
-    return rate * kMinRate;
-  }
+inline double
+EstimateCompressionRate(const z_stream *stream, double default_value)
+{
+    if (stream->total_in > 0) {
+        double rate               = 1.0f * stream->total_out / stream->total_in;
+        constexpr double kMinRate = 1.1;
+        return rate * kMinRate;
+    }
 
-  return default_value;
+    return default_value;
 }
 
-inline uint32_t RestrictAvailSize(size_t size) {
-  return static_cast<uint32_t>(std::min(size, static_cast<size_t>(UINT32_MAX)));
+inline uint32_t
+RestrictAvailSize(size_t size)
+{
+    return static_cast<uint32_t>(std::min(size, static_cast<size_t>(UINT32_MAX)));
 }
 
 // See document of inflateInit2 in zlib.h
@@ -37,207 +41,223 @@ constexpr int ZLIB_INIT_FLAG_GZIP = 16;
 // he size to increase every time Z_BUF_ERROR returns.
 constexpr int kOutBufferIncreaseSize = 32;
 
-bool DoAppend(z_stream *stream, CompressionOutputStream *out_stream,
-              const void *input_buffer, std::size_t input_size, bool is_deflate,
-              bool finish) {
-  TILE_CHECK(stream && out_stream);
+bool
+DoAppend(z_stream *stream,
+         CompressionOutputStream *out_stream,
+         const void *input_buffer,
+         std::size_t input_size,
+         bool is_deflate,
+         bool finish)
+{
+    TILE_CHECK(stream && out_stream);
 
-  if (!finish && (input_buffer == nullptr || input_size == 0)) {
-    // no input data
-    return true;
-  }
+    if (!finish && (input_buffer == nullptr || input_size == 0)) {
+        // no input data
+        return true;
+    }
 
-  stream->next_in = reinterpret_cast<Bytef *>(const_cast<void *>(input_buffer));
-  int code = Z_OK;
-  // the number of  `buffer too small error`
-  int need_more_space_cnt = 0;
-  std::string tmp_buffer;
-  size_t left_size = input_size;
-  while (left_size > 0 || need_more_space_cnt > 0 || finish) {
-    stream->avail_in = RestrictAvailSize(left_size);
-    const auto current_avail_in = stream->avail_in;
-    std::size_t out_size;
-    if (!need_more_space_cnt) {
-      void *out_data;
-      if (!out_stream->Next(&out_data, &out_size)) {
-        // out buffer is full
-        return false;
-      }
+    stream->next_in = reinterpret_cast<Bytef *>(const_cast<void *>(input_buffer));
+    int code        = Z_OK;
+    // the number of  `buffer too small error`
+    int need_more_space_cnt = 0;
+    std::string tmp_buffer;
+    size_t left_size = input_size;
+    while (left_size > 0 || need_more_space_cnt > 0 || finish) {
+        stream->avail_in            = RestrictAvailSize(left_size);
+        const auto current_avail_in = stream->avail_in;
+        std::size_t out_size;
+        if (!need_more_space_cnt) {
+            void *out_data;
+            if (!out_stream->Next(&out_data, &out_size)) {
+                // out buffer is full
+                return false;
+            }
 
-      stream->next_out = reinterpret_cast<Bytef *>(out_data);
+            stream->next_out = reinterpret_cast<Bytef *>(out_data);
+        } else {
+            double rate = EstimateCompressionRate(stream, 0.5);
+            tmp_buffer.resize(left_size * rate + need_more_space_cnt * kOutBufferIncreaseSize);
+            stream->next_out = reinterpret_cast<Bytef *>(internal::RemoveConstPtr(tmp_buffer.data()));
+            out_size         = tmp_buffer.size();
+        }
+
+        stream->avail_out                   = RestrictAvailSize(out_size);
+        const std::size_t current_avail_out = stream->avail_out;
+
+        TILE_CHECK_GT(stream->avail_out, 0, "Avail_out should never be zero before the call.");
+        int flush_option = finish ? Z_FINISH : Z_NO_FLUSH;
+        if (is_deflate) {
+            code = deflate(stream, flush_option);
+        } else {
+            code = inflate(stream, flush_option);
+        }
+
+        // https://refspecs.linuxbase.org/LSB_3.0.0/LSB-Core-generic/LSB-Core-generic/zlib-inflate-1.html
+        // No progress is possible; either avail_in or avail_out was zero.
+        if (code == Z_BUF_ERROR) {
+            if (need_more_space_cnt == 0) { out_stream->BackUp(out_size); }
+
+            if (stream->avail_in == 0) {
+                // if not finish, we need more input data
+                // otherwise, fail to compress/decompress
+                return !finish;
+            }
+
+            ++need_more_space_cnt;
+            continue;
+        }
+
+        if (code < 0) {
+            TILE_LOG_ERROR_EVERY_SECOND("gzip compress error code [{}]", code);
+            break;
+        }
+
+        // consume input data (current_avail_in - stream->avail_in)
+        // produce output data (stream->avail_out)
+        left_size -= current_avail_in - stream->avail_in;
+        if (need_more_space_cnt == 0) {
+            out_stream->BackUp(stream->avail_out);
+        } else {
+            if (TILE_UNLIKELY(!CopyDataToCompressionOutputStream(
+                    out_stream, tmp_buffer.data(), current_avail_out - stream->avail_out))) {
+                return false;
+            }
+            need_more_space_cnt = 0;
+        }
+
+        if (code == Z_STREAM_END) { return true; }
+    }
+
+    return code == Z_OK;
+}
+}// namespace
+
+bool
+GzipCompressor::Compress(const void *src, std::size_t size, CompressionOutputStream *out)
+{
+    bool ok = Init(out);
+    ok &= Append(src, size);
+    ok &= Flush();
+    out_ = nullptr;
+    return ok;
+}
+
+bool
+GzipCompressor::Compress(const NoncontiguousBuffer &bytes, CompressionOutputStream *out)
+{
+    bool ok          = Init(out);
+    std::size_t left = bytes.ByteSize();
+    for (auto iter = bytes.begin(); ok && iter != bytes.end(); ++iter) {
+        auto len = std::min(left, iter->size());
+        ok &= Append(iter->data(), len);
+        left -= len;
+    }
+    ok &= Flush();
+    out_ = nullptr;
+    return ok;
+}
+
+bool
+GzipCompressor::Append(const void *buffer, std::size_t size)
+{
+    return DoAppend(&stream_->stream, out_, buffer, size, true, false);
+}
+
+bool
+GzipCompressor::Flush()
+{
+    TILE_CHECK(out_);
+    if (!DoAppend(&stream_->stream, out_, nullptr, 0, true, true)) { return false; }
+    return Release();
+}
+
+bool
+GzipCompressor::Init(CompressionOutputStream *out)
+{
+    TILE_CHECK(!out_);
+    stream_  = make_unique<detail::ZStream>();
+    int code = deflateInit2(
+        &stream_->stream, Z_DEFAULT_COMPRESSION, Z_DEFLATED, MAX_WBITS + ZLIB_INIT_FLAG_GZIP, 8, Z_DEFAULT_STRATEGY);
+    if (code != Z_OK) {
+        TILE_LOG_ERROR_EVERY_SECOND("deflateInit2 error code [{}]", code);
+        stream_ = nullptr;
     } else {
-      double rate = EstimateCompressionRate(stream, 0.5);
-      tmp_buffer.resize(left_size * rate +
-                        need_more_space_cnt * kOutBufferIncreaseSize);
-      stream->next_out = reinterpret_cast<Bytef *>(
-          internal::RemoveConstPtr(tmp_buffer.data()));
-      out_size = tmp_buffer.size();
+        out_ = out;
     }
+    return code == Z_OK;
+}
 
-    stream->avail_out = RestrictAvailSize(out_size);
-    const std::size_t current_avail_out = stream->avail_out;
+bool
+GzipCompressor::Release()
+{
+    TILE_CHECK(stream_);
+    int code = deflateEnd(&stream_->stream);
+    if (code != Z_OK) { TILE_LOG_WARNING_EVERY_SECOND("DeflateEnd fail with code [{}].", code); }
+    return code == Z_OK;
+}
 
-    TILE_CHECK_GT(stream->avail_out, 0,
-                  "Avail_out should never be zero before the call.");
-    int flush_option = finish ? Z_FINISH : Z_NO_FLUSH;
-    if (is_deflate) {
-      code = deflate(stream, flush_option);
+bool
+GzipDecompressor::Decompress(const void *src, std::size_t size, CompressionOutputStream *out)
+{
+    bool ok = Init(out);
+    ok &= Append(src, size);
+    ok &= Flush();
+    out_ = nullptr;
+    return ok;
+}
+
+bool
+GzipDecompressor::Decompress(const NoncontiguousBuffer &compressed, CompressionOutputStream *out)
+{
+    bool ok          = Init(out);
+    std::size_t left = compressed.ByteSize();
+    for (auto iter = compressed.begin(); ok && iter != compressed.end(); ++iter) {
+        auto len = std::min(left, iter->size());
+        ok &= Append(iter->data(), len);
+        left -= len;
+    }
+    ok &= Flush();
+    out_ = nullptr;
+    return ok;
+}
+
+bool
+GzipDecompressor::Append(const void *buffer, std::size_t size)
+{
+    return DoAppend(&stream_->stream, out_, buffer, size, false, false);
+}
+
+bool
+GzipDecompressor::Flush()
+{
+    TILE_CHECK(out_);
+    if (!DoAppend(&stream_->stream, out_, nullptr, 0, false, true)) { return false; }
+    return Release();
+}
+
+bool
+GzipDecompressor::Init(CompressionOutputStream *out)
+{
+    TILE_CHECK(!out_);
+    stream_  = make_unique<detail::ZStream>();
+    int code = inflateInit2(&stream_->stream, MAX_WBITS + ZLIB_INIT_FLAG_GZIP);
+    if (code != Z_OK) {
+        TILE_LOG_ERROR_EVERY_SECOND("inflateInit2 error code [{}]", code);
+        stream_ = nullptr;
     } else {
-      code = inflate(stream, flush_option);
+        out_ = out;
     }
-
-    // https://refspecs.linuxbase.org/LSB_3.0.0/LSB-Core-generic/LSB-Core-generic/zlib-inflate-1.html
-    // No progress is possible; either avail_in or avail_out was zero.
-    if (code == Z_BUF_ERROR) {
-      if (need_more_space_cnt == 0) {
-        out_stream->BackUp(out_size);
-      }
-
-      if (stream->avail_in == 0) {
-        // if not finish, we need more input data
-        // otherwise, fail to compress/decompress
-        return !finish;
-      }
-
-      ++need_more_space_cnt;
-      continue;
-    }
-
-    if (code < 0) {
-      TILE_LOG_ERROR_EVERY_SECOND("gzip compress error code [{}]", code);
-      break;
-    }
-
-    // consume input data (current_avail_in - stream->avail_in)
-    // produce output data (stream->avail_out)
-    left_size -= current_avail_in - stream->avail_in;
-    if (need_more_space_cnt == 0) {
-      out_stream->BackUp(stream->avail_out);
-    } else {
-      if (TILE_UNLIKELY(!CopyDataToCompressionOutputStream(
-              out_stream, tmp_buffer.data(),
-              current_avail_out - stream->avail_out))) {
-        return false;
-      }
-      need_more_space_cnt = 0;
-    }
-
-    if (code == Z_STREAM_END) {
-      return true;
-    }
-  }
-
-  return code == Z_OK;
-}
-} // namespace
-
-bool GzipCompressor::Compress(const void *src, std::size_t size,
-                              CompressionOutputStream *out) {
-  bool ok = Init(out);
-  ok &= Append(src, size);
-  ok &= Flush();
-  out_ = nullptr;
-  return ok;
-}
-bool GzipCompressor::Compress(const NoncontiguousBuffer &bytes,
-                              CompressionOutputStream *out) {
-  bool ok = Init(out);
-  std::size_t left = bytes.ByteSize();
-  for (auto iter = bytes.begin(); ok && iter != bytes.end(); ++iter) {
-    auto len = std::min(left, iter->size());
-    ok &= Append(iter->data(), len);
-    left -= len;
-  }
-  ok &= Flush();
-  out_ = nullptr;
-  return ok;
-}
-bool GzipCompressor::Append(const void *buffer, std::size_t size) {
-  return DoAppend(&stream_->stream, out_, buffer, size, true, false);
-}
-bool GzipCompressor::Flush() {
-  TILE_CHECK(out_);
-  if (!DoAppend(&stream_->stream, out_, nullptr, 0, true, true)) {
-    return false;
-  }
-  return Release();
+    return code == Z_OK;
 }
 
-bool GzipCompressor::Init(CompressionOutputStream *out) {
-  TILE_CHECK(!out_);
-  stream_ = make_unique<detail::ZStream>();
-  int code =
-      deflateInit2(&stream_->stream, Z_DEFAULT_COMPRESSION, Z_DEFLATED,
-                   MAX_WBITS + ZLIB_INIT_FLAG_GZIP, 8, Z_DEFAULT_STRATEGY);
-  if (code != Z_OK) {
-    TILE_LOG_ERROR_EVERY_SECOND("deflateInit2 error code [{}]", code);
-    stream_ = nullptr;
-  } else {
-    out_ = out;
-  }
-  return code == Z_OK;
-}
-bool GzipCompressor::Release() {
-  TILE_CHECK(stream_);
-  int code = deflateEnd(&stream_->stream);
-  if (code != Z_OK) {
-    TILE_LOG_WARNING_EVERY_SECOND("DeflateEnd fail with code [{}].", code);
-  }
-  return code == Z_OK;
+bool
+GzipDecompressor::Release()
+{
+    TILE_CHECK(stream_);
+    int code = inflateEnd(&stream_->stream);
+    if (code != Z_OK) { TILE_LOG_WARNING_EVERY_SECOND("DeflateEnd fail with code [{}].", code); }
+    return code == Z_OK;
 }
 
-bool GzipDecompressor::Decompress(const void *src, std::size_t size,
-                                  CompressionOutputStream *out) {
-  bool ok = Init(out);
-  ok &= Append(src, size);
-  ok &= Flush();
-  out_ = nullptr;
-  return ok;
-}
-bool GzipDecompressor::Decompress(const NoncontiguousBuffer &compressed,
-                                  CompressionOutputStream *out) {
-  bool ok = Init(out);
-  std::size_t left = compressed.ByteSize();
-  for (auto iter = compressed.begin(); ok && iter != compressed.end(); ++iter) {
-    auto len = std::min(left, iter->size());
-    ok &= Append(iter->data(), len);
-    left -= len;
-  }
-  ok &= Flush();
-  out_ = nullptr;
-  return ok;
-}
-
-bool GzipDecompressor::Append(const void *buffer, std::size_t size) {
-  return DoAppend(&stream_->stream, out_, buffer, size, false, false);
-}
-bool GzipDecompressor::Flush() {
-  TILE_CHECK(out_);
-  if (!DoAppend(&stream_->stream, out_, nullptr, 0, false, true)) {
-    return false;
-  }
-  return Release();
-}
-bool GzipDecompressor::Init(CompressionOutputStream *out) {
-  TILE_CHECK(!out_);
-  stream_ = make_unique<detail::ZStream>();
-  int code = inflateInit2(&stream_->stream, MAX_WBITS + ZLIB_INIT_FLAG_GZIP);
-  if (code != Z_OK) {
-    TILE_LOG_ERROR_EVERY_SECOND("inflateInit2 error code [{}]", code);
-    stream_ = nullptr;
-  } else {
-    out_ = out;
-  }
-  return code == Z_OK;
-}
-bool GzipDecompressor::Release() {
-  TILE_CHECK(stream_);
-  int code = inflateEnd(&stream_->stream);
-  if (code != Z_OK) {
-    TILE_LOG_WARNING_EVERY_SECOND("DeflateEnd fail with code [{}].", code);
-  }
-  return code == Z_OK;
-}
-
-} // namespace compression
-} // namespace tile
+}// namespace compression
+}// namespace tile
diff --git a/tile/base/compression/gzip.h b/tile/base/compression/gzip.h
index 6340752..2d7d18a 100644
--- a/tile/base/compression/gzip.h
+++ b/tile/base/compression/gzip.h
@@ -5,48 +5,43 @@
 
 #include <memory>
 
-
 #include "tile/base/compression/compression.h"
 
 namespace tile {
 namespace compression {
 namespace detail {
 struct ZStream;
-} // namespace detail
+}// namespace detail
 
 class GzipCompressor : public Compressor {
 public:
-  bool Compress(const void *src, std::size_t size,
-                CompressionOutputStream *out) override;
-  bool Compress(const NoncontiguousBuffer &bytes,
-                CompressionOutputStream *out) override;
+    bool Compress(const void *src, std::size_t size, CompressionOutputStream *out) override;
+    bool Compress(const NoncontiguousBuffer &bytes, CompressionOutputStream *out) override;
 
 private:
-  bool Append(const void *buffer, std::size_t size);
-  bool Flush();
-  bool Init(CompressionOutputStream *out);
-  bool Release();
-  std::unique_ptr<detail::ZStream> stream_;
-  CompressionOutputStream *out_ = nullptr;
+    bool Append(const void *buffer, std::size_t size);
+    bool Flush();
+    bool Init(CompressionOutputStream *out);
+    bool Release();
+    std::unique_ptr<detail::ZStream> stream_;
+    CompressionOutputStream *out_ = nullptr;
 };
 
 class GzipDecompressor : public Decompressor {
 public:
-  bool Decompress(const void *src, std::size_t size,
-                  CompressionOutputStream *out) override;
-  bool Decompress(const NoncontiguousBuffer &compressed,
-                  CompressionOutputStream *out) override;
+    bool Decompress(const void *src, std::size_t size, CompressionOutputStream *out) override;
+    bool Decompress(const NoncontiguousBuffer &compressed, CompressionOutputStream *out) override;
 
 private:
-  bool Append(const void *buffer, std::size_t size);
-  bool Flush();
-  bool Init(CompressionOutputStream *out);
-  bool Release();
-  std::unique_ptr<detail::ZStream> stream_;
-  CompressionOutputStream *out_ = nullptr;
+    bool Append(const void *buffer, std::size_t size);
+    bool Flush();
+    bool Init(CompressionOutputStream *out);
+    bool Release();
+    std::unique_ptr<detail::ZStream> stream_;
+    CompressionOutputStream *out_ = nullptr;
 };
 
-} // namespace compression
-} // namespace tile
+}// namespace compression
+}// namespace tile
 
-#endif // TILE_BASE_COMPRESSION_GZIP_H
+#endif// TILE_BASE_COMPRESSION_GZIP_H
diff --git a/tile/base/compression/util.cc b/tile/base/compression/util.cc
index ae021b0..3d2c0ec 100644
--- a/tile/base/compression/util.cc
+++ b/tile/base/compression/util.cc
@@ -1,37 +1,33 @@
 #include "util.h"
+
 namespace tile {
 namespace compression {
-bool CopyDataToCompressionOutputStream(CompressionOutputStream *out,
-                                       const void *data, std::size_t size) {
+bool
+CopyDataToCompressionOutputStream(CompressionOutputStream *out, const void *data, std::size_t size)
+{
 
-  if (size == 0) {
-    return true;
-  }
+    if (size == 0) { return true; }
 
-  std::size_t current_pos = 0;
-  std::size_t left_to_copy = size;
+    std::size_t current_pos  = 0;
+    std::size_t left_to_copy = size;
 
-  while (true) {
-    void *next_data;
-    std::size_t next_size;
-    if (TILE_UNLIKELY(!out->Next(&next_data, &next_size))) {
-      return false;
+    while (true) {
+        void *next_data;
+        std::size_t next_size;
+        if (TILE_UNLIKELY(!out->Next(&next_data, &next_size))) { return false; }
+
+        if (left_to_copy <= next_size) {
+            memcpy(next_data, reinterpret_cast<const char *>(data) + current_pos, left_to_copy);
+            out->BackUp(next_size - left_to_copy);
+            return true;
+        } else {
+            memcpy(next_data, reinterpret_cast<const char *>(data) + current_pos, next_size);
+            current_pos += next_size;
+            left_to_copy -= next_size;
+        }
     }
-
-    if (left_to_copy <= next_size) {
-      memcpy(next_data, reinterpret_cast<const char *>(data) + current_pos,
-             left_to_copy);
-      out->BackUp(next_size - left_to_copy);
-      return true;
-    } else {
-      memcpy(next_data, reinterpret_cast<const char *>(data) + current_pos,
-             next_size);
-      current_pos += next_size;
-      left_to_copy -= next_size;
-    }
-  }
-  TILE_UNREACHABLE("");
-  return false;
+    TILE_UNREACHABLE("");
+    return false;
 }
-} // namespace compression
-} // namespace tile
+}// namespace compression
+}// namespace tile
diff --git a/tile/base/compression/util.h b/tile/base/compression/util.h
index ea14542..21aaad0 100644
--- a/tile/base/compression/util.h
+++ b/tile/base/compression/util.h
@@ -7,9 +7,8 @@
 
 namespace tile {
 namespace compression {
-bool CopyDataToCompressionOutputStream(CompressionOutputStream *out,
-                                       const void *data, std::size_t size);
+bool CopyDataToCompressionOutputStream(CompressionOutputStream *out, const void *data, std::size_t size);
 }
-} // namespace tile
+}// namespace tile
 
-#endif // TILE_BASE_COMPRESSION_UTIL_H
+#endif// TILE_BASE_COMPRESSION_UTIL_H
diff --git a/tile/base/compression/util_test.cc b/tile/base/compression/util_test.cc
index 232bea7..ac75e09 100644
--- a/tile/base/compression/util_test.cc
+++ b/tile/base/compression/util_test.cc
@@ -4,19 +4,20 @@
 
 namespace tile {
 namespace compression {
-TEST(CopyDataToCompressionOutputStream, All) {
-  std::string s;
-  std::string a = "123456789+";
+TEST(CopyDataToCompressionOutputStream, All)
+{
+    std::string s;
+    std::string a = "123456789+";
 
-  TestCompressionOutputStream out1(&s, 2);
-  CopyDataToCompressionOutputStream(&out1, a.data(), 1);
-  CopyDataToCompressionOutputStream(&out1, a.data() + 1, 2);
-  CopyDataToCompressionOutputStream(&out1, a.data() + 3, 3);
-  CopyDataToCompressionOutputStream(&out1, a.data() + 6, 4);
-  out1.Flush();
+    TestCompressionOutputStream out1(&s, 2);
+    CopyDataToCompressionOutputStream(&out1, a.data(), 1);
+    CopyDataToCompressionOutputStream(&out1, a.data() + 1, 2);
+    CopyDataToCompressionOutputStream(&out1, a.data() + 3, 3);
+    CopyDataToCompressionOutputStream(&out1, a.data() + 6, 4);
+    out1.Flush();
 
-  ASSERT_EQ(s, a);
+    ASSERT_EQ(s, a);
 }
-} // namespace compression
+}// namespace compression
 
-} // namespace tile
+}// namespace tile
diff --git a/tile/base/compression_test.cc b/tile/base/compression_test.cc
index 084140b..77d814b 100644
--- a/tile/base/compression_test.cc
+++ b/tile/base/compression_test.cc
@@ -11,62 +11,67 @@ static const char *algos[] = {
     "gzip",
 };
 }
-TEST(MakeCompressor, All) {
-  auto &&c = MakeCompressor("gzip");
-  EXPECT_TRUE(c);
-  c = MakeCompressor("??");
-  EXPECT_FALSE(c);
+
+TEST(MakeCompressor, All)
+{
+    auto &&c = MakeCompressor("gzip");
+    EXPECT_TRUE(c);
+    c = MakeCompressor("??");
+    EXPECT_FALSE(c);
 }
 
-TEST(MakeDecompressor, All) {
-  auto &&c = MakeDecompressor("gzip");
-  EXPECT_TRUE(c);
-  c = MakeDecompressor("??");
-  EXPECT_FALSE(c);
+TEST(MakeDecompressor, All)
+{
+    auto &&c = MakeDecompressor("gzip");
+    EXPECT_TRUE(c);
+    c = MakeDecompressor("??");
+    EXPECT_FALSE(c);
 }
 
-TEST(CompressString, All) {
-  std::string original(1000, 'A');
-  auto c = Compress(MakeCompressor("gzip").get(), original);
-  EXPECT_TRUE(c);
-  auto d = Decompress(MakeDecompressor("gzip").get(), *c);
-  EXPECT_TRUE(d);
-  EXPECT_EQ(FlattenSlow(*d), original);
+TEST(CompressString, All)
+{
+    std::string original(1000, 'A');
+    auto c = Compress(MakeCompressor("gzip").get(), original);
+    EXPECT_TRUE(c);
+    auto d = Decompress(MakeDecompressor("gzip").get(), *c);
+    EXPECT_TRUE(d);
+    EXPECT_EQ(FlattenSlow(*d), original);
 }
 
-TEST(CompressNoncontiguousBuffer, All) {
-  NoncontiguousBufferBuilder nbb;
-  std::string original(1000, 'A');
-  nbb.Append(original.data(), original.size());
-  auto &&nb = nbb.DestructiveGet();
-  auto c = Compress(MakeCompressor("gzip").get(), nb);
-  EXPECT_TRUE(c);
-  auto d = Decompress(MakeDecompressor("gzip").get(), *c);
-  EXPECT_TRUE(d);
-  EXPECT_EQ(FlattenSlow(*d), original);
+TEST(CompressNoncontiguousBuffer, All)
+{
+    NoncontiguousBufferBuilder nbb;
+    std::string original(1000, 'A');
+    nbb.Append(original.data(), original.size());
+    auto &&nb = nbb.DestructiveGet();
+    auto c    = Compress(MakeCompressor("gzip").get(), nb);
+    EXPECT_TRUE(c);
+    auto d = Decompress(MakeDecompressor("gzip").get(), *c);
+    EXPECT_TRUE(d);
+    EXPECT_EQ(FlattenSlow(*d), original);
 }
 
-TEST(Decompressor, Empty) {
-  for (auto &&algo : algos) {
-    auto res = Decompress(MakeDecompressor(algo).get(), "");
+TEST(Decompressor, Empty)
+{
+    for (auto &&algo : algos) {
+        auto res = Decompress(MakeDecompressor(algo).get(), "");
 
-    // Failure in decompressing empty buffer is not an error. So long as
-    // decompressing a buffer produced by `Compress(..., "")` works correctly,
-    // we're fine.
-    if (res) {
-      // However, if the decompression does succeed, the resulting buffer should
-      // be empty.
-      EXPECT_TRUE(res->Empty());
+        // Failure in decompressing empty buffer is not an error. So long as
+        // decompressing a buffer produced by `Compress(..., "")` works correctly,
+        // we're fine.
+        if (res) {
+            // However, if the decompression does succeed, the resulting buffer should
+            // be empty.
+            EXPECT_TRUE(res->Empty());
+        }
     }
-  }
 }
 
-TEST(Decompressor, Invalid) {
-  for (auto &&algo : algos) {
-    auto res =
-        Decompress(MakeDecompressor(algo).get(),
-                   "this buffer is likely an invalid compressed buffer.");
-    EXPECT_FALSE(res);
-  }
+TEST(Decompressor, Invalid)
+{
+    for (auto &&algo : algos) {
+        auto res = Decompress(MakeDecompressor(algo).get(), "this buffer is likely an invalid compressed buffer.");
+        EXPECT_FALSE(res);
+    }
 }
-} // namespace tile
+}// namespace tile
diff --git a/tile/base/config/configurable.h b/tile/base/config/configurable.h
index ddbca56..99918b2 100644
--- a/tile/base/config/configurable.h
+++ b/tile/base/config/configurable.h
@@ -6,12 +6,12 @@
 
 namespace tile {
 class Configurable {
-  Configurable();
-  virtual ~Configurable() = default;
-  virtual void SetProperty(const Slice &name, const Slice &value) = 0;
-  virtual std::string GetProperty(const Slice &name) const = 0;
+    Configurable();
+    virtual ~Configurable()                                         = default;
+    virtual void SetProperty(const Slice &name, const Slice &value) = 0;
+    virtual std::string GetProperty(const Slice &name) const        = 0;
 };
 
-} // namespace tile
+}// namespace tile
 
-#endif // TILE_BASE_CONFIG_CONFIGURABLE_H
+#endif// TILE_BASE_CONFIG_CONFIGURABLE_H
diff --git a/tile/base/config/configuration.cc b/tile/base/config/configuration.cc
index dd921b0..6f2999b 100644
--- a/tile/base/config/configuration.cc
+++ b/tile/base/config/configuration.cc
@@ -4,80 +4,99 @@
 #include "tile/base/thread/unique_lock.h"
 
 namespace tile {
-bool Configuration::Has(const Slice &key) const {
-  UniqueLock<tile::Mutex> lock(mutex_);
-  std::string value;
-  return GetRaw(key, &value);
+bool
+Configuration::Has(const Slice &key) const
+{
+    UniqueLock<tile::Mutex> lock(mutex_);
+    std::string value;
+    return GetRaw(key, &value);
 }
 
-void Configuration::Remove(const Slice &key) {
-  UniqueLock<tile::Mutex> lock(mutex_);
-  if (events_enabled_) {
-    OnRemoving(key);
-  }
-  RemoveRaw(key);
-  if (events_enabled_) {
-    OnRemoved(key);
-  }
+void
+Configuration::Remove(const Slice &key)
+{
+    UniqueLock<tile::Mutex> lock(mutex_);
+    if (events_enabled_) { OnRemoving(key); }
+    RemoveRaw(key);
+    if (events_enabled_) { OnRemoved(key); }
 }
 
-void Configuration::EnableEvents(bool enable) { events_enabled_ = enable; }
-bool Configuration::EventsEnabled() const { return events_enabled_; }
-
-Configuration::Keys Configuration::keys(const Slice &root) const {
-  UniqueLock<tile::Mutex> lock(mutex_);
-  return Enumerate(root);
+void
+Configuration::EnableEvents(bool enable)
+{
+    events_enabled_ = enable;
 }
 
-#define TILE_DEFINE_CONFIG_GETTER(type, name)                                  \
-  std::optional<type> Configuration::Get##name(const Slice &key) const {       \
-    std::string value;                                                         \
-    if (GetRaw(key, &value)) {                                                 \
-      auto opt = TryParseTraits<type>::TryParse(value);                        \
-      if (opt.has_value()) {                                                   \
-        return *opt;                                                           \
-      } else {                                                                 \
-        return std::nullopt;                                                   \
-      }                                                                        \
-    } else {                                                                   \
-      return std::nullopt;                                                     \
-    }                                                                          \
-  }                                                                            \
-  type Configuration::Get##name(const Slice &key, type default_value) const {  \
-    auto opt = Get##name(key);                                                 \
-    if (opt.has_value()) {                                                     \
-      return *opt;                                                             \
-    } else {                                                                   \
-      return default_value;                                                    \
-    }                                                                          \
-  }
-
-#define TILE_DEFINE_CONFIG_SETTER(type, name)                                  \
-  void Configuration::Set##name(const Slice &key, type value) {                \
-    SetRawWithEvent(key, Format("{}", value));                                 \
-  }
-
-std::optional<std::string> Configuration::GetString(const Slice &key) const {
-  std::string value;
-  UniqueLock<tile::Mutex> lock(mutex_);
-  if (GetRaw(key, &value)) {
-    return value;
-  } else {
-    return std::nullopt;
-  }
+bool
+Configuration::EventsEnabled() const
+{
+    return events_enabled_;
 }
 
-std::string Configuration::GetString(const Slice &key,
-                                     std::string default_value) const {
-  auto opt = GetString(key);
-  return opt.has_value() ? *opt : default_value;
+Configuration::Keys
+Configuration::keys(const Slice &root) const
+{
+    UniqueLock<tile::Mutex> lock(mutex_);
+    return Enumerate(root);
 }
 
-void Configuration::SetString(const Slice &key, const std::string &value) {
-  SetRawWithEvent(key, value);
+#define TILE_DEFINE_CONFIG_GETTER(type, name)                                                                          \
+    std::optional<type> Configuration::Get##name(const Slice &key) const                                               \
+    {                                                                                                                  \
+        std::string value;                                                                                             \
+        if (GetRaw(key, &value)) {                                                                                     \
+            auto opt = TryParseTraits<type>::TryParse(value);                                                          \
+            if (opt.has_value()) {                                                                                     \
+                return *opt;                                                                                           \
+            } else {                                                                                                   \
+                return std::nullopt;                                                                                   \
+            }                                                                                                          \
+        } else {                                                                                                       \
+            return std::nullopt;                                                                                       \
+        }                                                                                                              \
+    }                                                                                                                  \
+    type Configuration::Get##name(const Slice &key, type default_value) const                                          \
+    {                                                                                                                  \
+        auto opt = Get##name(key);                                                                                     \
+        if (opt.has_value()) {                                                                                         \
+            return *opt;                                                                                               \
+        } else {                                                                                                       \
+            return default_value;                                                                                      \
+        }                                                                                                              \
+    }
+
+#define TILE_DEFINE_CONFIG_SETTER(type, name)                                                                          \
+    void Configuration::Set##name(const Slice &key, type value) { SetRawWithEvent(key, Format("{}", value)); }
+
+std::optional<std::string>
+Configuration::GetString(const Slice &key) const
+{
+    std::string value;
+    UniqueLock<tile::Mutex> lock(mutex_);
+    if (GetRaw(key, &value)) {
+        return value;
+    } else {
+        return std::nullopt;
+    }
 }
-void Configuration::SetBool(const Slice &key, bool value) {
-  SetRawWithEvent(key, value ? "true" : "false");
+
+std::string
+Configuration::GetString(const Slice &key, std::string default_value) const
+{
+    auto opt = GetString(key);
+    return opt.has_value() ? *opt : default_value;
+}
+
+void
+Configuration::SetString(const Slice &key, const std::string &value)
+{
+    SetRawWithEvent(key, value);
+}
+
+void
+Configuration::SetBool(const Slice &key, bool value)
+{
+    SetRawWithEvent(key, value ? "true" : "false");
 }
 
 TILE_DEFINE_CONFIG_GETTER(int, Int)
@@ -101,22 +120,19 @@ TILE_DEFINE_CONFIG_SETTER(uint32_t, UInt32)
 TILE_DEFINE_CONFIG_SETTER(uint64_t, UInt64)
 TILE_DEFINE_CONFIG_SETTER(double, Double)
 
-void Configuration::SetRawWithEvent(const Slice &key,
-                                    const std::string &value) {
-  if (events_enabled_) {
-    OnChanging(key, value);
-  }
+void
+Configuration::SetRawWithEvent(const Slice &key, const std::string &value)
+{
+    if (events_enabled_) { OnChanging(key, value); }
 
-  {
-    UniqueLock<tile::Mutex> lock(mutex_);
-    SetRaw(key, value);
-  }
+    {
+        UniqueLock<tile::Mutex> lock(mutex_);
+        SetRaw(key, value);
+    }
 
-  if (events_enabled_) {
-    OnChanged(key, value);
-  }
+    if (events_enabled_) { OnChanged(key, value); }
 }
 
 Configuration::~Configuration() {}
 
-} // namespace tile
+}// namespace tile
diff --git a/tile/base/config/configuration.h b/tile/base/config/configuration.h
index 4484dad..c595e3b 100644
--- a/tile/base/config/configuration.h
+++ b/tile/base/config/configuration.h
@@ -12,113 +12,111 @@
 namespace tile {
 class Configuration : public RefCounted<Configuration> {
 public:
-  using Keys = std::vector<std::string>;
-  using Ptr = RefPtr<Configuration>;
+    using Keys = std::vector<std::string>;
+    using Ptr  = RefPtr<Configuration>;
 
-  // events
-  // Key, Value
-  sigslot::signal2<const Slice &, const Slice &> OnChanging;
-  // Key, Value
-  sigslot::signal2<const Slice &, const Slice &> OnChanged;
-  // Key
-  sigslot::signal1<const Slice &> OnRemoving;
-  // Key
-  sigslot::signal1<const Slice &> OnRemoved;
+    // events
+    // Key, Value
+    sigslot::signal2<const Slice &, const Slice &> OnChanging;
+    // Key, Value
+    sigslot::signal2<const Slice &, const Slice &> OnChanged;
+    // Key
+    sigslot::signal1<const Slice &> OnRemoving;
+    // Key
+    sigslot::signal1<const Slice &> OnRemoved;
 
-  bool Has(const Slice &key) const;
-  void Remove(const Slice &key);
-  void EnableEvents(bool enable = true);
-  bool EventsEnabled() const;
+    bool Has(const Slice &key) const;
+    void Remove(const Slice &key);
+    void EnableEvents(bool enable = true);
+    bool EventsEnabled() const;
 
-  Keys keys(const Slice &root = "") const;
+    Keys keys(const Slice &root = "") const;
 
-#define TILE_DECLARE_CONFIG_GETTER(type, name)                                 \
-  std::optional<type> Get##name(const Slice &key) const;                       \
-  type Get##name(const Slice &key, type default_value) const;
+#define TILE_DECLARE_CONFIG_GETTER(type, name)                                                                         \
+    std::optional<type> Get##name(const Slice &key) const;                                                             \
+    type Get##name(const Slice &key, type default_value) const;
 
-#define TILE_DECLARE_CONFIG_SETTER(type, name)                                 \
-  virtual void Set##name(const Slice &key, type value);
+#define TILE_DECLARE_CONFIG_SETTER(type, name) virtual void Set##name(const Slice &key, type value);
 
-  std::string GetRawString(const Slice &key, const Slice &default_value) const;
-  // std::stirng GetString()
-  // int GetInt()
-  // unsigned int GetUInt()
-  // int16_t GetInt16()
-  // int32_t GetInt32()
-  // int64_t GetInt64()
-  // uint16_t GetUInt16()
-  // uint32_t GetUInt32()
-  // uint64_t GetUInt64()
-  // double GetDouble()
-  // bool GetBool()
+    std::string GetRawString(const Slice &key, const Slice &default_value) const;
+    // std::stirng GetString()
+    // int GetInt()
+    // unsigned int GetUInt()
+    // int16_t GetInt16()
+    // int32_t GetInt32()
+    // int64_t GetInt64()
+    // uint16_t GetUInt16()
+    // uint32_t GetUInt32()
+    // uint64_t GetUInt64()
+    // double GetDouble()
+    // bool GetBool()
 
-  // getters
-  TILE_DECLARE_CONFIG_GETTER(std::string, String)
-  TILE_DECLARE_CONFIG_GETTER(int, Int)
-  TILE_DECLARE_CONFIG_GETTER(unsigned int, UInt)
-  TILE_DECLARE_CONFIG_GETTER(int16_t, Int16)
-  TILE_DECLARE_CONFIG_GETTER(int32_t, Int32)
-  TILE_DECLARE_CONFIG_GETTER(int64_t, Int64)
-  TILE_DECLARE_CONFIG_GETTER(uint16_t, UInt16)
-  TILE_DECLARE_CONFIG_GETTER(uint32_t, UInt32)
-  TILE_DECLARE_CONFIG_GETTER(uint64_t, UInt64)
-  TILE_DECLARE_CONFIG_GETTER(double, Double)
-  TILE_DECLARE_CONFIG_GETTER(bool, Bool)
+    // getters
+    TILE_DECLARE_CONFIG_GETTER(std::string, String)
+    TILE_DECLARE_CONFIG_GETTER(int, Int)
+    TILE_DECLARE_CONFIG_GETTER(unsigned int, UInt)
+    TILE_DECLARE_CONFIG_GETTER(int16_t, Int16)
+    TILE_DECLARE_CONFIG_GETTER(int32_t, Int32)
+    TILE_DECLARE_CONFIG_GETTER(int64_t, Int64)
+    TILE_DECLARE_CONFIG_GETTER(uint16_t, UInt16)
+    TILE_DECLARE_CONFIG_GETTER(uint32_t, UInt32)
+    TILE_DECLARE_CONFIG_GETTER(uint64_t, UInt64)
+    TILE_DECLARE_CONFIG_GETTER(double, Double)
+    TILE_DECLARE_CONFIG_GETTER(bool, Bool)
 
 protected:
-  // setters
-  // SetString(const Slice &key, const std::string &value)
-  // SetInt(const Slice &key, int value)
-  // SetUInt(const Slice &key, unsigned int value)
-  // SetInt16(const Slice &key, int16_t value)
-  // SetInt32(const Slice &key, int32_t value)
-  // SetInt64(const Slice &key, int64_t value)
-  // SetUInt16(const Slice &key, uint16_t value)
-  // SetUInt32(const Slice &key, uint32_t value)
-  // SetUInt64(const Slice &key, uint64_t value)
-  // SetDouble(const Slice &key, double value)
-  // SetBool(const Slice &key, bool value)
-  TILE_DECLARE_CONFIG_SETTER(const std::string &, String)
-  TILE_DECLARE_CONFIG_SETTER(int, Int)
-  TILE_DECLARE_CONFIG_SETTER(unsigned int, UInt)
-  TILE_DECLARE_CONFIG_SETTER(int16_t, Int16)
-  TILE_DECLARE_CONFIG_SETTER(int32_t, Int32)
-  TILE_DECLARE_CONFIG_SETTER(int64_t, Int64)
-  TILE_DECLARE_CONFIG_SETTER(uint16_t, UInt16)
-  TILE_DECLARE_CONFIG_SETTER(uint32_t, UInt32)
-  TILE_DECLARE_CONFIG_SETTER(uint64_t, UInt64)
-  TILE_DECLARE_CONFIG_SETTER(double, Double)
-  TILE_DECLARE_CONFIG_SETTER(bool, Bool)
+    // setters
+    // SetString(const Slice &key, const std::string &value)
+    // SetInt(const Slice &key, int value)
+    // SetUInt(const Slice &key, unsigned int value)
+    // SetInt16(const Slice &key, int16_t value)
+    // SetInt32(const Slice &key, int32_t value)
+    // SetInt64(const Slice &key, int64_t value)
+    // SetUInt16(const Slice &key, uint16_t value)
+    // SetUInt32(const Slice &key, uint32_t value)
+    // SetUInt64(const Slice &key, uint64_t value)
+    // SetDouble(const Slice &key, double value)
+    // SetBool(const Slice &key, bool value)
+    TILE_DECLARE_CONFIG_SETTER(const std::string &, String)
+    TILE_DECLARE_CONFIG_SETTER(int, Int)
+    TILE_DECLARE_CONFIG_SETTER(unsigned int, UInt)
+    TILE_DECLARE_CONFIG_SETTER(int16_t, Int16)
+    TILE_DECLARE_CONFIG_SETTER(int32_t, Int32)
+    TILE_DECLARE_CONFIG_SETTER(int64_t, Int64)
+    TILE_DECLARE_CONFIG_SETTER(uint16_t, UInt16)
+    TILE_DECLARE_CONFIG_SETTER(uint32_t, UInt32)
+    TILE_DECLARE_CONFIG_SETTER(uint64_t, UInt64)
+    TILE_DECLARE_CONFIG_SETTER(double, Double)
+    TILE_DECLARE_CONFIG_SETTER(bool, Bool)
 
 #undef TILE_DECLARE_CONFIG_GETTER
 #undef TILE_DECLARE_CONFIG_SETTER
 
 protected:
-  class ScopedLock {
-  public:
-    explicit ScopedLock(const Configuration &config) : config_(config) {
-      config_.mutex_.Lock();
-    }
-    ~ScopedLock() { config_.mutex_.Unlock(); }
+    class ScopedLock {
+    public:
+        explicit ScopedLock(const Configuration &config) : config_(config) { config_.mutex_.Lock(); }
 
-  private:
-    const Configuration &config_;
-  };
+        ~ScopedLock() { config_.mutex_.Unlock(); }
 
-  virtual bool GetRaw(const Slice &key, std::string *value) const = 0;
-  virtual bool SetRaw(const Slice &key, const Slice &value) = 0;
-  virtual void RemoveRaw(const Slice &key) = 0;
-  virtual Keys Enumerate(const Slice &range) const = 0;
-  void SetRawWithEvent(const Slice &key, const std::string &value);
-  virtual ~Configuration();
+    private:
+        const Configuration &config_;
+    };
 
-  friend class std::default_delete<Configuration>;
-  friend class LayeredConfiguration;
+    virtual bool GetRaw(const Slice &key, std::string *value) const = 0;
+    virtual bool SetRaw(const Slice &key, const Slice &value)       = 0;
+    virtual void RemoveRaw(const Slice &key)                        = 0;
+    virtual Keys Enumerate(const Slice &range) const                = 0;
+    void SetRawWithEvent(const Slice &key, const std::string &value);
+    virtual ~Configuration();
+
+    friend class std::default_delete<Configuration>;
+    friend class LayeredConfiguration;
 
 private:
-  mutable Mutex mutex_;
-  bool events_enabled_{false};
+    mutable Mutex mutex_;
+    bool events_enabled_{false};
 };
-} // namespace tile
+}// namespace tile
 
-#endif // TILE_BASE_CONFIG_CONFIGURATION_H
+#endif// TILE_BASE_CONFIG_CONFIGURATION_H
diff --git a/tile/base/config/ini_file_configuration.cc b/tile/base/config/ini_file_configuration.cc
index 8bb1443..fa66366 100644
--- a/tile/base/config/ini_file_configuration.cc
+++ b/tile/base/config/ini_file_configuration.cc
@@ -1,143 +1,152 @@
 #include "tile/base/config/ini_file_configuration.h"
+
+#include "tile/base/string.h"
 #include "tile/base/thread/scoped_lock.h"
 
 namespace tile {
 
 IniFileConfiguration::IniFileConfiguration() {}
+
 // IniFileConfig::IniFileConfig(std::istream &istr) { load(istr); }
 // IniFileConfig::IniFileConfig(const std::string &path) { load(path); }
 IniFileConfiguration::~IniFileConfiguration() {}
 
-bool IniFileConfiguration::load(std::istream &istr) {
-  if (!istr.good()) {
-    return false;
-  }
+bool
+IniFileConfiguration::load(std::istream &istr)
+{
+    if (!istr.good()) { return false; }
 
-  Configuration::ScopedLock lock(*this);
-  map_.clear();
-  section_key_.clear();
-  while (!istr.eof()) {
-    ParseLine(istr);
-  }
-  return true;
-}
-bool IniFileConfiguration::load(const std::string &path) {
-  std::ifstream istr(path);
-  return load(istr);
-}
-bool IniFileConfiguration::GetRaw(const Slice &key, std::string *value) const {
-  auto iter = map_.find(key.ToString());
-  if (iter != map_.end()) {
-    *value = iter->second;
+    Configuration::ScopedLock lock(*this);
+    map_.clear();
+    section_key_.clear();
+    while (!istr.eof()) { ParseLine(istr); }
     return true;
-  } else {
-    return false;
-  }
-}
-bool IniFileConfiguration::SetRaw(const Slice &key, const Slice &value) {
-  map_[key] = value;
-  return true;
 }
 
-void IniFileConfiguration::RemoveRaw(const Slice &key) {
-  std::string prefix = key;
-  if (!prefix.empty()) {
-    prefix.push_back('.');
-  }
-  IStringMap::iterator it = map_.begin();
-  IStringMap::iterator cur;
-  while (it != map_.end()) {
-    if (EqualsIgnoreCase(cur->first, key) ||
-        EqualsIgnoreCase(cur->first, prefix)) {
-      it = map_.erase(cur);
+bool
+IniFileConfiguration::load(const std::string &path)
+{
+    std::ifstream istr(path);
+    return load(istr);
+}
+
+bool
+IniFileConfiguration::GetRaw(const Slice &key, std::string *value) const
+{
+    auto iter = map_.find(key.ToString());
+    if (iter != map_.end()) {
+        *value = iter->second;
+        return true;
     } else {
-      ++it;
+        return false;
     }
-  }
 }
 
-Configuration::Keys IniFileConfiguration::Enumerate(const Slice &key) const {
-  Configuration::Keys range;
-  std::set<Slice> keys;
-  std::string prefix = key.ToString();
-  if (prefix.empty()) {
-    prefix.push_back('.');
-  }
-
-  std::string::size_type psize = prefix.size();
-  for (const auto &p : map_) {
-    auto &key = p.first;
-    if (EqualsIgnoreCase(key, prefix, psize)) {
-      std::string::size_type end = key.find('.', psize);
-      std::string subkey;
-      if (end == std::string::npos) {
-        subkey = key.substr(psize);
-      } else {
-        subkey = key.substr(psize, end - psize);
-      }
-
-      if (keys.find(subkey) == keys.end()) {
-        keys.insert(subkey);
-        range.push_back(subkey);
-      }
-    }
-  }
-  return range;
+bool
+IniFileConfiguration::SetRaw(const Slice &key, const Slice &value)
+{
+    map_[key] = value;
+    return true;
 }
 
-void IniFileConfiguration::ParseLine(std::istream &istr) {
-  static const int eof = std::char_traits<char>::eof();
-  auto ReadLine = [&](std::string *line) {
-    line->clear();
-    while (true) {
-      int c = istr.get();
-      if (c == eof || c == '\n') {
-        return c != eof;
-      } else {
-        *line += (char)c;
-      }
+void
+IniFileConfiguration::RemoveRaw(const Slice &key)
+{
+    std::string prefix = key;
+    if (!prefix.empty()) { prefix.push_back('.'); }
+    IStringMap::iterator it = map_.begin();
+    IStringMap::iterator cur;
+    while (it != map_.end()) {
+        if (EqualsIgnoreCase(cur->first, key) || EqualsIgnoreCase(cur->first, prefix)) {
+            it = map_.erase(cur);
+        } else {
+            ++it;
+        }
     }
-  };
-
-  std::string raw_line;
-  while (ReadLine(&raw_line)) {
-    if (raw_line.empty()) {
-      continue;
-    }
-    Slice line = TrimLeft(raw_line);
-    if (line.empty() || line[0] == ';' || line[0] == '#') {
-      // skip empty line
-      // skip comment line ; or #
-      continue;
-    }
-
-    // parse section
-    if (line[0] == '[') {
-      auto pos = line.find(']');
-      if (pos == Slice::npos) {
-        section_key_ = Trim(line.substr(1));
-      } else {
-        section_key_ = Trim(line.substr(1, pos - 1));
-      }
-    } else {
-      auto strs = Split(line, "=", true, 2);
-      std::string full_key = section_key_;
-      if (!full_key.empty()) {
-        full_key.push_back('.');
-      }
-      full_key.append(Trim(strs[0]));
-      if (strs.size() > 1) {
-        map_[full_key] = Trim(strs[1]);
-      } else {
-        map_[full_key] = "";
-      }
-    }
-  }
-}
-bool IniFileConfiguration::ICompare::operator()(const std::string &s1,
-                                                const std::string &s2) const {
-  auto len = std::min(s1.size(), s2.size());
-  return strncmp(s1.c_str(), s2.c_str(), len) < 0;
 }
 
-} // namespace tile
+Configuration::Keys
+IniFileConfiguration::Enumerate(const Slice &key) const
+{
+    Configuration::Keys range;
+    std::set<Slice> keys;
+    std::string prefix = key.ToString();
+    if (prefix.empty()) { prefix.push_back('.'); }
+
+    std::string::size_type psize = prefix.size();
+    for (const auto &p : map_) {
+        auto &key = p.first;
+        if (EqualsIgnoreCase(key, prefix, psize)) {
+            std::string::size_type end = key.find('.', psize);
+            std::string subkey;
+            if (end == std::string::npos) {
+                subkey = key.substr(psize);
+            } else {
+                subkey = key.substr(psize, end - psize);
+            }
+
+            if (keys.find(subkey) == keys.end()) {
+                keys.insert(subkey);
+                range.push_back(subkey);
+            }
+        }
+    }
+    return range;
+}
+
+void
+IniFileConfiguration::ParseLine(std::istream &istr)
+{
+    static const int eof = std::char_traits<char>::eof();
+    auto ReadLine        = [&](std::string *line) {
+        line->clear();
+        while (true) {
+            int c = istr.get();
+            if (c == eof || c == '\n') {
+                return c != eof;
+            } else {
+                *line += (char) c;
+            }
+        }
+    };
+
+    std::string raw_line;
+    while (ReadLine(&raw_line)) {
+        if (raw_line.empty()) { continue; }
+        Slice line = TrimLeft(raw_line);
+        if (line.empty() || line[0] == ';' || line[0] == '#') {
+            // skip empty line
+            // skip comment line ; or #
+            continue;
+        }
+
+        // parse section
+        if (line[0] == '[') {
+            auto pos = line.find(']');
+            if (pos == Slice::npos) {
+                section_key_ = Trim(line.substr(1));
+            } else {
+                section_key_ = Trim(line.substr(1, pos - 1));
+            }
+        } else {
+            auto strs            = Split(line, "=", true, 2);
+            std::string full_key = section_key_;
+            if (!full_key.empty()) { full_key.push_back('.'); }
+            full_key.append(Trim(strs[0]));
+            if (strs.size() > 1) {
+                map_[full_key] = Trim(strs[1]);
+            } else {
+                map_[full_key] = "";
+            }
+        }
+    }
+}
+
+bool
+IniFileConfiguration::ICompare::operator()(const std::string &s1, const std::string &s2) const
+{
+    auto len = std::min(s1.size(), s2.size());
+    return strncmp(s1.c_str(), s2.c_str(), len) < 0;
+}
+
+}// namespace tile
diff --git a/tile/base/config/ini_file_configuration.h b/tile/base/config/ini_file_configuration.h
index 218c1ac..d71b05b 100644
--- a/tile/base/config/ini_file_configuration.h
+++ b/tile/base/config/ini_file_configuration.h
@@ -9,30 +9,32 @@
 namespace tile {
 class IniFileConfiguration : public Configuration {
 public:
-  using Ptr = RefPtr<IniFileConfiguration>;
+    using Ptr = RefPtr<IniFileConfiguration>;
 
-  IniFileConfiguration();
-  ~IniFileConfiguration() override;
-  // IniFileConfig(std::istream &istr);
-  // IniFileConfig(const std::string &path);
-  bool load(std::istream &istr);
-  bool load(const std::string &path);
+    IniFileConfiguration();
+    ~IniFileConfiguration() override;
+    // IniFileConfig(std::istream &istr);
+    // IniFileConfig(const std::string &path);
+    bool load(std::istream &istr);
+    bool load(const std::string &path);
 
 protected:
-  bool GetRaw(const Slice &key, std::string *value) const override;
-  bool SetRaw(const Slice &key, const Slice &value) override;
-  void RemoveRaw(const Slice &key) override;
-  Keys Enumerate(const Slice &range) const override;
+    bool GetRaw(const Slice &key, std::string *value) const override;
+    bool SetRaw(const Slice &key, const Slice &value) override;
+    void RemoveRaw(const Slice &key) override;
+    Keys Enumerate(const Slice &range) const override;
 
 private:
-  void ParseLine(std::istream &istr);
-  struct ICompare {
-    bool operator()(const std::string &s1, const std::string &s2) const;
-  };
-  typedef std::map<std::string, std::string, ICompare> IStringMap;
-  IStringMap map_;
-  std::string section_key_;
-};
-} // namespace tile
+    void ParseLine(std::istream &istr);
 
-#endif // TILE_BASE_CONFIG_INI_FILE_CONFIG_H
+    struct ICompare {
+        bool operator()(const std::string &s1, const std::string &s2) const;
+    };
+
+    typedef std::map<std::string, std::string, ICompare> IStringMap;
+    IStringMap map_;
+    std::string section_key_;
+};
+}// namespace tile
+
+#endif// TILE_BASE_CONFIG_INI_FILE_CONFIG_H
diff --git a/tile/base/config/ini_file_configuration_test.cc b/tile/base/config/ini_file_configuration_test.cc
index c8039c5..d789c84 100644
--- a/tile/base/config/ini_file_configuration_test.cc
+++ b/tile/base/config/ini_file_configuration_test.cc
@@ -17,29 +17,29 @@ a=4
 
 namespace tile {
 
-static_assert(
-    !detail::HasClassofImpl<IniFileConfiguration, Configuration>::value, "");
+static_assert(!detail::HasClassofImpl<IniFileConfiguration, Configuration>::value, "");
 
-TEST(IniFileConfig, LoadFromIStream) {
-  std::stringstream ss(kIniFileConfig);
-  Configuration::Ptr config = MakeRefCounted<IniFileConfiguration>();
-  ASSERT_FALSE(config->Has("a"));
-  ASSERT_FALSE(config->Has("sec1.a"));
-  ASSERT_FALSE(config->Has("sec3.a"));
-  if (config.Is<IniFileConfiguration>()) {
-    IniFileConfiguration::Ptr ini = config.As<IniFileConfiguration>();
-    ASSERT_TRUE(ini->load(ss));
-  }
-  ASSERT_TRUE(config->Has("a"));
-  ASSERT_TRUE(config->Has("sec1.a"));
-  ASSERT_TRUE(config->Has("sec3.a"));
-  ASSERT_TRUE(config->Has("sec2.kk.a"));
+TEST(IniFileConfig, LoadFromIStream)
+{
+    std::stringstream ss(kIniFileConfig);
+    Configuration::Ptr config = MakeRefCounted<IniFileConfiguration>();
+    ASSERT_FALSE(config->Has("a"));
+    ASSERT_FALSE(config->Has("sec1.a"));
+    ASSERT_FALSE(config->Has("sec3.a"));
+    if (config.Is<IniFileConfiguration>()) {
+        IniFileConfiguration::Ptr ini = config.As<IniFileConfiguration>();
+        ASSERT_TRUE(ini->load(ss));
+    }
+    ASSERT_TRUE(config->Has("a"));
+    ASSERT_TRUE(config->Has("sec1.a"));
+    ASSERT_TRUE(config->Has("sec3.a"));
+    ASSERT_TRUE(config->Has("sec2.kk.a"));
 
-  ASSERT_TRUE(config->GetInt("a"));
-  ASSERT_TRUE(config->GetInt("sec1.a"));
-  ASSERT_EQ(1, *config->GetInt("a"));
-  ASSERT_EQ(2, *config->GetInt("sec1.a"));
-  ASSERT_EQ(3, *config->GetInt("sec3.a"));
-  ASSERT_EQ(4, *config->GetInt("sec2.kk.a"));
+    ASSERT_TRUE(config->GetInt("a"));
+    ASSERT_TRUE(config->GetInt("sec1.a"));
+    ASSERT_EQ(1, *config->GetInt("a"));
+    ASSERT_EQ(2, *config->GetInt("sec1.a"));
+    ASSERT_EQ(3, *config->GetInt("sec3.a"));
+    ASSERT_EQ(4, *config->GetInt("sec2.kk.a"));
 }
-} // namespace tile
+}// namespace tile
diff --git a/tile/base/config/json_configuration.cc b/tile/base/config/json_configuration.cc
index 65f3e15..64db9d4 100644
--- a/tile/base/config/json_configuration.cc
+++ b/tile/base/config/json_configuration.cc
@@ -1,141 +1,153 @@
 #include "tile/base/config/json_configuration.h"
+
 #include "tile/base/logging.h"
+#include "tile/base/string.h"
 
 namespace tile {
 JSONConfiguration::JSONConfiguration() : object_() {}
+
 JSONConfiguration::~JSONConfiguration() {}
 
-bool JSONConfiguration::load(const std::string &path) {
-  std::ifstream istr(path);
-  return load(istr);
+bool
+JSONConfiguration::load(const std::string &path)
+{
+    std::ifstream istr(path);
+    return load(istr);
 }
 
-bool JSONConfiguration::load(std::istream &istr) {
-  if (!istr.good()) {
-    return false;
-  }
+bool
+JSONConfiguration::load(std::istream &istr)
+{
+    if (!istr.good()) { return false; }
 
-  Configuration::ScopedLock _(*this);
-  object_.clear();
-  Json::Reader reader;
-  return reader.parse(istr, object_, true);
+    Configuration::ScopedLock _(*this);
+    object_.clear();
+    Json::Reader reader;
+    return reader.parse(istr, object_, true);
 }
 
-void JSONConfiguration::SetInt(const Slice &key, int value) {
-  Configuration::ScopedLock _(*this);
-  SetValue(key, value);
+void
+JSONConfiguration::SetInt(const Slice &key, int value)
+{
+    Configuration::ScopedLock _(*this);
+    SetValue(key, value);
 }
 
-void JSONConfiguration::SetBool(const Slice &key, bool value) {
-  Configuration::ScopedLock _(*this);
-  SetValue(key, value);
+void
+JSONConfiguration::SetBool(const Slice &key, bool value)
+{
+    Configuration::ScopedLock _(*this);
+    SetValue(key, value);
 }
 
-void JSONConfiguration::SetDouble(const Slice &key, double value) {
-  Configuration::ScopedLock _(*this);
-  SetValue(key, value);
+void
+JSONConfiguration::SetDouble(const Slice &key, double value)
+{
+    Configuration::ScopedLock _(*this);
+    SetValue(key, value);
 }
 
-void JSONConfiguration::SetString(const Slice &key, const std::string &value) {
-  Configuration::ScopedLock _(*this);
-  SetValue(key, value);
+void
+JSONConfiguration::SetString(const Slice &key, const std::string &value)
+{
+    Configuration::ScopedLock _(*this);
+    SetValue(key, value);
 }
 
-void JSONConfiguration::RemoveRaw(const Slice &key) {
-  Json::Value *root;
-  Slice last_part;
-  if (!FindStart(key, &last_part, &root)) {
-    return;
-  }
-  root->removeMember(last_part);
-}
-std::string JSONConfiguration::Dump() const {
-  Configuration::ScopedLock _(*this);
-  return object_.toStyledString();
+void
+JSONConfiguration::RemoveRaw(const Slice &key)
+{
+    Json::Value *root;
+    Slice last_part;
+    if (!FindStart(key, &last_part, &root)) { return; }
+    root->removeMember(last_part);
 }
 
-bool JSONConfiguration::GetRaw(const Slice &key, std::string *value) const {
-  auto keys = Split(key, '.');
-  auto root = object_;
-  for (std::size_t i = 0; i < keys.size(); ++i) {
-    const auto &cur_key = keys[i];
-    if (cur_key.empty()) {
-      TILE_LOG_ERROR("Invalid key: {}", key);
-      return false;
-    }
-    if (!root.isMember(cur_key)) {
-      return false;
-    }
-    root = root[cur_key];
-  }
-
-  if (root.isConvertibleTo(Json::stringValue)) {
-    *value = root.asString();
-  } else {
-    *value = root.toStyledString();
-  }
-  return true;
+std::string
+JSONConfiguration::Dump() const
+{
+    Configuration::ScopedLock _(*this);
+    return object_.toStyledString();
 }
 
-bool JSONConfiguration::SetRaw(const Slice &key, const Slice &value) {
-  return SetValue(key, value.ToString());
-}
-
-Configuration::Keys JSONConfiguration::Enumerate(const Slice &range) const {
-  Configuration::Keys key_set;
-  std::string prefix = range;
-  if (!prefix.empty()) {
-    prefix += ".";
-  }
-
-  auto keys = Split(range, '.');
-  auto root = object_;
-  for (std::size_t i = 0; i < keys.size(); ++i) {
-    const auto &cur_key = keys[i];
-    if (cur_key.empty()) {
-      TILE_LOG_ERROR("Invalid range: {}", range);
-      return key_set;
-    }
-    if (!root.isMember(cur_key)) {
-      return key_set;
-    }
-    root = root[cur_key];
-  }
-
-  for (const auto &key : root.getMemberNames()) {
-    key_set.push_back(prefix + key);
-  }
-  return key_set;
-}
-
-bool JSONConfiguration::FindStart(const Slice &key, Slice *last_part,
-                                  Json::Value **parent_obj) {
-  auto keys = Split(key, '.');
-  if (keys.empty()) {
-    return false;
-  }
-
-  Json::Value *root = &object_;
-  for (std::size_t i = 0; i < keys.size() - 1; ++i) {
-    const auto &cur_key = keys[i];
-    if (cur_key.empty()) {
-      TILE_LOG_ERROR("Invalid key: {}", key);
-      return false;
+bool
+JSONConfiguration::GetRaw(const Slice &key, std::string *value) const
+{
+    auto keys = Split(key, '.');
+    auto root = object_;
+    for (std::size_t i = 0; i < keys.size(); ++i) {
+        const auto &cur_key = keys[i];
+        if (cur_key.empty()) {
+            TILE_LOG_ERROR("Invalid key: {}", key);
+            return false;
+        }
+        if (!root.isMember(cur_key)) { return false; }
+        root = root[cur_key];
     }
 
-    if (!root->isMember(cur_key)) {
-      (*root)[cur_key] = Json::Value(Json::objectValue);
-    } else if (!(*root)[cur_key].isObject()) {
-      TILE_LOG_ERROR("only leaf nodes can be set: key: {}, cur_key(idx={}): {}",
-                     key, i, cur_key);
-      return false;
+    if (root.isConvertibleTo(Json::stringValue)) {
+        *value = root.asString();
+    } else {
+        *value = root.toStyledString();
     }
-    root = &(*root)[cur_key];
-  }
-
-  *last_part = keys.back();
-  *parent_obj = root;
-  return true;
+    return true;
 }
 
-} // namespace tile
+bool
+JSONConfiguration::SetRaw(const Slice &key, const Slice &value)
+{
+    return SetValue(key, value.ToString());
+}
+
+Configuration::Keys
+JSONConfiguration::Enumerate(const Slice &range) const
+{
+    Configuration::Keys key_set;
+    std::string prefix = range;
+    if (!prefix.empty()) { prefix += "."; }
+
+    auto keys = Split(range, '.');
+    auto root = object_;
+    for (std::size_t i = 0; i < keys.size(); ++i) {
+        const auto &cur_key = keys[i];
+        if (cur_key.empty()) {
+            TILE_LOG_ERROR("Invalid range: {}", range);
+            return key_set;
+        }
+        if (!root.isMember(cur_key)) { return key_set; }
+        root = root[cur_key];
+    }
+
+    for (const auto &key : root.getMemberNames()) { key_set.push_back(prefix + key); }
+    return key_set;
+}
+
+bool
+JSONConfiguration::FindStart(const Slice &key, Slice *last_part, Json::Value **parent_obj)
+{
+    auto keys = Split(key, '.');
+    if (keys.empty()) { return false; }
+
+    Json::Value *root = &object_;
+    for (std::size_t i = 0; i < keys.size() - 1; ++i) {
+        const auto &cur_key = keys[i];
+        if (cur_key.empty()) {
+            TILE_LOG_ERROR("Invalid key: {}", key);
+            return false;
+        }
+
+        if (!root->isMember(cur_key)) {
+            (*root)[cur_key] = Json::Value(Json::objectValue);
+        } else if (!(*root)[cur_key].isObject()) {
+            TILE_LOG_ERROR("only leaf nodes can be set: key: {}, cur_key(idx={}): {}", key, i, cur_key);
+            return false;
+        }
+        root = &(*root)[cur_key];
+    }
+
+    *last_part  = keys.back();
+    *parent_obj = root;
+    return true;
+}
+
+}// namespace tile
diff --git a/tile/base/config/json_configuration.h b/tile/base/config/json_configuration.h
index be45c3a..f9c774e 100644
--- a/tile/base/config/json_configuration.h
+++ b/tile/base/config/json_configuration.h
@@ -9,41 +9,42 @@
 namespace tile {
 class JSONConfiguration : public Configuration {
 public:
-  using Ptr = RefPtr<JSONConfiguration>;
-  JSONConfiguration();
-  ~JSONConfiguration() override;
-  bool load(const std::string &path);
-  bool load(std::istream &istr);
+    using Ptr = RefPtr<JSONConfiguration>;
+    JSONConfiguration();
+    ~JSONConfiguration() override;
+    bool load(const std::string &path);
+    bool load(std::istream &istr);
 
-  void SetInt(const Slice &key, int value) override;
-  void SetBool(const Slice &key, bool value) override;
-  void SetDouble(const Slice &key, double value) override;
-  void SetString(const Slice &key, const std::string &value) override;
-  void RemoveRaw(const Slice &key) override;
+    void SetInt(const Slice &key, int value) override;
+    void SetBool(const Slice &key, bool value) override;
+    void SetDouble(const Slice &key, double value) override;
+    void SetString(const Slice &key, const std::string &value) override;
+    void RemoveRaw(const Slice &key) override;
 
-  std::string Dump() const;
+    std::string Dump() const;
 
 protected:
-  bool GetRaw(const Slice &key, std::string *value) const override;
-  bool SetRaw(const Slice &key, const Slice &value) override;
-  Keys Enumerate(const Slice &range) const override;
+    bool GetRaw(const Slice &key, std::string *value) const override;
+    bool SetRaw(const Slice &key, const Slice &value) override;
+    Keys Enumerate(const Slice &range) const override;
 
 private:
-  bool FindStart(const Slice &key, Slice *last_prt, Json::Value **parent_obj);
-  template <typename T> bool SetValue(const Slice &key, T value);
-  Json::Value object_;
+    bool FindStart(const Slice &key, Slice *last_prt, Json::Value **parent_obj);
+    template<typename T>
+    bool SetValue(const Slice &key, T value);
+    Json::Value object_;
 };
 
-template <typename T>
-bool JSONConfiguration::SetValue(const Slice &key, T value) {
-  Slice last_part;
-  Json::Value *root;
-  if (!FindStart(key, &last_part, &root)) {
-    return false;
-  }
-  (*root)[last_part] = Json::Value(value);
-  return true;
+template<typename T>
+bool
+JSONConfiguration::SetValue(const Slice &key, T value)
+{
+    Slice last_part;
+    Json::Value *root;
+    if (!FindStart(key, &last_part, &root)) { return false; }
+    (*root)[last_part] = Json::Value(value);
+    return true;
 }
-} // namespace tile
+}// namespace tile
 
-#endif // TILE_BASE_CONFIG_JSON_CONFIGURATION_H
+#endif// TILE_BASE_CONFIG_JSON_CONFIGURATION_H
diff --git a/tile/base/config/json_configuration_test.cc b/tile/base/config/json_configuration_test.cc
index e213681..eee5327 100644
--- a/tile/base/config/json_configuration_test.cc
+++ b/tile/base/config/json_configuration_test.cc
@@ -18,81 +18,87 @@ const char *kJsonConfig = R"(
     )";
 }
 
-TEST(JSONConfiguration, Load) {
-  JSONConfiguration config;
-  std::istringstream istr(kJsonConfig);
-  ASSERT_TRUE(config.load(istr));
-}
-TEST(JSONConfiguration, Has) {
-  JSONConfiguration config;
-  std::istringstream istr(kJsonConfig);
-  ASSERT_TRUE(config.load(istr));
-
-  ASSERT_TRUE(config.Has("key1"));
-  ASSERT_TRUE(config.Has("key2"));
-  ASSERT_TRUE(config.Has("key3"));
-  ASSERT_TRUE(config.Has("key4"));
-  ASSERT_TRUE(config.Has("key5"));
-  ASSERT_TRUE(config.Has("key5.key51"));
-  ASSERT_TRUE(config.Has("key5.key52"));
+TEST(JSONConfiguration, Load)
+{
+    JSONConfiguration config;
+    std::istringstream istr(kJsonConfig);
+    ASSERT_TRUE(config.load(istr));
 }
 
-TEST(JSONConfiguration, SampleSet) {
-  JSONConfiguration config;
-  std::istringstream istr(kJsonConfig);
-  ASSERT_TRUE(config.load(istr));
-  ASSERT_TRUE(config.GetInt32("key2"));
-  ASSERT_EQ(*config.GetInt32("key2"), 2);
+TEST(JSONConfiguration, Has)
+{
+    JSONConfiguration config;
+    std::istringstream istr(kJsonConfig);
+    ASSERT_TRUE(config.load(istr));
 
-  config.SetInt("key2", 20);
-  ASSERT_TRUE(config.GetInt32("key2"));
-  ASSERT_EQ(20, *config.GetInt32("key2")) << config.Dump();
-
-  config.SetDouble("key3", 30.0);
-  ASSERT_TRUE(config.GetDouble("key3"));
-  ASSERT_NEAR(30.0, *config.GetDouble("key3"), 0.0001) << config.Dump();
-
-  config.SetBool("key4", false);
-  ASSERT_TRUE(config.GetBool("key4"));
-  ASSERT_FALSE(*config.GetBool("key4")) << config.Dump();
+    ASSERT_TRUE(config.Has("key1"));
+    ASSERT_TRUE(config.Has("key2"));
+    ASSERT_TRUE(config.Has("key3"));
+    ASSERT_TRUE(config.Has("key4"));
+    ASSERT_TRUE(config.Has("key5"));
+    ASSERT_TRUE(config.Has("key5.key51"));
+    ASSERT_TRUE(config.Has("key5.key52"));
 }
 
-TEST(JSONConfiguration, LayeredSet) {
-  JSONConfiguration config;
-  std::istringstream istr(kJsonConfig);
-  ASSERT_TRUE(config.load(istr));
+TEST(JSONConfiguration, SampleSet)
+{
+    JSONConfiguration config;
+    std::istringstream istr(kJsonConfig);
+    ASSERT_TRUE(config.load(istr));
+    ASSERT_TRUE(config.GetInt32("key2"));
+    ASSERT_EQ(*config.GetInt32("key2"), 2);
 
-  // ASSERT_TRUE(config.GetInt32("key5.key52"));
-  config.SetInt("key5.key52", 520);
-  ASSERT_TRUE(config.GetInt32("key5.key52")) << config.Dump();
-  ASSERT_EQ(520, *config.GetInt32("key5.key52")) << config.Dump();
+    config.SetInt("key2", 20);
+    ASSERT_TRUE(config.GetInt32("key2"));
+    ASSERT_EQ(20, *config.GetInt32("key2")) << config.Dump();
 
-  // override by other type
-  config.SetBool("key5.key52", false);
-  ASSERT_TRUE(config.GetBool("key5.key52")) << config.Dump();
-  ASSERT_FALSE(*config.GetBool("key5.key52")) << config.Dump();
+    config.SetDouble("key3", 30.0);
+    ASSERT_TRUE(config.GetDouble("key3"));
+    ASSERT_NEAR(30.0, *config.GetDouble("key3"), 0.0001) << config.Dump();
+
+    config.SetBool("key4", false);
+    ASSERT_TRUE(config.GetBool("key4"));
+    ASSERT_FALSE(*config.GetBool("key4")) << config.Dump();
 }
 
-TEST(json_configuration, Enumerate) {
-  JSONConfiguration config;
-  std::istringstream istr(kJsonConfig);
-  ASSERT_TRUE(config.load(istr));
-  auto keys = config.keys("");
-  ASSERT_EQ(5, keys.size());
-  ASSERT_EQ("key1", keys[0]);
-  ASSERT_EQ("key2", keys[1]);
-  ASSERT_EQ("key3", keys[2]);
-  ASSERT_EQ("key4", keys[3]);
-  ASSERT_EQ("key5", keys[4]);
+TEST(JSONConfiguration, LayeredSet)
+{
+    JSONConfiguration config;
+    std::istringstream istr(kJsonConfig);
+    ASSERT_TRUE(config.load(istr));
 
-  keys = config.keys("key5");
-  ASSERT_EQ(2, keys.size());
-  ASSERT_EQ("key5.key51", keys[0]);
-  ASSERT_EQ("key5.key52", keys[1]);
+    // ASSERT_TRUE(config.GetInt32("key5.key52"));
+    config.SetInt("key5.key52", 520);
+    ASSERT_TRUE(config.GetInt32("key5.key52")) << config.Dump();
+    ASSERT_EQ(520, *config.GetInt32("key5.key52")) << config.Dump();
 
-  config.Remove("key5.key51");
-  keys = config.keys("key5");
-  ASSERT_EQ("key5.key52", keys[0]);
+    // override by other type
+    config.SetBool("key5.key52", false);
+    ASSERT_TRUE(config.GetBool("key5.key52")) << config.Dump();
+    ASSERT_FALSE(*config.GetBool("key5.key52")) << config.Dump();
 }
 
-} // namespace tile
+TEST(json_configuration, Enumerate)
+{
+    JSONConfiguration config;
+    std::istringstream istr(kJsonConfig);
+    ASSERT_TRUE(config.load(istr));
+    auto keys = config.keys("");
+    ASSERT_EQ(5, keys.size());
+    ASSERT_EQ("key1", keys[0]);
+    ASSERT_EQ("key2", keys[1]);
+    ASSERT_EQ("key3", keys[2]);
+    ASSERT_EQ("key4", keys[3]);
+    ASSERT_EQ("key5", keys[4]);
+
+    keys = config.keys("key5");
+    ASSERT_EQ(2, keys.size());
+    ASSERT_EQ("key5.key51", keys[0]);
+    ASSERT_EQ("key5.key52", keys[1]);
+
+    config.Remove("key5.key51");
+    keys = config.keys("key5");
+    ASSERT_EQ("key5.key52", keys[0]);
+}
+
+}// namespace tile
diff --git a/tile/base/config/layered_configuration.cc b/tile/base/config/layered_configuration.cc
index ea62c5e..d07e380 100644
--- a/tile/base/config/layered_configuration.cc
+++ b/tile/base/config/layered_configuration.cc
@@ -3,129 +3,147 @@
 namespace tile {
 
 LayeredConfiguration::LayeredConfiguration() {}
+
 LayeredConfiguration::~LayeredConfiguration() {}
 
-void LayeredConfiguration::Add(Configuration::Ptr cfg) {
-  Add(cfg, highest(), false);
+void
+LayeredConfiguration::Add(Configuration::Ptr cfg)
+{
+    Add(cfg, highest(), false);
 }
 
-void LayeredConfiguration::Add(Configuration::Ptr cfg, int priority) {
-  Add(cfg, priority, false);
+void
+LayeredConfiguration::Add(Configuration::Ptr cfg, int priority)
+{
+    Add(cfg, priority, false);
 }
 
-void LayeredConfiguration::Add(Configuration::Ptr cfg,
-                               const std::string &label) {
-  Add(cfg, label, highest(), false);
+void
+LayeredConfiguration::Add(Configuration::Ptr cfg, const std::string &label)
+{
+    Add(cfg, label, highest(), false);
 }
 
-void LayeredConfiguration::Add(Configuration::Ptr cfg, const std::string &label,
-                               int priority) {
-  Add(cfg, label, priority, false);
+void
+LayeredConfiguration::Add(Configuration::Ptr cfg, const std::string &label, int priority)
+{
+    Add(cfg, label, priority, false);
 }
 
-void LayeredConfiguration::Add(Configuration::Ptr cfg, const std::string &label,
-                               bool writeable) {
-  Add(cfg, label, highest(), writeable);
+void
+LayeredConfiguration::Add(Configuration::Ptr cfg, const std::string &label, bool writeable)
+{
+    Add(cfg, label, highest(), writeable);
 }
 
-void LayeredConfiguration::Add(Configuration::Ptr cfg, const std::string &label,
-                               int priority, bool writeable) {
-  Configuration::ScopedLock lock(*this);
-  ConfigItem item;
-  item.cfg = cfg;
-  item.priority = priority;
-  item.writeable = writeable;
-  item.label = label;
-  auto it = configs_.begin();
-  while (it != configs_.end() && it->priority < priority) {
-    ++it;
-  }
-  configs_.insert(it, item);
+void
+LayeredConfiguration::Add(Configuration::Ptr cfg, const std::string &label, int priority, bool writeable)
+{
+    Configuration::ScopedLock lock(*this);
+    ConfigItem item;
+    item.cfg       = cfg;
+    item.priority  = priority;
+    item.writeable = writeable;
+    item.label     = label;
+    auto it        = configs_.begin();
+    while (it != configs_.end() && it->priority < priority) { ++it; }
+    configs_.insert(it, item);
 }
 
-void LayeredConfiguration::Add(Configuration::Ptr cfg, int priority,
-                               bool writeable) {
-  Add(cfg, std::string(), priority, writeable);
-}
-void LayeredConfiguration::AddWriteable(Configuration::Ptr cfg, int priority) {
-  Add(cfg, priority, true);
+void
+LayeredConfiguration::Add(Configuration::Ptr cfg, int priority, bool writeable)
+{
+    Add(cfg, std::string(), priority, writeable);
 }
 
-Configuration::Ptr LayeredConfiguration::Find(const Slice &label) const {
-  Configuration::ScopedLock lock(*this);
+void
+LayeredConfiguration::AddWriteable(Configuration::Ptr cfg, int priority)
+{
+    Add(cfg, priority, true);
+}
 
-  for (const auto &conf : configs_) {
-    if (conf.label == label) {
-      return conf.cfg;
+Configuration::Ptr
+LayeredConfiguration::Find(const Slice &label) const
+{
+    Configuration::ScopedLock lock(*this);
+
+    for (const auto &conf : configs_) {
+        if (conf.label == label) { return conf.cfg; }
     }
-  }
-  return 0;
+    return 0;
 }
 
-void LayeredConfiguration::RemoveConfig(Configuration::Ptr cfg) {
-  Configuration::ScopedLock lock(*this);
-  for (auto it = configs_.begin(); it != configs_.end();) {
-    if (it->cfg == cfg) {
-      it = configs_.erase(it);
+void
+LayeredConfiguration::RemoveConfig(Configuration::Ptr cfg)
+{
+    Configuration::ScopedLock lock(*this);
+    for (auto it = configs_.begin(); it != configs_.end();) {
+        if (it->cfg == cfg) {
+            it = configs_.erase(it);
+        } else {
+            ++it;
+        }
+    }
+}
+
+bool
+LayeredConfiguration::GetRaw(const Slice &key, std::string *value) const
+{
+    for (const auto &conf : configs_) {
+        if (conf.cfg->GetRaw(key, value)) { return true; }
+    }
+    return false;
+}
+
+bool
+LayeredConfiguration::SetRaw(const Slice &key, const Slice &value)
+{
+    for (const auto &conf : configs_) {
+        if (conf.writeable && conf.cfg->SetRaw(key, value)) { return true; }
+    }
+    return false;
+}
+
+Configuration::Keys
+LayeredConfiguration::Enumerate(const Slice &key) const
+{
+    Configuration::Keys keys;
+    std::set<Slice> key_set;
+    for (const auto &conf : configs_) {
+        auto conf_keys = conf.cfg->Enumerate(key);
+        for (const auto &k : conf_keys) {
+            if (key_set.insert(k).second) { keys.push_back(k); }
+        }
+    }
+    return keys;
+}
+
+void
+LayeredConfiguration::RemoveRaw(const std::string &key)
+{
+    for (auto &conf : configs_) {
+        if (conf.writeable) { conf.cfg->RemoveRaw(key); }
+    }
+}
+
+int
+LayeredConfiguration::lowest() const
+{
+    if (configs_.empty()) {
+        return 0;
     } else {
-      ++it;
+        return configs_.front().priority - 1;
     }
-  }
 }
 
-bool LayeredConfiguration::GetRaw(const Slice &key, std::string *value) const {
-  for (const auto &conf : configs_) {
-    if (conf.cfg->GetRaw(key, value)) {
-      return true;
+int
+LayeredConfiguration::highest() const
+{
+    if (configs_.empty()) {
+        return 0;
+    } else {
+        return configs_.back().priority + 1;
     }
-  }
-  return false;
 }
 
-bool LayeredConfiguration::SetRaw(const Slice &key, const Slice &value) {
-  for (const auto &conf : configs_) {
-    if (conf.writeable && conf.cfg->SetRaw(key, value)) {
-      return true;
-    }
-  }
-  return false;
-}
-
-Configuration::Keys LayeredConfiguration::Enumerate(const Slice &key) const {
-  Configuration::Keys keys;
-  std::set<Slice> key_set;
-  for (const auto &conf : configs_) {
-    auto conf_keys = conf.cfg->Enumerate(key);
-    for (const auto &k : conf_keys) {
-      if (key_set.insert(k).second) {
-        keys.push_back(k);
-      }
-    }
-  }
-  return keys;
-}
-
-void LayeredConfiguration::RemoveRaw(const std::string &key) {
-  for (auto &conf : configs_) {
-    if (conf.writeable) {
-      conf.cfg->RemoveRaw(key);
-    }
-  }
-}
-
-int LayeredConfiguration::lowest() const {
-  if (configs_.empty()) {
-    return 0;
-  } else {
-    return configs_.front().priority - 1;
-  }
-}
-int LayeredConfiguration::highest() const {
-  if (configs_.empty()) {
-    return 0;
-  } else {
-    return configs_.back().priority + 1;
-  }
-}
-
-} // namespace tile
+}// namespace tile
diff --git a/tile/base/config/layered_configuration.h b/tile/base/config/layered_configuration.h
index aa8f9de..aba8f4a 100644
--- a/tile/base/config/layered_configuration.h
+++ b/tile/base/config/layered_configuration.h
@@ -9,47 +9,46 @@
 namespace tile {
 class LayeredConfiguration : public Configuration {
 public:
-  using Ptr = RefPtr<LayeredConfiguration>;
-  LayeredConfiguration();
-  LayeredConfiguration(const LayeredConfiguration &) = delete;
-  LayeredConfiguration &operator=(const LayeredConfiguration &) = delete;
+    using Ptr = RefPtr<LayeredConfiguration>;
+    LayeredConfiguration();
+    LayeredConfiguration(const LayeredConfiguration &)            = delete;
+    LayeredConfiguration &operator=(const LayeredConfiguration &) = delete;
 
-  void Add(Configuration::Ptr cfg);
-  void Add(Configuration::Ptr cfg, int priority);
-  void Add(Configuration::Ptr cfg, const std::string &label);
-  void Add(Configuration::Ptr cfg, const std::string &label, int priority);
-  void Add(Configuration::Ptr cfg, const std::string &label, bool writeable);
-  void Add(Configuration::Ptr cfg, const std::string &label, int priority,
-           bool writeable);
-  void Add(Configuration::Ptr cfg, int priority, bool writeable);
-  void AddWriteable(Configuration::Ptr cfg, int priority);
-  Configuration::Ptr Find(const Slice &label) const;
-  void RemoveConfig(Configuration::Ptr cfg);
+    void Add(Configuration::Ptr cfg);
+    void Add(Configuration::Ptr cfg, int priority);
+    void Add(Configuration::Ptr cfg, const std::string &label);
+    void Add(Configuration::Ptr cfg, const std::string &label, int priority);
+    void Add(Configuration::Ptr cfg, const std::string &label, bool writeable);
+    void Add(Configuration::Ptr cfg, const std::string &label, int priority, bool writeable);
+    void Add(Configuration::Ptr cfg, int priority, bool writeable);
+    void AddWriteable(Configuration::Ptr cfg, int priority);
+    Configuration::Ptr Find(const Slice &label) const;
+    void RemoveConfig(Configuration::Ptr cfg);
 
 protected:
-  struct ConfigItem {
-    Configuration::Ptr cfg;
-    // ... > -2 > -1 > 0 > 1 > 2 > 3 > 4 ...
-    int priority;
-    // can remove or set new?
-    bool writeable;
-    std::string label;
-  };
+    struct ConfigItem {
+        Configuration::Ptr cfg;
+        // ... > -2 > -1 > 0 > 1 > 2 > 3 > 4 ...
+        int priority;
+        // can remove or set new?
+        bool writeable;
+        std::string label;
+    };
 
-  bool GetRaw(const Slice &key, std::string *value) const override;
-  bool SetRaw(const Slice &key, const Slice &value) override;
-  Configuration::Keys Enumerate(const Slice &key) const override;
-  void RemoveRaw(const std::string &key);
+    bool GetRaw(const Slice &key, std::string *value) const override;
+    bool SetRaw(const Slice &key, const Slice &value) override;
+    Configuration::Keys Enumerate(const Slice &key) const override;
+    void RemoveRaw(const std::string &key);
 
-  int lowest() const;
-  int highest() const;
+    int lowest() const;
+    int highest() const;
 
-  ~LayeredConfiguration();
+    ~LayeredConfiguration();
 
 private:
-  using ConfigList = std::list<ConfigItem>;
-  ConfigList configs_;
+    using ConfigList = std::list<ConfigItem>;
+    ConfigList configs_;
 };
-} // namespace tile
+}// namespace tile
 
-#endif // TILE_BASE_CONFIG_LAYERED_CONFIGURATION_H
+#endif// TILE_BASE_CONFIG_LAYERED_CONFIGURATION_H
diff --git a/tile/base/configuration.h b/tile/base/configuration.h
index 0a980a9..50cf5f3 100644
--- a/tile/base/configuration.h
+++ b/tile/base/configuration.h
@@ -8,4 +8,4 @@
 #include "tile/base/config/ini_file_configuration.h"
 #include "tile/base/config/layered_configuration.h"
 
-#endif // TILE_BASE_CONFIGURATION_H
+#endif// TILE_BASE_CONFIGURATION_H
diff --git a/tile/base/data.h b/tile/base/data.h
index 77a321d..8f17b7d 100644
--- a/tile/base/data.h
+++ b/tile/base/data.h
@@ -4,4 +4,4 @@
 #pragma once
 #include "tile/base/data/json.h"
 
-#endif // TILE_BASE_DATA_H
+#endif// TILE_BASE_DATA_H
diff --git a/tile/base/data/json.h b/tile/base/data/json.h
index 21dec79..3c69b7e 100644
--- a/tile/base/data/json.h
+++ b/tile/base/data/json.h
@@ -11,28 +11,34 @@
 
 namespace tile {
 
-template <typename T>
-auto ToJson(const T &value)
-    -> enable_if_t<std::is_unsigned<T>::value, Json::Value> {
-  return static_cast<std::uint64_t>(value);
+template<typename T>
+auto
+ToJson(const T &value) -> enable_if_t<std::is_unsigned<T>::value, Json::Value>
+{
+    return static_cast<std::uint64_t>(value);
 }
 
-template <typename T>
-auto ToJson(const T &value)
-    -> enable_if_t<std::is_signed<T>::value, Json::Value> {
-  return static_cast<std::int64_t>(value);
-}
-template <typename T>
-auto ToJson(const T &value)
-    -> enable_if_t<!std::is_signed<T>::value && !std::is_unsigned<T>::value,
-                   Json::Value> {
-  return Format("{}", value);
+template<typename T>
+auto
+ToJson(const T &value) -> enable_if_t<std::is_signed<T>::value, Json::Value>
+{
+    return static_cast<std::int64_t>(value);
 }
 
-template <typename T> Json::Value ToJson(const std::atomic<T> &v) {
-  return ToJson(v.load(std::memory_order_relaxed));
+template<typename T>
+auto
+ToJson(const T &value) -> enable_if_t<!std::is_signed<T>::value && !std::is_unsigned<T>::value, Json::Value>
+{
+    return Format("{}", value);
 }
 
-} // namespace tile
+template<typename T>
+Json::Value
+ToJson(const std::atomic<T> &v)
+{
+    return ToJson(v.load(std::memory_order_relaxed));
+}
 
-#endif // TILE_BASE_DATA_JSON_H
+}// namespace tile
+
+#endif// TILE_BASE_DATA_JSON_H
diff --git a/tile/base/deferred.h b/tile/base/deferred.h
index cf5a054..ce0297e 100644
--- a/tile/base/deferred.h
+++ b/tile/base/deferred.h
@@ -9,56 +9,57 @@ namespace tile {
 
 class ScopedDeferred {
 public:
-  template <typename F>
-  explicit ScopedDeferred(F &&f) : action_(std::move(f)) {}
+    template<typename F>
+    explicit ScopedDeferred(F &&f) : action_(std::move(f))
+    {}
 
-  ~ScopedDeferred() { action_(); }
-  ScopedDeferred(const ScopedDeferred &) = delete;
-  ScopedDeferred &operator=(const ScopedDeferred &) = delete;
+    ~ScopedDeferred() { action_(); }
+
+    ScopedDeferred(const ScopedDeferred &)            = delete;
+    ScopedDeferred &operator=(const ScopedDeferred &) = delete;
 
 private:
-  std::function<void()> action_;
+    std::function<void()> action_;
 };
 
 class Deferred {
 public:
-  Deferred() = default;
-  template <typename F>
-  explicit Deferred(F &&f) : action_(std::forward<F>(f)) {}
+    Deferred() = default;
 
-  Deferred(Deferred &&other) noexcept : action_(std::move(other.action_)) {
-    other.action_ = nullptr;
-  }
-  Deferred &operator=(Deferred &&other) noexcept {
-    if (&other == this) {
-      return *this;
+    template<typename F>
+    explicit Deferred(F &&f) : action_(std::forward<F>(f))
+    {}
+
+    Deferred(Deferred &&other) noexcept : action_(std::move(other.action_)) { other.action_ = nullptr; }
+
+    Deferred &operator=(Deferred &&other) noexcept
+    {
+        if (&other == this) { return *this; }
+
+        Fire();
+        action_       = std::move(other.action_);
+        other.action_ = nullptr;
+        return *this;
     }
 
-    Fire();
-    action_ = std::move(other.action_);
-    other.action_ = nullptr;
-    return *this;
-  }
-  ~Deferred() {
-    if (action_) {
-      action_();
+    ~Deferred()
+    {
+        if (action_) { action_(); }
     }
-  }
 
-  explicit operator bool() const noexcept { return !!action_; }
+    explicit operator bool() const noexcept { return !!action_; }
 
-  void Fire() noexcept {
-    if (auto op = std::move(action_)) {
-      op();
+    void Fire() noexcept
+    {
+        if (auto op = std::move(action_)) { op(); }
     }
-  }
 
-  void Dimiss() noexcept { action_ = nullptr; }
+    void Dimiss() noexcept { action_ = nullptr; }
 
 private:
-  std::function<void()> action_;
+    std::function<void()> action_;
 };
 
-} // namespace tile
+}// namespace tile
 
-#endif // _TILE_BASE_DEFERED_H
+#endif// _TILE_BASE_DEFERED_H
diff --git a/tile/base/deferred_test.cc b/tile/base/deferred_test.cc
index 373768a..5a73ce5 100644
--- a/tile/base/deferred_test.cc
+++ b/tile/base/deferred_test.cc
@@ -2,49 +2,51 @@
 #include "gtest/gtest.h"
 
 namespace tile {
-TEST(ScopedDefered, All) {
-  bool f = false;
-  {
-    ScopedDeferred scoped_defered([&] { f = true; });
-    ASSERT_FALSE(f);
-  }
-  ASSERT_TRUE(f);
+TEST(ScopedDefered, All)
+{
+    bool f = false;
+    {
+        ScopedDeferred scoped_defered([&] { f = true; });
+        ASSERT_FALSE(f);
+    }
+    ASSERT_TRUE(f);
 }
 
-TEST(Defered, All) {
-  bool f1 = false;
-  bool f2 = false;
-  {
-    Deferred defer([&] { f1 = true; });
-    ASSERT_FALSE(f1);
-    Deferred defer2([&] { f2 = true; });
-    defer2.Dimiss();
+TEST(Defered, All)
+{
+    bool f1 = false;
+    bool f2 = false;
+    {
+        Deferred defer([&] { f1 = true; });
+        ASSERT_FALSE(f1);
+        Deferred defer2([&] { f2 = true; });
+        defer2.Dimiss();
+        ASSERT_FALSE(f2);
+    }
+    ASSERT_TRUE(f1);
     ASSERT_FALSE(f2);
-  }
-  ASSERT_TRUE(f1);
-  ASSERT_FALSE(f2);
 
-  bool f3 = false;
-  Deferred defer3([&] { f3 = true; });
-  ASSERT_FALSE(f3);
-  defer3.Fire();
-  ASSERT_TRUE(f3);
+    bool f3 = false;
+    Deferred defer3([&] { f3 = true; });
+    ASSERT_FALSE(f3);
+    defer3.Fire();
+    ASSERT_TRUE(f3);
 
-  bool f4 = false;
-  Deferred defer5;
-  {
-    Deferred defer4([&] { f4 = true; });
+    bool f4 = false;
+    Deferred defer5;
+    {
+        Deferred defer4([&] { f4 = true; });
+        ASSERT_FALSE(f4);
+        defer5 = std::move(defer4);
+    }
     ASSERT_FALSE(f4);
-    defer5 = std::move(defer4);
-  }
-  ASSERT_FALSE(f4);
-  auto defer6 = std::move(defer5);
-  defer5.Fire();
-  ASSERT_FALSE(defer5);
-  defer6.Fire();
-  ASSERT_TRUE(f4);
+    auto defer6 = std::move(defer5);
+    defer5.Fire();
+    ASSERT_FALSE(defer5);
+    defer6.Fire();
+    ASSERT_TRUE(f4);
 
-  Deferred().Fire();
-  Deferred().Dimiss();
+    Deferred().Fire();
+    Deferred().Dimiss();
 }
-} // namespace tile
+}// namespace tile
diff --git a/tile/base/demangle.cc b/tile/base/demangle.cc
index 7d68f68..97fbbf9 100644
--- a/tile/base/demangle.cc
+++ b/tile/base/demangle.cc
@@ -10,21 +10,21 @@
 
 namespace tile {
 
-std::string Demangle(const char *s) {
+std::string
+Demangle(const char *s)
+{
 #ifdef _MSC_VER
-  return s;
-#elif defined(__GNUC__) || defined(__clang__)
-  int status;
-  char *demangled = abi::__cxa_demangle(s, nullptr, nullptr, &status);
-  ScopedDeferred _([&] { free(demangled); });
-  if (!demangled) {
     return s;
-  }
-  return demangled;
+#elif defined(__GNUC__) || defined(__clang__)
+    int status;
+    char *demangled = abi::__cxa_demangle(s, nullptr, nullptr, &status);
+    ScopedDeferred _([&] { free(demangled); });
+    if (!demangled) { return s; }
+    return demangled;
 #else
 #error "Demangle not supported on current compiler."
 
 #endif
 }
 
-} // namespace tile
+}// namespace tile
diff --git a/tile/base/demangle.h b/tile/base/demangle.h
index 8df72b8..00109ce 100644
--- a/tile/base/demangle.h
+++ b/tile/base/demangle.h
@@ -11,8 +11,11 @@ namespace tile {
 
 std::string Demangle(const char *s);
 
-template <class T> std::string GetTypeName() {
-  return Demangle(typeid(T).name());
+template<class T>
+std::string
+GetTypeName()
+{
+    return Demangle(typeid(T).name());
 }
 
 #if __GNUC__ >= 12
@@ -20,14 +23,17 @@ template <class T> std::string GetTypeName() {
 #pragma GCC diagnostic ignored "-Wnonnull-compare"
 #endif
 
-template <class T> std::string GetTypeName(T &&o) {
-  return Demangle(typeid(std::forward<T>(o)).name());
+template<class T>
+std::string
+GetTypeName(T &&o)
+{
+    return Demangle(typeid(std::forward<T>(o)).name());
 }
 
 #if __GNUC__ >= 12
 #pragma GCC diagnostic pop
 #endif
 
-} // namespace tile
+}// namespace tile
 
-#endif // _TILE_BASE_DEMANGLE_H
+#endif// _TILE_BASE_DEMANGLE_H
diff --git a/tile/base/demangle_test.cc b/tile/base/demangle_test.cc
index 68ae2b0..81970de 100644
--- a/tile/base/demangle_test.cc
+++ b/tile/base/demangle_test.cc
@@ -3,16 +3,16 @@
 
 namespace tile {
 struct C {
-  struct D {
-    struct E {};
-  };
+    struct D {
+        struct E {};
+    };
 };
 
-TEST(Demangle, All) {
-  ASSERT_EQ("tile::C::D::E", GetTypeName<C::D::E>());
-  ASSERT_NE(GetTypeName<C::D>(), typeid(C::D::E).name());
-  ASSERT_EQ("invalid function name !@#$",
-            Demangle("invalid function name !@#$"));
+TEST(Demangle, All)
+{
+    ASSERT_EQ("tile::C::D::E", GetTypeName<C::D::E>());
+    ASSERT_NE(GetTypeName<C::D>(), typeid(C::D::E).name());
+    ASSERT_EQ("invalid function name !@#$", Demangle("invalid function name !@#$"));
 }
 
-} // namespace tile
+}// namespace tile
diff --git a/tile/base/dependency_registry.h b/tile/base/dependency_registry.h
index ac23ae6..14a3db8 100644
--- a/tile/base/dependency_registry.h
+++ b/tile/base/dependency_registry.h
@@ -21,186 +21,174 @@
 #include <utility>
 
 // class dependency
-#define TILE_DECLARE_CLASS_DEPENDENCY_REGISTRY(Registry, Interface, ...)       \
-  extern ::tile::detail::dependency_registry::ClassRegistry<                   \
-      struct Registry, Interface, ##__VA_ARGS__> &Registry
+#define TILE_DECLARE_CLASS_DEPENDENCY_REGISTRY(Registry, Interface, ...)                                               \
+    extern ::tile::detail::dependency_registry::ClassRegistry<struct Registry, Interface, ##__VA_ARGS__> &Registry
 
-#define TILE_DEFINE_CLASS_DEPENDENCY_REGISTRY(Registry, Interface, ...)        \
-  ::tile::detail::dependency_registry::ClassRegistry<                          \
-      struct Registry, Interface, ##__VA_ARGS__> &Registry =                   \
-      **::tile::internal::LazyInit<::tile::NeverDestroyed<                     \
-          ::tile::detail::dependency_registry::ClassRegistry<                  \
-              struct Registry, Interface, ##__VA_ARGS__>>>()
+#define TILE_DEFINE_CLASS_DEPENDENCY_REGISTRY(Registry, Interface, ...)                                                \
+    ::tile::detail::dependency_registry::ClassRegistry<struct Registry, Interface, ##__VA_ARGS__> &Registry =          \
+        **::tile::internal::LazyInit<::tile::NeverDestroyed<                                                           \
+            ::tile::detail::dependency_registry::ClassRegistry<struct Registry, Interface, ##__VA_ARGS__>>>()
 
-#define TILE_REGISTER_CLASS_DEPENDENCY(Registry, ImplementationName,           \
-                                       ImplementationClassName, ...)           \
-  TILE_REGISTER_CLASS_DEPENDENCY_FACTORY(                                      \
-      Registry, ImplementationName,                                            \
-      TILE_REGISTER_CLASS_DEPENDENCY_FUNCTION_AUX_INVOKE(                      \
-          ImplementationClassName, ##__VA_ARGS__))
+#define TILE_REGISTER_CLASS_DEPENDENCY(Registry, ImplementationName, ImplementationClassName, ...)                     \
+    TILE_REGISTER_CLASS_DEPENDENCY_FACTORY(                                                                            \
+        Registry, ImplementationName,                                                                                  \
+        TILE_REGISTER_CLASS_DEPENDENCY_FUNCTION_AUX_INVOKE(ImplementationClassName, ##__VA_ARGS__))
 
-#define TILE_REGISTER_CLASS_DEPENDENCY_FACTORY(Registry, Name, Factory)        \
-  __attribute__((constructor)) static void TILE_INTERNAL_PP_CAT(               \
-      tile_reserved_registry_dependency_class_register_, __COUNTER__)() {      \
-    auto registry = ::tile::internal::LazyInit<::tile::NeverDestroyed<         \
-        typename std::decay<decltype(Registry)>::type>>()                      \
-                        ->Get();                                               \
-    ::tile::detail::dependency_registry::AddToRegistry(registry, Name,         \
-                                                       Factory);               \
-  }
+#define TILE_REGISTER_CLASS_DEPENDENCY_FACTORY(Registry, Name, Factory)                                                \
+    __attribute__((constructor)) static void TILE_INTERNAL_PP_CAT(                                                     \
+        tile_reserved_registry_dependency_class_register_, __COUNTER__)()                                              \
+    {                                                                                                                  \
+        auto registry =                                                                                                \
+            ::tile::internal::LazyInit<::tile::NeverDestroyed<typename std::decay<decltype(Registry)>::type>>()        \
+                ->Get();                                                                                               \
+        ::tile::detail::dependency_registry::AddToRegistry(registry, Name, Factory);                                   \
+    }
 
 // object dependency
-#define TILE_DECLARE_OBJECT_DEPENDENCY_REGISTRY(Registry, Interface)           \
-  extern ::tile::detail::dependency_registry::ObjectRegistry<                  \
-      struct Registry, Interface> &Registry
+#define TILE_DECLARE_OBJECT_DEPENDENCY_REGISTRY(Registry, Interface)                                                   \
+    extern ::tile::detail::dependency_registry::ObjectRegistry<struct Registry, Interface> &Registry
 
-#define TILE_DEFINE_OBJECT_DEPENDENCY_REGISTRY(Registry, Interface)            \
-  ::tile::detail::dependency_registry::ObjectRegistry<struct Registry,         \
-                                                      Interface> &Registry =   \
-      **::tile::internal::LazyInit<::tile::NeverDestroyed<                     \
-          ::tile::detail::dependency_registry::ObjectRegistry<struct Registry, \
-                                                              Interface>>>()
+#define TILE_DEFINE_OBJECT_DEPENDENCY_REGISTRY(Registry, Interface)                                                    \
+    ::tile::detail::dependency_registry::ObjectRegistry<struct Registry, Interface> &Registry =                        \
+        **::tile::internal::LazyInit<                                                                                  \
+            ::tile::NeverDestroyed<::tile::detail::dependency_registry::ObjectRegistry<struct Registry, Interface>>>()
 
-#define TILE_REGISTER_OBJECT_DEPENDENCY(Registry, ObjectName,                  \
-                                        PointerOrFactory)                      \
-  __attribute__((constructor)) static void TILE_INTERNAL_PP_CAT(               \
-      tile_reserved_registry_dependency_object_register_, __COUNTER__)() {     \
-    auto registry = ::tile::internal::LazyInit<::tile::NeverDestroyed<         \
-        typename std::decay<decltype(Registry)>::type>>()                      \
-                        ->Get();                                               \
-    ::tile::detail::dependency_registry::AddToRegistry(registry, ObjectName,   \
-                                                       PointerOrFactory);      \
-  }
+#define TILE_REGISTER_OBJECT_DEPENDENCY(Registry, ObjectName, PointerOrFactory)                                        \
+    __attribute__((constructor)) static void TILE_INTERNAL_PP_CAT(                                                     \
+        tile_reserved_registry_dependency_object_register_, __COUNTER__)()                                             \
+    {                                                                                                                  \
+        auto registry =                                                                                                \
+            ::tile::internal::LazyInit<::tile::NeverDestroyed<typename std::decay<decltype(Registry)>::type>>()        \
+                ->Get();                                                                                               \
+        ::tile::detail::dependency_registry::AddToRegistry(registry, ObjectName, PointerOrFactory);                    \
+    }
 
 namespace tile {
 namespace detail {
 namespace dependency_registry {
 
-#define TILE_REGISTER_CLASS_DEPENDENCY_FUNCTION_AUX_INVOKE(Interface, ...)     \
-  ::tile::detail::dependency_registry::FactoryAux<Interface, ##__VA_ARGS__>
-template <typename Interface, typename... Args>
-std::unique_ptr<Interface> FactoryAux(Args &&...args) {
-  return make_unique<Interface>(std::forward<Args>(args)...);
+#define TILE_REGISTER_CLASS_DEPENDENCY_FUNCTION_AUX_INVOKE(Interface, ...)                                             \
+    ::tile::detail::dependency_registry::FactoryAux<Interface, ##__VA_ARGS__>
+
+template<typename Interface, typename... Args>
+std::unique_ptr<Interface>
+FactoryAux(Args &&...args)
+{
+    return make_unique<Interface>(std::forward<Args>(args)...);
 }
 
-template <typename T, typename... Args>
-void AddToRegistry(T *registry, Args &&...args) {
-  registry->Register(std::forward<Args>(args)...);
+template<typename T, typename... Args>
+void
+AddToRegistry(T *registry, Args &&...args)
+{
+    registry->Register(std::forward<Args>(args)...);
 }
 
-template <typename Tag, typename Interface, typename... FactoryArgs>
+template<typename Tag, typename Interface, typename... FactoryArgs>
 class ClassRegistry {
-  using Factory = std::function<std::unique_ptr<Interface>(FactoryArgs...)>;
+    using Factory = std::function<std::unique_ptr<Interface>(FactoryArgs...)>;
 
 public:
-  Factory TryGetFactory(Slice name) const noexcept {
-    auto iter = factories_.find(name.ToString());
-    if (iter == factories_.end()) {
-      return nullptr;
+    Factory TryGetFactory(Slice name) const noexcept
+    {
+        auto iter = factories_.find(name.ToString());
+        if (iter == factories_.end()) { return nullptr; }
+
+        auto constructor_ptr = iter->second.get();
+        return
+            [constructor_ptr](FactoryArgs... args) { return (*constructor_ptr)(std::forward<FactoryArgs>(args)...); };
     }
 
-    auto constructor_ptr = iter->second.get();
-    return [constructor_ptr](FactoryArgs... args) {
-      return (*constructor_ptr)(std::forward<FactoryArgs>(args)...);
+    Factory GetFactory(const std::string &name) const noexcept
+    {
+        auto result = TryGetFactory(name);
+        TILE_CHECK(result, "Class [{}] implement interface [{}] is not found.", name, GetTypeName<Interface>());
+
+        return result;
+    }
+
+    std::unique_ptr<Interface> TryNew(Slice name, FactoryArgs... args) const
+    {
+        auto iter = factories_.find(name.ToString());
+        if (iter == factories_.end()) { return nullptr; }
+
+        auto &constructor = iter->second;
+        return (*constructor)(std::forward<FactoryArgs>(args)...);
+    }
+
+    std::unique_ptr<Interface> New(const std::string &name, FactoryArgs... args) const
+    {
+        auto result = TryNew(name, std::forward<FactoryArgs>(args)...);
+        TILE_CHECK(result, "Class [{}] implement interface [{}] is not found.", name, GetTypeName<Interface>());
+        return result;
+    }
+
+private:
+    template<typename T, typename... Args>
+    friend void AddToRegistry(T *registry, Args &&...args);
+
+    void Register(const std::string &name, Factory factory)
+    {
+        TILE_CHECK(factories_.find(name) == factories_.end(), "Duplicate class dependency: ");
+        factories_[name] = make_unique<Factory>(std::move(factory));
+    }
+
+private:
+    std::unordered_map<std::string, std::unique_ptr<Factory>> factories_;
+};
+
+template<typename Tag, typename Interface>
+class ObjectRegistry {
+public:
+    Interface *TryGet(Slice name) const
+    {
+        auto iter = objects_.find(name.ToString());
+        if (iter == objects_.end()) { return nullptr; }
+        auto &&e = *iter->second;
+        std::call_once(e.flag, [&] { e.object = e.initializer(); });
+        return e.object.Get();
+    }
+
+    Interface *Get(Slice name) const
+    {
+        auto result = TryGet(name);
+        TILE_CHECK(result, "Object dependency [{}] implementing interface [{}] is not found", name,
+                   GetTypeName<Interface>());
+        return result;
+    }
+
+private:
+    template<typename T, typename... Args>
+    friend void AddToRegistry(T *registry, Args &&...args);
+
+    void Register(const std::string &name, Interface *object)
+    {
+        TILE_DCHECK(objects_.find(name) == objects_.end());
+        auto &&e = objects_[name];
+        e        = make_unique<LazilyInstantiatedObject>();
+        std::call_once(e->flag, [&] { e->object = MaybeOwning<Interface>(non_owning, object); });
+    }
+
+    void Register(const std::string &name, std::function<MaybeOwning<Interface>()> initializer)
+    {
+        TILE_CHECK(objects_.find(name) == objects_.end(), "Double registration of object dependency [{}]", name);
+
+        objects_[name]              = make_unique<LazilyInstantiatedObject>();
+        objects_[name]->initializer = std::move(initializer);
+    }
+
+private:
+    struct LazilyInstantiatedObject {
+        std::once_flag flag;
+        MaybeOwning<Interface> object;
+        std::function<MaybeOwning<Interface>()> initializer;
     };
-  }
 
-  Factory GetFactory(const std::string &name) const noexcept {
-    auto result = TryGetFactory(name);
-    TILE_CHECK(result, "Class [{}] implement interface [{}] is not found.",
-               name, GetTypeName<Interface>());
-
-    return result;
-  }
-
-  std::unique_ptr<Interface> TryNew(Slice name, FactoryArgs... args) const {
-    auto iter = factories_.find(name.ToString());
-    if (iter == factories_.end()) {
-      return nullptr;
-    }
-
-    auto &constructor = iter->second;
-    return (*constructor)(std::forward<FactoryArgs>(args)...);
-  }
-
-  std::unique_ptr<Interface> New(const std::string &name,
-                                 FactoryArgs... args) const {
-    auto result = TryNew(name, std::forward<FactoryArgs>(args)...);
-    TILE_CHECK(result, "Class [{}] implement interface [{}] is not found.",
-               name, GetTypeName<Interface>());
-    return result;
-  }
-
-private:
-  template <typename T, typename... Args>
-  friend void AddToRegistry(T *registry, Args &&...args);
-
-  void Register(const std::string &name, Factory factory) {
-    TILE_CHECK(factories_.find(name) == factories_.end(),
-               "Duplicate class dependency: ");
-    factories_[name] = make_unique<Factory>(std::move(factory));
-  }
-
-private:
-  std::unordered_map<std::string, std::unique_ptr<Factory>> factories_;
+    std::unordered_map<std::string, std::unique_ptr<LazilyInstantiatedObject>> objects_;
 };
 
-template <typename Tag, typename Interface> class ObjectRegistry {
-public:
-  Interface *TryGet(Slice name) const {
-    auto iter = objects_.find(name.ToString());
-    if (iter == objects_.end()) {
-      return nullptr;
-    }
-    auto &&e = *iter->second;
-    std::call_once(e.flag, [&] { e.object = e.initializer(); });
-    return e.object.Get();
-  }
+}// namespace dependency_registry
+}// namespace detail
+}// namespace tile
 
-  Interface *Get(Slice name) const {
-    auto result = TryGet(name);
-    TILE_CHECK(
-        result,
-        "Object dependency [{}] implementing interface [{}] is not found", name,
-        GetTypeName<Interface>());
-    return result;
-  }
-
-private:
-  template <typename T, typename... Args>
-  friend void AddToRegistry(T *registry, Args &&...args);
-
-  void Register(const std::string &name, Interface *object) {
-    TILE_DCHECK(objects_.find(name) == objects_.end());
-    auto &&e = objects_[name];
-    e = make_unique<LazilyInstantiatedObject>();
-    std::call_once(e->flag, [&] {
-      e->object = MaybeOwning<Interface>(non_owning, object);
-    });
-  }
-
-  void Register(const std::string &name,
-                std::function<MaybeOwning<Interface>()> initializer) {
-    TILE_CHECK(objects_.find(name) == objects_.end(),
-               "Double registration of object dependency [{}]", name);
-
-    objects_[name] = make_unique<LazilyInstantiatedObject>();
-    objects_[name]->initializer = std::move(initializer);
-  }
-
-private:
-  struct LazilyInstantiatedObject {
-    std::once_flag flag;
-    MaybeOwning<Interface> object;
-    std::function<MaybeOwning<Interface>()> initializer;
-  };
-
-  std::unordered_map<std::string, std::unique_ptr<LazilyInstantiatedObject>>
-      objects_;
-};
-
-} // namespace dependency_registry
-} // namespace detail
-} // namespace tile
-
-#endif // TILE_BASE_DEPENDENCY_REGISTRY_H
+#endif// TILE_BASE_DEPENDENCY_REGISTRY_H
diff --git a/tile/base/dependency_registry_test.cc b/tile/base/dependency_registry_test.cc
index 89f7164..df2c3ff 100644
--- a/tile/base/dependency_registry_test.cc
+++ b/tile/base/dependency_registry_test.cc
@@ -1,77 +1,84 @@
 #include "tile/base/dependency_registry.h"
 #include "gtest/gtest.h"
+
 namespace tile {
 struct Destroyer {
-  virtual ~Destroyer() = default;
+    virtual ~Destroyer() = default;
 };
 
 struct FastDestroyer : Destroyer {
-  FastDestroyer() { ++instances; }
-  ~FastDestroyer() override { --instances; }
-  static int instances;
+    FastDestroyer() { ++instances; }
+
+    ~FastDestroyer() override { --instances; }
+
+    static int instances;
 };
+
 int FastDestroyer::instances = 0;
 
 struct GentleDestroyer : Destroyer {
-  GentleDestroyer() { ++instances; }
-  ~GentleDestroyer() override { --instances; }
-  static int instances;
+    GentleDestroyer() { ++instances; }
+
+    ~GentleDestroyer() override { --instances; }
+
+    static int instances;
 };
+
 int GentleDestroyer::instances = 0;
 
 struct SpeedDestroyer : Destroyer {
-  explicit SpeedDestroyer(int) {}
+    explicit SpeedDestroyer(int) {}
 };
+
 struct SpeedDestroyer2 : Destroyer {};
 
 TILE_DECLARE_CLASS_DEPENDENCY_REGISTRY(world_destroyer, Destroyer);
 TILE_DEFINE_CLASS_DEPENDENCY_REGISTRY(world_destroyer, Destroyer);
-TILE_REGISTER_CLASS_DEPENDENCY(world_destroyer, "fast-destroyer",
-                               FastDestroyer);
+TILE_REGISTER_CLASS_DEPENDENCY(world_destroyer, "fast-destroyer", FastDestroyer);
 TILE_REGISTER_CLASS_DEPENDENCY_FACTORY(world_destroyer, "gentle-destroyer", [] {
-  return make_unique<GentleDestroyer>();
+    return make_unique<GentleDestroyer>();
 });
 GentleDestroyer global_gentle_destroyer;
 
 TILE_DECLARE_CLASS_DEPENDENCY_REGISTRY(with_arg_destroyer, Destroyer, int);
 TILE_DEFINE_CLASS_DEPENDENCY_REGISTRY(with_arg_destroyer, Destroyer, int);
-TILE_REGISTER_CLASS_DEPENDENCY(with_arg_destroyer, "speed-destroyer",
-                               SpeedDestroyer, int);
-TILE_REGISTER_CLASS_DEPENDENCY_FACTORY(with_arg_destroyer, "speed-destroyer-2",
-                                       [](int speed) {
-                                         return make_unique<SpeedDestroyer2>();
-                                       });
+TILE_REGISTER_CLASS_DEPENDENCY(with_arg_destroyer, "speed-destroyer", SpeedDestroyer, int);
+TILE_REGISTER_CLASS_DEPENDENCY_FACTORY(with_arg_destroyer, "speed-destroyer-2", [](int speed) {
+    return make_unique<SpeedDestroyer2>();
+});
 
-TEST(DependencyRegistry, Class) {
-  EXPECT_TRUE(world_destroyer.TryGetFactory("gentle-destroyer"));
-  EXPECT_TRUE(world_destroyer.TryGetFactory("fast-destroyer"));
-  EXPECT_FALSE(world_destroyer.TryGetFactory("404-destroyer"));
-  EXPECT_TRUE(world_destroyer.TryNew("gentle-destroyer"));
-  EXPECT_TRUE(world_destroyer.TryNew("fast-destroyer"));
-  EXPECT_FALSE(world_destroyer.TryGetFactory("404-destroyer"));
+TEST(DependencyRegistry, Class)
+{
+    EXPECT_TRUE(world_destroyer.TryGetFactory("gentle-destroyer"));
+    EXPECT_TRUE(world_destroyer.TryGetFactory("fast-destroyer"));
+    EXPECT_FALSE(world_destroyer.TryGetFactory("404-destroyer"));
+    EXPECT_TRUE(world_destroyer.TryNew("gentle-destroyer"));
+    EXPECT_TRUE(world_destroyer.TryNew("fast-destroyer"));
+    EXPECT_FALSE(world_destroyer.TryGetFactory("404-destroyer"));
 
-  EXPECT_EQ(1, GentleDestroyer::instances); // The global one.
-  EXPECT_EQ(0, FastDestroyer::instances);
-
-  {
-    auto gentle = world_destroyer.TryNew("gentle-destroyer");
-    EXPECT_EQ(2, GentleDestroyer::instances);
+    EXPECT_EQ(1, GentleDestroyer::instances);// The global one.
+    EXPECT_EQ(0, FastDestroyer::instances);
+
+    {
+        auto gentle = world_destroyer.TryNew("gentle-destroyer");
+        EXPECT_EQ(2, GentleDestroyer::instances);
+        EXPECT_EQ(0, FastDestroyer::instances);
+        auto fast = world_destroyer.TryNew("fast-destroyer");
+        EXPECT_EQ(2, GentleDestroyer::instances);
+        EXPECT_EQ(1, FastDestroyer::instances);
+    }
+    EXPECT_EQ(1, GentleDestroyer::instances);
     EXPECT_EQ(0, FastDestroyer::instances);
-    auto fast = world_destroyer.TryNew("fast-destroyer");
-    EXPECT_EQ(2, GentleDestroyer::instances);
-    EXPECT_EQ(1, FastDestroyer::instances);
-  }
-  EXPECT_EQ(1, GentleDestroyer::instances);
-  EXPECT_EQ(0, FastDestroyer::instances);
 }
 
-TEST(DependencyRegistry, ClassWithArgs) {
-  EXPECT_TRUE(with_arg_destroyer.TryGetFactory("speed-destroyer"));
-  EXPECT_TRUE(with_arg_destroyer.TryGetFactory("speed-destroyer-2"));
-  EXPECT_FALSE(with_arg_destroyer.TryGetFactory("speed-destroyer-3"));
-  EXPECT_TRUE(with_arg_destroyer.TryNew("speed-destroyer", 456));
-  EXPECT_TRUE(with_arg_destroyer.TryNew("speed-destroyer-2", 456));
-  EXPECT_FALSE(with_arg_destroyer.TryNew("speed-destroyer-3", 456));
+TEST(DependencyRegistry, ClassWithArgs)
+{
+    EXPECT_TRUE(with_arg_destroyer.TryGetFactory("speed-destroyer"));
+    EXPECT_TRUE(with_arg_destroyer.TryGetFactory("speed-destroyer-2"));
+    EXPECT_FALSE(with_arg_destroyer.TryGetFactory("speed-destroyer-3"));
+    EXPECT_TRUE(with_arg_destroyer.TryNew("speed-destroyer", 456));
+    EXPECT_TRUE(with_arg_destroyer.TryNew("speed-destroyer-2", 456));
+    EXPECT_FALSE(with_arg_destroyer.TryNew("speed-destroyer-3", 456));
 }
 
-} // namespace tile
+}// namespace tile
diff --git a/tile/base/down_cast.h b/tile/base/down_cast.h
index fa5ed7a..bde1421 100644
--- a/tile/base/down_cast.h
+++ b/tile/base/down_cast.h
@@ -8,18 +8,22 @@
 #include <type_traits>
 
 namespace tile {
-template <typename To, typename From,
-          typename R = typename std::conditional<std::is_const<From>::value,
-                                                 const To *, To *>::type>
-inline R down_cast(From *ptr) {
-  TILE_DCHECK(dynamic_cast<R>(ptr));
-  return static_cast<R>(ptr);
+template<typename To,
+         typename From,
+         typename R = typename std::conditional<std::is_const<From>::value, const To *, To *>::type>
+inline R
+down_cast(From *ptr)
+{
+    TILE_DCHECK(dynamic_cast<R>(ptr));
+    return static_cast<R>(ptr);
 }
 
-template <typename To, typename From>
-inline auto down_cast(From &ref) -> decltype(down_cast(&ref)) {
-  return down_cast<To>(&ref);
+template<typename To, typename From>
+inline auto
+down_cast(From &ref) -> decltype(down_cast(&ref))
+{
+    return down_cast<To>(&ref);
 }
-} // namespace tile
+}// namespace tile
 
-#endif // _TILE_BASE_DOWN_CAST_H
+#endif// _TILE_BASE_DOWN_CAST_H
diff --git a/tile/base/down_cast_test.cc b/tile/base/down_cast_test.cc
index afde504..57b135d 100644
--- a/tile/base/down_cast_test.cc
+++ b/tile/base/down_cast_test.cc
@@ -3,22 +3,25 @@
 
 namespace tile {
 struct A {
-  virtual ~A() = default;
+    virtual ~A() = default;
 };
+
 struct B : A {};
 
-TEST(DownCast, All) {
-  B b;
-  A *ptr = &b;
-  ASSERT_NE(nullptr, down_cast<B>(ptr));
-  ASSERT_NE(nullptr, down_cast<B>(const_cast<const A *>(ptr)));
+TEST(DownCast, All)
+{
+    B b;
+    A *ptr = &b;
+    ASSERT_NE(nullptr, down_cast<B>(ptr));
+    ASSERT_NE(nullptr, down_cast<B>(const_cast<const A *>(ptr)));
 }
 
 #ifndef NDEBUG
-TEST(CastDeathTest, DownCast) {
-  A a;
-  A *ptr = &a;
-  ASSERT_DEATH(down_cast<B>(ptr), "");
+TEST(CastDeathTest, DownCast)
+{
+    A a;
+    A *ptr = &a;
+    ASSERT_DEATH(down_cast<B>(ptr), "");
 }
 #endif
-} // namespace tile
+}// namespace tile
diff --git a/tile/base/encoding.h b/tile/base/encoding.h
index 827dabf..698e337 100644
--- a/tile/base/encoding.h
+++ b/tile/base/encoding.h
@@ -7,4 +7,4 @@
 #include "tile/base/encoding/hex.h"
 #include "tile/base/encoding/percent.h"
 
-#endif // _TILE_BASE_ENCODING_H
+#endif// _TILE_BASE_ENCODING_H
diff --git a/tile/base/encoding/base64.cc b/tile/base/encoding/base64.cc
index 98f536c..490645d 100644
--- a/tile/base/encoding/base64.cc
+++ b/tile/base/encoding/base64.cc
@@ -19,137 +19,132 @@ static constexpr std::size_t kBufferSize = BLOCK_SIZE_1M;
 #undef BLOCK_SIZE_64K
 #undef BLOCK_SIZE_1M
 
-} // namespace
+}// namespace
 
-std::string EncodeBase64(Slice from) {
-  std::string result;
-  EncodeBase64(from, &result);
-  return result;
-}
-std::optional<std::string> DecodeBase64(Slice from) {
-  std::string result;
-  if (!DecodeBase64(from, &result)) {
-    return std::nullopt;
-  }
-  return result;
+std::string
+EncodeBase64(Slice from)
+{
+    std::string result;
+    EncodeBase64(from, &result);
+    return result;
 }
 
-void EncodeBase64(Slice from, std::string *to) {
-  TILE_CHECK(from.size() < std::numeric_limits<int>::max(),
-             "Not implemented: Source bytes too long. {} > max_size({})",
-             from.size(), std::numeric_limits<int>::max());
-
-  const auto size = 4 * ((from.size() + 2) / 3);
-  to->resize(size);
-  base64_encodestate state;
-  base64_init_encodestate(&state);
-
-  std::size_t used = 0;
-  std::size_t input_len;
-  while (!from.empty()) {
-    input_len = std::min(kBufferSize, from.size());
-    used += base64_encode_block(
-        reinterpret_cast<const char *>(from.data()), input_len,
-        reinterpret_cast<char *>(internal::RemoveConstPtr(to->data())) + used,
-        &state);
-    from.RemovePrefix(input_len);
-  };
-  base64_encode_blockend(
-      reinterpret_cast<char *>(internal::RemoveConstPtr(to->data())) + used,
-      &state);
-
-  // bool success =
-  //     Base64::Encode(from.data(), from.size(),
-  //                    internal::RemoveConstPtr(to->data()), to->size());
-  // TILE_CHECK(success, "Unexpected: Failed to do base64-encode.");
+std::optional<std::string>
+DecodeBase64(Slice from)
+{
+    std::string result;
+    if (!DecodeBase64(from, &result)) { return std::nullopt; }
+    return result;
 }
 
-bool DecodeBase64(Slice from, std::string *to) {
-  if (TILE_UNLIKELY(from.empty())) {
-    to->clear();
-    return true;
-  }
+void
+EncodeBase64(Slice from, std::string *to)
+{
+    TILE_CHECK(from.size() < std::numeric_limits<int>::max(),
+               "Not implemented: Source bytes too long. {} > max_size({})", from.size(),
+               std::numeric_limits<int>::max());
 
-  std::string safe_from_str;
-  // auto padding
-  auto padding = (4 - from.size() % 4) % 4;
-  if (padding > 2) {
-    return false;
-  } else if (padding != 0) {
-    TILE_LOG_WARNING("`from.size()` [{}] Can not be divisible by 4. "
-                     "auto add padding [{}] `=`",
-                     from.size(), padding);
-    safe_from_str = from.ToString() + std::string(padding, '=');
-    from = safe_from_str;
-  }
+    const auto size = 4 * ((from.size() + 2) / 3);
+    to->resize(size);
+    base64_encodestate state;
+    base64_init_encodestate(&state);
 
-  auto size = 3 * from.size() / 4;
-  to->resize(size);
-
-  {
-    Slice input = from;
-    base64_decodestate state;
-    base64_init_decodestate(&state);
     std::size_t used = 0;
-    while (!input.empty()) {
-      auto input_len = std::min(kBufferSize, from.size());
-      auto encoded_len = base64_decode_block(
-          input.data(), input_len,
-          reinterpret_cast<char *>(internal::RemoveConstPtr(to->data())) + used,
-          &state);
-      if (TILE_UNLIKELY(encoded_len == 0)) {
-        return false;
-      }
-      used += encoded_len;
-      input.RemovePrefix(input_len);
-    }
-  }
+    std::size_t input_len;
+    while (!from.empty()) {
+        input_len = std::min(kBufferSize, from.size());
+        used += base64_encode_block(reinterpret_cast<const char *>(from.data()), input_len,
+                                    reinterpret_cast<char *>(internal::RemoveConstPtr(to->data())) + used, &state);
+        from.RemovePrefix(input_len);
+    };
+    base64_encode_blockend(reinterpret_cast<char *>(internal::RemoveConstPtr(to->data())) + used, &state);
 
-  // === Sample
-  // {
-  //   bool success =
-  //       Base64::Decode(from.data(), from.size(),
-  //                      internal::RemoveConstPtr(to->data()), to->size());
-  //   if (!success) {
-  //     return false;
-  //   }
-  // }
-
-  // === OpenSSL
-  // int rc;
-  // rc = EVP_DecodeBlock(
-  //     reinterpret_cast<unsigned char
-  //     *>(internal::RemoveConstPtr(to->data())), reinterpret_cast<const
-  //     unsigned char *>(from.data()), from.size());
-  // if (rc != size) {
-  //   return false;
-  // }
-  //
-  // @sa: https://tools.ietf.org/html/rfc4648#section-4
-  //
-  // (1) The final quantum of encoding input is an integral multiple of 24
-  //     bits; here, the final unit of encoded output will be an integral
-  //     multiple of 4 characters with no "=" padding.
-  //
-  // (2) The final quantum of encoding input is exactly 8 bits; here, the
-  //     final unit of encoded output will be two characters followed by
-  //     two "=" padding characters.
-  //
-  // (3) The final quantum of encoding input is exactly 16 bits; here, the
-  //     final unit of encoded output will be three characters followed by
-  //     one "=" padding character.
-  TILE_CHECK(from.size() >= 2 && to->size() >= 2);
-  if (from[from.size() - 1] == '=') {
-    to->pop_back();
-  }
-
-  if (from[from.size() - 2] == '=') {
-    to->pop_back();
-  }
-
-  // to->pop_back(); // Remove Terminating null
-
-  return true;
+    // bool success =
+    //     Base64::Encode(from.data(), from.size(),
+    //                    internal::RemoveConstPtr(to->data()), to->size());
+    // TILE_CHECK(success, "Unexpected: Failed to do base64-encode.");
 }
 
-} // namespace tile
+bool
+DecodeBase64(Slice from, std::string *to)
+{
+    if (TILE_UNLIKELY(from.empty())) {
+        to->clear();
+        return true;
+    }
+
+    std::string safe_from_str;
+    // auto padding
+    auto padding = (4 - from.size() % 4) % 4;
+    if (padding > 2) {
+        return false;
+    } else if (padding != 0) {
+        TILE_LOG_WARNING("`from.size()` [{}] Can not be divisible by 4. "
+                         "auto add padding [{}] `=`",
+                         from.size(), padding);
+        safe_from_str = from.ToString() + std::string(padding, '=');
+        from          = safe_from_str;
+    }
+
+    auto size = 3 * from.size() / 4;
+    to->resize(size);
+
+    {
+        Slice input = from;
+        base64_decodestate state;
+        base64_init_decodestate(&state);
+        std::size_t used = 0;
+        while (!input.empty()) {
+            auto input_len   = std::min(kBufferSize, from.size());
+            auto encoded_len = base64_decode_block(
+                input.data(), input_len, reinterpret_cast<char *>(internal::RemoveConstPtr(to->data())) + used, &state);
+            if (TILE_UNLIKELY(encoded_len == 0)) { return false; }
+            used += encoded_len;
+            input.RemovePrefix(input_len);
+        }
+    }
+
+    // === Sample
+    // {
+    //   bool success =
+    //       Base64::Decode(from.data(), from.size(),
+    //                      internal::RemoveConstPtr(to->data()), to->size());
+    //   if (!success) {
+    //     return false;
+    //   }
+    // }
+
+    // === OpenSSL
+    // int rc;
+    // rc = EVP_DecodeBlock(
+    //     reinterpret_cast<unsigned char
+    //     *>(internal::RemoveConstPtr(to->data())), reinterpret_cast<const
+    //     unsigned char *>(from.data()), from.size());
+    // if (rc != size) {
+    //   return false;
+    // }
+    //
+    // @sa: https://tools.ietf.org/html/rfc4648#section-4
+    //
+    // (1) The final quantum of encoding input is an integral multiple of 24
+    //     bits; here, the final unit of encoded output will be an integral
+    //     multiple of 4 characters with no "=" padding.
+    //
+    // (2) The final quantum of encoding input is exactly 8 bits; here, the
+    //     final unit of encoded output will be two characters followed by
+    //     two "=" padding characters.
+    //
+    // (3) The final quantum of encoding input is exactly 16 bits; here, the
+    //     final unit of encoded output will be three characters followed by
+    //     one "=" padding character.
+    TILE_CHECK(from.size() >= 2 && to->size() >= 2);
+    if (from[from.size() - 1] == '=') { to->pop_back(); }
+
+    if (from[from.size() - 2] == '=') { to->pop_back(); }
+
+    // to->pop_back(); // Remove Terminating null
+
+    return true;
+}
+
+}// namespace tile
diff --git a/tile/base/encoding/base64.h b/tile/base/encoding/base64.h
index 09a19ae..87a3c68 100644
--- a/tile/base/encoding/base64.h
+++ b/tile/base/encoding/base64.h
@@ -13,6 +13,6 @@ std::optional<std::string> DecodeBase64(Slice from);
 
 void EncodeBase64(Slice from, std::string *to);
 bool DecodeBase64(Slice from, std::string *to);
-} // namespace tile
+}// namespace tile
 
-#endif // _TILE_BASE_ENCODING_BASE64_H
+#endif// _TILE_BASE_ENCODING_BASE64_H
diff --git a/tile/base/encoding/base64_test.cc b/tile/base/encoding/base64_test.cc
index 7996f52..b851bbf 100644
--- a/tile/base/encoding/base64_test.cc
+++ b/tile/base/encoding/base64_test.cc
@@ -9,70 +9,75 @@
 
 namespace tile {
 
-static constexpr auto kText = ".<>@????????";
-static constexpr auto kBase64Text = "Ljw+QD8/Pz8/Pz8/";
-static constexpr auto kText2 = ".<>@???????";
+static constexpr auto kText        = ".<>@????????";
+static constexpr auto kBase64Text  = "Ljw+QD8/Pz8/Pz8/";
+static constexpr auto kText2       = ".<>@???????";
 static constexpr auto kBase64Text2 = "Ljw+QD8/Pz8/Pz8=";
 
-TEST(Base64, Default) {
-  EXPECT_EQ(kBase64Text, EncodeBase64(kText));
-  auto decoded = DecodeBase64(kBase64Text);
-  ASSERT_TRUE(decoded);
-  EXPECT_EQ(kText, *decoded);
-  EXPECT_FALSE(DecodeBase64("some-invalid-base64-encoded!!"));
-}
-
-TEST(Base64, Padding) {
-  EXPECT_EQ(kBase64Text2, EncodeBase64(kText2));
-
-  auto decoded = DecodeBase64(kBase64Text2);
-  ASSERT_TRUE(decoded);
-  EXPECT_EQ(kText2, *decoded);
-}
-
-TEST(Base64, Empty) {
-  EXPECT_EQ("", EncodeBase64(""));
-  auto decoded = DecodeBase64("");
-  ASSERT_TRUE(decoded);
-  EXPECT_EQ("", *decoded);
-}
-
-TEST(Base64, AutoPadding) {
-  static constexpr auto kChar = "A";
-
-  EXPECT_EQ("QQ==", EncodeBase64(kChar));
-
-  {
-    auto decoded = DecodeBase64("QQ==");
+TEST(Base64, Default)
+{
+    EXPECT_EQ(kBase64Text, EncodeBase64(kText));
+    auto decoded = DecodeBase64(kBase64Text);
     ASSERT_TRUE(decoded);
-    EXPECT_EQ(kChar, *decoded);
-  }
-
-  // auto padding, 1
-  {
-    auto decoded1 = DecodeBase64("QQ=");
-    ASSERT_TRUE(decoded1);
-    EXPECT_EQ(kChar, *decoded1);
-  }
-
-  // auto padding, 2
-  {
-    auto decoded2 = DecodeBase64("QQ");
-    ASSERT_TRUE(decoded2);
-    EXPECT_EQ(kChar, *decoded2);
-  }
+    EXPECT_EQ(kText, *decoded);
+    EXPECT_FALSE(DecodeBase64("some-invalid-base64-encoded!!"));
 }
 
-TEST(Base64, Torture) {
-  std::string random_str;
-  std::string encoded;
-  std::string decoded;
-  for (int i = 0; i != 1000; ++i) {
-    testing::RandomString(&random_str, 10000, 10000);
-    EncodeBase64(random_str, &encoded);
-    ASSERT_TRUE(DecodeBase64(encoded, &decoded));
-    EXPECT_EQ(random_str, decoded);
-  }
+TEST(Base64, Padding)
+{
+    EXPECT_EQ(kBase64Text2, EncodeBase64(kText2));
+
+    auto decoded = DecodeBase64(kBase64Text2);
+    ASSERT_TRUE(decoded);
+    EXPECT_EQ(kText2, *decoded);
 }
 
-} // namespace tile
+TEST(Base64, Empty)
+{
+    EXPECT_EQ("", EncodeBase64(""));
+    auto decoded = DecodeBase64("");
+    ASSERT_TRUE(decoded);
+    EXPECT_EQ("", *decoded);
+}
+
+TEST(Base64, AutoPadding)
+{
+    static constexpr auto kChar = "A";
+
+    EXPECT_EQ("QQ==", EncodeBase64(kChar));
+
+    {
+        auto decoded = DecodeBase64("QQ==");
+        ASSERT_TRUE(decoded);
+        EXPECT_EQ(kChar, *decoded);
+    }
+
+    // auto padding, 1
+    {
+        auto decoded1 = DecodeBase64("QQ=");
+        ASSERT_TRUE(decoded1);
+        EXPECT_EQ(kChar, *decoded1);
+    }
+
+    // auto padding, 2
+    {
+        auto decoded2 = DecodeBase64("QQ");
+        ASSERT_TRUE(decoded2);
+        EXPECT_EQ(kChar, *decoded2);
+    }
+}
+
+TEST(Base64, Torture)
+{
+    std::string random_str;
+    std::string encoded;
+    std::string decoded;
+    for (int i = 0; i != 1000; ++i) {
+        testing::RandomString(&random_str, 10000, 10000);
+        EncodeBase64(random_str, &encoded);
+        ASSERT_TRUE(DecodeBase64(encoded, &decoded));
+        EXPECT_EQ(random_str, decoded);
+    }
+}
+
+}// namespace tile
diff --git a/tile/base/encoding/detail/base64_impl.h b/tile/base/encoding/detail/base64_impl.h
index 6e8034f..e3ba4cd 100644
--- a/tile/base/encoding/detail/base64_impl.h
+++ b/tile/base/encoding/detail/base64_impl.h
@@ -3,286 +3,247 @@
 
 #include <string>
 
-const char kBase64Alphabet[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
-                               "abcdefghijklmnopqrstuvwxyz"
-                               "0123456789+/";
+const char kBase64Alphabet[] =
+    "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+    "abcdefghijklmnopqrstuvwxyz"
+    "0123456789+/";
 
 namespace {
-static inline unsigned char b64_lookup_aux(unsigned char c) {
-  if (c >= 'A' && c <= 'Z')
-    return c - 'A';
-  if (c >= 'a' && c <= 'z')
-    return c - 71;
-  if (c >= '0' && c <= '9')
-    return c + 4;
-  if (c == '+')
-    return 62;
-  if (c == '/')
-    return 63;
-  return 255;
+static inline unsigned char
+b64_lookup_aux(unsigned char c)
+{
+    if (c >= 'A' && c <= 'Z') return c - 'A';
+    if (c >= 'a' && c <= 'z') return c - 71;
+    if (c >= '0' && c <= '9') return c + 4;
+    if (c == '+') return 62;
+    if (c == '/') return 63;
+    return 255;
 }
-struct Base64LookupInitializer {
-  Base64LookupInitializer() {
-    for (int i = 0; i < 256; i++) {
-      kBase64Lookup[i] = b64_lookup_aux(i);
-    }
-  }
 
-  int kBase64Lookup[256];
+struct Base64LookupInitializer {
+    Base64LookupInitializer()
+    {
+        for (int i = 0; i < 256; i++) { kBase64Lookup[i] = b64_lookup_aux(i); }
+    }
+
+    int kBase64Lookup[256];
 };
 
-static inline unsigned char b64_lookup_aux1(unsigned char c) {
-  static Base64LookupInitializer init;
-  return init.kBase64Lookup[c];
+static inline unsigned char
+b64_lookup_aux1(unsigned char c)
+{
+    static Base64LookupInitializer init;
+    return init.kBase64Lookup[c];
+}
+}// namespace
+
+inline unsigned char
+b64_lookup(unsigned char c)
+{
+    return b64_lookup_aux1(c);
 }
-} // namespace
-inline unsigned char b64_lookup(unsigned char c) { return b64_lookup_aux1(c); }
 
 class Base64 {
 public:
-  static bool Encode(const std::string &in, std::string *out) {
-    int i = 0, j = 0;
-    size_t enc_len = 0;
-    unsigned char a3[3];
-    unsigned char a4[4];
+    static bool Encode(const std::string &in, std::string *out)
+    {
+        int i = 0, j = 0;
+        size_t enc_len = 0;
+        unsigned char a3[3];
+        unsigned char a4[4];
 
-    out->resize(EncodedLength(in));
+        out->resize(EncodedLength(in));
 
-    size_t input_len = in.size();
-    std::string::const_iterator input = in.begin();
+        size_t input_len                  = in.size();
+        std::string::const_iterator input = in.begin();
 
-    while (input_len--) {
-      a3[i++] = *(input++);
-      if (i == 3) {
-        a3_to_a4(a4, a3);
+        while (input_len--) {
+            a3[i++] = *(input++);
+            if (i == 3) {
+                a3_to_a4(a4, a3);
 
-        for (i = 0; i < 4; i++) {
-          (*out)[enc_len++] = kBase64Alphabet[a4[i]];
+                for (i = 0; i < 4; i++) { (*out)[enc_len++] = kBase64Alphabet[a4[i]]; }
+
+                i = 0;
+            }
         }
 
-        i = 0;
-      }
-    }
+        if (i) {
+            for (j = i; j < 3; j++) { a3[j] = '\0'; }
 
-    if (i) {
-      for (j = i; j < 3; j++) {
-        a3[j] = '\0';
-      }
+            a3_to_a4(a4, a3);
 
-      a3_to_a4(a4, a3);
+            for (j = 0; j < i + 1; j++) { (*out)[enc_len++] = kBase64Alphabet[a4[j]]; }
 
-      for (j = 0; j < i + 1; j++) {
-        (*out)[enc_len++] = kBase64Alphabet[a4[j]];
-      }
-
-      while ((i++ < 3)) {
-        (*out)[enc_len++] = '=';
-      }
-    }
-
-    return (enc_len == out->size());
-  }
-
-  static bool Encode(const char *input, size_t input_length, char *out,
-                     size_t out_length) {
-    int i = 0, j = 0;
-    char *out_begin = out;
-    unsigned char a3[3];
-    unsigned char a4[4];
-
-    size_t encoded_length = EncodedLength(input_length);
-
-    if (out_length < encoded_length)
-      return false;
-
-    while (input_length--) {
-      a3[i++] = *input++;
-      if (i == 3) {
-        a3_to_a4(a4, a3);
-
-        for (i = 0; i < 4; i++) {
-          *out++ = kBase64Alphabet[a4[i]];
-        }
-        // out[0] = kBase64Alphabet[a4[0]];
-        // out[1] = kBase64Alphabet[a4[1]];
-        // out[2] = kBase64Alphabet[a4[2]];
-        // out[3] = kBase64Alphabet[a4[3]];
-        // out += 4;
-
-        i = 0;
-      }
-    }
-
-    if (i) {
-      for (j = i; j < 3; j++) {
-        a3[j] = '\0';
-      }
-
-      a3_to_a4(a4, a3);
-
-      for (j = 0; j < i + 1; j++) {
-        *out++ = kBase64Alphabet[a4[j]];
-      }
-
-      while ((i++ < 3)) {
-        *out++ = '=';
-      }
-    }
-
-    return (out == (out_begin + encoded_length));
-  }
-
-  static bool Decode(const std::string &in, std::string *out) {
-    int i = 0, j = 0;
-    size_t dec_len = 0;
-    unsigned char a3[3];
-    unsigned char a4[4];
-
-    size_t input_len = in.size();
-    std::string::const_iterator input = in.begin();
-
-    out->resize(DecodedLength(in));
-
-    while (input_len--) {
-      if (*input == '=') {
-        break;
-      }
-
-      a4[i++] = *(input++);
-      if (i == 4) {
-        for (i = 0; i < 4; i++) {
-          a4[i] = b64_lookup(a4[i]);
+            while ((i++ < 3)) { (*out)[enc_len++] = '='; }
         }
 
-        a4_to_a3(a3, a4);
+        return (enc_len == out->size());
+    }
 
-        for (i = 0; i < 3; i++) {
-          (*out)[dec_len++] = a3[i];
+    static bool Encode(const char *input, size_t input_length, char *out, size_t out_length)
+    {
+        int i = 0, j = 0;
+        char *out_begin = out;
+        unsigned char a3[3];
+        unsigned char a4[4];
+
+        size_t encoded_length = EncodedLength(input_length);
+
+        if (out_length < encoded_length) return false;
+
+        while (input_length--) {
+            a3[i++] = *input++;
+            if (i == 3) {
+                a3_to_a4(a4, a3);
+
+                for (i = 0; i < 4; i++) { *out++ = kBase64Alphabet[a4[i]]; }
+                // out[0] = kBase64Alphabet[a4[0]];
+                // out[1] = kBase64Alphabet[a4[1]];
+                // out[2] = kBase64Alphabet[a4[2]];
+                // out[3] = kBase64Alphabet[a4[3]];
+                // out += 4;
+
+                i = 0;
+            }
         }
 
-        i = 0;
-      }
-    }
+        if (i) {
+            for (j = i; j < 3; j++) { a3[j] = '\0'; }
 
-    if (i) {
-      for (j = i; j < 4; j++) {
-        a4[j] = '\0';
-      }
+            a3_to_a4(a4, a3);
 
-      for (j = 0; j < 4; j++) {
-        a4[j] = b64_lookup(a4[j]);
-      }
+            for (j = 0; j < i + 1; j++) { *out++ = kBase64Alphabet[a4[j]]; }
 
-      a4_to_a3(a3, a4);
-
-      for (j = 0; j < i - 1; j++) {
-        (*out)[dec_len++] = a3[j];
-      }
-    }
-
-    return (dec_len == out->size());
-  }
-
-  static bool Decode(const char *input, size_t input_length, char *out,
-                     size_t out_length) {
-    int i = 0, j = 0;
-    char *out_begin = out;
-    unsigned char a3[3];
-    unsigned char a4[4];
-
-    size_t decoded_length = DecodedLength(input, input_length);
-
-    if (out_length < decoded_length)
-      return false;
-
-    while (input_length--) {
-      if (*input == '=') {
-        break;
-      }
-
-      a4[i++] = *(input++);
-      if (i == 4) {
-        for (i = 0; i < 4; i++) {
-          a4[i] = b64_lookup(a4[i]);
+            while ((i++ < 3)) { *out++ = '='; }
         }
 
-        a4_to_a3(a3, a4);
+        return (out == (out_begin + encoded_length));
+    }
 
-        for (i = 0; i < 3; i++) {
-          *out++ = a3[i];
+    static bool Decode(const std::string &in, std::string *out)
+    {
+        int i = 0, j = 0;
+        size_t dec_len = 0;
+        unsigned char a3[3];
+        unsigned char a4[4];
+
+        size_t input_len                  = in.size();
+        std::string::const_iterator input = in.begin();
+
+        out->resize(DecodedLength(in));
+
+        while (input_len--) {
+            if (*input == '=') { break; }
+
+            a4[i++] = *(input++);
+            if (i == 4) {
+                for (i = 0; i < 4; i++) { a4[i] = b64_lookup(a4[i]); }
+
+                a4_to_a3(a3, a4);
+
+                for (i = 0; i < 3; i++) { (*out)[dec_len++] = a3[i]; }
+
+                i = 0;
+            }
         }
 
-        i = 0;
-      }
+        if (i) {
+            for (j = i; j < 4; j++) { a4[j] = '\0'; }
+
+            for (j = 0; j < 4; j++) { a4[j] = b64_lookup(a4[j]); }
+
+            a4_to_a3(a3, a4);
+
+            for (j = 0; j < i - 1; j++) { (*out)[dec_len++] = a3[j]; }
+        }
+
+        return (dec_len == out->size());
     }
 
-    if (i) {
-      for (j = i; j < 4; j++) {
-        a4[j] = '\0';
-      }
+    static bool Decode(const char *input, size_t input_length, char *out, size_t out_length)
+    {
+        int i = 0, j = 0;
+        char *out_begin = out;
+        unsigned char a3[3];
+        unsigned char a4[4];
 
-      for (j = 0; j < 4; j++) {
-        a4[j] = b64_lookup(a4[j]);
-      }
+        size_t decoded_length = DecodedLength(input, input_length);
 
-      a4_to_a3(a3, a4);
+        if (out_length < decoded_length) return false;
 
-      for (j = 0; j < i - 1; j++) {
-        *out++ = a3[j];
-      }
+        while (input_length--) {
+            if (*input == '=') { break; }
+
+            a4[i++] = *(input++);
+            if (i == 4) {
+                for (i = 0; i < 4; i++) { a4[i] = b64_lookup(a4[i]); }
+
+                a4_to_a3(a3, a4);
+
+                for (i = 0; i < 3; i++) { *out++ = a3[i]; }
+
+                i = 0;
+            }
+        }
+
+        if (i) {
+            for (j = i; j < 4; j++) { a4[j] = '\0'; }
+
+            for (j = 0; j < 4; j++) { a4[j] = b64_lookup(a4[j]); }
+
+            a4_to_a3(a3, a4);
+
+            for (j = 0; j < i - 1; j++) { *out++ = a3[j]; }
+        }
+
+        return (out == (out_begin + decoded_length));
     }
 
-    return (out == (out_begin + decoded_length));
-  }
+    static size_t DecodedLength(const char *in, size_t in_length)
+    {
+        int numEq          = 0;
 
-  static size_t DecodedLength(const char *in, size_t in_length) {
-    int numEq = 0;
+        const char *in_end = in + in_length;
+        while (*--in_end == '=') ++numEq;
 
-    const char *in_end = in + in_length;
-    while (*--in_end == '=')
-      ++numEq;
-
-    return ((6 * in_length) / 8) - numEq;
-  }
-
-  static size_t DecodedLength(const std::string &in) {
-    int numEq = 0;
-    size_t n = in.size();
-
-    for (std::string::const_reverse_iterator it = in.rbegin(); *it == '=';
-         ++it) {
-      ++numEq;
+        return ((6 * in_length) / 8) - numEq;
     }
 
-    return ((6 * n) / 8) - numEq;
-  }
+    static size_t DecodedLength(const std::string &in)
+    {
+        int numEq = 0;
+        size_t n  = in.size();
 
-  inline static size_t EncodedLength(size_t length) {
-    return (length + 2 - ((length + 2) % 3)) / 3 * 4;
-  }
+        for (std::string::const_reverse_iterator it = in.rbegin(); *it == '='; ++it) { ++numEq; }
 
-  inline static size_t EncodedLength(const std::string &in) {
-    return EncodedLength(in.length());
-  }
+        return ((6 * n) / 8) - numEq;
+    }
 
-  inline static void StripPadding(std::string *in) {
-    while (!in->empty() && *(in->rbegin()) == '=')
-      in->resize(in->size() - 1);
-  }
+    inline static size_t EncodedLength(size_t length) { return (length + 2 - ((length + 2) % 3)) / 3 * 4; }
+
+    inline static size_t EncodedLength(const std::string &in) { return EncodedLength(in.length()); }
+
+    inline static void StripPadding(std::string *in)
+    {
+        while (!in->empty() && *(in->rbegin()) == '=') in->resize(in->size() - 1);
+    }
 
 private:
-  static inline void a3_to_a4(unsigned char *a4, unsigned char *a3) {
-    a4[0] = (a3[0] & 0xfc) >> 2;
-    a4[1] = ((a3[0] & 0x03) << 4) + ((a3[1] & 0xf0) >> 4);
-    a4[2] = ((a3[1] & 0x0f) << 2) + ((a3[2] & 0xc0) >> 6);
-    a4[3] = (a3[2] & 0x3f);
-  }
+    static inline void a3_to_a4(unsigned char *a4, unsigned char *a3)
+    {
+        a4[0] = (a3[0] & 0xfc) >> 2;
+        a4[1] = ((a3[0] & 0x03) << 4) + ((a3[1] & 0xf0) >> 4);
+        a4[2] = ((a3[1] & 0x0f) << 2) + ((a3[2] & 0xc0) >> 6);
+        a4[3] = (a3[2] & 0x3f);
+    }
 
-  static inline void a4_to_a3(unsigned char *a3, unsigned char *a4) {
-    a3[0] = (a4[0] << 2) + ((a4[1] & 0x30) >> 4);
-    a3[1] = ((a4[1] & 0xf) << 4) + ((a4[2] & 0x3c) >> 2);
-    a3[2] = ((a4[2] & 0x3) << 6) + a4[3];
-  }
+    static inline void a4_to_a3(unsigned char *a3, unsigned char *a4)
+    {
+        a3[0] = (a4[0] << 2) + ((a4[1] & 0x30) >> 4);
+        a3[1] = ((a4[1] & 0xf) << 4) + ((a4[2] & 0x3c) >> 2);
+        a3[2] = ((a4[2] & 0x3) << 6) + a4[3];
+    }
 };
 
-#endif // BASE64_H
+#endif// BASE64_H
diff --git a/tile/base/encoding/detail/hex_chars.cc b/tile/base/encoding/detail/hex_chars.cc
index de6cdab..222c74e 100644
--- a/tile/base/encoding/detail/hex_chars.cc
+++ b/tile/base/encoding/detail/hex_chars.cc
@@ -6,80 +6,88 @@ namespace detail {
 namespace {
 static constexpr auto kCharMin = std::numeric_limits<char>::min();
 static constexpr auto kCharMax = std::numeric_limits<char>::max();
-static constexpr auto kSize = kCharMax - kCharMin + 1;
+static constexpr auto kSize    = kCharMax - kCharMin + 1;
 
-int AsciiCodeFromCharPairSlow(char a, char b) {
-  a = ToLower(a);
-  b = ToLower(b);
-  auto ToNum = [](char x) {
-    if (x >= '0' && x <= '9') {
-      return x - '0';
-    } else if (x >= 'a' && x <= 'f') {
-      return x - 'a' + 10;
+int
+AsciiCodeFromCharPairSlow(char a, char b)
+{
+    a          = ToLower(a);
+    b          = ToLower(b);
+    auto ToNum = [](char x) {
+        if (x >= '0' && x <= '9') {
+            return x - '0';
+        } else if (x >= 'a' && x <= 'f') {
+            return x - 'a' + 10;
+        } else {
+            return -1;
+        }
+    };
+
+    int x = ToNum(a);
+    int y = ToNum(b);
+    if (x == -1 || y == -1) { return -1; }
+
+    return (x << 4) | y;
+}
+
+std::pair<char, char>
+AsciiCodeToCharPairSlow(std::uint8_t value, bool uppercase)
+{
+    if (uppercase) {
+        return std::make_pair(kHexCharsUpper[value >> 4], kHexCharsUpper[value & 0x0f]);
     } else {
-      return -1;
+        return std::make_pair(kHexCharsLower[value >> 4], kHexCharsLower[value & 0x0f]);
     }
-  };
-
-  int x = ToNum(a);
-  int y = ToNum(b);
-  if (x == -1 || y == -1) {
-    return -1;
-  }
-
-  return (x << 4) | y;
 }
 
-std::pair<char, char> AsciiCodeToCharPairSlow(std::uint8_t value,
-                                              bool uppercase) {
-  if (uppercase) {
-    return std::make_pair(kHexCharsUpper[value >> 4],
-                          kHexCharsUpper[value & 0x0f]);
-  } else {
-    return std::make_pair(kHexCharsLower[value >> 4],
-                          kHexCharsLower[value & 0x0f]);
-  }
-}
-
-std::array<std::array<int, 256>, 256> GenAsciiCodeFromCharPairTable() {
-  std::array<std::array<int, 256>, 256> table;
-  for (char i = kCharMin; i != kCharMax; ++i) {
-    for (char j = kCharMin; j != kCharMax; ++j) {
-      table[i - kCharMin][j - kCharMin] = AsciiCodeFromCharPairSlow(i, j);
+std::array<std::array<int, 256>, 256>
+GenAsciiCodeFromCharPairTable()
+{
+    std::array<std::array<int, 256>, 256> table;
+    for (char i = kCharMin; i != kCharMax; ++i) {
+        for (char j = kCharMin; j != kCharMax; ++j) {
+            table[i - kCharMin][j - kCharMin] = AsciiCodeFromCharPairSlow(i, j);
+        }
     }
-  }
-  return table;
+    return table;
 }
 
 std::array<std::pair<char, char>, 256>
-GenAsciiCodeToCharPairTable(bool uppercase) {
-  std::array<std::pair<char, char>, 256> table;
-  for (int i = 0; i != 256; ++i) {
-    table[i] = AsciiCodeToCharPairSlow(i, uppercase);
-  }
-  return table;
+GenAsciiCodeToCharPairTable(bool uppercase)
+{
+    std::array<std::pair<char, char>, 256> table;
+    for (int i = 0; i != 256; ++i) { table[i] = AsciiCodeToCharPairSlow(i, uppercase); }
+    return table;
 }
 
-} // namespace
+}// namespace
 
-int AsciiCodeFromCharPair(char a, char b) {
-  static auto table = GenAsciiCodeFromCharPairTable();
-  return table[a - kCharMin][b - kCharMin];
+int
+AsciiCodeFromCharPair(char a, char b)
+{
+    static auto table = GenAsciiCodeFromCharPairTable();
+    return table[a - kCharMin][b - kCharMin];
 }
 
-inline std::pair<char, char> AsciiCodeToUpperCharPair(std::uint8_t value) {
-  static auto table = GenAsciiCodeToCharPairTable(true);
-  return table[value];
-}
-inline std::pair<char, char> AsciiCodeToLowerCharPair(std::uint8_t value) {
-  static auto table = GenAsciiCodeToCharPairTable(false);
-  return table[value];
+inline std::pair<char, char>
+AsciiCodeToUpperCharPair(std::uint8_t value)
+{
+    static auto table = GenAsciiCodeToCharPairTable(true);
+    return table[value];
 }
 
-std::pair<char, char> AsciiCodeToCharPair(std::uint8_t value, bool uppercase) {
-  return uppercase ? AsciiCodeToUpperCharPair(value)
-                   : AsciiCodeToLowerCharPair(value);
+inline std::pair<char, char>
+AsciiCodeToLowerCharPair(std::uint8_t value)
+{
+    static auto table = GenAsciiCodeToCharPairTable(false);
+    return table[value];
 }
 
-} // namespace detail
-} // namespace tile
+std::pair<char, char>
+AsciiCodeToCharPair(std::uint8_t value, bool uppercase)
+{
+    return uppercase ? AsciiCodeToUpperCharPair(value) : AsciiCodeToLowerCharPair(value);
+}
+
+}// namespace detail
+}// namespace tile
diff --git a/tile/base/encoding/detail/hex_chars.h b/tile/base/encoding/detail/hex_chars.h
index f29db0a..eca32c7 100644
--- a/tile/base/encoding/detail/hex_chars.h
+++ b/tile/base/encoding/detail/hex_chars.h
@@ -13,7 +13,7 @@ namespace tile {
 namespace detail {
 
 struct CharPair {
-  char a, b;
+    char a, b;
 };
 
 static constexpr char kHexCharsLower[] = "0123456789abcdef";
@@ -23,10 +23,9 @@ static constexpr char kHexCharsUpper[] = "0123456789ABCDEF";
 
 int AsciiCodeFromCharPair(char a, char b);
 
-std::pair<char, char> AsciiCodeToCharPair(std::uint8_t value,
-                                          bool uppercase = true);
+std::pair<char, char> AsciiCodeToCharPair(std::uint8_t value, bool uppercase = true);
 
-} // namespace detail
-} // namespace tile
+}// namespace detail
+}// namespace tile
 
-#endif // _TILE_BASE_ENCODING_DETAIL_HEX_CHARS_H
+#endif// _TILE_BASE_ENCODING_DETAIL_HEX_CHARS_H
diff --git a/tile/base/encoding/hex.cc b/tile/base/encoding/hex.cc
index 3ed8f36..60ba213 100644
--- a/tile/base/encoding/hex.cc
+++ b/tile/base/encoding/hex.cc
@@ -6,48 +6,49 @@
 
 namespace tile {
 
-std::string EncodeHex(Slice from, bool uppercase) {
-  std::string result;
-  EncodeHex(from, &result, uppercase);
-  return result;
+std::string
+EncodeHex(Slice from, bool uppercase)
+{
+    std::string result;
+    EncodeHex(from, &result, uppercase);
+    return result;
 }
 
-std::optional<std::string> DecodeHex(Slice from) {
-  std::string result;
-  if (!DecodeHex(from, &result)) {
-    return std::nullopt;
-  }
-  return result;
+std::optional<std::string>
+DecodeHex(Slice from)
+{
+    std::string result;
+    if (!DecodeHex(from, &result)) { return std::nullopt; }
+    return result;
 }
 
-void EncodeHex(Slice from, std::string *to, bool uppercase) {
-  to->clear();
-  to->reserve(from.size() * 2);
-  for (auto &&e : from) {
-    // auto index = static_cast<std::uint8_t>(e);
-    auto pair =
-        detail::AsciiCodeToCharPair(static_cast<std::uint8_t>(e), uppercase);
-    to->append({pair.first, pair.second});
-  }
+void
+EncodeHex(Slice from, std::string *to, bool uppercase)
+{
+    to->clear();
+    to->reserve(from.size() * 2);
+    for (auto &&e : from) {
+        // auto index = static_cast<std::uint8_t>(e);
+        auto pair = detail::AsciiCodeToCharPair(static_cast<std::uint8_t>(e), uppercase);
+        to->append({pair.first, pair.second});
+    }
 }
 
-bool DecodeHex(Slice from, std::string *to) {
-  if (from.size() % 2 != 0) {
-    return false;
-  }
+bool
+DecodeHex(Slice from, std::string *to)
+{
+    if (from.size() % 2 != 0) { return false; }
 
-  to->clear();
-  to->reserve(from.size() / 2);
-  for (size_t i = 0; i != from.size(); i += 2) {
-    auto v = detail::AsciiCodeFromCharPair(from[i], from[i + 1]);
-    if (v == -1) {
-      return false;
+    to->clear();
+    to->reserve(from.size() / 2);
+    for (size_t i = 0; i != from.size(); i += 2) {
+        auto v = detail::AsciiCodeFromCharPair(from[i], from[i + 1]);
+        if (v == -1) { return false; }
+
+        TILE_CHECK(v >= 0 && v <= 255);
+        to->push_back(v);
     }
 
-    TILE_CHECK(v >= 0 && v <= 255);
-    to->push_back(v);
-  }
-
-  return true;
+    return true;
 }
-} // namespace tile
+}// namespace tile
diff --git a/tile/base/encoding/hex.h b/tile/base/encoding/hex.h
index 3ecacc8..98d916e 100644
--- a/tile/base/encoding/hex.h
+++ b/tile/base/encoding/hex.h
@@ -11,6 +11,6 @@ std::optional<std::string> DecodeHex(Slice from);
 
 void EncodeHex(Slice from, std::string *to, bool uppercase = false);
 bool DecodeHex(Slice from, std::string *to);
-} // namespace tile
+}// namespace tile
 
-#endif // TILE_BASE_ENCODING_HEX_H
+#endif// TILE_BASE_ENCODING_HEX_H
diff --git a/tile/base/encoding/hex_test.cc b/tile/base/encoding/hex_test.cc
index 1ecf190..879bef7 100644
--- a/tile/base/encoding/hex_test.cc
+++ b/tile/base/encoding/hex_test.cc
@@ -7,23 +7,25 @@
 namespace tile {
 const char Hex123456FF[] = "\x12\x34\x56\xFF";
 
-TEST(Hex, Default) {
-  EXPECT_EQ("123456ff", EncodeHex(Hex123456FF));
-  EXPECT_EQ("123456FF", EncodeHex(Hex123456FF, true));
-  EXPECT_EQ(Hex123456FF, *DecodeHex("123456ff"));
-  EXPECT_EQ(Hex123456FF, *DecodeHex("123456FF"));
+TEST(Hex, Default)
+{
+    EXPECT_EQ("123456ff", EncodeHex(Hex123456FF));
+    EXPECT_EQ("123456FF", EncodeHex(Hex123456FF, true));
+    EXPECT_EQ(Hex123456FF, *DecodeHex("123456ff"));
+    EXPECT_EQ(Hex123456FF, *DecodeHex("123456FF"));
 }
 
-TEST(Hex, Random) {
-  std::string random_str;
-  std::string encoded;
-  std::string decoded;
-  for (int i = 0; i != 1000; ++i) {
-    testing::RandomString(&random_str);
-    EncodeHex(random_str, &encoded);
-    ASSERT_TRUE(DecodeHex(encoded, &decoded));
-    EXPECT_EQ(random_str, decoded);
-  }
+TEST(Hex, Random)
+{
+    std::string random_str;
+    std::string encoded;
+    std::string decoded;
+    for (int i = 0; i != 1000; ++i) {
+        testing::RandomString(&random_str);
+        EncodeHex(random_str, &encoded);
+        ASSERT_TRUE(DecodeHex(encoded, &decoded));
+        EXPECT_EQ(random_str, decoded);
+    }
 }
 
-} // namespace tile
+}// namespace tile
diff --git a/tile/base/encoding/percent.cc b/tile/base/encoding/percent.cc
index 6efa3f8..a1c86f5 100644
--- a/tile/base/encoding/percent.cc
+++ b/tile/base/encoding/percent.cc
@@ -7,112 +7,107 @@ namespace tile {
 
 // [0-9a-zA-Z]
 namespace {
-std::array<bool, 256> GenerateUnescapedCharBitmap(Slice unescaped_chars) {
-  std::array<bool, 256> result{};
-  for (auto &&e : unescaped_chars) {
-    result[e] = true;
-  }
+std::array<bool, 256>
+GenerateUnescapedCharBitmap(Slice unescaped_chars)
+{
+    std::array<bool, 256> result{};
+    for (auto &&e : unescaped_chars) { result[e] = true; }
 
-  for (int i = 0; i != 10; ++i) {
-    result[i + '0'] = true;
-  }
+    for (int i = 0; i != 10; ++i) { result[i + '0'] = true; }
 
-  for (int i = 0; i != 26; ++i) {
-    result[i + 'A'] = true;
-    result[i + 'a'] = true;
-  }
+    for (int i = 0; i != 26; ++i) {
+        result[i + 'A'] = true;
+        result[i + 'a'] = true;
+    }
 
-  return result;
+    return result;
 }
 
 const std::array<std::array<bool, 256>, 2> &
-GetUnescapedCharBitmap(const PercentEncodingStyle &style) {
-  static const std::array<std::array<bool, 256>, 2> kUnescapedChars[] = {
-      /* emca262 = */ {GenerateUnescapedCharBitmap("_-,;:!?.'()@*/&#+=~$"),
-                       GenerateUnescapedCharBitmap("_-!.*~'()")},
+GetUnescapedCharBitmap(const PercentEncodingStyle &style)
+{
+    static const std::array<std::array<bool, 256>, 2> kUnescapedChars[] = {
+        /* emca262 = */ {GenerateUnescapedCharBitmap("_-,;:!?.'()@*/&#+=~$"),   GenerateUnescapedCharBitmap("_-!.*~'()")   },
 
-      /* rfc3986 = */
-      {GenerateUnescapedCharBitmap("_-,;:!?.'()[]@*/&#+=~$"),
-       GenerateUnescapedCharBitmap("_-.~")
+        /* rfc3986 = */
+        {GenerateUnescapedCharBitmap("_-,;:!?.'()[]@*/&#+=~$"), GenerateUnescapedCharBitmap("_-.~")
 
-      },
-      /* rfc5987 = */
-      {GenerateUnescapedCharBitmap("!#$&+-.^_`|~"),
-       GenerateUnescapedCharBitmap("!#$&+-.^_`|~")}};
+        },
+        /* rfc5987 = */
+        {GenerateUnescapedCharBitmap("!#$&+-.^_`|~"),           GenerateUnescapedCharBitmap("!#$&+-.^_`|~")}
+    };
 
-  return kUnescapedChars[static_cast<int>(style)];
+    return kUnescapedChars[static_cast<int>(style)];
 }
-} // namespace
+}// namespace
 
-PercentEncodingOptions::PercentEncodingOptions(PercentEncodingStyle s, bool er)
-    : style(s), escape_reserved(er) {}
+PercentEncodingOptions::PercentEncodingOptions(PercentEncodingStyle s, bool er) : style(s), escape_reserved(er) {}
 
-std::string EncodePercent(Slice from, const PercentEncodingOptions &options) {
-  std::string result;
-  EncodePercent(from, &result, options);
-  return result;
-}
-std::optional<std::string> DecodePercent(Slice from,
-                                         bool decode_plus_sign_as_whitespace) {
-  std::string result;
-  if (DecodePercent(from, &result, decode_plus_sign_as_whitespace)) {
+std::string
+EncodePercent(Slice from, const PercentEncodingOptions &options)
+{
+    std::string result;
+    EncodePercent(from, &result, options);
     return result;
-  }
-  return std::nullopt;
 }
 
-void EncodePercent(Slice from, std::string *to,
-                   const PercentEncodingOptions &options) {
-
-  auto &&unescaped =
-      GetUnescapedCharBitmap(options.style)[options.escape_reserved];
-
-  int escape_char_count = 0;
-  for (auto &&e : from) {
-    if (!unescaped[static_cast<std::uint8_t>(e)]) {
-      ++escape_char_count;
-    }
-  }
-
-  to->clear();
-  to->reserve(from.size() + escape_char_count * 2);
-
-  for (auto &&e : from) {
-    if (TILE_UNLIKELY(unescaped[static_cast<std::uint8_t>(e)])) {
-      to->push_back(e);
-    } else {
-      auto hex_pair = detail::AsciiCodeToCharPair(static_cast<std::uint8_t>(e));
-      to->append({'%', hex_pair.first, hex_pair.second});
-    }
-  }
+std::optional<std::string>
+DecodePercent(Slice from, bool decode_plus_sign_as_whitespace)
+{
+    std::string result;
+    if (DecodePercent(from, &result, decode_plus_sign_as_whitespace)) { return result; }
+    return std::nullopt;
 }
 
-bool DecodePercent(Slice from, std::string *to,
-                   bool decode_plus_sign_as_whitespace) {
-  to->clear();
-  to->reserve(from.size());
-  for (auto iter = from.begin(); iter != from.end();) {
-    if (*iter == '%') {
-      if (iter + 3 > from.end()) {
-        return false;
-      }
-      auto v = detail::AsciiCodeFromCharPair(*(iter + 1), *(iter + 2));
-      if (TILE_LIKELY(v != -1)) {
-        to->push_back(v);
-        iter += 3;
-      } else {
-        // invalid char
-        return false;
-      }
-    } else {
-      if (decode_plus_sign_as_whitespace && *iter == '+') {
-        to->push_back(' ');
-        ++iter;
-      } else {
-        to->push_back(*iter++);
-      }
+void
+EncodePercent(Slice from, std::string *to, const PercentEncodingOptions &options)
+{
+
+    auto &&unescaped      = GetUnescapedCharBitmap(options.style)[options.escape_reserved];
+
+    int escape_char_count = 0;
+    for (auto &&e : from) {
+        if (!unescaped[static_cast<std::uint8_t>(e)]) { ++escape_char_count; }
+    }
+
+    to->clear();
+    to->reserve(from.size() + escape_char_count * 2);
+
+    for (auto &&e : from) {
+        if (TILE_UNLIKELY(unescaped[static_cast<std::uint8_t>(e)])) {
+            to->push_back(e);
+        } else {
+            auto hex_pair = detail::AsciiCodeToCharPair(static_cast<std::uint8_t>(e));
+            to->append({'%', hex_pair.first, hex_pair.second});
+        }
     }
-  }
-  return true;
 }
-} // namespace tile
+
+bool
+DecodePercent(Slice from, std::string *to, bool decode_plus_sign_as_whitespace)
+{
+    to->clear();
+    to->reserve(from.size());
+    for (auto iter = from.begin(); iter != from.end();) {
+        if (*iter == '%') {
+            if (iter + 3 > from.end()) { return false; }
+            auto v = detail::AsciiCodeFromCharPair(*(iter + 1), *(iter + 2));
+            if (TILE_LIKELY(v != -1)) {
+                to->push_back(v);
+                iter += 3;
+            } else {
+                // invalid char
+                return false;
+            }
+        } else {
+            if (decode_plus_sign_as_whitespace && *iter == '+') {
+                to->push_back(' ');
+                ++iter;
+            } else {
+                to->push_back(*iter++);
+            }
+        }
+    }
+    return true;
+}
+}// namespace tile
diff --git a/tile/base/encoding/percent.h b/tile/base/encoding/percent.h
index cd9343d..f029a8b 100644
--- a/tile/base/encoding/percent.h
+++ b/tile/base/encoding/percent.h
@@ -9,32 +9,28 @@
 
 namespace tile {
 enum class PercentEncodingStyle {
-  Ecma262 = 0,
-  Rfc3986 = 1,
-  Rfc5987 = 2,
+    Ecma262 = 0,
+    Rfc3986 = 1,
+    Rfc5987 = 2,
 };
 
 struct PercentEncodingOptions {
-  PercentEncodingStyle style = PercentEncodingStyle::Rfc3986;
-  bool escape_reserved = true;
+    PercentEncodingStyle style = PercentEncodingStyle::Rfc3986;
+    bool escape_reserved       = true;
 
-  PercentEncodingOptions(PercentEncodingStyle s = PercentEncodingStyle::Rfc3986,
-                         bool escape_reserved = true);
+    PercentEncodingOptions(PercentEncodingStyle s = PercentEncodingStyle::Rfc3986, bool escape_reserved = true);
 };
 
 std::string
 EncodePercent(Slice from,
-              const PercentEncodingOptions &options =
-                  internal::EarlyInitConstant<PercentEncodingOptions>());
-std::optional<std::string>
-DecodePercent(Slice from, bool decode_plus_sign_as_whitespace = false);
+              const PercentEncodingOptions &options = internal::EarlyInitConstant<PercentEncodingOptions>());
+std::optional<std::string> DecodePercent(Slice from, bool decode_plus_sign_as_whitespace = false);
 
-void EncodePercent(Slice from, std::string *to,
-                   const PercentEncodingOptions &options =
-                       internal::EarlyInitConstant<PercentEncodingOptions>());
-bool DecodePercent(Slice from, std::string *to,
-                   bool decode_plus_sign_as_whitespace = false);
+void EncodePercent(Slice from,
+                   std::string *to,
+                   const PercentEncodingOptions &options = internal::EarlyInitConstant<PercentEncodingOptions>());
+bool DecodePercent(Slice from, std::string *to, bool decode_plus_sign_as_whitespace = false);
 
-} // namespace tile
+}// namespace tile
 
-#endif // TILE_BASE_ENCODING_PERCENT_H
+#endif// TILE_BASE_ENCODING_PERCENT_H
diff --git a/tile/base/encoding/percent_test.cc b/tile/base/encoding/percent_test.cc
index 94edabe..488fc6a 100644
--- a/tile/base/encoding/percent_test.cc
+++ b/tile/base/encoding/percent_test.cc
@@ -6,103 +6,97 @@
 
 namespace tile {
 
-TEST(PercentEncoding, Emca262) {
-  // Shamelessly copied from:
-  //
-  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/encodeURIComponent
-  Slice set1 = ";,/?:@&=+$";  // Reserved Characters
-  Slice set2 = "-_.!~*'()";   // Unescaped Characters
-  Slice set3 = "#";           // Number Sign
-  Slice set4 = "ABC abc 123"; // Alphanumeric Characters + Space
+TEST(PercentEncoding, Emca262)
+{
+    // Shamelessly copied from:
+    //
+    // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/encodeURIComponent
+    Slice set1 = ";,/?:@&=+$"; // Reserved Characters
+    Slice set2 = "-_.!~*'()";  // Unescaped Characters
+    Slice set3 = "#";          // Number Sign
+    Slice set4 = "ABC abc 123";// Alphanumeric Characters + Space
 
-  // Reserved chars are escaped.
-  const PercentEncodingOptions ecma262_reversed(PercentEncodingStyle::Ecma262,
-                                                true);
+    // Reserved chars are escaped.
+    const PercentEncodingOptions ecma262_reversed(PercentEncodingStyle::Ecma262, true);
 
-  EXPECT_EQ("%3B%2C%2F%3F%3A%40%26%3D%2B%24",
-            EncodePercent(set1, ecma262_reversed));
-  EXPECT_EQ("-_.!~*'()", EncodePercent(set2, ecma262_reversed));
-  EXPECT_EQ("%23", EncodePercent(set3, ecma262_reversed));
-  EXPECT_EQ("ABC%20abc%20123", EncodePercent(set4, ecma262_reversed));
+    EXPECT_EQ("%3B%2C%2F%3F%3A%40%26%3D%2B%24", EncodePercent(set1, ecma262_reversed));
+    EXPECT_EQ("-_.!~*'()", EncodePercent(set2, ecma262_reversed));
+    EXPECT_EQ("%23", EncodePercent(set3, ecma262_reversed));
+    EXPECT_EQ("ABC%20abc%20123", EncodePercent(set4, ecma262_reversed));
 
-  EXPECT_EQ(set1, DecodePercent("%3B%2C%2F%3F%3A%40%26%3D%2B%24"));
-  EXPECT_EQ(set2, DecodePercent("-_.!~*'()"));
-  EXPECT_EQ(set3, DecodePercent("%23"));
-  EXPECT_EQ(set4, DecodePercent("ABC%20abc%20123"));
+    EXPECT_EQ(set1, DecodePercent("%3B%2C%2F%3F%3A%40%26%3D%2B%24"));
+    EXPECT_EQ(set2, DecodePercent("-_.!~*'()"));
+    EXPECT_EQ(set3, DecodePercent("%23"));
+    EXPECT_EQ(set4, DecodePercent("ABC%20abc%20123"));
 
-  // Reserved chars are kept.
-  const PercentEncodingOptions ecma262(PercentEncodingStyle::Ecma262, false);
-  EXPECT_EQ(";,/?:@&=+$", EncodePercent(set1, ecma262));
-  EXPECT_EQ("-_.!~*'()", EncodePercent(set2, ecma262));
-  EXPECT_EQ("#", EncodePercent(set3, ecma262));
-  EXPECT_EQ("ABC%20abc%20123", EncodePercent(set4, ecma262));
+    // Reserved chars are kept.
+    const PercentEncodingOptions ecma262(PercentEncodingStyle::Ecma262, false);
+    EXPECT_EQ(";,/?:@&=+$", EncodePercent(set1, ecma262));
+    EXPECT_EQ("-_.!~*'()", EncodePercent(set2, ecma262));
+    EXPECT_EQ("#", EncodePercent(set3, ecma262));
+    EXPECT_EQ("ABC%20abc%20123", EncodePercent(set4, ecma262));
 
-  EXPECT_EQ(set1, DecodePercent(";,/?:@&=+$"));
-  EXPECT_EQ(set2, DecodePercent("-_.!~*'()"));
-  EXPECT_EQ(set3, DecodePercent("#"));
-  EXPECT_EQ(set4, DecodePercent("ABC%20abc%20123"));
+    EXPECT_EQ(set1, DecodePercent(";,/?:@&=+$"));
+    EXPECT_EQ(set2, DecodePercent("-_.!~*'()"));
+    EXPECT_EQ(set3, DecodePercent("#"));
+    EXPECT_EQ(set4, DecodePercent("ABC%20abc%20123"));
 }
 
-TEST(PercentEncoding, Rfc3986) {
-  Slice str = "_-,;:!?.'()[]@*/&#+=~$ABC abc 123";
+TEST(PercentEncoding, Rfc3986)
+{
+    Slice str = "_-,;:!?.'()[]@*/&#+=~$ABC abc 123";
 
-  const PercentEncodingOptions rfc3986_reversed(PercentEncodingStyle::Rfc3986,
-                                                true);
-  const PercentEncodingOptions rfc3986(PercentEncodingStyle::Rfc3986, false);
-  EXPECT_EQ(
-      "_-%2C%3B%3A%21%3F.%27%28%29%5B%5D%40%2A%2F%26%23%2B%3D~%24ABC%20abc%"
-      "20123",
-      EncodePercent(str, rfc3986_reversed));
-  EXPECT_EQ("_-,;:!?.'()[]@*/&#+=~$ABC%20abc%20123",
-            EncodePercent(str, rfc3986));
-  EXPECT_EQ(str,
-            DecodePercent("_-%2C%3B%3A%21%3F.%27%28%29%5B%5D%40%2A%2F%26%23%"
-                          "2B%3D~%24ABC%20abc%20123"));
-  EXPECT_EQ(str, DecodePercent("_-,;:!?.'()[]@*/&#+=~$ABC%20abc%20123"));
+    const PercentEncodingOptions rfc3986_reversed(PercentEncodingStyle::Rfc3986, true);
+    const PercentEncodingOptions rfc3986(PercentEncodingStyle::Rfc3986, false);
+    EXPECT_EQ("_-%2C%3B%3A%21%3F.%27%28%29%5B%5D%40%2A%2F%26%23%2B%3D~%24ABC%20abc%"
+              "20123",
+              EncodePercent(str, rfc3986_reversed));
+    EXPECT_EQ("_-,;:!?.'()[]@*/&#+=~$ABC%20abc%20123", EncodePercent(str, rfc3986));
+    EXPECT_EQ(str,
+              DecodePercent("_-%2C%3B%3A%21%3F.%27%28%29%5B%5D%40%2A%2F%26%23%"
+                            "2B%3D~%24ABC%20abc%20123"));
+    EXPECT_EQ(str, DecodePercent("_-,;:!?.'()[]@*/&#+=~$ABC%20abc%20123"));
 }
 
-TEST(PercentEncoding, Rfc5987) {
-  // `encodeRFC5987ValueChars from MDN does not seems quite right (in that it
-  // does escape `#` `$` ..., which is not required.):
-  //
-  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/encodeURIComponent
-  //
-  // auto encode_rfc5987_value_chars = [](Slice str) {
-  //   auto result =
-  //       EncodePercent(str, PercentEncodingOptions{.style =
-  //       PercentEncodingStyle::Ecma262});
-  //   result = Replace(result, "'", "%" + EncodeHex("'"));
-  //   result = Replace(result, "(", "%" + EncodeHex("("));
-  //   result = Replace(result, ")", "%" + EncodeHex(")"));
-  //   result = Replace(result, "*", "%" + EncodeHex("*"));
-  //   result = Replace(result, "%7C", "|");
-  //   result = Replace(result, "%60", "`");
-  //   result = Replace(result, "%5E", "^");
-  //   return result;
-  // };
-  //
-  // EXPECT_EQ(
-  //     encode_rfc5987_value_chars(str),
-  //     EncodePercent(str, PercentEncodingOptions{.style =
-  //     PercentEncodingStyle::Rfc5987}));
+TEST(PercentEncoding, Rfc5987)
+{
+    // `encodeRFC5987ValueChars from MDN does not seems quite right (in that it
+    // does escape `#` `$` ..., which is not required.):
+    //
+    // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/encodeURIComponent
+    //
+    // auto encode_rfc5987_value_chars = [](Slice str) {
+    //   auto result =
+    //       EncodePercent(str, PercentEncodingOptions{.style =
+    //       PercentEncodingStyle::Ecma262});
+    //   result = Replace(result, "'", "%" + EncodeHex("'"));
+    //   result = Replace(result, "(", "%" + EncodeHex("("));
+    //   result = Replace(result, ")", "%" + EncodeHex(")"));
+    //   result = Replace(result, "*", "%" + EncodeHex("*"));
+    //   result = Replace(result, "%7C", "|");
+    //   result = Replace(result, "%60", "`");
+    //   result = Replace(result, "%5E", "^");
+    //   return result;
+    // };
+    //
+    // EXPECT_EQ(
+    //     encode_rfc5987_value_chars(str),
+    //     EncodePercent(str, PercentEncodingOptions{.style =
+    //     PercentEncodingStyle::Rfc5987}));
 
-  const PercentEncodingOptions rfc5987(PercentEncodingStyle::Rfc5987, false);
-  const PercentEncodingOptions rfc5987_reversed(PercentEncodingStyle::Rfc5987,
-                                                true);
+    const PercentEncodingOptions rfc5987(PercentEncodingStyle::Rfc5987, false);
+    const PercentEncodingOptions rfc5987_reversed(PercentEncodingStyle::Rfc5987, true);
 
-  Slice str = "!123'-!#$&()*,./:;?@[]^_`|~+=ABC abc";
+    Slice str = "!123'-!#$&()*,./:;?@[]^_`|~+=ABC abc";
 
-  EXPECT_EQ("!123%27-!#$&%28%29%2A%2C.%2F%3A%3B%3F%40%5B%5D^_`|~+%3DABC%20abc",
-            EncodePercent(str, rfc5987));
-  EXPECT_EQ(
-      str,
-      DecodePercent(
-          "!123%27-!#$&%28%29%2A%2C.%2F%3A%3B%3F%40%5B%5D^_`|~+%3DABC%20abc"));
+    EXPECT_EQ("!123%27-!#$&%28%29%2A%2C.%2F%3A%3B%3F%40%5B%5D^_`|~+%3DABC%20abc", EncodePercent(str, rfc5987));
+    EXPECT_EQ(str, DecodePercent("!123%27-!#$&%28%29%2A%2C.%2F%3A%3B%3F%40%5B%5D^_`|~+%3DABC%20abc"));
 }
 
-TEST(PercentEncoding, DecodePlusSignAsWhitespace) {
-  EXPECT_EQ("a+b", DecodePercent("a+b"));
-  EXPECT_EQ("a b", DecodePercent("a+b", true));
+TEST(PercentEncoding, DecodePlusSignAsWhitespace)
+{
+    EXPECT_EQ("a+b", DecodePercent("a+b"));
+    EXPECT_EQ("a b", DecodePercent("a+b", true));
 }
 
-} // namespace tile
+}// namespace tile
diff --git a/tile/base/encoding_benchmark.cc b/tile/base/encoding_benchmark.cc
index e51f216..dcbd05d 100644
--- a/tile/base/encoding_benchmark.cc
+++ b/tile/base/encoding_benchmark.cc
@@ -7,77 +7,90 @@
 
 namespace tile {
 
-void Benchmark_Base64Encode(benchmark::State &state) {
-  std::string random_str;
-  std::string out;
-  while (state.KeepRunning()) {
-    state.PauseTiming();
-    testing::RandomString(&random_str);
-    state.ResumeTiming();
+void
+Benchmark_Base64Encode(benchmark::State &state)
+{
+    std::string random_str;
+    std::string out;
+    while (state.KeepRunning()) {
+        state.PauseTiming();
+        testing::RandomString(&random_str);
+        state.ResumeTiming();
 
-    EncodeBase64(random_str, &out);
-  }
-}
-void Benchmark_Base64Decode(benchmark::State &state) {
-  std::string random_str;
-  std::string base64;
-  std::string plain_text;
-  while (state.KeepRunning()) {
-    state.PauseTiming();
-    testing::RandomString(&random_str);
-    EncodeBase64(random_str, &base64);
-    state.ResumeTiming();
-
-    DecodeBase64(base64, &plain_text);
-  }
+        EncodeBase64(random_str, &out);
+    }
 }
 
-void Benchmark_PercentEncode(benchmark::State &state) {
-  std::string random_str;
-  std::string out;
-  while (state.KeepRunning()) {
-    state.PauseTiming();
-    testing::RandomString(&random_str);
-    state.ResumeTiming();
-    EncodeBase64(random_str, &out);
-  }
+void
+Benchmark_Base64Decode(benchmark::State &state)
+{
+    std::string random_str;
+    std::string base64;
+    std::string plain_text;
+    while (state.KeepRunning()) {
+        state.PauseTiming();
+        testing::RandomString(&random_str);
+        EncodeBase64(random_str, &base64);
+        state.ResumeTiming();
+
+        DecodeBase64(base64, &plain_text);
+    }
 }
 
-void Benchmark_PercentDecode(benchmark::State &state) {
-  std::string random_str;
-  std::string percent;
-  std::string plain_text;
-  while (state.KeepRunning()) {
-    state.PauseTiming();
-    testing::RandomString(&random_str);
-    EncodePercent(random_str, &percent);
-    state.ResumeTiming();
-    DecodePercent(percent, &plain_text);
-  }
+void
+Benchmark_PercentEncode(benchmark::State &state)
+{
+    std::string random_str;
+    std::string out;
+    while (state.KeepRunning()) {
+        state.PauseTiming();
+        testing::RandomString(&random_str);
+        state.ResumeTiming();
+        EncodeBase64(random_str, &out);
+    }
 }
 
-void Benchmark_HexEncode(benchmark::State &state) {
-  std::string random_str;
-  std::string percent;
-  while (state.KeepRunning()) {
-    state.PauseTiming();
-    testing::RandomString(&random_str);
-    state.ResumeTiming();
-    EncodeHex(random_str, &percent);
-  }
+void
+Benchmark_PercentDecode(benchmark::State &state)
+{
+    std::string random_str;
+    std::string percent;
+    std::string plain_text;
+    while (state.KeepRunning()) {
+        state.PauseTiming();
+        testing::RandomString(&random_str);
+        EncodePercent(random_str, &percent);
+        state.ResumeTiming();
+        DecodePercent(percent, &plain_text);
+    }
 }
 
-void Benchmark_HexDecode(benchmark::State &state) {
-  std::string random_str;
-  std::string percent;
-  std::string plain_text;
-  while (state.KeepRunning()) {
-    state.PauseTiming();
-    testing::RandomString(&random_str);
-    EncodeHex(random_str, &percent);
-    state.ResumeTiming();
-    DecodeHex(percent, &plain_text);
-  }
+void
+Benchmark_HexEncode(benchmark::State &state)
+{
+    std::string random_str;
+    std::string percent;
+    while (state.KeepRunning()) {
+        state.PauseTiming();
+        testing::RandomString(&random_str);
+        state.ResumeTiming();
+        EncodeHex(random_str, &percent);
+    }
+}
+
+void
+Benchmark_HexDecode(benchmark::State &state)
+{
+    std::string random_str;
+    std::string percent;
+    std::string plain_text;
+    while (state.KeepRunning()) {
+        state.PauseTiming();
+        testing::RandomString(&random_str);
+        EncodeHex(random_str, &percent);
+        state.ResumeTiming();
+        DecodeHex(percent, &plain_text);
+    }
 }
 
 BENCHMARK(Benchmark_Base64Encode);
@@ -86,4 +99,4 @@ BENCHMARK(Benchmark_PercentEncode);
 BENCHMARK(Benchmark_PercentDecode);
 BENCHMARK(Benchmark_HexEncode);
 BENCHMARK(Benchmark_HexDecode);
-} // namespace tile
+}// namespace tile
diff --git a/tile/base/enum.h b/tile/base/enum.h
index cc8de79..c55ba51 100644
--- a/tile/base/enum.h
+++ b/tile/base/enum.h
@@ -6,35 +6,33 @@
 #include "tile/base/internal/meta.h"
 
 namespace tile {
-template <class T, class = enable_if_t<std::is_enum<T>::value>>
-constexpr auto underlying_value(T v) -> typename std::underlying_type<T>::type {
-  return static_cast<typename std::underlying_type<T>::type>(v);
+template<class T, class = enable_if_t<std::is_enum<T>::value>>
+constexpr auto
+underlying_value(T v) -> typename std::underlying_type<T>::type
+{
+    return static_cast<typename std::underlying_type<T>::type>(v);
 }
 
-#define TILE_DEFINE_ENUM_BITMASK_BINARY_OP(Type, Op)                           \
-  constexpr Type operator Op(Type left, Type right) {                          \
-    return static_cast<Type>(::tile::underlying_value(left)                    \
-                                 Op ::tile::underlying_value(right));          \
-  }
-#define TILE_DEFINE_ENUM_BITMASK_UNARY_OP(Type, Op)                            \
-  constexpr Type operator Op(Type v) {                                         \
-    return static_cast<Type>(Op ::tile::underlying_value(v));                  \
-  }
-#define TILE_DEFINE_ENUM_BITMASK_BINARY_ASSIGN_OP(Type, Op)                    \
-  constexpr Type &operator Op(Type & left, Type right) { return left Op right; }
+#define TILE_DEFINE_ENUM_BITMASK_BINARY_OP(Type, Op)                                                                   \
+    constexpr Type operator Op(Type left, Type right)                                                                  \
+    {                                                                                                                  \
+        return static_cast<Type>(::tile::underlying_value(left) Op ::tile::underlying_value(right));                   \
+    }
+#define TILE_DEFINE_ENUM_BITMASK_UNARY_OP(Type, Op)                                                                    \
+    constexpr Type operator Op(Type v) { return static_cast<Type>(Op ::tile::underlying_value(v)); }
+#define TILE_DEFINE_ENUM_BITMASK_BINARY_ASSIGN_OP(Type, Op)                                                            \
+    constexpr Type &operator Op(Type & left, Type right) { return left Op right; }
 
-#define TILE_DEFINE_ENUM_BITMASK_OPS(Type)                                     \
-  TILE_DEFINE_ENUM_BITMASK_BINARY_OP(Type, |)                                  \
-  TILE_DEFINE_ENUM_BITMASK_BINARY_OP(Type, &)                                  \
-  TILE_DEFINE_ENUM_BITMASK_BINARY_OP(Type, ^)                                  \
-  TILE_DEFINE_ENUM_BITMASK_BINARY_ASSIGN_OP(Type, |=)                          \
-  TILE_DEFINE_ENUM_BITMASK_BINARY_ASSIGN_OP(Type, &=)                          \
-  TILE_DEFINE_ENUM_BITMASK_BINARY_ASSIGN_OP(Type, ^=)                          \
-  TILE_DEFINE_ENUM_BITMASK_UNARY_OP(Type, ~)                                   \
-  constexpr bool operator!(Type value) {                                       \
-    return !::tile::underlying_value(value);                                   \
-  }
+#define TILE_DEFINE_ENUM_BITMASK_OPS(Type)                                                                             \
+    TILE_DEFINE_ENUM_BITMASK_BINARY_OP(Type, |)                                                                        \
+    TILE_DEFINE_ENUM_BITMASK_BINARY_OP(Type, &)                                                                        \
+    TILE_DEFINE_ENUM_BITMASK_BINARY_OP(Type, ^)                                                                        \
+    TILE_DEFINE_ENUM_BITMASK_BINARY_ASSIGN_OP(Type, |=)                                                                \
+    TILE_DEFINE_ENUM_BITMASK_BINARY_ASSIGN_OP(Type, &=)                                                                \
+    TILE_DEFINE_ENUM_BITMASK_BINARY_ASSIGN_OP(Type, ^=)                                                                \
+    TILE_DEFINE_ENUM_BITMASK_UNARY_OP(Type, ~)                                                                         \
+    constexpr bool operator!(Type value) { return !::tile::underlying_value(value); }
 
-} // namespace tile
+}// namespace tile
 
-#endif // _TILE_BASE_ENUM_H
+#endif// _TILE_BASE_ENUM_H
diff --git a/tile/base/erased_ptr.h b/tile/base/erased_ptr.h
index 878fd28..49cea40 100644
--- a/tile/base/erased_ptr.h
+++ b/tile/base/erased_ptr.h
@@ -12,58 +12,69 @@ namespace tile {
 // RAII wrapper ptr
 class ErasedPtr final {
 public:
-  using Deleter = void (*)(void *);
-  constexpr ErasedPtr(std::nullptr_t = nullptr)
-      : ptr_(nullptr), deleter_(nullptr) {}
-  template <typename T>
-  constexpr ErasedPtr(T *ptr) noexcept
-      : ptr_(ptr), deleter_([](void *ptr) { delete static_cast<T *>(ptr); }) {}
-  template <typename T, typename D>
-  constexpr ErasedPtr(T *ptr, D deleter) noexcept
-      : ptr_(ptr), deleter_(deleter) {}
-  ErasedPtr(ErasedPtr &&ptr) noexcept : ptr_(ptr.ptr_), deleter_(ptr.deleter_) {
-    ptr.ptr_ = nullptr;
-  }
+    using Deleter = void (*)(void *);
 
-  ErasedPtr &operator=(ErasedPtr &&ptr) noexcept {
-    if (TILE_LIKELY(this != &ptr)) {
-      Reset();
+    constexpr ErasedPtr(std::nullptr_t = nullptr) : ptr_(nullptr), deleter_(nullptr) {}
+
+    template<typename T>
+    constexpr ErasedPtr(T *ptr) noexcept
+        : ptr_(ptr),
+          deleter_([](void *ptr) { delete static_cast<T *>(ptr); })
+    {}
+
+    template<typename T, typename D>
+    constexpr ErasedPtr(T *ptr, D deleter) noexcept
+        : ptr_(ptr),
+          deleter_(deleter)
+    {}
+
+    ErasedPtr(ErasedPtr &&ptr) noexcept : ptr_(ptr.ptr_), deleter_(ptr.deleter_) { ptr.ptr_ = nullptr; }
+
+    ErasedPtr &operator=(ErasedPtr &&ptr) noexcept
+    {
+        if (TILE_LIKELY(this != &ptr)) { Reset(); }
+        return *this;
     }
-    return *this;
-  }
 
-  ErasedPtr(const ErasedPtr &) = delete;
-  ErasedPtr &operator=(const ErasedPtr &) = delete;
+    ErasedPtr(const ErasedPtr &)            = delete;
+    ErasedPtr &operator=(const ErasedPtr &) = delete;
 
-  ~ErasedPtr() {
-    if (ptr_) {
-      deleter_(ptr_);
+    ~ErasedPtr()
+    {
+        if (ptr_) { deleter_(ptr_); }
     }
-  }
 
-  constexpr void *Get() const noexcept { return ptr_; }
-  template <typename T> T *UncheckedGet() const noexcept {
-    return static_cast<T *>(ptr_);
-  }
-  constexpr explicit operator bool() const noexcept { return !!ptr_; }
-  void Reset(std::nullptr_t = nullptr) noexcept {
-    if (ptr_) {
-      deleter_(ptr_);
-      ptr_ = nullptr;
+    constexpr void *Get() const noexcept { return ptr_; }
+
+    template<typename T>
+    T *UncheckedGet() const noexcept
+    {
+        return static_cast<T *>(ptr_);
     }
-  }
-  TILE_NODISCARD void *Leak() noexcept {
-    void *rc = nullptr;
-    std::swap(rc, ptr_);
-    return rc;
-  }
 
-  constexpr Deleter GetDeleter() const noexcept { return deleter_; }
+    constexpr explicit operator bool() const noexcept { return !!ptr_; }
+
+    void Reset(std::nullptr_t = nullptr) noexcept
+    {
+        if (ptr_) {
+            deleter_(ptr_);
+            ptr_ = nullptr;
+        }
+    }
+
+    TILE_NODISCARD void *Leak() noexcept
+    {
+        void *rc = nullptr;
+        std::swap(rc, ptr_);
+        return rc;
+    }
+
+    constexpr Deleter GetDeleter() const noexcept { return deleter_; }
 
 private:
-  void *ptr_;
-  Deleter deleter_;
+    void *ptr_;
+    Deleter deleter_;
 };
-} // namespace tile
+}// namespace tile
 
-#endif // _TILE_BASE_ERASED_PTR_H
+#endif// _TILE_BASE_ERASED_PTR_H
diff --git a/tile/base/expected.h b/tile/base/expected.h
index c7057f4..eae217c 100644
--- a/tile/base/expected.h
+++ b/tile/base/expected.h
@@ -17,9 +17,9 @@
 #define expected_lite_MINOR 6
 #define expected_lite_PATCH 3
 
-#define expected_lite_VERSION                                                  \
-  expected_STRINGIFY(expected_lite_MAJOR) "." expected_STRINGIFY(              \
-      expected_lite_MINOR) "." expected_STRINGIFY(expected_lite_PATCH)
+#define expected_lite_VERSION                                                                                          \
+    expected_STRINGIFY(expected_lite_MAJOR) "." expected_STRINGIFY(expected_lite_MINOR) "." expected_STRINGIFY(        \
+        expected_lite_PATCH)
 
 #define expected_STRINGIFY(x) expected_STRINGIFY_(x)
 #define expected_STRINGIFY_(x) #x
@@ -45,8 +45,7 @@
 // expected selection and configuration:
 
 #if !defined(nsel_CONFIG_SELECT_EXPECTED)
-#define nsel_CONFIG_SELECT_EXPECTED                                            \
-  (nsel_HAVE_STD_EXPECTED ? nsel_EXPECTED_STD : nsel_EXPECTED_NONSTD)
+#define nsel_CONFIG_SELECT_EXPECTED (nsel_HAVE_STD_EXPECTED ? nsel_EXPECTED_STD : nsel_EXPECTED_NONSTD)
 #endif
 
 // Proposal revisions:
@@ -89,7 +88,7 @@
 
 #ifndef nsel_CONFIG_NO_EXCEPTIONS
 #if defined(_MSC_VER)
-#include <cstddef> // for _HAS_EXCEPTIONS
+#include <cstddef>// for _HAS_EXCEPTIONS
 #endif
 #if defined(__cpp_exceptions) || defined(__EXCEPTIONS) || (_HAS_EXCEPTIONS)
 #define nsel_CONFIG_NO_EXCEPTIONS 0
@@ -134,10 +133,9 @@
 #define nsel_HAVE_STD_EXPECTED 0
 #endif
 
-#define nsel_USES_STD_EXPECTED                                                 \
-  ((nsel_CONFIG_SELECT_EXPECTED == nsel_EXPECTED_STD) ||                       \
-   ((nsel_CONFIG_SELECT_EXPECTED == nsel_EXPECTED_DEFAULT) &&                  \
-    nsel_HAVE_STD_EXPECTED))
+#define nsel_USES_STD_EXPECTED                                                                                         \
+    ((nsel_CONFIG_SELECT_EXPECTED == nsel_EXPECTED_STD)                                                                \
+     || ((nsel_CONFIG_SELECT_EXPECTED == nsel_EXPECTED_DEFAULT) && nsel_HAVE_STD_EXPECTED))
 
 //
 // in_place: code duplicated in any-lite, expected-lite, expected-lite,
@@ -166,71 +164,74 @@ using std::in_place_type_t;
 #define nonstd_lite_in_place_type_t(T) std::in_place_type_t<T>
 #define nonstd_lite_in_place_index_t(K) std::in_place_index_t<K>
 
-#define nonstd_lite_in_place(T)                                                \
-  std::in_place_t {}
-#define nonstd_lite_in_place_type(T)                                           \
-  std::in_place_type_t<T> {}
-#define nonstd_lite_in_place_index(K)                                          \
-  std::in_place_index_t<K> {}
+#define nonstd_lite_in_place(T)                                                                                        \
+    std::in_place_t {}
+#define nonstd_lite_in_place_type(T)                                                                                   \
+    std::in_place_type_t<T> {}
+#define nonstd_lite_in_place_index(K)                                                                                  \
+    std::in_place_index_t<K> {}
 
-} // namespace nonstd
+}// namespace nonstd
 
-#else // nsel_CPP17_OR_GREATER
+#else// nsel_CPP17_OR_GREATER
 
 #include <cstddef>
 
 namespace nonstd {
 namespace detail {
 
-template <class T> struct in_place_type_tag {};
+template<class T>
+struct in_place_type_tag {};
 
-template <std::size_t K> struct in_place_index_tag {};
+template<std::size_t K>
+struct in_place_index_tag {};
 
-} // namespace detail
+}// namespace detail
 
 struct in_place_t {};
 
-template <class T>
+template<class T>
 inline in_place_t
-in_place(detail::in_place_type_tag<T> = detail::in_place_type_tag<T>()) {
-  return in_place_t();
+in_place(detail::in_place_type_tag<T> = detail::in_place_type_tag<T>())
+{
+    return in_place_t();
 }
 
-template <std::size_t K>
+template<std::size_t K>
 inline in_place_t
-in_place(detail::in_place_index_tag<K> = detail::in_place_index_tag<K>()) {
-  return in_place_t();
+in_place(detail::in_place_index_tag<K> = detail::in_place_index_tag<K>())
+{
+    return in_place_t();
 }
 
-template <class T>
+template<class T>
 inline in_place_t
-in_place_type(detail::in_place_type_tag<T> = detail::in_place_type_tag<T>()) {
-  return in_place_t();
+in_place_type(detail::in_place_type_tag<T> = detail::in_place_type_tag<T>())
+{
+    return in_place_t();
 }
 
-template <std::size_t K>
-inline in_place_t in_place_index(
-    detail::in_place_index_tag<K> = detail::in_place_index_tag<K>()) {
-  return in_place_t();
+template<std::size_t K>
+inline in_place_t
+in_place_index(detail::in_place_index_tag<K> = detail::in_place_index_tag<K>())
+{
+    return in_place_t();
 }
 
 // mimic templated typedef:
 
-#define nonstd_lite_in_place_t(T)                                              \
-  nonstd::in_place_t (&)(nonstd::detail::in_place_type_tag<T>)
-#define nonstd_lite_in_place_type_t(T)                                         \
-  nonstd::in_place_t (&)(nonstd::detail::in_place_type_tag<T>)
-#define nonstd_lite_in_place_index_t(K)                                        \
-  nonstd::in_place_t (&)(nonstd::detail::in_place_index_tag<K>)
+#define nonstd_lite_in_place_t(T) nonstd::in_place_t (&)(nonstd::detail::in_place_type_tag<T>)
+#define nonstd_lite_in_place_type_t(T) nonstd::in_place_t (&)(nonstd::detail::in_place_type_tag<T>)
+#define nonstd_lite_in_place_index_t(K) nonstd::in_place_t (&)(nonstd::detail::in_place_index_tag<K>)
 
 #define nonstd_lite_in_place(T) nonstd::in_place_type<T>
 #define nonstd_lite_in_place_type(T) nonstd::in_place_type<T>
 #define nonstd_lite_in_place_index(K) nonstd::in_place_index<K>
 
-} // namespace nonstd
+}// namespace nonstd
 
-#endif // nsel_CPP17_OR_GREATER
-#endif // nonstd_lite_HAVE_IN_PLACE_TYPES
+#endif// nsel_CPP17_OR_GREATER
+#endif// nonstd_lite_HAVE_IN_PLACE_TYPES
 
 //
 // Using std::expected:
@@ -244,9 +245,9 @@ namespace nonstd {
 
 using std::expected;
 //  ...
-} // namespace nonstd
+}// namespace nonstd
 
-#else // nsel_USES_STD_EXPECTED
+#else// nsel_USES_STD_EXPECTED
 
 #include <cassert>
 #include <exception>
@@ -262,7 +263,7 @@ using std::expected;
 
 #if nsel_CONFIG_NO_EXCEPTIONS
 #if nsel_CONFIG_NO_EXCEPTIONS_SEH
-#include <windows.h> // for ExceptionCodes
+#include <windows.h>// for ExceptionCodes
 #else
 // already included: <cassert>
 #endif
@@ -309,26 +310,22 @@ using std::expected;
 
 #if defined(_MSC_VER) && !defined(__clang__)
 #define nsel_COMPILER_MSVC_VER (_MSC_VER)
-#define nsel_COMPILER_MSVC_VERSION                                             \
-  (_MSC_VER / 10 - 10 * (5 + (_MSC_VER < 1900)))
+#define nsel_COMPILER_MSVC_VERSION (_MSC_VER / 10 - 10 * (5 + (_MSC_VER < 1900)))
 #else
 #define nsel_COMPILER_MSVC_VER 0
 #define nsel_COMPILER_MSVC_VERSION 0
 #endif
 
-#define nsel_COMPILER_VERSION(major, minor, patch)                             \
-  (10 * (10 * (major) + (minor)) + (patch))
+#define nsel_COMPILER_VERSION(major, minor, patch) (10 * (10 * (major) + (minor)) + (patch))
 
 #if defined(__clang__)
-#define nsel_COMPILER_CLANG_VERSION                                            \
-  nsel_COMPILER_VERSION(__clang_major__, __clang_minor__, __clang_patchlevel__)
+#define nsel_COMPILER_CLANG_VERSION nsel_COMPILER_VERSION(__clang_major__, __clang_minor__, __clang_patchlevel__)
 #else
 #define nsel_COMPILER_CLANG_VERSION 0
 #endif
 
 #if defined(__GNUC__) && !defined(__clang__)
-#define nsel_COMPILER_GNUC_VERSION                                             \
-  nsel_COMPILER_VERSION(__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__)
+#define nsel_COMPILER_GNUC_VERSION nsel_COMPILER_VERSION(__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__)
 #else
 #define nsel_COMPILER_GNUC_VERSION 0
 #endif
@@ -338,16 +335,13 @@ using std::expected;
 
 // Method enabling
 
-#define nsel_REQUIRES_0(...)                                                   \
-  template <bool B = (__VA_ARGS__), typename std::enable_if<B, int>::type = 0>
+#define nsel_REQUIRES_0(...) template<bool B = (__VA_ARGS__), typename std::enable_if<B, int>::type = 0>
 
-#define nsel_REQUIRES_T(...)                                                   \
-  , typename std::enable_if<(__VA_ARGS__), int>::type = 0
+#define nsel_REQUIRES_T(...) , typename std::enable_if<(__VA_ARGS__), int>::type = 0
 
 #define nsel_REQUIRES_R(R, ...) typename std::enable_if<(__VA_ARGS__), R>::type
 
-#define nsel_REQUIRES_A(...)                                                   \
-  , typename std::enable_if<(__VA_ARGS__), void *>::type = nullptr
+#define nsel_REQUIRES_A(...) , typename std::enable_if<(__VA_ARGS__), void *>::type = nullptr
 
 // Presence of language and library features:
 
@@ -366,7 +360,7 @@ using std::expected;
 #pragma clang diagnostic push
 #elif defined __GNUC__
 #pragma GCC diagnostic push
-#endif // __clang__
+#endif// __clang__
 
 #if nsel_COMPILER_MSVC_VERSION >= 140
 #pragma warning(push)
@@ -395,2643 +389,2478 @@ nsel_DISABLE_MSVC_WARNINGS(26409)
     // expected:
     //
 
-    namespace nonstd {
-  namespace expected_lite {
+    namespace nonstd
+{
+    namespace expected_lite {
 
-  // type traits C++17:
+    // type traits C++17:
 
-  namespace std17 {
+    namespace std17 {
 
 #if nsel_CPP17_OR_GREATER
 
-  using std::conjunction;
-  using std::is_nothrow_swappable;
-  using std::is_swappable;
+    using std::conjunction;
+    using std::is_nothrow_swappable;
+    using std::is_swappable;
 
-#else // nsel_CPP17_OR_GREATER
+#else// nsel_CPP17_OR_GREATER
 
-  namespace detail {
+    namespace detail {
 
-  using std::swap;
+    using std::swap;
 
-  struct is_swappable {
-    template <typename T, typename = decltype(swap(std::declval<T &>(),
-                                                   std::declval<T &>()))>
-    static std::true_type test(int /* unused */);
+    struct is_swappable {
+        template<typename T, typename = decltype(swap(std::declval<T &>(), std::declval<T &>()))>
+        static std::true_type test(int /* unused */);
 
-    template <typename> static std::false_type test(...);
-  };
+        template<typename>
+        static std::false_type test(...);
+    };
 
-  struct is_nothrow_swappable {
-    // wrap noexcept(expr) in separate function as work-around for VC140
-    // (VS2015):
+    struct is_nothrow_swappable {
+        // wrap noexcept(expr) in separate function as work-around for VC140
+        // (VS2015):
 
-    template <typename T> static constexpr bool satisfies() {
-      return noexcept(swap(std::declval<T &>(), std::declval<T &>()));
-    }
+        template<typename T>
+        static constexpr bool satisfies()
+        {
+            return noexcept(swap(std::declval<T &>(), std::declval<T &>()));
+        }
 
-    template <typename T>
-    static auto test(int) -> std::integral_constant<bool, satisfies<T>()> {}
+        template<typename T>
+        static auto test(int) -> std::integral_constant<bool, satisfies<T>()>
+        {}
 
-    template <typename> static auto test(...) -> std::false_type;
-  };
-  } // namespace detail
+        template<typename>
+        static auto test(...) -> std::false_type;
+    };
+    }// namespace detail
 
-  // is [nothrow] swappable:
+    // is [nothrow] swappable:
 
-  template <typename T>
-  struct is_swappable : decltype(detail::is_swappable::test<T>(0)) {};
+    template<typename T>
+    struct is_swappable : decltype(detail::is_swappable::test<T>(0)) {};
 
-  template <typename T>
-  struct is_nothrow_swappable
-      : decltype(detail::is_nothrow_swappable::test<T>(0)) {};
+    template<typename T>
+    struct is_nothrow_swappable : decltype(detail::is_nothrow_swappable::test<T>(0)) {};
 
-  // conjunction:
+    // conjunction:
 
-  template <typename...> struct conjunction : std::true_type {};
-  template <typename B1> struct conjunction<B1> : B1 {};
+    template<typename...>
+    struct conjunction : std::true_type {};
 
-  template <typename B1, typename... Bn>
-  struct conjunction<B1, Bn...>
-      : std::conditional<bool(B1::value), conjunction<Bn...>, B1>::type {};
+    template<typename B1>
+    struct conjunction<B1> : B1 {};
 
-#endif // nsel_CPP17_OR_GREATER
+    template<typename B1, typename... Bn>
+    struct conjunction<B1, Bn...> : std::conditional<bool(B1::value), conjunction<Bn...>, B1>::type {};
 
-  } // namespace std17
+#endif// nsel_CPP17_OR_GREATER
 
-  // type traits C++20:
+    }// namespace std17
 
-  namespace std20 {
+    // type traits C++20:
+
+    namespace std20 {
 
 #if defined(__cpp_lib_remove_cvref)
 
-  using std::remove_cvref;
+    using std::remove_cvref;
 
 #else
 
-  template <typename T> struct remove_cvref {
-    typedef
-        typename std::remove_cv<typename std::remove_reference<T>::type>::type
-            type;
-  };
+    template<typename T>
+    struct remove_cvref {
+        typedef typename std::remove_cv<typename std::remove_reference<T>::type>::type type;
+    };
 
 #endif
 
-  } // namespace std20
+    }// namespace std20
 
-  // forward declaration:
+    // forward declaration:
 
-  template <typename T, typename E> class expected;
+    template<typename T, typename E>
+    class expected;
 
-  namespace detail {
+    namespace detail {
 
 #if nsel_P2505R >= 3
-  template <typename T> struct is_expected : std::false_type {};
+    template<typename T>
+    struct is_expected : std::false_type {};
 
-  template <typename T, typename E>
-  struct is_expected<expected<T, E>> : std::true_type {};
-#endif // nsel_P2505R >= 3
+    template<typename T, typename E>
+    struct is_expected<expected<T, E>> : std::true_type {};
+#endif// nsel_P2505R >= 3
 
-  /// discriminated union to hold value or 'error'.
+    /// discriminated union to hold value or 'error'.
 
-  template <typename T, typename E> class storage_t_noncopy_nonmove_impl {
-    template <typename, typename> friend class nonstd::expected_lite::expected;
+    template<typename T, typename E>
+    class storage_t_noncopy_nonmove_impl {
+        template<typename, typename>
+        friend class nonstd::expected_lite::expected;
 
-  public:
-    using value_type = T;
-    using error_type = E;
+    public:
+        using value_type = T;
+        using error_type = E;
 
-    // no-op construction
-    storage_t_noncopy_nonmove_impl() {}
-    ~storage_t_noncopy_nonmove_impl() {}
+        // no-op construction
+        storage_t_noncopy_nonmove_impl() {}
 
-    explicit storage_t_noncopy_nonmove_impl(bool has_value)
-        : m_has_value(has_value) {}
+        ~storage_t_noncopy_nonmove_impl() {}
 
-    void construct_value() { new (&m_value) value_type(); }
+        explicit storage_t_noncopy_nonmove_impl(bool has_value) : m_has_value(has_value) {}
 
-    // void construct_value( value_type const & e )
-    // {
-    //     new( &m_value ) value_type( e );
-    // }
+        void construct_value() { new (&m_value) value_type(); }
 
-    // void construct_value( value_type && e )
-    // {
-    //     new( &m_value ) value_type( std::move( e ) );
-    // }
+        // void construct_value( value_type const & e )
+        // {
+        //     new( &m_value ) value_type( e );
+        // }
 
-    template <class... Args> void emplace_value(Args &&...args) {
-      new (&m_value) value_type(std::forward<Args>(args)...);
-    }
+        // void construct_value( value_type && e )
+        // {
+        //     new( &m_value ) value_type( std::move( e ) );
+        // }
 
-    template <class U, class... Args>
-    void emplace_value(std::initializer_list<U> il, Args &&...args) {
-      new (&m_value) value_type(il, std::forward<Args>(args)...);
-    }
+        template<class... Args>
+        void emplace_value(Args &&...args)
+        {
+            new (&m_value) value_type(std::forward<Args>(args)...);
+        }
 
-    void destruct_value() { m_value.~value_type(); }
+        template<class U, class... Args>
+        void emplace_value(std::initializer_list<U> il, Args &&...args)
+        {
+            new (&m_value) value_type(il, std::forward<Args>(args)...);
+        }
 
-    // void construct_error( error_type const & e )
-    // {
-    //     // new( &m_error ) error_type( e );
-    // }
+        void destruct_value() { m_value.~value_type(); }
 
-    // void construct_error( error_type && e )
-    // {
-    //     // new( &m_error ) error_type( std::move( e ) );
-    // }
+        // void construct_error( error_type const & e )
+        // {
+        //     // new( &m_error ) error_type( e );
+        // }
 
-    template <class... Args> void emplace_error(Args &&...args) {
-      new (&m_error) error_type(std::forward<Args>(args)...);
-    }
+        // void construct_error( error_type && e )
+        // {
+        //     // new( &m_error ) error_type( std::move( e ) );
+        // }
 
-    template <class U, class... Args>
-    void emplace_error(std::initializer_list<U> il, Args &&...args) {
-      new (&m_error) error_type(il, std::forward<Args>(args)...);
-    }
+        template<class... Args>
+        void emplace_error(Args &&...args)
+        {
+            new (&m_error) error_type(std::forward<Args>(args)...);
+        }
 
-    void destruct_error() { m_error.~error_type(); }
+        template<class U, class... Args>
+        void emplace_error(std::initializer_list<U> il, Args &&...args)
+        {
+            new (&m_error) error_type(il, std::forward<Args>(args)...);
+        }
 
-    constexpr value_type const &value() const & { return m_value; }
+        void destruct_error() { m_error.~error_type(); }
 
-    value_type &value() & { return m_value; }
+        constexpr value_type const &value() const & { return m_value; }
 
-    constexpr value_type const &&value() const && { return std::move(m_value); }
+        value_type &value() & { return m_value; }
 
-    nsel_constexpr14 value_type &&value() && { return std::move(m_value); }
+        constexpr value_type const &&value() const && { return std::move(m_value); }
 
-    value_type const *value_ptr() const { return &m_value; }
+        nsel_constexpr14 value_type &&value() && { return std::move(m_value); }
 
-    value_type *value_ptr() { return &m_value; }
+        value_type const *value_ptr() const { return &m_value; }
 
-    error_type const &error() const & { return m_error; }
+        value_type *value_ptr() { return &m_value; }
 
-    error_type &error() & { return m_error; }
+        error_type const &error() const & { return m_error; }
 
-    constexpr error_type const &&error() const && { return std::move(m_error); }
+        error_type &error() & { return m_error; }
 
-    nsel_constexpr14 error_type &&error() && { return std::move(m_error); }
+        constexpr error_type const &&error() const && { return std::move(m_error); }
 
-    bool has_value() const { return m_has_value; }
+        nsel_constexpr14 error_type &&error() && { return std::move(m_error); }
 
-    void set_has_value(bool v) { m_has_value = v; }
+        bool has_value() const { return m_has_value; }
 
-  private:
-    union {
-      value_type m_value;
-      error_type m_error;
+        void set_has_value(bool v) { m_has_value = v; }
+
+    private:
+        union {
+            value_type m_value;
+            error_type m_error;
+        };
+
+        bool m_has_value = false;
     };
 
-    bool m_has_value = false;
-  };
+    template<typename T, typename E>
+    class storage_t_impl {
+        template<typename, typename>
+        friend class nonstd::expected_lite::expected;
 
-  template <typename T, typename E> class storage_t_impl {
-    template <typename, typename> friend class nonstd::expected_lite::expected;
+    public:
+        using value_type = T;
+        using error_type = E;
 
-  public:
-    using value_type = T;
-    using error_type = E;
+        // no-op construction
+        storage_t_impl() {}
 
-    // no-op construction
-    storage_t_impl() {}
-    ~storage_t_impl() {}
+        ~storage_t_impl() {}
 
-    explicit storage_t_impl(bool has_value) : m_has_value(has_value) {}
+        explicit storage_t_impl(bool has_value) : m_has_value(has_value) {}
 
-    void construct_value() { new (&m_value) value_type(); }
+        void construct_value() { new (&m_value) value_type(); }
 
-    void construct_value(value_type const &e) { new (&m_value) value_type(e); }
+        void construct_value(value_type const &e) { new (&m_value) value_type(e); }
 
-    void construct_value(value_type &&e) {
-      new (&m_value) value_type(std::move(e));
-    }
+        void construct_value(value_type &&e) { new (&m_value) value_type(std::move(e)); }
 
-    template <class... Args> void emplace_value(Args &&...args) {
-      new (&m_value) value_type(std::forward<Args>(args)...);
-    }
+        template<class... Args>
+        void emplace_value(Args &&...args)
+        {
+            new (&m_value) value_type(std::forward<Args>(args)...);
+        }
 
-    template <class U, class... Args>
-    void emplace_value(std::initializer_list<U> il, Args &&...args) {
-      new (&m_value) value_type(il, std::forward<Args>(args)...);
-    }
+        template<class U, class... Args>
+        void emplace_value(std::initializer_list<U> il, Args &&...args)
+        {
+            new (&m_value) value_type(il, std::forward<Args>(args)...);
+        }
 
-    void destruct_value() { m_value.~value_type(); }
+        void destruct_value() { m_value.~value_type(); }
 
-    void construct_error(error_type const &e) { new (&m_error) error_type(e); }
+        void construct_error(error_type const &e) { new (&m_error) error_type(e); }
 
-    void construct_error(error_type &&e) {
-      new (&m_error) error_type(std::move(e));
-    }
+        void construct_error(error_type &&e) { new (&m_error) error_type(std::move(e)); }
 
-    template <class... Args> void emplace_error(Args &&...args) {
-      new (&m_error) error_type(std::forward<Args>(args)...);
-    }
+        template<class... Args>
+        void emplace_error(Args &&...args)
+        {
+            new (&m_error) error_type(std::forward<Args>(args)...);
+        }
 
-    template <class U, class... Args>
-    void emplace_error(std::initializer_list<U> il, Args &&...args) {
-      new (&m_error) error_type(il, std::forward<Args>(args)...);
-    }
+        template<class U, class... Args>
+        void emplace_error(std::initializer_list<U> il, Args &&...args)
+        {
+            new (&m_error) error_type(il, std::forward<Args>(args)...);
+        }
 
-    void destruct_error() { m_error.~error_type(); }
+        void destruct_error() { m_error.~error_type(); }
 
-    constexpr value_type const &value() const & { return m_value; }
+        constexpr value_type const &value() const & { return m_value; }
 
-    value_type &value() & { return m_value; }
+        value_type &value() & { return m_value; }
 
-    constexpr value_type const &&value() const && { return std::move(m_value); }
+        constexpr value_type const &&value() const && { return std::move(m_value); }
 
-    nsel_constexpr14 value_type &&value() && { return std::move(m_value); }
+        nsel_constexpr14 value_type &&value() && { return std::move(m_value); }
 
-    value_type const *value_ptr() const { return &m_value; }
+        value_type const *value_ptr() const { return &m_value; }
 
-    value_type *value_ptr() { return &m_value; }
+        value_type *value_ptr() { return &m_value; }
 
-    error_type const &error() const & { return m_error; }
+        error_type const &error() const & { return m_error; }
 
-    error_type &error() & { return m_error; }
+        error_type &error() & { return m_error; }
 
-    constexpr error_type const &&error() const && { return std::move(m_error); }
+        constexpr error_type const &&error() const && { return std::move(m_error); }
 
-    nsel_constexpr14 error_type &&error() && { return std::move(m_error); }
+        nsel_constexpr14 error_type &&error() && { return std::move(m_error); }
 
-    bool has_value() const { return m_has_value; }
+        bool has_value() const { return m_has_value; }
 
-    void set_has_value(bool v) { m_has_value = v; }
+        void set_has_value(bool v) { m_has_value = v; }
 
-  private:
-    union {
-      value_type m_value;
-      error_type m_error;
+    private:
+        union {
+            value_type m_value;
+            error_type m_error;
+        };
+
+        bool m_has_value = false;
     };
 
-    bool m_has_value = false;
-  };
+    /// discriminated union to hold only 'error'.
 
-  /// discriminated union to hold only 'error'.
+    template<typename E>
+    struct storage_t_impl<void, E> {
+        template<typename, typename>
+        friend class nonstd::expected_lite::expected;
 
-  template <typename E> struct storage_t_impl<void, E> {
-    template <typename, typename> friend class nonstd::expected_lite::expected;
+    public:
+        using value_type = void;
+        using error_type = E;
 
-  public:
-    using value_type = void;
-    using error_type = E;
+        // no-op construction
+        storage_t_impl() {}
 
-    // no-op construction
-    storage_t_impl() {}
-    ~storage_t_impl() {}
+        ~storage_t_impl() {}
 
-    explicit storage_t_impl(bool has_value) : m_has_value(has_value) {}
+        explicit storage_t_impl(bool has_value) : m_has_value(has_value) {}
 
-    void construct_error(error_type const &e) { new (&m_error) error_type(e); }
+        void construct_error(error_type const &e) { new (&m_error) error_type(e); }
 
-    void construct_error(error_type &&e) {
-      new (&m_error) error_type(std::move(e));
-    }
+        void construct_error(error_type &&e) { new (&m_error) error_type(std::move(e)); }
 
-    template <class... Args> void emplace_error(Args &&...args) {
-      new (&m_error) error_type(std::forward<Args>(args)...);
-    }
+        template<class... Args>
+        void emplace_error(Args &&...args)
+        {
+            new (&m_error) error_type(std::forward<Args>(args)...);
+        }
 
-    template <class U, class... Args>
-    void emplace_error(std::initializer_list<U> il, Args &&...args) {
-      new (&m_error) error_type(il, std::forward<Args>(args)...);
-    }
+        template<class U, class... Args>
+        void emplace_error(std::initializer_list<U> il, Args &&...args)
+        {
+            new (&m_error) error_type(il, std::forward<Args>(args)...);
+        }
 
-    void destruct_error() { m_error.~error_type(); }
+        void destruct_error() { m_error.~error_type(); }
 
-    error_type const &error() const & { return m_error; }
+        error_type const &error() const & { return m_error; }
 
-    error_type &error() & { return m_error; }
+        error_type &error() & { return m_error; }
 
-    constexpr error_type const &&error() const && { return std::move(m_error); }
+        constexpr error_type const &&error() const && { return std::move(m_error); }
 
-    nsel_constexpr14 error_type &&error() && { return std::move(m_error); }
+        nsel_constexpr14 error_type &&error() && { return std::move(m_error); }
 
-    bool has_value() const { return m_has_value; }
+        bool has_value() const { return m_has_value; }
 
-    void set_has_value(bool v) { m_has_value = v; }
+        void set_has_value(bool v) { m_has_value = v; }
 
-  private:
-    union {
-      char m_dummy;
-      error_type m_error;
+    private:
+        union {
+            char m_dummy;
+            error_type m_error;
+        };
+
+        bool m_has_value = false;
     };
 
-    bool m_has_value = false;
-  };
+    template<typename T, typename E, bool isConstructable, bool isMoveable>
+    class storage_t {
+    public:
+    };
 
-  template <typename T, typename E, bool isConstructable, bool isMoveable>
-  class storage_t {
-  public:
-  };
+    template<typename T, typename E>
+    class storage_t<T, E, false, false> : public storage_t_noncopy_nonmove_impl<T, E> {
+    public:
+        storage_t()  = default;
+        ~storage_t() = default;
 
-  template <typename T, typename E>
-  class storage_t<T, E, false, false>
-      : public storage_t_noncopy_nonmove_impl<T, E> {
-  public:
-    storage_t() = default;
-    ~storage_t() = default;
+        explicit storage_t(bool has_value) : storage_t_noncopy_nonmove_impl<T, E>(has_value) {}
 
-    explicit storage_t(bool has_value)
-        : storage_t_noncopy_nonmove_impl<T, E>(has_value) {}
+        storage_t(storage_t const &other) = delete;
+        storage_t(storage_t &&other)      = delete;
+    };
 
-    storage_t(storage_t const &other) = delete;
-    storage_t(storage_t &&other) = delete;
-  };
+    template<typename T, typename E>
+    class storage_t<T, E, true, true> : public storage_t_impl<T, E> {
+    public:
+        storage_t()  = default;
+        ~storage_t() = default;
 
-  template <typename T, typename E>
-  class storage_t<T, E, true, true> : public storage_t_impl<T, E> {
-  public:
-    storage_t() = default;
-    ~storage_t() = default;
+        explicit storage_t(bool has_value) : storage_t_impl<T, E>(has_value) {}
 
-    explicit storage_t(bool has_value) : storage_t_impl<T, E>(has_value) {}
+        storage_t(storage_t const &other) : storage_t_impl<T, E>(other.has_value())
+        {
+            if (this->has_value())
+                this->construct_value(other.value());
+            else
+                this->construct_error(other.error());
+        }
 
-    storage_t(storage_t const &other)
-        : storage_t_impl<T, E>(other.has_value()) {
-      if (this->has_value())
-        this->construct_value(other.value());
-      else
-        this->construct_error(other.error());
-    }
+        storage_t(storage_t &&other) : storage_t_impl<T, E>(other.has_value())
+        {
+            if (this->has_value())
+                this->construct_value(std::move(other.value()));
+            else
+                this->construct_error(std::move(other.error()));
+        }
+    };
 
-    storage_t(storage_t &&other) : storage_t_impl<T, E>(other.has_value()) {
-      if (this->has_value())
-        this->construct_value(std::move(other.value()));
-      else
-        this->construct_error(std::move(other.error()));
-    }
-  };
+    template<typename E>
+    class storage_t<void, E, true, true> : public storage_t_impl<void, E> {
+    public:
+        storage_t()  = default;
+        ~storage_t() = default;
 
-  template <typename E>
-  class storage_t<void, E, true, true> : public storage_t_impl<void, E> {
-  public:
-    storage_t() = default;
-    ~storage_t() = default;
+        explicit storage_t(bool has_value) : storage_t_impl<void, E>(has_value) {}
 
-    explicit storage_t(bool has_value) : storage_t_impl<void, E>(has_value) {}
+        storage_t(storage_t const &other) : storage_t_impl<void, E>(other.has_value())
+        {
+            if (this->has_value())
+                ;
+            else
+                this->construct_error(other.error());
+        }
 
-    storage_t(storage_t const &other)
-        : storage_t_impl<void, E>(other.has_value()) {
-      if (this->has_value())
-        ;
-      else
-        this->construct_error(other.error());
-    }
+        storage_t(storage_t &&other) : storage_t_impl<void, E>(other.has_value())
+        {
+            if (this->has_value())
+                ;
+            else
+                this->construct_error(std::move(other.error()));
+        }
+    };
 
-    storage_t(storage_t &&other) : storage_t_impl<void, E>(other.has_value()) {
-      if (this->has_value())
-        ;
-      else
-        this->construct_error(std::move(other.error()));
-    }
-  };
+    template<typename T, typename E>
+    class storage_t<T, E, true, false> : public storage_t_impl<T, E> {
+    public:
+        storage_t()  = default;
+        ~storage_t() = default;
 
-  template <typename T, typename E>
-  class storage_t<T, E, true, false> : public storage_t_impl<T, E> {
-  public:
-    storage_t() = default;
-    ~storage_t() = default;
+        explicit storage_t(bool has_value) : storage_t_impl<T, E>(has_value) {}
 
-    explicit storage_t(bool has_value) : storage_t_impl<T, E>(has_value) {}
+        storage_t(storage_t const &other) : storage_t_impl<T, E>(other.has_value())
+        {
+            if (this->has_value())
+                this->construct_value(other.value());
+            else
+                this->construct_error(other.error());
+        }
 
-    storage_t(storage_t const &other)
-        : storage_t_impl<T, E>(other.has_value()) {
-      if (this->has_value())
-        this->construct_value(other.value());
-      else
-        this->construct_error(other.error());
-    }
+        storage_t(storage_t &&other) = delete;
+    };
 
-    storage_t(storage_t &&other) = delete;
-  };
+    template<typename E>
+    class storage_t<void, E, true, false> : public storage_t_impl<void, E> {
+    public:
+        storage_t()  = default;
+        ~storage_t() = default;
 
-  template <typename E>
-  class storage_t<void, E, true, false> : public storage_t_impl<void, E> {
-  public:
-    storage_t() = default;
-    ~storage_t() = default;
+        explicit storage_t(bool has_value) : storage_t_impl<void, E>(has_value) {}
 
-    explicit storage_t(bool has_value) : storage_t_impl<void, E>(has_value) {}
+        storage_t(storage_t const &other) : storage_t_impl<void, E>(other.has_value())
+        {
+            if (this->has_value())
+                ;
+            else
+                this->construct_error(other.error());
+        }
 
-    storage_t(storage_t const &other)
-        : storage_t_impl<void, E>(other.has_value()) {
-      if (this->has_value())
-        ;
-      else
-        this->construct_error(other.error());
-    }
+        storage_t(storage_t &&other) = delete;
+    };
 
-    storage_t(storage_t &&other) = delete;
-  };
+    template<typename T, typename E>
+    class storage_t<T, E, false, true> : public storage_t_impl<T, E> {
+    public:
+        storage_t()  = default;
+        ~storage_t() = default;
 
-  template <typename T, typename E>
-  class storage_t<T, E, false, true> : public storage_t_impl<T, E> {
-  public:
-    storage_t() = default;
-    ~storage_t() = default;
+        explicit storage_t(bool has_value) : storage_t_impl<T, E>(has_value) {}
 
-    explicit storage_t(bool has_value) : storage_t_impl<T, E>(has_value) {}
+        storage_t(storage_t const &other) = delete;
 
-    storage_t(storage_t const &other) = delete;
+        storage_t(storage_t &&other) : storage_t_impl<T, E>(other.has_value())
+        {
+            if (this->has_value())
+                this->construct_value(std::move(other.value()));
+            else
+                this->construct_error(std::move(other.error()));
+        }
+    };
 
-    storage_t(storage_t &&other) : storage_t_impl<T, E>(other.has_value()) {
-      if (this->has_value())
-        this->construct_value(std::move(other.value()));
-      else
-        this->construct_error(std::move(other.error()));
-    }
-  };
+    template<typename E>
+    class storage_t<void, E, false, true> : public storage_t_impl<void, E> {
+    public:
+        storage_t()  = default;
+        ~storage_t() = default;
 
-  template <typename E>
-  class storage_t<void, E, false, true> : public storage_t_impl<void, E> {
-  public:
-    storage_t() = default;
-    ~storage_t() = default;
+        explicit storage_t(bool has_value) : storage_t_impl<void, E>(has_value) {}
 
-    explicit storage_t(bool has_value) : storage_t_impl<void, E>(has_value) {}
+        storage_t(storage_t const &other) = delete;
 
-    storage_t(storage_t const &other) = delete;
-
-    storage_t(storage_t &&other) : storage_t_impl<void, E>(other.has_value()) {
-      if (this->has_value())
-        ;
-      else
-        this->construct_error(std::move(other.error()));
-    }
-  };
+        storage_t(storage_t &&other) : storage_t_impl<void, E>(other.has_value())
+        {
+            if (this->has_value())
+                ;
+            else
+                this->construct_error(std::move(other.error()));
+        }
+    };
 
 #if nsel_P2505R >= 3
-  // C++11 invoke implementation
-  template <typename> struct is_reference_wrapper : std::false_type {};
-  template <typename T>
-  struct is_reference_wrapper<std::reference_wrapper<T>> : std::true_type {};
+    // C++11 invoke implementation
+    template<typename>
+    struct is_reference_wrapper : std::false_type {};
 
-  template <
-      typename FnT, typename ClassT, typename ObjectT,
-      typename... Args nsel_REQUIRES_T(
-          std::is_function<FnT>::value &&
-          (std::is_same<ClassT,
-                        typename std20::remove_cvref<ObjectT>::type>::value ||
-           std::is_base_of<
-               ClassT, typename std20::remove_cvref<ObjectT>::type>::value))>
-  nsel_constexpr auto invoke_member_function_impl(
-      FnT ClassT::*memfnptr, ObjectT &&obj,
-      Args &&...args) noexcept(noexcept((std::forward<ObjectT>(obj).*
-                                         memfnptr)(std::forward<Args>(
-      args)...))) -> decltype((std::forward<ObjectT>(obj).*
-                               memfnptr)(std::forward<Args>(args)...)) {
-    return (std::forward<ObjectT>(obj).*memfnptr)(std::forward<Args>(args)...);
-  }
+    template<typename T>
+    struct is_reference_wrapper<std::reference_wrapper<T>> : std::true_type {};
 
-  template <typename FnT, typename ClassT, typename ObjectT,
-            typename... Args nsel_REQUIRES_T(
-                std::is_function<FnT>::value &&is_reference_wrapper<
-                    typename std20::remove_cvref<ObjectT>::type>::value)>
-  nsel_constexpr auto
-  invoke_member_function_impl(FnT ClassT::*memfnptr, ObjectT &&obj,
-                              Args &&...args) noexcept(noexcept((obj.get().*
-                                                                 memfnptr)(
-      std::forward<Args>(args)...)))
-      -> decltype((obj.get().*memfnptr)(std::forward<Args>(args)...)) {
-    return (obj.get().*memfnptr)(std::forward<Args>(args)...);
-  }
+    template<typename FnT,
+             typename ClassT,
+             typename ObjectT,
+             typename... Args nsel_REQUIRES_T(
+                 std::is_function<FnT>::value
+                 && (std::is_same<ClassT, typename std20::remove_cvref<ObjectT>::type>::value
+                     || std::is_base_of<ClassT, typename std20::remove_cvref<ObjectT>::type>::value))>
+    nsel_constexpr auto invoke_member_function_impl(FnT ClassT::*memfnptr, ObjectT &&obj, Args &&...args) noexcept(
+        noexcept((std::forward<ObjectT>(obj).*memfnptr)(std::forward<Args>(args)...)))
+        -> decltype((std::forward<ObjectT>(obj).*memfnptr)(std::forward<Args>(args)...))
+    {
+        return (std::forward<ObjectT>(obj).*memfnptr)(std::forward<Args>(args)...);
+    }
 
-  template <
-      typename FnT, typename ClassT, typename ObjectT,
-      typename... Args nsel_REQUIRES_T(
-          std::is_function<FnT>::value &&
-          !std::is_same<ClassT,
-                        typename std20::remove_cvref<ObjectT>::type>::value &&
-          !std::is_base_of<
-              ClassT, typename std20::remove_cvref<ObjectT>::type>::value &&
-          !is_reference_wrapper<
-              typename std20::remove_cvref<ObjectT>::type>::value)>
-  nsel_constexpr auto invoke_member_function_impl(
-      FnT ClassT::*memfnptr, ObjectT &&obj,
-      Args &&...args) noexcept(noexcept(((*std::forward<ObjectT>(obj)).*
-                                         memfnptr)(std::forward<Args>(
-      args)...))) -> decltype(((*std::forward<ObjectT>(obj)).*
-                               memfnptr)(std::forward<Args>(args)...)) {
-    return ((*std::forward<ObjectT>(obj)).*
-            memfnptr)(std::forward<Args>(args)...);
-  }
+    template<typename FnT,
+             typename ClassT,
+             typename ObjectT,
+             typename... Args nsel_REQUIRES_T(std::is_function<FnT>::value &&is_reference_wrapper<
+                                              typename std20::remove_cvref<ObjectT>::type>::value)>
+    nsel_constexpr auto invoke_member_function_impl(FnT ClassT::*memfnptr, ObjectT &&obj, Args &&...args) noexcept(
+        noexcept((obj.get().*memfnptr)(std::forward<Args>(args)...)))
+        -> decltype((obj.get().*memfnptr)(std::forward<Args>(args)...))
+    {
+        return (obj.get().*memfnptr)(std::forward<Args>(args)...);
+    }
 
-  template <
-      typename MemberT, typename ClassT,
-      typename ObjectT nsel_REQUIRES_T(
-          std::is_same<ClassT,
-                       typename std20::remove_cvref<ObjectT>::type>::value ||
-          std::is_base_of<ClassT,
-                          typename std20::remove_cvref<ObjectT>::type>::value)>
-  nsel_constexpr auto
-  invoke_member_object_impl(MemberT ClassT::*memobjptr, ObjectT &&obj) noexcept(
-      noexcept(std::forward<ObjectT>(obj).*
-               memobjptr)) -> decltype(std::forward<ObjectT>(obj).*memobjptr) {
-    return std::forward<ObjectT>(obj).*memobjptr;
-  }
+    template<typename FnT,
+             typename ClassT,
+             typename ObjectT,
+             typename... Args nsel_REQUIRES_T(
+                 std::is_function<FnT>::value
+                 && !std::is_same<ClassT, typename std20::remove_cvref<ObjectT>::type>::value
+                 && !std::is_base_of<ClassT, typename std20::remove_cvref<ObjectT>::type>::value
+                 && !is_reference_wrapper<typename std20::remove_cvref<ObjectT>::type>::value)>
+    nsel_constexpr auto invoke_member_function_impl(FnT ClassT::*memfnptr, ObjectT &&obj, Args &&...args) noexcept(
+        noexcept(((*std::forward<ObjectT>(obj)).*memfnptr)(std::forward<Args>(args)...)))
+        -> decltype(((*std::forward<ObjectT>(obj)).*memfnptr)(std::forward<Args>(args)...))
+    {
+        return ((*std::forward<ObjectT>(obj)).*memfnptr)(std::forward<Args>(args)...);
+    }
 
-  template <typename MemberT, typename ClassT,
-            typename ObjectT nsel_REQUIRES_T(
-                is_reference_wrapper<
-                    typename std20::remove_cvref<ObjectT>::type>::value)>
-  nsel_constexpr auto
-  invoke_member_object_impl(MemberT ClassT::*memobjptr, ObjectT &&obj) noexcept(
-      noexcept(obj.get().*memobjptr)) -> decltype(obj.get().*memobjptr) {
-    return obj.get().*memobjptr;
-  }
+    template<typename MemberT,
+             typename ClassT,
+             typename ObjectT nsel_REQUIRES_T(
+                 std::is_same<ClassT, typename std20::remove_cvref<ObjectT>::type>::value
+                 || std::is_base_of<ClassT, typename std20::remove_cvref<ObjectT>::type>::value)>
+    nsel_constexpr auto invoke_member_object_impl(MemberT ClassT::*memobjptr, ObjectT &&obj) noexcept(
+        noexcept(std::forward<ObjectT>(obj).*memobjptr)) -> decltype(std::forward<ObjectT>(obj).*memobjptr)
+    {
+        return std::forward<ObjectT>(obj).*memobjptr;
+    }
 
-  template <
-      typename MemberT, typename ClassT,
-      typename ObjectT nsel_REQUIRES_T(
-          !std::is_same<ClassT,
-                        typename std20::remove_cvref<ObjectT>::type>::value &&
-          !std::is_base_of<
-              ClassT, typename std20::remove_cvref<ObjectT>::type>::value &&
-          !is_reference_wrapper<
-              typename std20::remove_cvref<ObjectT>::type>::value)>
-  nsel_constexpr auto
-  invoke_member_object_impl(MemberT ClassT::*memobjptr, ObjectT &&obj) noexcept(
-      noexcept((*std::forward<ObjectT>(obj)).*memobjptr))
-      -> decltype((*std::forward<ObjectT>(obj)).*memobjptr) {
-    return (*std::forward<ObjectT>(obj)).*memobjptr;
-  }
+    template<typename MemberT,
+             typename ClassT,
+             typename ObjectT nsel_REQUIRES_T(is_reference_wrapper<typename std20::remove_cvref<ObjectT>::type>::value)>
+    nsel_constexpr auto invoke_member_object_impl(MemberT ClassT::*memobjptr, ObjectT &&obj) noexcept(
+        noexcept(obj.get().*memobjptr)) -> decltype(obj.get().*memobjptr)
+    {
+        return obj.get().*memobjptr;
+    }
 
-  template <typename F, typename... Args nsel_REQUIRES_T(
-                            std::is_member_function_pointer<
-                                typename std20::remove_cvref<F>::type>::value)>
-  nsel_constexpr auto invoke(F &&f, Args &&...args) noexcept(
-      noexcept(invoke_member_function_impl(std::forward<F>(f),
-                                           std::forward<Args>(args)...)))
-      -> decltype(invoke_member_function_impl(std::forward<F>(f),
-                                              std::forward<Args>(args)...)) {
-    return invoke_member_function_impl(std::forward<F>(f),
-                                       std::forward<Args>(args)...);
-  }
+    template<typename MemberT,
+             typename ClassT,
+             typename ObjectT nsel_REQUIRES_T(
+                 !std::is_same<ClassT, typename std20::remove_cvref<ObjectT>::type>::value
+                 && !std::is_base_of<ClassT, typename std20::remove_cvref<ObjectT>::type>::value
+                 && !is_reference_wrapper<typename std20::remove_cvref<ObjectT>::type>::value)>
+    nsel_constexpr auto invoke_member_object_impl(MemberT ClassT::*memobjptr, ObjectT &&obj) noexcept(
+        noexcept((*std::forward<ObjectT>(obj)).*memobjptr)) -> decltype((*std::forward<ObjectT>(obj)).*memobjptr)
+    {
+        return (*std::forward<ObjectT>(obj)).*memobjptr;
+    }
 
-  template <typename F, typename... Args nsel_REQUIRES_T(
-                            std::is_member_object_pointer<
-                                typename std20::remove_cvref<F>::type>::value)>
-  nsel_constexpr auto invoke(F &&f, Args &&...args) noexcept(
-      noexcept(invoke_member_object_impl(std::forward<F>(f),
-                                         std::forward<Args>(args)...)))
-      -> decltype(invoke_member_object_impl(std::forward<F>(f),
-                                            std::forward<Args>(args)...)) {
-    return invoke_member_object_impl(std::forward<F>(f),
-                                     std::forward<Args>(args)...);
-  }
+    template<
+        typename F,
+        typename... Args nsel_REQUIRES_T(std::is_member_function_pointer<typename std20::remove_cvref<F>::type>::value)>
+    nsel_constexpr auto invoke(F &&f, Args &&...args) noexcept(
+        noexcept(invoke_member_function_impl(std::forward<F>(f), std::forward<Args>(args)...)))
+        -> decltype(invoke_member_function_impl(std::forward<F>(f), std::forward<Args>(args)...))
+    {
+        return invoke_member_function_impl(std::forward<F>(f), std::forward<Args>(args)...);
+    }
 
-  template <typename F, typename... Args nsel_REQUIRES_T(
-                            !std::is_member_function_pointer<
-                                typename std20::remove_cvref<F>::type>::value &&
-                            !std::is_member_object_pointer<
-                                typename std20::remove_cvref<F>::type>::value)>
-  nsel_constexpr auto invoke(F &&f, Args &&...args) noexcept(
-      noexcept(std::forward<F>(f)(std::forward<Args>(args)...)))
-      -> decltype(std::forward<F>(f)(std::forward<Args>(args)...)) {
-    return std::forward<F>(f)(std::forward<Args>(args)...);
-  }
+    template<
+        typename F,
+        typename... Args nsel_REQUIRES_T(std::is_member_object_pointer<typename std20::remove_cvref<F>::type>::value)>
+    nsel_constexpr auto invoke(F &&f, Args &&...args) noexcept(
+        noexcept(invoke_member_object_impl(std::forward<F>(f), std::forward<Args>(args)...)))
+        -> decltype(invoke_member_object_impl(std::forward<F>(f), std::forward<Args>(args)...))
+    {
+        return invoke_member_object_impl(std::forward<F>(f), std::forward<Args>(args)...);
+    }
 
-  template <typename F, typename... Args>
-  using invoke_result_nocvref_t = typename std20::remove_cvref<decltype(invoke(
-      std::declval<F>(), std::declval<Args>()...))>::type;
+    template<typename F,
+             typename... Args nsel_REQUIRES_T(
+                 !std::is_member_function_pointer<typename std20::remove_cvref<F>::type>::value
+                 && !std::is_member_object_pointer<typename std20::remove_cvref<F>::type>::value)>
+    nsel_constexpr auto invoke(F &&f, Args &&...args) noexcept(noexcept(
+        std::forward<F>(f)(std::forward<Args>(args)...))) -> decltype(std::forward<F>(f)(std::forward<Args>(args)...))
+    {
+        return std::forward<F>(f)(std::forward<Args>(args)...);
+    }
+
+    template<typename F, typename... Args>
+    using invoke_result_nocvref_t =
+        typename std20::remove_cvref<decltype(invoke(std::declval<F>(), std::declval<Args>()...))>::type;
 
 #if nsel_P2505R >= 5
-  template <typename F, typename... Args>
-  using transform_invoke_result_t = typename std::remove_cv<decltype(invoke(
-      std::declval<F>(), std::declval<Args>()...))>::type;
+    template<typename F, typename... Args>
+    using transform_invoke_result_t =
+        typename std::remove_cv<decltype(invoke(std::declval<F>(), std::declval<Args>()...))>::type;
 #else
-  template <typename F, typename... Args>
-  using transform_invoke_result_t = invoke_result_nocvref_t
-#endif // nsel_P2505R >= 5
+    template<typename F, typename... Args>
+    using transform_invoke_result_t = invoke_result_nocvref_t
+#endif// nsel_P2505R >= 5
 
-  template <typename T>
-  struct valid_expected_value_type
-      : std::integral_constant<bool, std::is_destructible<T>::value &&
-                                         !std::is_reference<T>::value &&
-                                         !std::is_array<T>::value> {};
+    template<typename T>
+    struct valid_expected_value_type
+        : std::integral_constant<bool,
+                                 std::is_destructible<T>::value && !std::is_reference<T>::value
+                                     && !std::is_array<T>::value> {};
 
-#endif // nsel_P2505R >= 3
-  } // namespace detail
+#endif// nsel_P2505R >= 3
+    }// namespace detail
 
-  /// x.x.5 Unexpected object type; unexpected_type; C++17 and later can also
-  /// use aliased type unexpected.
+    /// x.x.5 Unexpected object type; unexpected_type; C++17 and later can also
+    /// use aliased type unexpected.
 
 #if nsel_P0323R <= 2
-  template <typename E = std::exception_ptr>
-  class unexpected_type
+    template<typename E = std::exception_ptr>
+    class unexpected_type
 #else
-  template <typename E>
-  class unexpected_type
-#endif // nsel_P0323R
-  {
-  public:
-    using error_type = E;
+    template<typename E>
+    class unexpected_type
+#endif// nsel_P0323R
+    {
+    public:
+        using error_type = E;
 
-    // x.x.5.2.1 Constructors
+        // x.x.5.2.1 Constructors
 
-    //  unexpected_type() = delete;
+        //  unexpected_type() = delete;
 
-    constexpr unexpected_type(unexpected_type const &) = default;
-    constexpr unexpected_type(unexpected_type &&) = default;
+        constexpr unexpected_type(unexpected_type const &) = default;
+        constexpr unexpected_type(unexpected_type &&)      = default;
 
-    template <typename... Args nsel_REQUIRES_T(
-        std::is_constructible<E, Args &&...>::value)>
-    constexpr explicit unexpected_type(nonstd_lite_in_place_t(E),
-                                       Args &&...args)
-        : m_error(std::forward<Args>(args)...) {}
+        template<typename... Args nsel_REQUIRES_T(std::is_constructible<E, Args &&...>::value)>
+        constexpr explicit unexpected_type(nonstd_lite_in_place_t(E), Args &&...args)
+            : m_error(std::forward<Args>(args)...)
+        {}
 
-    template <typename U, typename... Args nsel_REQUIRES_T(
-                              std::is_constructible<E, std::initializer_list<U>,
-                                                    Args &&...>::value)>
-    constexpr explicit unexpected_type(nonstd_lite_in_place_t(E),
-                                       std::initializer_list<U> il,
-                                       Args &&...args)
-        : m_error(il, std::forward<Args>(args)...) {}
+        template<
+            typename U,
+            typename... Args nsel_REQUIRES_T(std::is_constructible<E, std::initializer_list<U>, Args &&...>::value)>
+        constexpr explicit unexpected_type(nonstd_lite_in_place_t(E), std::initializer_list<U> il, Args &&...args)
+            : m_error(il, std::forward<Args>(args)...)
+        {}
 
-    template <typename E2 nsel_REQUIRES_T(
-        std::is_constructible<E, E2>::value &&
-        !std::is_same<typename std20::remove_cvref<E2>::type,
-                      nonstd_lite_in_place_t(E2)>::value &&
-        !std::is_same<typename std20::remove_cvref<E2>::type,
-                      unexpected_type>::value)>
-    constexpr explicit unexpected_type(E2 &&error)
-        : m_error(std::forward<E2>(error)) {}
+        template<typename E2 nsel_REQUIRES_T(
+            std::is_constructible<E, E2>::value
+            && !std::is_same<typename std20::remove_cvref<E2>::type, nonstd_lite_in_place_t(E2)>::value
+            && !std::is_same<typename std20::remove_cvref<E2>::type, unexpected_type>::value)>
+        constexpr explicit unexpected_type(E2 &&error) : m_error(std::forward<E2>(error))
+        {}
 
-    template <typename E2 nsel_REQUIRES_T(
-        std::is_constructible<E, E2>::value &&
-        !std::is_constructible<E, unexpected_type<E2> &>::value &&
-        !std::is_constructible<E, unexpected_type<E2>>::value &&
-        !std::is_constructible<E, unexpected_type<E2> const &>::value &&
-        !std::is_constructible<E, unexpected_type<E2> const>::value &&
-        !std::is_convertible<unexpected_type<E2> &, E>::value &&
-        !std::is_convertible<unexpected_type<E2>, E>::value &&
-        !std::is_convertible<unexpected_type<E2> const &, E>::value &&
-        !std::is_convertible<unexpected_type<E2> const, E>::value &&
-        !std::is_convertible<E2 const &, E>::value /*=> explicit */
-        )>
-    constexpr explicit unexpected_type(unexpected_type<E2> const &error)
-        : m_error(E{error.value()}) {}
+        template<typename E2 nsel_REQUIRES_T(
+            std::is_constructible<E, E2>::value && !std::is_constructible<E, unexpected_type<E2> &>::value
+            && !std::is_constructible<E, unexpected_type<E2>>::value
+            && !std::is_constructible<E, unexpected_type<E2> const &>::value
+            && !std::is_constructible<E, unexpected_type<E2> const>::value
+            && !std::is_convertible<unexpected_type<E2> &, E>::value
+            && !std::is_convertible<unexpected_type<E2>, E>::value
+            && !std::is_convertible<unexpected_type<E2> const &, E>::value
+            && !std::is_convertible<unexpected_type<E2> const, E>::value
+            && !std::is_convertible<E2 const &, E>::value /*=> explicit */
+            )>
+        constexpr explicit unexpected_type(unexpected_type<E2> const &error) : m_error(E{error.value()})
+        {}
 
-    template <typename E2 nsel_REQUIRES_T(
-        std::is_constructible<E, E2>::value &&
-        !std::is_constructible<E, unexpected_type<E2> &>::value &&
-        !std::is_constructible<E, unexpected_type<E2>>::value &&
-        !std::is_constructible<E, unexpected_type<E2> const &>::value &&
-        !std::is_constructible<E, unexpected_type<E2> const>::value &&
-        !std::is_convertible<unexpected_type<E2> &, E>::value &&
-        !std::is_convertible<unexpected_type<E2>, E>::value &&
-        !std::is_convertible<unexpected_type<E2> const &, E>::value &&
-        !std::is_convertible<unexpected_type<E2> const, E>::value &&
-        std::is_convertible<E2 const &, E>::value /*=> explicit */
-        )>
-    constexpr /*non-explicit*/ unexpected_type(unexpected_type<E2> const &error)
-        : m_error(error.value()) {}
+        template<typename E2 nsel_REQUIRES_T(
+            std::is_constructible<E, E2>::value && !std::is_constructible<E, unexpected_type<E2> &>::value
+            && !std::is_constructible<E, unexpected_type<E2>>::value
+            && !std::is_constructible<E, unexpected_type<E2> const &>::value
+            && !std::is_constructible<E, unexpected_type<E2> const>::value
+            && !std::is_convertible<unexpected_type<E2> &, E>::value
+            && !std::is_convertible<unexpected_type<E2>, E>::value
+            && !std::is_convertible<unexpected_type<E2> const &, E>::value
+            && !std::is_convertible<unexpected_type<E2> const, E>::value
+            && std::is_convertible<E2 const &, E>::value /*=> explicit */
+            )>
+        constexpr /*non-explicit*/ unexpected_type(unexpected_type<E2> const &error) : m_error(error.value())
+        {}
 
-    template <typename E2 nsel_REQUIRES_T(
-        std::is_constructible<E, E2>::value &&
-        !std::is_constructible<E, unexpected_type<E2> &>::value &&
-        !std::is_constructible<E, unexpected_type<E2>>::value &&
-        !std::is_constructible<E, unexpected_type<E2> const &>::value &&
-        !std::is_constructible<E, unexpected_type<E2> const>::value &&
-        !std::is_convertible<unexpected_type<E2> &, E>::value &&
-        !std::is_convertible<unexpected_type<E2>, E>::value &&
-        !std::is_convertible<unexpected_type<E2> const &, E>::value &&
-        !std::is_convertible<unexpected_type<E2> const, E>::value &&
-        !std::is_convertible<E2 const &, E>::value /*=> explicit */
-        )>
-    constexpr explicit unexpected_type(unexpected_type<E2> &&error)
-        : m_error(E{std::move(error.value())}) {}
+        template<typename E2 nsel_REQUIRES_T(
+            std::is_constructible<E, E2>::value && !std::is_constructible<E, unexpected_type<E2> &>::value
+            && !std::is_constructible<E, unexpected_type<E2>>::value
+            && !std::is_constructible<E, unexpected_type<E2> const &>::value
+            && !std::is_constructible<E, unexpected_type<E2> const>::value
+            && !std::is_convertible<unexpected_type<E2> &, E>::value
+            && !std::is_convertible<unexpected_type<E2>, E>::value
+            && !std::is_convertible<unexpected_type<E2> const &, E>::value
+            && !std::is_convertible<unexpected_type<E2> const, E>::value
+            && !std::is_convertible<E2 const &, E>::value /*=> explicit */
+            )>
+        constexpr explicit unexpected_type(unexpected_type<E2> &&error) : m_error(E{std::move(error.value())})
+        {}
 
-    template <typename E2 nsel_REQUIRES_T(
-        std::is_constructible<E, E2>::value &&
-        !std::is_constructible<E, unexpected_type<E2> &>::value &&
-        !std::is_constructible<E, unexpected_type<E2>>::value &&
-        !std::is_constructible<E, unexpected_type<E2> const &>::value &&
-        !std::is_constructible<E, unexpected_type<E2> const>::value &&
-        !std::is_convertible<unexpected_type<E2> &, E>::value &&
-        !std::is_convertible<unexpected_type<E2>, E>::value &&
-        !std::is_convertible<unexpected_type<E2> const &, E>::value &&
-        !std::is_convertible<unexpected_type<E2> const, E>::value &&
-        std::is_convertible<E2 const &, E>::value /*=> non-explicit */
-        )>
-    constexpr /*non-explicit*/ unexpected_type(unexpected_type<E2> &&error)
-        : m_error(std::move(error.value())) {}
+        template<typename E2 nsel_REQUIRES_T(
+            std::is_constructible<E, E2>::value && !std::is_constructible<E, unexpected_type<E2> &>::value
+            && !std::is_constructible<E, unexpected_type<E2>>::value
+            && !std::is_constructible<E, unexpected_type<E2> const &>::value
+            && !std::is_constructible<E, unexpected_type<E2> const>::value
+            && !std::is_convertible<unexpected_type<E2> &, E>::value
+            && !std::is_convertible<unexpected_type<E2>, E>::value
+            && !std::is_convertible<unexpected_type<E2> const &, E>::value
+            && !std::is_convertible<unexpected_type<E2> const, E>::value
+            && std::is_convertible<E2 const &, E>::value /*=> non-explicit */
+            )>
+        constexpr /*non-explicit*/ unexpected_type(unexpected_type<E2> &&error) : m_error(std::move(error.value()))
+        {}
 
-    // x.x.5.2.2 Assignment
+        // x.x.5.2.2 Assignment
 
-    nsel_constexpr14 unexpected_type &
-    operator=(unexpected_type const &) = default;
-    nsel_constexpr14 unexpected_type &operator=(unexpected_type &&) = default;
+        nsel_constexpr14 unexpected_type &operator=(unexpected_type const &) = default;
+        nsel_constexpr14 unexpected_type &operator=(unexpected_type &&)      = default;
 
-    template <typename E2 = E>
-    nsel_constexpr14 unexpected_type &
-    operator=(unexpected_type<E2> const &other) {
-      unexpected_type{other.value()}.swap(*this);
-      return *this;
-    }
+        template<typename E2 = E>
+        nsel_constexpr14 unexpected_type &operator=(unexpected_type<E2> const &other)
+        {
+            unexpected_type{other.value()}.swap(*this);
+            return *this;
+        }
 
-    template <typename E2 = E>
-    nsel_constexpr14 unexpected_type &operator=(unexpected_type<E2> &&other) {
-      unexpected_type{std::move(other.value())}.swap(*this);
-      return *this;
-    }
+        template<typename E2 = E>
+        nsel_constexpr14 unexpected_type &operator=(unexpected_type<E2> &&other)
+        {
+            unexpected_type{std::move(other.value())}.swap(*this);
+            return *this;
+        }
 
-    // x.x.5.2.3 Observers
+        // x.x.5.2.3 Observers
 
-    nsel_constexpr14 E &value() & noexcept { return m_error; }
+        nsel_constexpr14 E &value() & noexcept { return m_error; }
 
-    constexpr E const &value() const & noexcept { return m_error; }
+        constexpr E const &value() const & noexcept { return m_error; }
 
 #if !nsel_COMPILER_GNUC_VERSION || nsel_COMPILER_GNUC_VERSION >= 490
 
-    nsel_constexpr14 E &&value() && noexcept { return std::move(m_error); }
+        nsel_constexpr14 E &&value() && noexcept { return std::move(m_error); }
 
-    constexpr E const &&value() const && noexcept { return std::move(m_error); }
+        constexpr E const &&value() const && noexcept { return std::move(m_error); }
 
 #endif
 
-    // x.x.5.2.4 Swap
+        // x.x.5.2.4 Swap
 
-    template <typename U = E>
-    nsel_REQUIRES_R(void, std17::is_swappable<U>::value)
-        swap(unexpected_type &other) noexcept(
-            std17::is_nothrow_swappable<U>::value) {
-      using std::swap;
-      swap(m_error, other.m_error);
-    }
+        template<typename U = E>
+        nsel_REQUIRES_R(void, std17::is_swappable<U>::value)
+            swap(unexpected_type &other) noexcept(std17::is_nothrow_swappable<U>::value)
+        {
+            using std::swap;
+            swap(m_error, other.m_error);
+        }
 
-    // TODO: ??? unexpected_type: in-class friend operator==, !=
+        // TODO: ??? unexpected_type: in-class friend operator==, !=
 
-  private:
-    error_type m_error;
-  };
+    private:
+        error_type m_error;
+    };
 
 #if nsel_CPP17_OR_GREATER
 
-  /// template deduction guide:
+    /// template deduction guide:
 
-  template <typename E> unexpected_type(E) -> unexpected_type<E>;
+    template<typename E>
+    unexpected_type(E) -> unexpected_type<E>;
 
 #endif
 
-  /// class unexpected_type, std::exception_ptr specialization (P0323R2)
+    /// class unexpected_type, std::exception_ptr specialization (P0323R2)
 
 #if !nsel_CONFIG_NO_EXCEPTIONS
 #if nsel_P0323R <= 2
 
-  // TODO: Should expected be specialized for particular E types such as
-  // exception_ptr and how?
-  //       See p0323r7 2.1. Ergonomics, http://wg21.link/p0323
-  template <> class unexpected_type<std::exception_ptr> {
-  public:
-    using error_type = std::exception_ptr;
+    // TODO: Should expected be specialized for particular E types such as
+    // exception_ptr and how?
+    //       See p0323r7 2.1. Ergonomics, http://wg21.link/p0323
+    template<>
+    class unexpected_type<std::exception_ptr> {
+    public:
+        using error_type  = std::exception_ptr;
 
-    unexpected_type() = delete;
+        unexpected_type() = delete;
 
-    ~unexpected_type() {}
+        ~unexpected_type() {}
 
-    explicit unexpected_type(std::exception_ptr const &error)
-        : m_error(error) {}
+        explicit unexpected_type(std::exception_ptr const &error) : m_error(error) {}
 
-    explicit unexpected_type(std::exception_ptr &&error)
-        : m_error(std::move(error)) {}
+        explicit unexpected_type(std::exception_ptr &&error) : m_error(std::move(error)) {}
 
-    template <typename E>
-    explicit unexpected_type(E error)
-        : m_error(std::make_exception_ptr(error)) {}
+        template<typename E>
+        explicit unexpected_type(E error) : m_error(std::make_exception_ptr(error))
+        {}
 
-    std::exception_ptr const &value() const { return m_error; }
+        std::exception_ptr const &value() const { return m_error; }
 
-    std::exception_ptr &value() { return m_error; }
+        std::exception_ptr &value() { return m_error; }
 
-  private:
-    std::exception_ptr m_error;
-  };
+    private:
+        std::exception_ptr m_error;
+    };
 
-#endif // nsel_P0323R
-#endif // !nsel_CONFIG_NO_EXCEPTIONS
+#endif// nsel_P0323R
+#endif// !nsel_CONFIG_NO_EXCEPTIONS
 
-  /// x.x.4, Unexpected equality operators
+    /// x.x.4, Unexpected equality operators
 
-  template <typename E1, typename E2>
-  constexpr bool operator==(unexpected_type<E1> const &x,
-                            unexpected_type<E2> const &y) {
-    return x.value() == y.value();
-  }
-
-  template <typename E1, typename E2>
-  constexpr bool operator!=(unexpected_type<E1> const &x,
-                            unexpected_type<E2> const &y) {
-    return !(x == y);
-  }
-
-#if nsel_P0323R <= 2
-
-  template <typename E>
-  constexpr bool operator<(unexpected_type<E> const &x,
-                           unexpected_type<E> const &y) {
-    return x.value() < y.value();
-  }
-
-  template <typename E>
-  constexpr bool operator>(unexpected_type<E> const &x,
-                           unexpected_type<E> const &y) {
-    return (y < x);
-  }
-
-  template <typename E>
-  constexpr bool operator<=(unexpected_type<E> const &x,
-                            unexpected_type<E> const &y) {
-    return !(y < x);
-  }
-
-  template <typename E>
-  constexpr bool operator>=(unexpected_type<E> const &x,
-                            unexpected_type<E> const &y) {
-    return !(x < y);
-  }
-
-#endif // nsel_P0323R
-
-  /// x.x.5 Specialized algorithms
-
-  template <typename E nsel_REQUIRES_T(std17::is_swappable<E>::value)>
-  void swap(unexpected_type<E> &x,
-            unexpected_type<E> &y) noexcept(noexcept(x.swap(y))) {
-    x.swap(y);
-  }
-
-#if nsel_P0323R <= 2
-
-  // unexpected: relational operators for std::exception_ptr:
-
-  inline constexpr bool
-  operator<(unexpected_type<std::exception_ptr> const & /*x*/,
-            unexpected_type<std::exception_ptr> const & /*y*/) {
-    return false;
-  }
-
-  inline constexpr bool
-  operator>(unexpected_type<std::exception_ptr> const & /*x*/,
-            unexpected_type<std::exception_ptr> const & /*y*/) {
-    return false;
-  }
-
-  inline constexpr bool
-  operator<=(unexpected_type<std::exception_ptr> const &x,
-             unexpected_type<std::exception_ptr> const &y) {
-    return (x == y);
-  }
-
-  inline constexpr bool
-  operator>=(unexpected_type<std::exception_ptr> const &x,
-             unexpected_type<std::exception_ptr> const &y) {
-    return (x == y);
-  }
-
-#endif // nsel_P0323R
-
-  // unexpected: traits
-
-#if nsel_P0323R <= 3
-
-  template <typename E> struct is_unexpected : std::false_type {};
-
-  template <typename E>
-  struct is_unexpected<unexpected_type<E>> : std::true_type {};
-
-#endif // nsel_P0323R
-
-  // unexpected: factory
-
-  // keep make_unexpected() removed in p0323r2 for pre-C++17:
-
-  template <typename E>
-  nsel_constexpr14 auto
-  make_unexpected(E &&value) -> unexpected_type<typename std::decay<E>::type> {
-    return unexpected_type<typename std::decay<E>::type>(
-        std::forward<E>(value));
-  }
-
-#if nsel_P0323R <= 3
-
-  /*nsel_constexpr14*/ auto inline make_unexpected_from_current_exception()
-      -> unexpected_type<std::exception_ptr> {
-    return unexpected_type<std::exception_ptr>(std::current_exception());
-  }
-
-#endif // nsel_P0323R
-
-  /// x.x.6, x.x.7 expected access error
-
-  template <typename E> class bad_expected_access;
-
-  /// x.x.7 bad_expected_access<void>: expected access error
-
-  template <> class bad_expected_access<void> : public std::exception {
-  public:
-    explicit bad_expected_access() : std::exception() {}
-  };
-
-  /// x.x.6 bad_expected_access: expected access error
-
-#if !nsel_CONFIG_NO_EXCEPTIONS
-
-  template <typename E>
-  class bad_expected_access : public bad_expected_access<void> {
-  public:
-    using error_type = E;
-
-    explicit bad_expected_access(error_type error) : m_error(error) {}
-
-    virtual char const *what() const noexcept override {
-      return "bad_expected_access";
+    template<typename E1, typename E2>
+    constexpr bool operator==(unexpected_type<E1> const &x, unexpected_type<E2> const &y)
+    {
+        return x.value() == y.value();
     }
 
-    nsel_constexpr14 error_type &error() & { return m_error; }
+    template<typename E1, typename E2>
+    constexpr bool operator!=(unexpected_type<E1> const &x, unexpected_type<E2> const &y)
+    {
+        return !(x == y);
+    }
 
-    constexpr error_type const &error() const & { return m_error; }
+#if nsel_P0323R <= 2
+
+    template<typename E>
+    constexpr bool operator<(unexpected_type<E> const &x, unexpected_type<E> const &y)
+    {
+        return x.value() < y.value();
+    }
+
+    template<typename E>
+    constexpr bool operator>(unexpected_type<E> const &x, unexpected_type<E> const &y)
+    {
+        return (y < x);
+    }
+
+    template<typename E>
+    constexpr bool operator<=(unexpected_type<E> const &x, unexpected_type<E> const &y)
+    {
+        return !(y < x);
+    }
+
+    template<typename E>
+    constexpr bool operator>=(unexpected_type<E> const &x, unexpected_type<E> const &y)
+    {
+        return !(x < y);
+    }
+
+#endif// nsel_P0323R
+
+    /// x.x.5 Specialized algorithms
+
+    template<typename E nsel_REQUIRES_T(std17::is_swappable<E>::value)>
+    void swap(unexpected_type<E> &x, unexpected_type<E> &y) noexcept(noexcept(x.swap(y)))
+    {
+        x.swap(y);
+    }
+
+#if nsel_P0323R <= 2
+
+    // unexpected: relational operators for std::exception_ptr:
+
+    inline constexpr bool operator<(unexpected_type<std::exception_ptr> const & /*x*/,
+                                    unexpected_type<std::exception_ptr> const & /*y*/)
+    {
+        return false;
+    }
+
+    inline constexpr bool operator>(unexpected_type<std::exception_ptr> const & /*x*/,
+                                    unexpected_type<std::exception_ptr> const & /*y*/)
+    {
+        return false;
+    }
+
+    inline constexpr bool operator<=(unexpected_type<std::exception_ptr> const &x,
+                                     unexpected_type<std::exception_ptr> const &y)
+    {
+        return (x == y);
+    }
+
+    inline constexpr bool operator>=(unexpected_type<std::exception_ptr> const &x,
+                                     unexpected_type<std::exception_ptr> const &y)
+    {
+        return (x == y);
+    }
+
+#endif// nsel_P0323R
+
+    // unexpected: traits
+
+#if nsel_P0323R <= 3
+
+    template<typename E>
+    struct is_unexpected : std::false_type {};
+
+    template<typename E>
+    struct is_unexpected<unexpected_type<E>> : std::true_type {};
+
+#endif// nsel_P0323R
+
+    // unexpected: factory
+
+    // keep make_unexpected() removed in p0323r2 for pre-C++17:
+
+    template<typename E>
+    nsel_constexpr14 auto make_unexpected(E &&value) -> unexpected_type<typename std::decay<E>::type>
+    {
+        return unexpected_type<typename std::decay<E>::type>(std::forward<E>(value));
+    }
+
+#if nsel_P0323R <= 3
+
+    /*nsel_constexpr14*/ auto inline make_unexpected_from_current_exception() -> unexpected_type<std::exception_ptr>
+    {
+        return unexpected_type<std::exception_ptr>(std::current_exception());
+    }
+
+#endif// nsel_P0323R
+
+    /// x.x.6, x.x.7 expected access error
+
+    template<typename E>
+    class bad_expected_access;
+
+    /// x.x.7 bad_expected_access<void>: expected access error
+
+    template<>
+    class bad_expected_access<void> : public std::exception {
+    public:
+        explicit bad_expected_access() : std::exception() {}
+    };
+
+    /// x.x.6 bad_expected_access: expected access error
+
+#if !nsel_CONFIG_NO_EXCEPTIONS
+
+    template<typename E>
+    class bad_expected_access : public bad_expected_access<void> {
+    public:
+        using error_type = E;
+
+        explicit bad_expected_access(error_type error) : m_error(error) {}
+
+        virtual char const *what() const noexcept override { return "bad_expected_access"; }
+
+        nsel_constexpr14 error_type &error() & { return m_error; }
+
+        constexpr error_type const &error() const & { return m_error; }
 
 #if !nsel_COMPILER_GNUC_VERSION || nsel_COMPILER_GNUC_VERSION >= 490
 
-    nsel_constexpr14 error_type &&error() && { return std::move(m_error); }
+        nsel_constexpr14 error_type &&error() && { return std::move(m_error); }
 
-    constexpr error_type const &&error() const && { return std::move(m_error); }
+        constexpr error_type const &&error() const && { return std::move(m_error); }
 
 #endif
 
-  private:
-    error_type m_error;
-  };
+    private:
+        error_type m_error;
+    };
 
-#endif // nsel_CONFIG_NO_EXCEPTIONS
+#endif// nsel_CONFIG_NO_EXCEPTIONS
 
-  /// x.x.8 unexpect tag, in_place_unexpected tag: construct an error
+    /// x.x.8 unexpect tag, in_place_unexpected tag: construct an error
 
-  struct unexpect_t {};
-  using in_place_unexpected_t = unexpect_t;
+    struct unexpect_t {};
 
-  nsel_inline17 constexpr unexpect_t unexpect{};
-  nsel_inline17 constexpr unexpect_t in_place_unexpected{};
+    using in_place_unexpected_t = unexpect_t;
 
-  /// class error_traits
+    nsel_inline17 constexpr unexpect_t unexpect{};
+    nsel_inline17 constexpr unexpect_t in_place_unexpected{};
+
+    /// class error_traits
 
 #if nsel_CONFIG_NO_EXCEPTIONS
 
-  namespace detail {
-  inline bool text(char const * /*text*/) { return true; }
-  } // namespace detail
+    namespace detail {
+    inline bool text(char const * /*text*/) { return true; }
+    }// namespace detail
 
-  template <typename Error> struct error_traits {
-    static void rethrow(Error const & /*e*/) {
+    template<typename Error>
+    struct error_traits {
+        static void rethrow(Error const & /*e*/)
+        {
 #if nsel_CONFIG_NO_EXCEPTIONS_SEH
-      RaiseException(EXCEPTION_ACCESS_VIOLATION, EXCEPTION_NONCONTINUABLE, 0,
-                     NULL);
+            RaiseException(EXCEPTION_ACCESS_VIOLATION, EXCEPTION_NONCONTINUABLE, 0, NULL);
 #else
-      assert(false && detail::text("throw bad_expected_access<Error>{ e };"));
+            assert(false && detail::text("throw bad_expected_access<Error>{ e };"));
 #endif
-    }
-  };
-
-  template <> struct error_traits<std::exception_ptr> {
-    static void rethrow(std::exception_ptr const & /*e*/) {
-#if nsel_CONFIG_NO_EXCEPTIONS_SEH
-      RaiseException(EXCEPTION_ACCESS_VIOLATION, EXCEPTION_NONCONTINUABLE, 0,
-                     NULL);
-#else
-      assert(
-          false &&
-          detail::text("throw bad_expected_access<std::exception_ptr>{ e };"));
-#endif
-    }
-  };
-
-  template <> struct error_traits<std::error_code> {
-    static void rethrow(std::error_code const & /*e*/) {
-#if nsel_CONFIG_NO_EXCEPTIONS_SEH
-      RaiseException(EXCEPTION_ACCESS_VIOLATION, EXCEPTION_NONCONTINUABLE, 0,
-                     NULL);
-#else
-      assert(false && detail::text("throw std::system_error( e );"));
-#endif
-    }
-  };
-
-#else // nsel_CONFIG_NO_EXCEPTIONS
-
-  template <typename Error> struct error_traits {
-    static void rethrow(Error const &e) { throw bad_expected_access<Error>{e}; }
-  };
-
-  template <> struct error_traits<std::exception_ptr> {
-    static void rethrow(std::exception_ptr const &e) {
-      std::rethrow_exception(e);
-    }
-  };
-
-  template <> struct error_traits<std::error_code> {
-    static void rethrow(std::error_code const &e) {
-      throw std::system_error(e);
-    }
-  };
-
-#endif // nsel_CONFIG_NO_EXCEPTIONS
-
-#if nsel_P2505R >= 3
-  namespace detail {
-
-  // from https://en.cppreference.com/w/cpp/utility/expected/unexpected:
-  // "the type of the unexpected value. The type must not be an array type, a
-  // non-object type, a specialization of std::unexpected, or a cv-qualified
-  // type."
-  template <typename T>
-  struct valid_unexpected_type
-      : std::integral_constant<
-            bool,
-            std::is_same<T, typename std20::remove_cvref<T>::type>::value &&
-                std::is_object<T>::value && !std::is_array<T>::value> {};
-
-  template <typename T>
-  struct valid_unexpected_type<unexpected_type<T>> : std::false_type {};
-
-  } // namespace detail
-#endif // nsel_P2505R >= 3
-
-  } // namespace expected_lite
-
-  // provide nonstd::unexpected_type:
-
-  using expected_lite::unexpected_type;
-
-  namespace expected_lite {
-
-  /// class expected
-
-#if nsel_P0323R <= 2
-  template <typename T, typename E = std::exception_ptr>
-  class expected
-#else
-  template <typename T, typename E>
-  class expected
-#endif // nsel_P0323R
-  {
-  private:
-    template <typename, typename> friend class expected;
-
-  public:
-    using value_type = T;
-    using error_type = E;
-    using unexpected_type = nonstd::unexpected_type<E>;
-
-    template <typename U> struct rebind {
-      using type = expected<U, error_type>;
+        }
     };
 
-    // x.x.4.1 constructors
+    template<>
+    struct error_traits<std::exception_ptr> {
+        static void rethrow(std::exception_ptr const & /*e*/)
+        {
+#if nsel_CONFIG_NO_EXCEPTIONS_SEH
+            RaiseException(EXCEPTION_ACCESS_VIOLATION, EXCEPTION_NONCONTINUABLE, 0, NULL);
+#else
+            assert(false && detail::text("throw bad_expected_access<std::exception_ptr>{ e };"));
+#endif
+        }
+    };
 
-    nsel_REQUIRES_0(std::is_default_constructible<T>::value) nsel_constexpr14
-        expected()
-        : contained(true) {
-      contained.construct_value();
-    }
+    template<>
+    struct error_traits<std::error_code> {
+        static void rethrow(std::error_code const & /*e*/)
+        {
+#if nsel_CONFIG_NO_EXCEPTIONS_SEH
+            RaiseException(EXCEPTION_ACCESS_VIOLATION, EXCEPTION_NONCONTINUABLE, 0, NULL);
+#else
+            assert(false && detail::text("throw std::system_error( e );"));
+#endif
+        }
+    };
 
-    nsel_constexpr14 expected(expected const &) = default;
-    nsel_constexpr14 expected(expected &&) = default;
+#else// nsel_CONFIG_NO_EXCEPTIONS
 
-    template <typename U,
-              typename G nsel_REQUIRES_T(
-                  std::is_constructible<T, U const &>::value
-                      &&std::is_constructible<E, G const &>::value &&
-                  !std::is_constructible<T, expected<U, G> &>::value &&
-                  !std::is_constructible<T, expected<U, G> &&>::value &&
-                  !std::is_constructible<T, expected<U, G> const &>::value &&
-                  !std::is_constructible<T, expected<U, G> const &&>::value &&
-                  !std::is_convertible<expected<U, G> &, T>::value &&
-                  !std::is_convertible<expected<U, G> &&, T>::value &&
-                  !std::is_convertible<expected<U, G> const &, T>::value &&
-                  !std::is_convertible<expected<U, G> const &&, T>::value &&
-                  (!std::is_convertible<U const &, T>::value ||
-                   !std::is_convertible<G const &, E>::value) /*=> explicit */
-                  )>
-    nsel_constexpr14 explicit expected(expected<U, G> const &other)
-        : contained(other.has_value()) {
-      if (has_value())
-        contained.construct_value(T{other.contained.value()});
-      else
-        contained.construct_error(E{other.contained.error()});
-    }
+    template<typename Error>
+    struct error_traits {
+        static void rethrow(Error const &e) { throw bad_expected_access<Error>{e}; }
+    };
 
-    template <typename U,
-              typename G nsel_REQUIRES_T(
-                  std::is_constructible<T, U const &>::value
-                      &&std::is_constructible<E, G const &>::value &&
-                  !std::is_constructible<T, expected<U, G> &>::value &&
-                  !std::is_constructible<T, expected<U, G> &&>::value &&
-                  !std::is_constructible<T, expected<U, G> const &>::value &&
-                  !std::is_constructible<T, expected<U, G> const &&>::value &&
-                  !std::is_convertible<expected<U, G> &, T>::value &&
-                  !std::is_convertible<expected<U, G> &&, T>::value &&
-                  !std::is_convertible<expected<U, G> const &, T>::value &&
-                  !std::is_convertible<expected<U, G> const &&, T>::value &&
-                  !(!std::is_convertible<U const &, T>::value ||
-                    !std::is_convertible<G const &, E>::value) /*=> non-explicit
-                                                                */
-                  )>
-    nsel_constexpr14 /*non-explicit*/ expected(expected<U, G> const &other)
-        : contained(other.has_value()) {
-      if (has_value())
-        contained.construct_value(other.contained.value());
-      else
-        contained.construct_error(other.contained.error());
-    }
+    template<>
+    struct error_traits<std::exception_ptr> {
+        static void rethrow(std::exception_ptr const &e) { std::rethrow_exception(e); }
+    };
 
-    template <typename U,
-              typename G nsel_REQUIRES_T(
-                  std::is_constructible<T, U>::value
-                      &&std::is_constructible<E, G>::value &&
-                  !std::is_constructible<T, expected<U, G> &>::value &&
-                  !std::is_constructible<T, expected<U, G> &&>::value &&
-                  !std::is_constructible<T, expected<U, G> const &>::value &&
-                  !std::is_constructible<T, expected<U, G> const &&>::value &&
-                  !std::is_convertible<expected<U, G> &, T>::value &&
-                  !std::is_convertible<expected<U, G> &&, T>::value &&
-                  !std::is_convertible<expected<U, G> const &, T>::value &&
-                  !std::is_convertible<expected<U, G> const &&, T>::value &&
-                  (!std::is_convertible<U, T>::value ||
-                   !std::is_convertible<G, E>::value) /*=> explicit */
-                  )>
-    nsel_constexpr14 explicit expected(expected<U, G> &&other)
-        : contained(other.has_value()) {
-      if (has_value())
-        contained.construct_value(T{std::move(other.contained.value())});
-      else
-        contained.construct_error(E{std::move(other.contained.error())});
-    }
+    template<>
+    struct error_traits<std::error_code> {
+        static void rethrow(std::error_code const &e) { throw std::system_error(e); }
+    };
 
-    template <typename U,
-              typename G nsel_REQUIRES_T(
-                  std::is_constructible<T, U>::value
-                      &&std::is_constructible<E, G>::value &&
-                  !std::is_constructible<T, expected<U, G> &>::value &&
-                  !std::is_constructible<T, expected<U, G> &&>::value &&
-                  !std::is_constructible<T, expected<U, G> const &>::value &&
-                  !std::is_constructible<T, expected<U, G> const &&>::value &&
-                  !std::is_convertible<expected<U, G> &, T>::value &&
-                  !std::is_convertible<expected<U, G> &&, T>::value &&
-                  !std::is_convertible<expected<U, G> const &, T>::value &&
-                  !std::is_convertible<expected<U, G> const &&, T>::value &&
-                  !(!std::is_convertible<U, T>::value ||
-                    !std::is_convertible<G, E>::value) /*=> non-explicit */
-                  )>
-    nsel_constexpr14 /*non-explicit*/ expected(expected<U, G> &&other)
-        : contained(other.has_value()) {
-      if (has_value())
-        contained.construct_value(std::move(other.contained.value()));
-      else
-        contained.construct_error(std::move(other.contained.error()));
-    }
+#endif// nsel_CONFIG_NO_EXCEPTIONS
 
-    template <
-        typename U = T nsel_REQUIRES_T(std::is_copy_constructible<U>::value)>
-    nsel_constexpr14 expected(value_type const &value) : contained(true) {
-      contained.construct_value(value);
-    }
+#if nsel_P2505R >= 3
+    namespace detail {
 
-    template <typename U = T nsel_REQUIRES_T(
-                  std::is_constructible<T, U &&>::value &&
-                  !std::is_same<typename std20::remove_cvref<U>::type,
-                                nonstd_lite_in_place_t(U)>::value &&
-                  !std::is_same<expected<T, E>,
-                                typename std20::remove_cvref<U>::type>::value &&
-                  !std::is_same<nonstd::unexpected_type<E>,
-                                typename std20::remove_cvref<U>::type>::value &&
-                  !std::is_convertible<U &&, T>::value /*=> explicit */
-                  )>
-    nsel_constexpr14 explicit expected(U &&value) noexcept(
-        std::is_nothrow_move_constructible<U>::value &&
-        std::is_nothrow_move_constructible<E>::value)
-        : contained(true) {
-      contained.construct_value(T{std::forward<U>(value)});
-    }
+    // from https://en.cppreference.com/w/cpp/utility/expected/unexpected:
+    // "the type of the unexpected value. The type must not be an array type, a
+    // non-object type, a specialization of std::unexpected, or a cv-qualified
+    // type."
+    template<typename T>
+    struct valid_unexpected_type
+        : std::integral_constant<bool,
+                                 std::is_same<T, typename std20::remove_cvref<T>::type>::value
+                                     && std::is_object<T>::value && !std::is_array<T>::value> {};
 
-    template <typename U = T nsel_REQUIRES_T(
-                  std::is_constructible<T, U &&>::value &&
-                  !std::is_same<typename std20::remove_cvref<U>::type,
-                                nonstd_lite_in_place_t(U)>::value &&
-                  !std::is_same<expected<T, E>,
-                                typename std20::remove_cvref<U>::type>::value &&
-                  !std::is_same<nonstd::unexpected_type<E>,
-                                typename std20::remove_cvref<U>::type>::value &&
-                  std::is_convertible<U &&, T>::value /*=> non-explicit */
-                  )>
-    nsel_constexpr14 /*non-explicit*/
-    expected(U &&value) noexcept(std::is_nothrow_move_constructible<U>::value &&
-                                 std::is_nothrow_move_constructible<E>::value)
-        : contained(true) {
-      contained.construct_value(std::forward<U>(value));
-    }
+    template<typename T>
+    struct valid_unexpected_type<unexpected_type<T>> : std::false_type {};
 
-    // construct error:
+    }// namespace detail
+#endif// nsel_P2505R >= 3
 
-    template <typename G = E nsel_REQUIRES_T(
-                  std::is_constructible<E, G const &>::value &&
-                  !std::is_convertible<G const &, E>::value /*=> explicit */
-                  )>
-    nsel_constexpr14 explicit expected(nonstd::unexpected_type<G> const &error)
-        : contained(false) {
-      contained.construct_error(E{error.value()});
-    }
+    }// namespace expected_lite
 
-    template <typename G = E nsel_REQUIRES_T(
-                  std::is_constructible<E, G const &>::value &&
-                      std::is_convertible<G const &, E>::value /*=> non-explicit
-                                                                */
-                  )>
-    nsel_constexpr14 /*non-explicit*/
-    expected(nonstd::unexpected_type<G> const &error)
-        : contained(false) {
-      contained.construct_error(error.value());
-    }
+    // provide nonstd::unexpected_type:
 
-    template <typename G = E nsel_REQUIRES_T(
-                  std::is_constructible<E, G &&>::value &&
-                  !std::is_convertible<G &&, E>::value /*=> explicit */
-                  )>
-    nsel_constexpr14 explicit expected(nonstd::unexpected_type<G> &&error)
-        : contained(false) {
-      contained.construct_error(E{std::move(error.value())});
-    }
+    using expected_lite::unexpected_type;
 
-    template <typename G = E nsel_REQUIRES_T(
-                  std::is_constructible<E, G &&>::value
-                      &&std::is_convertible<G &&, E>::value /*=> non-explicit */
-                  )>
-    nsel_constexpr14 /*non-explicit*/
-    expected(nonstd::unexpected_type<G> &&error)
-        : contained(false) {
-      contained.construct_error(std::move(error.value()));
-    }
+    namespace expected_lite {
 
-    // in-place construction, value
+    /// class expected
 
-    template <typename... Args nsel_REQUIRES_T(
-        std::is_constructible<T, Args &&...>::value)>
-    nsel_constexpr14 explicit expected(nonstd_lite_in_place_t(T),
-                                       Args &&...args)
-        : contained(true) {
-      contained.emplace_value(std::forward<Args>(args)...);
-    }
-
-    template <typename U, typename... Args nsel_REQUIRES_T(
-                              std::is_constructible<T, std::initializer_list<U>,
-                                                    Args &&...>::value)>
-    nsel_constexpr14 explicit expected(nonstd_lite_in_place_t(T),
-                                       std::initializer_list<U> il,
-                                       Args &&...args)
-        : contained(true) {
-      contained.emplace_value(il, std::forward<Args>(args)...);
-    }
-
-    // in-place construction, error
-
-    template <typename... Args nsel_REQUIRES_T(
-        std::is_constructible<E, Args &&...>::value)>
-    nsel_constexpr14 explicit expected(unexpect_t, Args &&...args)
-        : contained(false) {
-      contained.emplace_error(std::forward<Args>(args)...);
-    }
-
-    template <typename U, typename... Args nsel_REQUIRES_T(
-                              std::is_constructible<E, std::initializer_list<U>,
-                                                    Args &&...>::value)>
-    nsel_constexpr14 explicit expected(unexpect_t, std::initializer_list<U> il,
-                                       Args &&...args)
-        : contained(false) {
-      contained.emplace_error(il, std::forward<Args>(args)...);
-    }
-
-    // x.x.4.2 destructor
-
-    // TODO: ~expected: triviality
-    // Effects: If T is not cv void and is_trivially_destructible_v<T> is false
-    // and bool(*this), calls val.~T(). If is_trivially_destructible_v<E> is
-    // false and !bool(*this), calls unexpect.~unexpected<E>(). Remarks: If
-    // either T is cv void or is_trivially_destructible_v<T> is true, and
-    // is_trivially_destructible_v<E> is true, then this destructor shall be a
-    // trivial destructor.
-
-    ~expected() {
-      if (has_value())
-        contained.destruct_value();
-      else
-        contained.destruct_error();
-    }
-
-    // x.x.4.3 assignment
-
-    expected &operator=(expected const &other) {
-      expected(other).swap(*this);
-      return *this;
-    }
-
-    expected &operator=(expected &&other) noexcept(
-        std::is_nothrow_move_constructible<T>::value &&
-        std::is_nothrow_move_assignable<T>::value &&
-        std::is_nothrow_move_constructible<E>::value  // added for missing
-        && std::is_nothrow_move_assignable<E>::value) //   nothrow above
+#if nsel_P0323R <= 2
+    template<typename T, typename E = std::exception_ptr>
+    class expected
+#else
+    template<typename T, typename E>
+    class expected
+#endif// nsel_P0323R
     {
-      expected(std::move(other)).swap(*this);
-      return *this;
-    }
+    private:
+        template<typename, typename>
+        friend class expected;
 
-    template <typename U nsel_REQUIRES_T(
-        !std::is_same<expected<T, E>,
-                      typename std20::remove_cvref<U>::type>::value &&
-        std17::conjunction<std::is_scalar<T>,
-                           std::is_same<T, std::decay<U>>>::value &&
-        std::is_constructible<T, U>::value &&
-        std::is_assignable<T &, U>::value &&
-        std::is_nothrow_move_constructible<E>::value)>
-    expected &operator=(U &&value) {
-      expected(std::forward<U>(value)).swap(*this);
-      return *this;
-    }
+    public:
+        using value_type      = T;
+        using error_type      = E;
+        using unexpected_type = nonstd::unexpected_type<E>;
 
-    template <typename G = E nsel_REQUIRES_T(
-                  std::is_constructible<E, G const &>::value
-                      &&std::is_copy_constructible<G>::
-                          value // TODO: std::is_nothrow_copy_constructible<G>
-                              &&std::is_copy_assignable<G>::value)>
-    expected &operator=(nonstd::unexpected_type<G> const &error) {
-      expected(unexpect, error.value()).swap(*this);
-      return *this;
-    }
+        template<typename U>
+        struct rebind {
+            using type = expected<U, error_type>;
+        };
 
-    template <
-        typename G = E nsel_REQUIRES_T(
-            std::is_constructible<E, G &&>::value &&std::is_move_constructible<
-                G>::value // TODO: std::is_nothrow_move_constructible<G>
-                &&std::is_move_assignable<G>::value)>
-    expected &operator=(nonstd::unexpected_type<G> &&error) {
-      expected(unexpect, std::move(error.value())).swap(*this);
-      return *this;
-    }
+        // x.x.4.1 constructors
 
-    template <typename... Args nsel_REQUIRES_T(
-        std::is_nothrow_constructible<T, Args &&...>::value)>
-    value_type &emplace(Args &&...args) {
-      expected(nonstd_lite_in_place(T), std::forward<Args>(args)...)
-          .swap(*this);
-      return value();
-    }
+        nsel_REQUIRES_0(std::is_default_constructible<T>::value) nsel_constexpr14 expected() : contained(true)
+        {
+            contained.construct_value();
+        }
 
-    template <typename U,
-              typename... Args nsel_REQUIRES_T(
-                  std::is_nothrow_constructible<T, std::initializer_list<U> &,
-                                                Args &&...>::value)>
-    value_type &emplace(std::initializer_list<U> il, Args &&...args) {
-      expected(nonstd_lite_in_place(T), il, std::forward<Args>(args)...)
-          .swap(*this);
-      return value();
-    }
+        nsel_constexpr14 expected(expected const &) = default;
+        nsel_constexpr14 expected(expected &&)      = default;
 
-    // x.x.4.4 swap
+        template<typename U,
+                 typename G nsel_REQUIRES_T(
+                     std::is_constructible<T, U const &>::value &&std::is_constructible<E, G const &>::value
+                     && !std::is_constructible<T, expected<U, G> &>::value
+                     && !std::is_constructible<T, expected<U, G> &&>::value
+                     && !std::is_constructible<T, expected<U, G> const &>::value
+                     && !std::is_constructible<T, expected<U, G> const &&>::value
+                     && !std::is_convertible<expected<U, G> &, T>::value
+                     && !std::is_convertible<expected<U, G> &&, T>::value
+                     && !std::is_convertible<expected<U, G> const &, T>::value
+                     && !std::is_convertible<expected<U, G> const &&, T>::value
+                     && (!std::is_convertible<U const &, T>::value
+                         || !std::is_convertible<G const &, E>::value) /*=> explicit */
+                     )>
+        nsel_constexpr14 explicit expected(expected<U, G> const &other) : contained(other.has_value())
+        {
+            if (has_value())
+                contained.construct_value(T{other.contained.value()});
+            else
+                contained.construct_error(E{other.contained.error()});
+        }
 
-    template <typename U = T, typename G = E>
-    nsel_REQUIRES_R(
-        void, std17::is_swappable<U>::value &&std17::is_swappable<G>::value &&
-                  (std::is_move_constructible<U>::value ||
-                   std::is_move_constructible<G>::value))
-        swap(expected &other) noexcept(
-            std::is_nothrow_move_constructible<T>::value &&
-            std17::is_nothrow_swappable<T &>::value &&
-            std::is_nothrow_move_constructible<E>::value &&
-            std17::is_nothrow_swappable<E &>::value) {
-      using std::swap;
+        template<typename U,
+                 typename G nsel_REQUIRES_T(
+                     std::is_constructible<T, U const &>::value &&std::is_constructible<E, G const &>::value
+                     && !std::is_constructible<T, expected<U, G> &>::value
+                     && !std::is_constructible<T, expected<U, G> &&>::value
+                     && !std::is_constructible<T, expected<U, G> const &>::value
+                     && !std::is_constructible<T, expected<U, G> const &&>::value
+                     && !std::is_convertible<expected<U, G> &, T>::value
+                     && !std::is_convertible<expected<U, G> &&, T>::value
+                     && !std::is_convertible<expected<U, G> const &, T>::value
+                     && !std::is_convertible<expected<U, G> const &&, T>::value
+                     && !(!std::is_convertible<U const &, T>::value
+                          || !std::is_convertible<G const &, E>::value) /*=> non-explicit
+                                                                */
+                     )>
+        nsel_constexpr14 /*non-explicit*/ expected(expected<U, G> const &other) : contained(other.has_value())
+        {
+            if (has_value())
+                contained.construct_value(other.contained.value());
+            else
+                contained.construct_error(other.contained.error());
+        }
 
-      if (bool(*this) && bool(other)) {
-        swap(contained.value(), other.contained.value());
-      } else if (!bool(*this) && !bool(other)) {
-        swap(contained.error(), other.contained.error());
-      } else if (bool(*this) && !bool(other)) {
-        error_type t(std::move(other.error()));
-        other.contained.destruct_error();
-        other.contained.construct_value(std::move(contained.value()));
-        contained.destruct_value();
-        contained.construct_error(std::move(t));
-        bool has_value = contained.has_value();
-        bool other_has_value = other.has_value();
-        other.contained.set_has_value(has_value);
-        contained.set_has_value(other_has_value);
-      } else if (!bool(*this) && bool(other)) {
-        other.swap(*this);
-      }
-    }
+        template<typename U,
+                 typename G nsel_REQUIRES_T(
+                     std::is_constructible<T, U>::value &&std::is_constructible<E, G>::value
+                     && !std::is_constructible<T, expected<U, G> &>::value
+                     && !std::is_constructible<T, expected<U, G> &&>::value
+                     && !std::is_constructible<T, expected<U, G> const &>::value
+                     && !std::is_constructible<T, expected<U, G> const &&>::value
+                     && !std::is_convertible<expected<U, G> &, T>::value
+                     && !std::is_convertible<expected<U, G> &&, T>::value
+                     && !std::is_convertible<expected<U, G> const &, T>::value
+                     && !std::is_convertible<expected<U, G> const &&, T>::value
+                     && (!std::is_convertible<U, T>::value || !std::is_convertible<G, E>::value) /*=> explicit */
+                     )>
+        nsel_constexpr14 explicit expected(expected<U, G> &&other) : contained(other.has_value())
+        {
+            if (has_value())
+                contained.construct_value(T{std::move(other.contained.value())});
+            else
+                contained.construct_error(E{std::move(other.contained.error())});
+        }
 
-    // x.x.4.5 observers
+        template<typename U,
+                 typename G nsel_REQUIRES_T(
+                     std::is_constructible<T, U>::value &&std::is_constructible<E, G>::value
+                     && !std::is_constructible<T, expected<U, G> &>::value
+                     && !std::is_constructible<T, expected<U, G> &&>::value
+                     && !std::is_constructible<T, expected<U, G> const &>::value
+                     && !std::is_constructible<T, expected<U, G> const &&>::value
+                     && !std::is_convertible<expected<U, G> &, T>::value
+                     && !std::is_convertible<expected<U, G> &&, T>::value
+                     && !std::is_convertible<expected<U, G> const &, T>::value
+                     && !std::is_convertible<expected<U, G> const &&, T>::value
+                     && !(!std::is_convertible<U, T>::value || !std::is_convertible<G, E>::value) /*=> non-explicit */
+                     )>
+        nsel_constexpr14 /*non-explicit*/ expected(expected<U, G> &&other) : contained(other.has_value())
+        {
+            if (has_value())
+                contained.construct_value(std::move(other.contained.value()));
+            else
+                contained.construct_error(std::move(other.contained.error()));
+        }
 
-    constexpr value_type const *operator->() const {
-      return assert(has_value()), contained.value_ptr();
-    }
+        template<typename U = T nsel_REQUIRES_T(std::is_copy_constructible<U>::value)>
+        nsel_constexpr14 expected(value_type const &value) : contained(true)
+        {
+            contained.construct_value(value);
+        }
 
-    value_type *operator->() {
-      return assert(has_value()), contained.value_ptr();
-    }
+        template<typename U = T nsel_REQUIRES_T(
+                     std::is_constructible<T, U &&>::value
+                     && !std::is_same<typename std20::remove_cvref<U>::type, nonstd_lite_in_place_t(U)>::value
+                     && !std::is_same<expected<T, E>, typename std20::remove_cvref<U>::type>::value
+                     && !std::is_same<nonstd::unexpected_type<E>, typename std20::remove_cvref<U>::type>::value
+                     && !std::is_convertible<U &&, T>::value /*=> explicit */
+                     )>
+        nsel_constexpr14 explicit expected(U &&value) noexcept(std::is_nothrow_move_constructible<U>::value
+                                                               && std::is_nothrow_move_constructible<E>::value)
+            : contained(true)
+        {
+            contained.construct_value(T{std::forward<U>(value)});
+        }
 
-    constexpr value_type const &operator*() const & {
-      return assert(has_value()), contained.value();
-    }
+        template<typename U = T nsel_REQUIRES_T(
+                     std::is_constructible<T, U &&>::value
+                     && !std::is_same<typename std20::remove_cvref<U>::type, nonstd_lite_in_place_t(U)>::value
+                     && !std::is_same<expected<T, E>, typename std20::remove_cvref<U>::type>::value
+                     && !std::is_same<nonstd::unexpected_type<E>, typename std20::remove_cvref<U>::type>::value
+                     && std::is_convertible<U &&, T>::value /*=> non-explicit */
+                     )>
+        nsel_constexpr14 /*non-explicit*/
+        expected(U &&value) noexcept(std::is_nothrow_move_constructible<U>::value
+                                     && std::is_nothrow_move_constructible<E>::value)
+            : contained(true)
+        {
+            contained.construct_value(std::forward<U>(value));
+        }
 
-    value_type &operator*() & { return assert(has_value()), contained.value(); }
+        // construct error:
+
+        template<typename G = E nsel_REQUIRES_T(std::is_constructible<E, G const &>::value
+                                                && !std::is_convertible<G const &, E>::value /*=> explicit */
+                                                )>
+        nsel_constexpr14 explicit expected(nonstd::unexpected_type<G> const &error) : contained(false)
+        {
+            contained.construct_error(E{error.value()});
+        }
+
+        template<typename G = E nsel_REQUIRES_T(std::is_constructible<E, G const &>::value
+                                                    &&std::is_convertible<G const &, E>::value /*=> non-explicit
+                                                                */
+                                                )>
+        nsel_constexpr14 /*non-explicit*/
+        expected(nonstd::unexpected_type<G> const &error)
+            : contained(false)
+        {
+            contained.construct_error(error.value());
+        }
+
+        template<typename G = E nsel_REQUIRES_T(std::is_constructible<E, G &&>::value
+                                                && !std::is_convertible<G &&, E>::value /*=> explicit */
+                                                )>
+        nsel_constexpr14 explicit expected(nonstd::unexpected_type<G> &&error) : contained(false)
+        {
+            contained.construct_error(E{std::move(error.value())});
+        }
+
+        template<typename G = E nsel_REQUIRES_T(
+                     std::is_constructible<E, G &&>::value &&std::is_convertible<G &&, E>::value /*=> non-explicit */
+                     )>
+        nsel_constexpr14 /*non-explicit*/
+        expected(nonstd::unexpected_type<G> &&error)
+            : contained(false)
+        {
+            contained.construct_error(std::move(error.value()));
+        }
+
+        // in-place construction, value
+
+        template<typename... Args nsel_REQUIRES_T(std::is_constructible<T, Args &&...>::value)>
+        nsel_constexpr14 explicit expected(nonstd_lite_in_place_t(T), Args &&...args) : contained(true)
+        {
+            contained.emplace_value(std::forward<Args>(args)...);
+        }
+
+        template<
+            typename U,
+            typename... Args nsel_REQUIRES_T(std::is_constructible<T, std::initializer_list<U>, Args &&...>::value)>
+        nsel_constexpr14 explicit expected(nonstd_lite_in_place_t(T), std::initializer_list<U> il, Args &&...args)
+            : contained(true)
+        {
+            contained.emplace_value(il, std::forward<Args>(args)...);
+        }
+
+        // in-place construction, error
+
+        template<typename... Args nsel_REQUIRES_T(std::is_constructible<E, Args &&...>::value)>
+        nsel_constexpr14 explicit expected(unexpect_t, Args &&...args) : contained(false)
+        {
+            contained.emplace_error(std::forward<Args>(args)...);
+        }
+
+        template<
+            typename U,
+            typename... Args nsel_REQUIRES_T(std::is_constructible<E, std::initializer_list<U>, Args &&...>::value)>
+        nsel_constexpr14 explicit expected(unexpect_t, std::initializer_list<U> il, Args &&...args) : contained(false)
+        {
+            contained.emplace_error(il, std::forward<Args>(args)...);
+        }
+
+        // x.x.4.2 destructor
+
+        // TODO: ~expected: triviality
+        // Effects: If T is not cv void and is_trivially_destructible_v<T> is false
+        // and bool(*this), calls val.~T(). If is_trivially_destructible_v<E> is
+        // false and !bool(*this), calls unexpect.~unexpected<E>(). Remarks: If
+        // either T is cv void or is_trivially_destructible_v<T> is true, and
+        // is_trivially_destructible_v<E> is true, then this destructor shall be a
+        // trivial destructor.
+
+        ~expected()
+        {
+            if (has_value())
+                contained.destruct_value();
+            else
+                contained.destruct_error();
+        }
+
+        // x.x.4.3 assignment
+
+        expected &operator=(expected const &other)
+        {
+            expected(other).swap(*this);
+            return *this;
+        }
+
+        expected &operator=(expected &&other) noexcept(
+            std::is_nothrow_move_constructible<T>::value && std::is_nothrow_move_assignable<T>::value
+            && std::is_nothrow_move_constructible<E>::value// added for missing
+            && std::is_nothrow_move_assignable<E>::value)  //   nothrow above
+        {
+            expected(std::move(other)).swap(*this);
+            return *this;
+        }
+
+        template<typename U nsel_REQUIRES_T(
+            !std::is_same<expected<T, E>, typename std20::remove_cvref<U>::type>::value
+            && std17::conjunction<std::is_scalar<T>, std::is_same<T, std::decay<U>>>::value
+            && std::is_constructible<T, U>::value && std::is_assignable<T &, U>::value
+            && std::is_nothrow_move_constructible<E>::value)>
+        expected &operator=(U &&value)
+        {
+            expected(std::forward<U>(value)).swap(*this);
+            return *this;
+        }
+
+        template<typename G = E nsel_REQUIRES_T(std::is_constructible<E, G const &>::value &&std::is_copy_constructible<
+                                                G>::value// TODO: std::is_nothrow_copy_constructible<G>
+                                                    &&std::is_copy_assignable<G>::value)>
+        expected &operator=(nonstd::unexpected_type<G> const &error)
+        {
+            expected(unexpect, error.value()).swap(*this);
+            return *this;
+        }
+
+        template<typename G = E nsel_REQUIRES_T(std::is_constructible<E, G &&>::value &&std::is_move_constructible<
+                                                G>::value// TODO: std::is_nothrow_move_constructible<G>
+                                                    &&std::is_move_assignable<G>::value)>
+        expected &operator=(nonstd::unexpected_type<G> &&error)
+        {
+            expected(unexpect, std::move(error.value())).swap(*this);
+            return *this;
+        }
+
+        template<typename... Args nsel_REQUIRES_T(std::is_nothrow_constructible<T, Args &&...>::value)>
+        value_type &emplace(Args &&...args)
+        {
+            expected(nonstd_lite_in_place(T), std::forward<Args>(args)...).swap(*this);
+            return value();
+        }
+
+        template<typename U,
+                 typename... Args nsel_REQUIRES_T(
+                     std::is_nothrow_constructible<T, std::initializer_list<U> &, Args &&...>::value)>
+        value_type &emplace(std::initializer_list<U> il, Args &&...args)
+        {
+            expected(nonstd_lite_in_place(T), il, std::forward<Args>(args)...).swap(*this);
+            return value();
+        }
+
+        // x.x.4.4 swap
+
+        template<typename U = T, typename G = E>
+        nsel_REQUIRES_R(void,
+                        std17::is_swappable<U>::value &&std17::is_swappable<G>::value
+                            && (std::is_move_constructible<U>::value || std::is_move_constructible<G>::value))
+            swap(expected &other) noexcept(
+                std::is_nothrow_move_constructible<T>::value && std17::is_nothrow_swappable<T &>::value
+                && std::is_nothrow_move_constructible<E>::value && std17::is_nothrow_swappable<E &>::value)
+        {
+            using std::swap;
+
+            if (bool(*this) && bool(other)) {
+                swap(contained.value(), other.contained.value());
+            } else if (!bool(*this) && !bool(other)) {
+                swap(contained.error(), other.contained.error());
+            } else if (bool(*this) && !bool(other)) {
+                error_type t(std::move(other.error()));
+                other.contained.destruct_error();
+                other.contained.construct_value(std::move(contained.value()));
+                contained.destruct_value();
+                contained.construct_error(std::move(t));
+                bool has_value       = contained.has_value();
+                bool other_has_value = other.has_value();
+                other.contained.set_has_value(has_value);
+                contained.set_has_value(other_has_value);
+            } else if (!bool(*this) && bool(other)) {
+                other.swap(*this);
+            }
+        }
+
+        // x.x.4.5 observers
+
+        constexpr value_type const *operator->() const { return assert(has_value()), contained.value_ptr(); }
+
+        value_type *operator->() { return assert(has_value()), contained.value_ptr(); }
+
+        constexpr value_type const &operator*() const & { return assert(has_value()), contained.value(); }
+
+        value_type &operator*() & { return assert(has_value()), contained.value(); }
 
 #if !nsel_COMPILER_GNUC_VERSION || nsel_COMPILER_GNUC_VERSION >= 490
 
-    constexpr value_type const &&operator*() const && {
-      return std::move((assert(has_value()), contained.value()));
-    }
+        constexpr value_type const &&operator*() const &&
+        {
+            return std::move((assert(has_value()), contained.value()));
+        }
 
-    nsel_constexpr14 value_type &&operator*() && {
-      return std::move((assert(has_value()), contained.value()));
-    }
+        nsel_constexpr14 value_type &&operator*() && { return std::move((assert(has_value()), contained.value())); }
 
 #endif
 
-    constexpr explicit operator bool() const noexcept { return has_value(); }
+        constexpr explicit operator bool() const noexcept { return has_value(); }
 
-    constexpr bool has_value() const noexcept { return contained.has_value(); }
+        constexpr bool has_value() const noexcept { return contained.has_value(); }
 
-    constexpr value_type const &value() const & {
-      return has_value()
-                 ? (contained.value())
-                 : (error_traits<error_type>::rethrow(contained.error()),
-                    contained.value());
-    }
+        constexpr value_type const &value() const &
+        {
+            return has_value() ? (contained.value())
+                               : (error_traits<error_type>::rethrow(contained.error()), contained.value());
+        }
 
-    value_type &value() & {
-      return has_value()
-                 ? (contained.value())
-                 : (error_traits<error_type>::rethrow(contained.error()),
-                    contained.value());
-    }
+        value_type &value() &
+        {
+            return has_value() ? (contained.value())
+                               : (error_traits<error_type>::rethrow(contained.error()), contained.value());
+        }
 
 #if !nsel_COMPILER_GNUC_VERSION || nsel_COMPILER_GNUC_VERSION >= 490
 
-    constexpr value_type const &&value() const && {
-      return std::move(
-          has_value() ? (contained.value())
-                      : (error_traits<error_type>::rethrow(contained.error()),
-                         contained.value()));
-    }
+        constexpr value_type const &&value() const &&
+        {
+            return std::move(has_value() ? (contained.value())
+                                         : (error_traits<error_type>::rethrow(contained.error()), contained.value()));
+        }
 
-    nsel_constexpr14 value_type &&value() && {
-      return std::move(
-          has_value() ? (contained.value())
-                      : (error_traits<error_type>::rethrow(contained.error()),
-                         contained.value()));
-    }
+        nsel_constexpr14 value_type &&value() &&
+        {
+            return std::move(has_value() ? (contained.value())
+                                         : (error_traits<error_type>::rethrow(contained.error()), contained.value()));
+        }
 
 #endif
 
-    constexpr error_type const &error() const & {
-      return assert(!has_value()), contained.error();
-    }
+        constexpr error_type const &error() const & { return assert(!has_value()), contained.error(); }
 
-    error_type &error() & { return assert(!has_value()), contained.error(); }
+        error_type &error() & { return assert(!has_value()), contained.error(); }
 
 #if !nsel_COMPILER_GNUC_VERSION || nsel_COMPILER_GNUC_VERSION >= 490
 
-    constexpr error_type const &&error() const && {
-      return std::move((assert(!has_value()), contained.error()));
-    }
+        constexpr error_type const &&error() const && { return std::move((assert(!has_value()), contained.error())); }
 
-    error_type &&error() && {
-      return std::move((assert(!has_value()), contained.error()));
-    }
+        error_type &&error() && { return std::move((assert(!has_value()), contained.error())); }
 
 #endif
 
-    constexpr unexpected_type get_unexpected() const {
-      return make_unexpected(contained.error());
-    }
+        constexpr unexpected_type get_unexpected() const { return make_unexpected(contained.error()); }
 
-    template <typename Ex> bool has_exception() const {
-      using ContainedEx = typename std::remove_reference<
-          decltype(get_unexpected().value())>::type;
-      return !has_value() && std::is_base_of<Ex, ContainedEx>::value;
-    }
+        template<typename Ex>
+        bool has_exception() const
+        {
+            using ContainedEx = typename std::remove_reference<decltype(get_unexpected().value())>::type;
+            return !has_value() && std::is_base_of<Ex, ContainedEx>::value;
+        }
 
-    template <
-        typename U nsel_REQUIRES_T(std::is_copy_constructible<T>::value
-                                       &&std::is_convertible<U &&, T>::value)>
-    value_type value_or(U &&v) const & {
-      return has_value() ? contained.value()
-                         : static_cast<T>(std::forward<U>(v));
-    }
+        template<typename U nsel_REQUIRES_T(std::is_copy_constructible<T>::value &&std::is_convertible<U &&, T>::value)>
+        value_type value_or(U &&v) const &
+        {
+            return has_value() ? contained.value() : static_cast<T>(std::forward<U>(v));
+        }
 
-    template <
-        typename U nsel_REQUIRES_T(std::is_move_constructible<T>::value
-                                       &&std::is_convertible<U &&, T>::value)>
-    value_type value_or(U &&v) && {
-      return has_value() ? std::move(contained.value())
-                         : static_cast<T>(std::forward<U>(v));
-    }
+        template<typename U nsel_REQUIRES_T(std::is_move_constructible<T>::value &&std::is_convertible<U &&, T>::value)>
+        value_type value_or(U &&v) &&
+        {
+            return has_value() ? std::move(contained.value()) : static_cast<T>(std::forward<U>(v));
+        }
 
 #if nsel_P2505R >= 4
-    template <
-        typename G = E nsel_REQUIRES_T(std::is_copy_constructible<E>::value
-                                           &&std::is_convertible<G, E>::value)>
-    nsel_constexpr error_type error_or(G &&e) const & {
-      return has_value() ? static_cast<E>(std::forward<G>(e))
-                         : contained.error();
-    }
+        template<
+            typename G = E nsel_REQUIRES_T(std::is_copy_constructible<E>::value &&std::is_convertible<G, E>::value)>
+        nsel_constexpr error_type error_or(G &&e) const &
+        {
+            return has_value() ? static_cast<E>(std::forward<G>(e)) : contained.error();
+        }
 
-    template <
-        typename G = E nsel_REQUIRES_T(std::is_move_constructible<E>::value
-                                           &&std::is_convertible<G, E>::value)>
-    nsel_constexpr14 error_type error_or(G &&e) && {
-      return has_value() ? static_cast<E>(std::forward<G>(e))
-                         : std::move(contained.error());
-    }
-#endif // nsel_P2505R >= 4
+        template<
+            typename G = E nsel_REQUIRES_T(std::is_move_constructible<E>::value &&std::is_convertible<G, E>::value)>
+        nsel_constexpr14 error_type error_or(G &&e) &&
+        {
+            return has_value() ? static_cast<E>(std::forward<G>(e)) : std::move(contained.error());
+        }
+#endif// nsel_P2505R >= 4
 
 #if nsel_P2505R >= 3
-    // Monadic operations (P2505)
-    template <typename F nsel_REQUIRES_T(
-        detail::is_expected<detail::invoke_result_nocvref_t<F, value_type &>>::
-            value &&std::is_same<typename detail::invoke_result_nocvref_t<
-                                     F, value_type &>::error_type,
-                                 error_type>::value
-                &&std::is_constructible<error_type, error_type &>::value)>
-    nsel_constexpr14 detail::invoke_result_nocvref_t<F, value_type &>
-    and_then(F &&f) & {
-      return has_value() ? detail::invoke_result_nocvref_t<F, value_type &>(
-                               detail::invoke(std::forward<F>(f), value()))
-                         : detail::invoke_result_nocvref_t<F, value_type &>(
-                               unexpect, error());
-    }
+        // Monadic operations (P2505)
+        template<typename F nsel_REQUIRES_T(
+            detail::is_expected<detail::invoke_result_nocvref_t<F, value_type &>>::value
+                &&std::is_same<typename detail::invoke_result_nocvref_t<F, value_type &>::error_type, error_type>::value
+                    &&std::is_constructible<error_type, error_type &>::value)>
+        nsel_constexpr14 detail::invoke_result_nocvref_t<F, value_type &> and_then(F &&f) &
+        {
+            return has_value()
+                ? detail::invoke_result_nocvref_t<F, value_type &>(detail::invoke(std::forward<F>(f), value()))
+                : detail::invoke_result_nocvref_t<F, value_type &>(unexpect, error());
+        }
 
-    template <typename F nsel_REQUIRES_T(
-        detail::is_expected<
-            detail::invoke_result_nocvref_t<F, const value_type &>>::value
-            &&std::is_same<typename detail::invoke_result_nocvref_t<
-                               F, const value_type &>::error_type,
-                           error_type>::value
-                &&std::is_constructible<error_type, const error_type &>::value)>
-    nsel_constexpr detail::invoke_result_nocvref_t<F, const value_type &>
-    and_then(F &&f) const & {
-      return has_value()
-                 ? detail::invoke_result_nocvref_t<F, const value_type &>(
-                       detail::invoke(std::forward<F>(f), value()))
-                 : detail::invoke_result_nocvref_t<F, const value_type &>(
-                       unexpect, error());
-    }
+        template<typename F nsel_REQUIRES_T(
+            detail::is_expected<detail::invoke_result_nocvref_t<F, const value_type &>>::value
+                &&std::is_same<typename detail::invoke_result_nocvref_t<F, const value_type &>::error_type,
+                               error_type>::value &&std::is_constructible<error_type, const error_type &>::value)>
+        nsel_constexpr detail::invoke_result_nocvref_t<F, const value_type &> and_then(F &&f) const &
+        {
+            return has_value()
+                ? detail::invoke_result_nocvref_t<F, const value_type &>(detail::invoke(std::forward<F>(f), value()))
+                : detail::invoke_result_nocvref_t<F, const value_type &>(unexpect, error());
+        }
 
 #if !nsel_COMPILER_GNUC_VERSION || nsel_COMPILER_GNUC_VERSION >= 490
-    template <typename F nsel_REQUIRES_T(
-        detail::is_expected<detail::invoke_result_nocvref_t<F, value_type &&>>::
-            value &&std::is_same<typename detail::invoke_result_nocvref_t<
-                                     F, value_type &&>::error_type,
-                                 error_type>::value
-                &&std::is_constructible<error_type, error_type &&>::value)>
-    nsel_constexpr14 detail::invoke_result_nocvref_t<F, value_type &&>
-    and_then(F &&f) && {
-      return has_value()
-                 ? detail::invoke_result_nocvref_t<F, value_type &&>(
-                       detail::invoke(std::forward<F>(f), std::move(value())))
-                 : detail::invoke_result_nocvref_t<F, value_type &&>(
-                       unexpect, std::move(error()));
-    }
+        template<typename F nsel_REQUIRES_T(
+            detail::is_expected<detail::invoke_result_nocvref_t<F, value_type &&>>::value &&
+                std::is_same<typename detail::invoke_result_nocvref_t<F, value_type &&>::error_type, error_type>::value
+                    &&std::is_constructible<error_type, error_type &&>::value)>
+        nsel_constexpr14 detail::invoke_result_nocvref_t<F, value_type &&> and_then(F &&f) &&
+        {
+            return has_value()
+                ? detail::invoke_result_nocvref_t<F, value_type &&>(
+                      detail::invoke(std::forward<F>(f), std::move(value())))
+                : detail::invoke_result_nocvref_t<F, value_type &&>(unexpect, std::move(error()));
+        }
 
-    template <typename F nsel_REQUIRES_T(
-        detail::is_expected<
-            detail::invoke_result_nocvref_t<F, const value_type &&>>::value
-            &&std::is_same<typename detail::invoke_result_nocvref_t<
-                               F, const value_type &>::error_type,
-                           error_type>::value &&
-                std::is_constructible<error_type, const error_type &&>::value)>
-    nsel_constexpr detail::invoke_result_nocvref_t<F, const value_type &&>
-    and_then(F &&f) const && {
-      return has_value()
-                 ? detail::invoke_result_nocvref_t<F, const value_type &&>(
-                       detail::invoke(std::forward<F>(f), std::move(value())))
-                 : detail::invoke_result_nocvref_t<F, const value_type &&>(
-                       unexpect, std::move(error()));
-    }
+        template<typename F nsel_REQUIRES_T(
+            detail::is_expected<detail::invoke_result_nocvref_t<F, const value_type &&>>::value
+                &&std::is_same<typename detail::invoke_result_nocvref_t<F, const value_type &>::error_type,
+                               error_type>::value &&std::is_constructible<error_type, const error_type &&>::value)>
+        nsel_constexpr detail::invoke_result_nocvref_t<F, const value_type &&> and_then(F &&f) const &&
+        {
+            return has_value()
+                ? detail::invoke_result_nocvref_t<F, const value_type &&>(
+                      detail::invoke(std::forward<F>(f), std::move(value())))
+                : detail::invoke_result_nocvref_t<F, const value_type &&>(unexpect, std::move(error()));
+        }
 #endif
 
-    template <typename F nsel_REQUIRES_T(
-        detail::is_expected<detail::invoke_result_nocvref_t<F, error_type &>>::
-            value &&std::is_same<typename detail::invoke_result_nocvref_t<
-                                     F, error_type &>::value_type,
-                                 value_type>::value
+        template<typename F nsel_REQUIRES_T(
+            detail::is_expected<detail::invoke_result_nocvref_t<F, error_type &>>::value
+                &&std::is_same<typename detail::invoke_result_nocvref_t<F, error_type &>::value_type, value_type>::value
+                    &&std::is_constructible<value_type, value_type &>::value)>
+        nsel_constexpr14 detail::invoke_result_nocvref_t<F, error_type &> or_else(F &&f) &
+        {
+            return has_value()
+                ? detail::invoke_result_nocvref_t<F, error_type &>(value())
+                : detail::invoke_result_nocvref_t<F, error_type &>(detail::invoke(std::forward<F>(f), error()));
+        }
+
+        template<typename F nsel_REQUIRES_T(
+            detail::is_expected<detail::invoke_result_nocvref_t<F, const error_type &>>::value
+                &&std::is_same<typename detail::invoke_result_nocvref_t<F, const error_type &>::value_type,
+                               value_type>::value &&std::is_constructible<value_type, const value_type &>::value)>
+        nsel_constexpr detail::invoke_result_nocvref_t<F, const error_type &> or_else(F &&f) const &
+        {
+            return has_value()
+                ? detail::invoke_result_nocvref_t<F, const error_type &>(value())
+                : detail::invoke_result_nocvref_t<F, const error_type &>(detail::invoke(std::forward<F>(f), error()));
+        }
+
+#if !nsel_COMPILER_GNUC_VERSION || nsel_COMPILER_GNUC_VERSION >= 490
+        template<typename F nsel_REQUIRES_T(
+            detail::is_expected<detail::invoke_result_nocvref_t<F, error_type &&>>::value &&
+                std::is_same<typename detail::invoke_result_nocvref_t<F, error_type &&>::value_type, value_type>::value
+                    &&std::is_constructible<value_type, value_type &&>::value)>
+        nsel_constexpr14 detail::invoke_result_nocvref_t<F, error_type &&> or_else(F &&f) &&
+        {
+            return has_value()
+                ? detail::invoke_result_nocvref_t<F, error_type &&>(std::move(value()))
+                : detail::invoke_result_nocvref_t<F, error_type &&>(
+                      detail::invoke(std::forward<F>(f), std::move(error())));
+        }
+
+        template<typename F nsel_REQUIRES_T(
+            detail::is_expected<detail::invoke_result_nocvref_t<F, const error_type &&>>::value
+                &&std::is_same<typename detail::invoke_result_nocvref_t<F, const error_type &&>::value_type,
+                               value_type>::value &&std::is_constructible<value_type, const value_type &&>::value)>
+        nsel_constexpr detail::invoke_result_nocvref_t<F, const error_type &&> or_else(F &&f) const &&
+        {
+            return has_value()
+                ? detail::invoke_result_nocvref_t<F, const error_type &&>(std::move(value()))
+                : detail::invoke_result_nocvref_t<F, const error_type &&>(
+                      detail::invoke(std::forward<F>(f), std::move(error())));
+        }
+#endif
+
+        template<typename F nsel_REQUIRES_T(
+            std::is_constructible<error_type, error_type &>::value
+            && !std::is_void<detail::transform_invoke_result_t<F, value_type &>>::value
+            && detail::valid_expected_value_type<detail::transform_invoke_result_t<F, value_type &>>::value)>
+        nsel_constexpr14 expected<detail::transform_invoke_result_t<F, value_type &>, error_type> transform(F &&f) &
+        {
+            return has_value()
+                ? expected<detail::transform_invoke_result_t<F, value_type &>, error_type>(
+                      detail::invoke(std::forward<F>(f), **this))
+                : make_unexpected(error());
+        }
+
+        template<typename F nsel_REQUIRES_T(std::is_constructible<error_type, error_type &>::value &&std::is_void<
+                                            detail::transform_invoke_result_t<F, value_type &>>::value)>
+        nsel_constexpr14 expected<void, error_type> transform(F &&f) &
+        {
+            return has_value() ? (detail::invoke(std::forward<F>(f), **this), expected<void, error_type>())
+                               : make_unexpected(error());
+        }
+
+        template<typename F nsel_REQUIRES_T(
+            std::is_constructible<error_type, const error_type &>::value
+            && !std::is_void<detail::transform_invoke_result_t<F, const value_type &>>::value
+            && detail::valid_expected_value_type<detail::transform_invoke_result_t<F, const value_type &>>::value)>
+        nsel_constexpr expected<detail::transform_invoke_result_t<F, const value_type &>, error_type>
+        transform(F &&f) const &
+        {
+            return has_value()
+                ? expected<detail::transform_invoke_result_t<F, const value_type &>, error_type>(
+                      detail::invoke(std::forward<F>(f), **this))
+                : make_unexpected(error());
+        }
+
+        template<typename F nsel_REQUIRES_T(std::is_constructible<error_type, const error_type &>::value &&std::is_void<
+                                            detail::transform_invoke_result_t<F, const value_type &>>::value)>
+        nsel_constexpr expected<void, error_type> transform(F &&f) const &
+        {
+            return has_value() ? (detail::invoke(std::forward<F>(f), **this), expected<void, error_type>())
+                               : make_unexpected(error());
+        }
+
+#if !nsel_COMPILER_GNUC_VERSION || nsel_COMPILER_GNUC_VERSION >= 490
+        template<typename F nsel_REQUIRES_T(
+            std::is_constructible<error_type, error_type &&>::value
+            && !std::is_void<detail::transform_invoke_result_t<F, value_type &&>>::value
+            && detail::valid_expected_value_type<detail::transform_invoke_result_t<F, value_type &&>>::value)>
+        nsel_constexpr14 expected<detail::transform_invoke_result_t<F, value_type &&>, error_type> transform(F &&f) &&
+        {
+            return has_value()
+                ? expected<detail::transform_invoke_result_t<F, value_type &&>, error_type>(
+                      detail::invoke(std::forward<F>(f), std::move(**this)))
+                : make_unexpected(std::move(error()));
+        }
+
+        template<typename F nsel_REQUIRES_T(std::is_constructible<error_type, error_type &&>::value &&std::is_void<
+                                            detail::transform_invoke_result_t<F, value_type &&>>::value)>
+        nsel_constexpr14 expected<void, error_type> transform(F &&f) &&
+        {
+            return has_value() ? (detail::invoke(std::forward<F>(f), **this), expected<void, error_type>())
+                               : make_unexpected(std::move(error()));
+        }
+
+        template<typename F nsel_REQUIRES_T(
+            std::is_constructible<error_type, const error_type &&>::value
+            && !std::is_void<detail::transform_invoke_result_t<F, const value_type &&>>::value
+            && detail::valid_expected_value_type<detail::transform_invoke_result_t<F, const value_type &&>>::value)>
+        nsel_constexpr expected<detail::transform_invoke_result_t<F, const value_type &&>, error_type>
+        transform(F &&f) const &&
+        {
+            return has_value()
+                ? expected<detail::transform_invoke_result_t<F, const value_type &&>, error_type>(
+                      detail::invoke(std::forward<F>(f), std::move(**this)))
+                : make_unexpected(std::move(error()));
+        }
+
+        template<typename F nsel_REQUIRES_T(
+            std::is_constructible<error_type, const error_type &&>::value
+                &&std::is_void<detail::transform_invoke_result_t<F, const value_type &&>>::value)>
+        nsel_constexpr expected<void, error_type> transform(F &&f) const &&
+        {
+            return has_value() ? (detail::invoke(std::forward<F>(f), **this), expected<void, error_type>())
+                               : make_unexpected(std::move(error()));
+        }
+#endif
+
+        template<typename F nsel_REQUIRES_T(
+            detail::valid_unexpected_type<detail::transform_invoke_result_t<F, error_type &>>::value
                 &&std::is_constructible<value_type, value_type &>::value)>
-    nsel_constexpr14 detail::invoke_result_nocvref_t<F, error_type &>
-    or_else(F &&f) & {
-      return has_value()
-                 ? detail::invoke_result_nocvref_t<F, error_type &>(value())
-                 : detail::invoke_result_nocvref_t<F, error_type &>(
-                       detail::invoke(std::forward<F>(f), error()));
-    }
+        nsel_constexpr14 expected<value_type, detail::transform_invoke_result_t<F, error_type &>>
+        transform_error(F &&f) &
+        {
+            return has_value()
+                ? expected<value_type, detail::transform_invoke_result_t<F, error_type &>>(in_place, **this)
+                : make_unexpected(detail::invoke(std::forward<F>(f), error()));
+        }
 
-    template <typename F nsel_REQUIRES_T(
-        detail::is_expected<
-            detail::invoke_result_nocvref_t<F, const error_type &>>::value
-            &&std::is_same<typename detail::invoke_result_nocvref_t<
-                               F, const error_type &>::value_type,
-                           value_type>::value
+        template<typename F nsel_REQUIRES_T(
+            detail::valid_unexpected_type<detail::transform_invoke_result_t<F, const error_type &>>::value
                 &&std::is_constructible<value_type, const value_type &>::value)>
-    nsel_constexpr detail::invoke_result_nocvref_t<F, const error_type &>
-    or_else(F &&f) const & {
-      return has_value()
-                 ? detail::invoke_result_nocvref_t<F, const error_type &>(
-                       value())
-                 : detail::invoke_result_nocvref_t<F, const error_type &>(
-                       detail::invoke(std::forward<F>(f), error()));
-    }
+        nsel_constexpr expected<value_type, detail::transform_invoke_result_t<F, const error_type &>>
+        transform_error(F &&f) const &
+        {
+            return has_value()
+                ? expected<value_type, detail::transform_invoke_result_t<F, const error_type &>>(in_place, **this)
+                : make_unexpected(detail::invoke(std::forward<F>(f), error()));
+        }
 
 #if !nsel_COMPILER_GNUC_VERSION || nsel_COMPILER_GNUC_VERSION >= 490
-    template <typename F nsel_REQUIRES_T(
-        detail::is_expected<detail::invoke_result_nocvref_t<F, error_type &&>>::
-            value &&std::is_same<typename detail::invoke_result_nocvref_t<
-                                     F, error_type &&>::value_type,
-                                 value_type>::value
+        template<typename F nsel_REQUIRES_T(
+            detail::valid_unexpected_type<detail::transform_invoke_result_t<F, error_type &&>>::value
                 &&std::is_constructible<value_type, value_type &&>::value)>
-    nsel_constexpr14 detail::invoke_result_nocvref_t<F, error_type &&>
-    or_else(F &&f) && {
-      return has_value()
-                 ? detail::invoke_result_nocvref_t<F, error_type &&>(
-                       std::move(value()))
-                 : detail::invoke_result_nocvref_t<F, error_type &&>(
-                       detail::invoke(std::forward<F>(f), std::move(error())));
-    }
+        nsel_constexpr14 expected<value_type, detail::transform_invoke_result_t<F, error_type &&>>
+        transform_error(F &&f) &&
+        {
+            return has_value()
+                ? expected<value_type, detail::transform_invoke_result_t<F, error_type &&>>(in_place, std::move(**this))
+                : make_unexpected(detail::invoke(std::forward<F>(f), std::move(error())));
+        }
 
-    template <typename F nsel_REQUIRES_T(
-        detail::is_expected<
-            detail::invoke_result_nocvref_t<F, const error_type &&>>::value
-            &&std::is_same<typename detail::invoke_result_nocvref_t<
-                               F, const error_type &&>::value_type,
-                           value_type>::value &&
-                std::is_constructible<value_type, const value_type &&>::value)>
-    nsel_constexpr detail::invoke_result_nocvref_t<F, const error_type &&>
-    or_else(F &&f) const && {
-      return has_value()
-                 ? detail::invoke_result_nocvref_t<F, const error_type &&>(
-                       std::move(value()))
-                 : detail::invoke_result_nocvref_t<F, const error_type &&>(
-                       detail::invoke(std::forward<F>(f), std::move(error())));
-    }
+        template<typename F nsel_REQUIRES_T(
+            detail::valid_unexpected_type<detail::transform_invoke_result_t<F, const error_type &&>>::value
+                &&std::is_constructible<value_type, const value_type &&>::value)>
+        nsel_constexpr expected<value_type, detail::transform_invoke_result_t<F, const error_type &&>>
+        transform_error(F &&f) const &&
+        {
+            return has_value()
+                ? expected<value_type, detail::transform_invoke_result_t<F, const error_type &&>>(
+                      in_place, std::move(**this))
+                : make_unexpected(detail::invoke(std::forward<F>(f), std::move(error())));
+        }
 #endif
+#endif// nsel_P2505R >= 3
+        // unwrap()
 
-    template <typename F nsel_REQUIRES_T(
-        std::is_constructible<error_type, error_type &>::value &&
-        !std::is_void<
-            detail::transform_invoke_result_t<F, value_type &>>::value &&
-        detail::valid_expected_value_type<
-            detail::transform_invoke_result_t<F, value_type &>>::value)>
-    nsel_constexpr14
-        expected<detail::transform_invoke_result_t<F, value_type &>, error_type>
-        transform(F &&f) & {
-      return has_value()
-                 ? expected<detail::transform_invoke_result_t<F, value_type &>,
-                            error_type>(
-                       detail::invoke(std::forward<F>(f), **this))
-                 : make_unexpected(error());
-    }
+        //  template <class U, class E>
+        //  constexpr expected<U,E> expected<expected<U,E>,E>::unwrap() const&;
 
-    template <typename F nsel_REQUIRES_T(
-        std::is_constructible<error_type, error_type &>::value &&std::is_void<
-            detail::transform_invoke_result_t<F, value_type &>>::value)>
-    nsel_constexpr14 expected<void, error_type> transform(F &&f) & {
-      return has_value() ? (detail::invoke(std::forward<F>(f), **this),
-                            expected<void, error_type>())
-                         : make_unexpected(error());
-    }
+        //  template <class T, class E>
+        //  constexpr expected<T,E> expected<T,E>::unwrap() const&;
 
-    template <typename F nsel_REQUIRES_T(
-        std::is_constructible<error_type, const error_type &>::value &&
-        !std::is_void<
-            detail::transform_invoke_result_t<F, const value_type &>>::value &&
-        detail::valid_expected_value_type<
-            detail::transform_invoke_result_t<F, const value_type &>>::value)>
-    nsel_constexpr
-        expected<detail::transform_invoke_result_t<F, const value_type &>,
-                 error_type>
-        transform(F &&f) const & {
-      return has_value()
-                 ? expected<
-                       detail::transform_invoke_result_t<F, const value_type &>,
-                       error_type>(detail::invoke(std::forward<F>(f), **this))
-                 : make_unexpected(error());
-    }
+        //  template <class U, class E>
+        //  expected<U,E> expected<expected<U,E>, E>::unwrap() &&;
 
-    template <typename F nsel_REQUIRES_T(
-        std::is_constructible<error_type, const error_type &>::value
-            &&std::is_void<detail::transform_invoke_result_t<
-                F, const value_type &>>::value)>
-    nsel_constexpr expected<void, error_type> transform(F &&f) const & {
-      return has_value() ? (detail::invoke(std::forward<F>(f), **this),
-                            expected<void, error_type>())
-                         : make_unexpected(error());
-    }
+        //  template <class T, class E>
+        //  template expected<T,E> expected<T,E>::unwrap() &&;
 
-#if !nsel_COMPILER_GNUC_VERSION || nsel_COMPILER_GNUC_VERSION >= 490
-    template <typename F nsel_REQUIRES_T(
-        std::is_constructible<error_type, error_type &&>::value &&
-        !std::is_void<
-            detail::transform_invoke_result_t<F, value_type &&>>::value &&
-        detail::valid_expected_value_type<
-            detail::transform_invoke_result_t<F, value_type &&>>::value)>
-    nsel_constexpr14
-        expected<detail::transform_invoke_result_t<F, value_type &&>,
-                 error_type>
-        transform(F &&f) && {
-      return has_value()
-                 ? expected<detail::transform_invoke_result_t<F, value_type &&>,
-                            error_type>(
-                       detail::invoke(std::forward<F>(f), std::move(**this)))
-                 : make_unexpected(std::move(error()));
-    }
+        // factories
 
-    template <typename F nsel_REQUIRES_T(
-        std::is_constructible<error_type, error_type &&>::value &&std::is_void<
-            detail::transform_invoke_result_t<F, value_type &&>>::value)>
-    nsel_constexpr14 expected<void, error_type> transform(F &&f) && {
-      return has_value() ? (detail::invoke(std::forward<F>(f), **this),
-                            expected<void, error_type>())
-                         : make_unexpected(std::move(error()));
-    }
+        //  template< typename Ex, typename F>
+        //  expected<T,E> catch_exception(F&& f);
 
-    template <typename F nsel_REQUIRES_T(
-        std::is_constructible<error_type, const error_type &&>::value &&
-        !std::is_void<
-            detail::transform_invoke_result_t<F, const value_type &&>>::value &&
-        detail::valid_expected_value_type<
-            detail::transform_invoke_result_t<F, const value_type &&>>::value)>
-    nsel_constexpr
-        expected<detail::transform_invoke_result_t<F, const value_type &&>,
-                 error_type>
-        transform(F &&f) const && {
-      return has_value() ? expected<detail::transform_invoke_result_t<
-                                        F, const value_type &&>,
-                                    error_type>(detail::invoke(
-                               std::forward<F>(f), std::move(**this)))
-                         : make_unexpected(std::move(error()));
-    }
+        //  template< typename F>
+        //  expected<decltype(func(declval<T>())),E> map(F&& func) ;
 
-    template <typename F nsel_REQUIRES_T(
-        std::is_constructible<error_type, const error_type &&>::value
-            &&std::is_void<detail::transform_invoke_result_t<
-                F, const value_type &&>>::value)>
-    nsel_constexpr expected<void, error_type> transform(F &&f) const && {
-      return has_value() ? (detail::invoke(std::forward<F>(f), **this),
-                            expected<void, error_type>())
-                         : make_unexpected(std::move(error()));
-    }
-#endif
+        //  template< typename F>
+        //  'see below' bind(F&& func);
 
-    template <typename F nsel_REQUIRES_T(
-        detail::valid_unexpected_type<
-            detail::transform_invoke_result_t<F, error_type &>>::value
-            &&std::is_constructible<value_type, value_type &>::value)>
-    nsel_constexpr14
-        expected<value_type, detail::transform_invoke_result_t<F, error_type &>>
-        transform_error(F &&f) & {
-      return has_value()
-                 ? expected<value_type,
-                            detail::transform_invoke_result_t<F, error_type &>>(
-                       in_place, **this)
-                 : make_unexpected(detail::invoke(std::forward<F>(f), error()));
-    }
+        //  template< typename F>
+        //  expected<T,E> catch_error(F&& f);
 
-    template <typename F nsel_REQUIRES_T(
-        detail::valid_unexpected_type<
-            detail::transform_invoke_result_t<F, const error_type &>>::value
-            &&std::is_constructible<value_type, const value_type &>::value)>
-    nsel_constexpr
-        expected<value_type,
-                 detail::transform_invoke_result_t<F, const error_type &>>
-        transform_error(F &&f) const & {
-      return has_value()
-                 ? expected<value_type, detail::transform_invoke_result_t<
-                                            F, const error_type &>>(in_place,
-                                                                    **this)
-                 : make_unexpected(detail::invoke(std::forward<F>(f), error()));
-    }
+        //  template< typename F>
+        //  'see below' then(F&& func);
 
-#if !nsel_COMPILER_GNUC_VERSION || nsel_COMPILER_GNUC_VERSION >= 490
-    template <typename F nsel_REQUIRES_T(
-        detail::valid_unexpected_type<
-            detail::transform_invoke_result_t<F, error_type &&>>::value
-            &&std::is_constructible<value_type, value_type &&>::value)>
-    nsel_constexpr14
-        expected<value_type,
-                 detail::transform_invoke_result_t<F, error_type &&>>
-        transform_error(F &&f) && {
-      return has_value()
-                 ? expected<value_type, detail::transform_invoke_result_t<
-                                            F, error_type &&>>(
-                       in_place, std::move(**this))
-                 : make_unexpected(
-                       detail::invoke(std::forward<F>(f), std::move(error())));
-    }
+    private:
+        detail::storage_t<T,
+                          E,
+                          std::is_copy_constructible<T>::value && std::is_copy_constructible<E>::value,
+                          std::is_move_constructible<T>::value && std::is_move_constructible<E>::value>
+            contained;
+    };
 
-    template <typename F nsel_REQUIRES_T(
-        detail::valid_unexpected_type<
-            detail::transform_invoke_result_t<F, const error_type &&>>::value
-            &&std::is_constructible<value_type, const value_type &&>::value)>
-    nsel_constexpr
-        expected<value_type,
-                 detail::transform_invoke_result_t<F, const error_type &&>>
-        transform_error(F &&f) const && {
-      return has_value()
-                 ? expected<value_type, detail::transform_invoke_result_t<
-                                            F, const error_type &&>>(
-                       in_place, std::move(**this))
-                 : make_unexpected(
-                       detail::invoke(std::forward<F>(f), std::move(error())));
-    }
-#endif
-#endif // nsel_P2505R >= 3
-    // unwrap()
+    /// class expected, void specialization
 
-    //  template <class U, class E>
-    //  constexpr expected<U,E> expected<expected<U,E>,E>::unwrap() const&;
+    template<typename E>
+    class expected<void, E> {
+    private:
+        template<typename, typename>
+        friend class expected;
 
-    //  template <class T, class E>
-    //  constexpr expected<T,E> expected<T,E>::unwrap() const&;
+    public:
+        using value_type      = void;
+        using error_type      = E;
+        using unexpected_type = nonstd::unexpected_type<E>;
 
-    //  template <class U, class E>
-    //  expected<U,E> expected<expected<U,E>, E>::unwrap() &&;
+        // x.x.4.1 constructors
 
-    //  template <class T, class E>
-    //  template expected<T,E> expected<T,E>::unwrap() &&;
+        constexpr expected() noexcept : contained(true) {}
 
-    // factories
+        nsel_constexpr14 expected(expected const &other) = default;
+        nsel_constexpr14 expected(expected &&other)      = default;
 
-    //  template< typename Ex, typename F>
-    //  expected<T,E> catch_exception(F&& f);
+        constexpr explicit expected(nonstd_lite_in_place_t(void)) : contained(true) {}
 
-    //  template< typename F>
-    //  expected<decltype(func(declval<T>())),E> map(F&& func) ;
+        template<typename G = E nsel_REQUIRES_T(!std::is_convertible<G const &, E>::value /*=> explicit */
+                                                )>
+        nsel_constexpr14 explicit expected(nonstd::unexpected_type<G> const &error) : contained(false)
+        {
+            contained.construct_error(E{error.value()});
+        }
 
-    //  template< typename F>
-    //  'see below' bind(F&& func);
+        template<typename G = E nsel_REQUIRES_T(std::is_convertible<G const &, E>::value /*=> non-explicit */
+                                                )>
+        nsel_constexpr14 /*non-explicit*/
+        expected(nonstd::unexpected_type<G> const &error)
+            : contained(false)
+        {
+            contained.construct_error(error.value());
+        }
 
-    //  template< typename F>
-    //  expected<T,E> catch_error(F&& f);
+        template<typename G = E nsel_REQUIRES_T(!std::is_convertible<G &&, E>::value /*=> explicit */
+                                                )>
+        nsel_constexpr14 explicit expected(nonstd::unexpected_type<G> &&error) : contained(false)
+        {
+            contained.construct_error(E{std::move(error.value())});
+        }
 
-    //  template< typename F>
-    //  'see below' then(F&& func);
+        template<typename G = E nsel_REQUIRES_T(std::is_convertible<G &&, E>::value /*=> non-explicit */
+                                                )>
+        nsel_constexpr14 /*non-explicit*/
+        expected(nonstd::unexpected_type<G> &&error)
+            : contained(false)
+        {
+            contained.construct_error(std::move(error.value()));
+        }
 
-  private:
-    detail::storage_t<T, E,
-                      std::is_copy_constructible<T>::value &&
-                          std::is_copy_constructible<E>::value,
-                      std::is_move_constructible<T>::value &&
-                          std::is_move_constructible<E>::value>
-        contained;
-  };
+        template<typename... Args nsel_REQUIRES_T(std::is_constructible<E, Args &&...>::value)>
+        nsel_constexpr14 explicit expected(unexpect_t, Args &&...args) : contained(false)
+        {
+            contained.emplace_error(std::forward<Args>(args)...);
+        }
 
-  /// class expected, void specialization
+        template<
+            typename U,
+            typename... Args nsel_REQUIRES_T(std::is_constructible<E, std::initializer_list<U>, Args &&...>::value)>
+        nsel_constexpr14 explicit expected(unexpect_t, std::initializer_list<U> il, Args &&...args) : contained(false)
+        {
+            contained.emplace_error(il, std::forward<Args>(args)...);
+        }
 
-  template <typename E> class expected<void, E> {
-  private:
-    template <typename, typename> friend class expected;
+        // destructor
 
-  public:
-    using value_type = void;
-    using error_type = E;
-    using unexpected_type = nonstd::unexpected_type<E>;
+        ~expected()
+        {
+            if (!has_value()) { contained.destruct_error(); }
+        }
 
-    // x.x.4.1 constructors
+        // x.x.4.3 assignment
 
-    constexpr expected() noexcept : contained(true) {}
+        expected &operator=(expected const &other)
+        {
+            expected(other).swap(*this);
+            return *this;
+        }
 
-    nsel_constexpr14 expected(expected const &other) = default;
-    nsel_constexpr14 expected(expected &&other) = default;
+        expected &operator=(expected &&other) noexcept(std::is_nothrow_move_assignable<E>::value
+                                                       && std::is_nothrow_move_constructible<E>::value)
+        {
+            expected(std::move(other)).swap(*this);
+            return *this;
+        }
 
-    constexpr explicit expected(nonstd_lite_in_place_t(void))
-        : contained(true) {}
+        void emplace() { expected().swap(*this); }
 
-    template <typename G = E nsel_REQUIRES_T(
-                  !std::is_convertible<G const &, E>::value /*=> explicit */
-                  )>
-    nsel_constexpr14 explicit expected(nonstd::unexpected_type<G> const &error)
-        : contained(false) {
-      contained.construct_error(E{error.value()});
-    }
+        // x.x.4.4 swap
 
-    template <typename G = E nsel_REQUIRES_T(
-                  std::is_convertible<G const &, E>::value /*=> non-explicit */
-                  )>
-    nsel_constexpr14 /*non-explicit*/
-    expected(nonstd::unexpected_type<G> const &error)
-        : contained(false) {
-      contained.construct_error(error.value());
-    }
+        template<typename G = E>
+        nsel_REQUIRES_R(void, std17::is_swappable<G>::value &&std::is_move_constructible<G>::value)
+            swap(expected &other) noexcept(std::is_nothrow_move_constructible<E>::value
+                                           && std17::is_nothrow_swappable<E &>::value)
+        {
+            using std::swap;
 
-    template <typename G = E nsel_REQUIRES_T(
-                  !std::is_convertible<G &&, E>::value /*=> explicit */
-                  )>
-    nsel_constexpr14 explicit expected(nonstd::unexpected_type<G> &&error)
-        : contained(false) {
-      contained.construct_error(E{std::move(error.value())});
-    }
+            if (!bool(*this) && !bool(other)) {
+                swap(contained.error(), other.contained.error());
+            } else if (bool(*this) && !bool(other)) {
+                contained.construct_error(std::move(other.error()));
+                bool has_value       = contained.has_value();
+                bool other_has_value = other.has_value();
+                other.contained.set_has_value(has_value);
+                contained.set_has_value(other_has_value);
+            } else if (!bool(*this) && bool(other)) {
+                other.swap(*this);
+            }
+        }
 
-    template <typename G = E nsel_REQUIRES_T(
-                  std::is_convertible<G &&, E>::value /*=> non-explicit */
-                  )>
-    nsel_constexpr14 /*non-explicit*/
-    expected(nonstd::unexpected_type<G> &&error)
-        : contained(false) {
-      contained.construct_error(std::move(error.value()));
-    }
+        // x.x.4.5 observers
 
-    template <typename... Args nsel_REQUIRES_T(
-        std::is_constructible<E, Args &&...>::value)>
-    nsel_constexpr14 explicit expected(unexpect_t, Args &&...args)
-        : contained(false) {
-      contained.emplace_error(std::forward<Args>(args)...);
-    }
+        constexpr explicit operator bool() const noexcept { return has_value(); }
 
-    template <typename U, typename... Args nsel_REQUIRES_T(
-                              std::is_constructible<E, std::initializer_list<U>,
-                                                    Args &&...>::value)>
-    nsel_constexpr14 explicit expected(unexpect_t, std::initializer_list<U> il,
-                                       Args &&...args)
-        : contained(false) {
-      contained.emplace_error(il, std::forward<Args>(args)...);
-    }
+        constexpr bool has_value() const noexcept { return contained.has_value(); }
 
-    // destructor
+        void value() const
+        {
+            if (!has_value()) { error_traits<error_type>::rethrow(contained.error()); }
+        }
 
-    ~expected() {
-      if (!has_value()) {
-        contained.destruct_error();
-      }
-    }
+        constexpr error_type const &error() const & { return assert(!has_value()), contained.error(); }
 
-    // x.x.4.3 assignment
-
-    expected &operator=(expected const &other) {
-      expected(other).swap(*this);
-      return *this;
-    }
-
-    expected &operator=(expected &&other) noexcept(
-        std::is_nothrow_move_assignable<E>::value &&
-        std::is_nothrow_move_constructible<E>::value) {
-      expected(std::move(other)).swap(*this);
-      return *this;
-    }
-
-    void emplace() { expected().swap(*this); }
-
-    // x.x.4.4 swap
-
-    template <typename G = E>
-    nsel_REQUIRES_R(
-        void,
-        std17::is_swappable<G>::value &&std::is_move_constructible<G>::value)
-        swap(expected &other) noexcept(
-            std::is_nothrow_move_constructible<E>::value &&
-            std17::is_nothrow_swappable<E &>::value) {
-      using std::swap;
-
-      if (!bool(*this) && !bool(other)) {
-        swap(contained.error(), other.contained.error());
-      } else if (bool(*this) && !bool(other)) {
-        contained.construct_error(std::move(other.error()));
-        bool has_value = contained.has_value();
-        bool other_has_value = other.has_value();
-        other.contained.set_has_value(has_value);
-        contained.set_has_value(other_has_value);
-      } else if (!bool(*this) && bool(other)) {
-        other.swap(*this);
-      }
-    }
-
-    // x.x.4.5 observers
-
-    constexpr explicit operator bool() const noexcept { return has_value(); }
-
-    constexpr bool has_value() const noexcept { return contained.has_value(); }
-
-    void value() const {
-      if (!has_value()) {
-        error_traits<error_type>::rethrow(contained.error());
-      }
-    }
-
-    constexpr error_type const &error() const & {
-      return assert(!has_value()), contained.error();
-    }
-
-    error_type &error() & { return assert(!has_value()), contained.error(); }
+        error_type &error() & { return assert(!has_value()), contained.error(); }
 
 #if !nsel_COMPILER_GNUC_VERSION || nsel_COMPILER_GNUC_VERSION >= 490
 
-    constexpr error_type const &&error() const && {
-      return std::move((assert(!has_value()), contained.error()));
-    }
+        constexpr error_type const &&error() const && { return std::move((assert(!has_value()), contained.error())); }
 
-    error_type &&error() && {
-      return std::move((assert(!has_value()), contained.error()));
-    }
+        error_type &&error() && { return std::move((assert(!has_value()), contained.error())); }
 
 #endif
 
-    constexpr unexpected_type get_unexpected() const {
-      return make_unexpected(contained.error());
-    }
+        constexpr unexpected_type get_unexpected() const { return make_unexpected(contained.error()); }
 
-    template <typename Ex> bool has_exception() const {
-      using ContainedEx = typename std::remove_reference<
-          decltype(get_unexpected().value())>::type;
-      return !has_value() && std::is_base_of<Ex, ContainedEx>::value;
-    }
+        template<typename Ex>
+        bool has_exception() const
+        {
+            using ContainedEx = typename std::remove_reference<decltype(get_unexpected().value())>::type;
+            return !has_value() && std::is_base_of<Ex, ContainedEx>::value;
+        }
 
 #if nsel_P2505R >= 4
-    template <
-        typename G = E nsel_REQUIRES_T(std::is_copy_constructible<E>::value
-                                           &&std::is_convertible<G, E>::value)>
-    nsel_constexpr error_type error_or(G &&e) const & {
-      return has_value() ? static_cast<E>(std::forward<G>(e))
-                         : contained.error();
-    }
+        template<
+            typename G = E nsel_REQUIRES_T(std::is_copy_constructible<E>::value &&std::is_convertible<G, E>::value)>
+        nsel_constexpr error_type error_or(G &&e) const &
+        {
+            return has_value() ? static_cast<E>(std::forward<G>(e)) : contained.error();
+        }
 
-    template <
-        typename G = E nsel_REQUIRES_T(std::is_move_constructible<E>::value
-                                           &&std::is_convertible<G, E>::value)>
-    nsel_constexpr14 error_type error_or(G &&e) && {
-      return has_value() ? static_cast<E>(std::forward<G>(e))
-                         : std::move(contained.error());
-    }
-#endif // nsel_P2505R >= 4
+        template<
+            typename G = E nsel_REQUIRES_T(std::is_move_constructible<E>::value &&std::is_convertible<G, E>::value)>
+        nsel_constexpr14 error_type error_or(G &&e) &&
+        {
+            return has_value() ? static_cast<E>(std::forward<G>(e)) : std::move(contained.error());
+        }
+#endif// nsel_P2505R >= 4
 
 #if nsel_P2505R >= 3
-    // Monadic operations (P2505)
-    template <typename F nsel_REQUIRES_T(
-        detail::is_expected<detail::invoke_result_nocvref_t<F>>::value &&std::
-            is_same<typename detail::invoke_result_nocvref_t<F>::error_type,
-                    error_type>::value
-                &&std::is_constructible<error_type, error_type &>::value)>
-    nsel_constexpr14 detail::invoke_result_nocvref_t<F> and_then(F &&f) & {
-      return has_value()
-                 ? detail::invoke_result_nocvref_t<F>(
-                       detail::invoke(std::forward<F>(f)))
-                 : detail::invoke_result_nocvref_t<F>(unexpect, error());
-    }
+        // Monadic operations (P2505)
+        template<typename F nsel_REQUIRES_T(
+            detail::is_expected<detail::invoke_result_nocvref_t<F>>::value
+                &&std::is_same<typename detail::invoke_result_nocvref_t<F>::error_type, error_type>::value
+                    &&std::is_constructible<error_type, error_type &>::value)>
+        nsel_constexpr14 detail::invoke_result_nocvref_t<F> and_then(F &&f) &
+        {
+            return has_value() ? detail::invoke_result_nocvref_t<F>(detail::invoke(std::forward<F>(f)))
+                               : detail::invoke_result_nocvref_t<F>(unexpect, error());
+        }
 
-    template <typename F nsel_REQUIRES_T(
-        detail::is_expected<detail::invoke_result_nocvref_t<F>>::value &&std::
-            is_same<typename detail::invoke_result_nocvref_t<F>::error_type,
-                    error_type>::value
-                &&std::is_constructible<error_type, const error_type &>::value)>
-    nsel_constexpr detail::invoke_result_nocvref_t<F> and_then(F &&f) const & {
-      return has_value()
-                 ? detail::invoke_result_nocvref_t<F>(
-                       detail::invoke(std::forward<F>(f)))
-                 : detail::invoke_result_nocvref_t<F>(unexpect, error());
-    }
+        template<typename F nsel_REQUIRES_T(
+            detail::is_expected<detail::invoke_result_nocvref_t<F>>::value
+                &&std::is_same<typename detail::invoke_result_nocvref_t<F>::error_type, error_type>::value
+                    &&std::is_constructible<error_type, const error_type &>::value)>
+        nsel_constexpr detail::invoke_result_nocvref_t<F> and_then(F &&f) const &
+        {
+            return has_value() ? detail::invoke_result_nocvref_t<F>(detail::invoke(std::forward<F>(f)))
+                               : detail::invoke_result_nocvref_t<F>(unexpect, error());
+        }
 
 #if !nsel_COMPILER_GNUC_VERSION || nsel_COMPILER_GNUC_VERSION >= 490
-    template <typename F nsel_REQUIRES_T(
-        detail::is_expected<detail::invoke_result_nocvref_t<F>>::value &&std::
-            is_same<typename detail::invoke_result_nocvref_t<F>::error_type,
-                    error_type>::value
-                &&std::is_constructible<error_type, error_type &&>::value)>
-    nsel_constexpr14 detail::invoke_result_nocvref_t<F> and_then(F &&f) && {
-      return has_value() ? detail::invoke_result_nocvref_t<F>(
-                               detail::invoke(std::forward<F>(f)))
-                         : detail::invoke_result_nocvref_t<F>(
-                               unexpect, std::move(error()));
-    }
+        template<typename F nsel_REQUIRES_T(
+            detail::is_expected<detail::invoke_result_nocvref_t<F>>::value
+                &&std::is_same<typename detail::invoke_result_nocvref_t<F>::error_type, error_type>::value
+                    &&std::is_constructible<error_type, error_type &&>::value)>
+        nsel_constexpr14 detail::invoke_result_nocvref_t<F> and_then(F &&f) &&
+        {
+            return has_value() ? detail::invoke_result_nocvref_t<F>(detail::invoke(std::forward<F>(f)))
+                               : detail::invoke_result_nocvref_t<F>(unexpect, std::move(error()));
+        }
 
-    template <typename F nsel_REQUIRES_T(
-        detail::is_expected<detail::invoke_result_nocvref_t<F>>::value &&std::
-            is_same<typename detail::invoke_result_nocvref_t<F>::error_type,
-                    error_type>::value &&
-                std::is_constructible<error_type, const error_type &&>::value)>
-    nsel_constexpr detail::invoke_result_nocvref_t<F> and_then(F &&f) const && {
-      return has_value() ? detail::invoke_result_nocvref_t<F>(
-                               detail::invoke(std::forward<F>(f)))
-                         : detail::invoke_result_nocvref_t<F>(
-                               unexpect, std::move(error()));
-    }
+        template<typename F nsel_REQUIRES_T(
+            detail::is_expected<detail::invoke_result_nocvref_t<F>>::value
+                &&std::is_same<typename detail::invoke_result_nocvref_t<F>::error_type, error_type>::value
+                    &&std::is_constructible<error_type, const error_type &&>::value)>
+        nsel_constexpr detail::invoke_result_nocvref_t<F> and_then(F &&f) const &&
+        {
+            return has_value() ? detail::invoke_result_nocvref_t<F>(detail::invoke(std::forward<F>(f)))
+                               : detail::invoke_result_nocvref_t<F>(unexpect, std::move(error()));
+        }
 #endif
 
-    template <typename F nsel_REQUIRES_T(
-        detail::is_expected<detail::invoke_result_nocvref_t<F, error_type &>>::
-            value &&std::is_void<typename detail::invoke_result_nocvref_t<
-                F, error_type &>::value_type>::value)>
-    nsel_constexpr14 detail::invoke_result_nocvref_t<F, error_type &>
-    or_else(F &&f) & {
-      return has_value() ? detail::invoke_result_nocvref_t<F, error_type &>()
-                         : detail::invoke_result_nocvref_t<F, error_type &>(
-                               detail::invoke(std::forward<F>(f), error()));
-    }
+        template<typename F nsel_REQUIRES_T(
+            detail::is_expected<detail::invoke_result_nocvref_t<F, error_type &>>::value
+                &&std::is_void<typename detail::invoke_result_nocvref_t<F, error_type &>::value_type>::value)>
+        nsel_constexpr14 detail::invoke_result_nocvref_t<F, error_type &> or_else(F &&f) &
+        {
+            return has_value()
+                ? detail::invoke_result_nocvref_t<F, error_type &>()
+                : detail::invoke_result_nocvref_t<F, error_type &>(detail::invoke(std::forward<F>(f), error()));
+        }
 
-    template <typename F nsel_REQUIRES_T(
-        detail::is_expected<
-            detail::invoke_result_nocvref_t<F, const error_type &>>::value
-            &&std::is_void<typename detail::invoke_result_nocvref_t<
-                F, const error_type &>::value_type>::value)>
-    nsel_constexpr detail::invoke_result_nocvref_t<F, const error_type &>
-    or_else(F &&f) const & {
-      return has_value()
-                 ? detail::invoke_result_nocvref_t<F, const error_type &>()
-                 : detail::invoke_result_nocvref_t<F, const error_type &>(
-                       detail::invoke(std::forward<F>(f), error()));
-    }
+        template<typename F nsel_REQUIRES_T(
+            detail::is_expected<detail::invoke_result_nocvref_t<F, const error_type &>>::value
+                &&std::is_void<typename detail::invoke_result_nocvref_t<F, const error_type &>::value_type>::value)>
+        nsel_constexpr detail::invoke_result_nocvref_t<F, const error_type &> or_else(F &&f) const &
+        {
+            return has_value()
+                ? detail::invoke_result_nocvref_t<F, const error_type &>()
+                : detail::invoke_result_nocvref_t<F, const error_type &>(detail::invoke(std::forward<F>(f), error()));
+        }
 
 #if !nsel_COMPILER_GNUC_VERSION || nsel_COMPILER_GNUC_VERSION >= 490
-    template <typename F nsel_REQUIRES_T(
-        detail::is_expected<detail::invoke_result_nocvref_t<F, error_type &&>>::
-            value &&std::is_void<typename detail::invoke_result_nocvref_t<
-                F, error_type &&>::value_type>::value)>
-    nsel_constexpr14 detail::invoke_result_nocvref_t<F, error_type &&>
-    or_else(F &&f) && {
-      return has_value()
-                 ? detail::invoke_result_nocvref_t<F, error_type &&>()
-                 : detail::invoke_result_nocvref_t<F, error_type &&>(
-                       detail::invoke(std::forward<F>(f), std::move(error())));
-    }
+        template<typename F nsel_REQUIRES_T(
+            detail::is_expected<detail::invoke_result_nocvref_t<F, error_type &&>>::value
+                &&std::is_void<typename detail::invoke_result_nocvref_t<F, error_type &&>::value_type>::value)>
+        nsel_constexpr14 detail::invoke_result_nocvref_t<F, error_type &&> or_else(F &&f) &&
+        {
+            return has_value()
+                ? detail::invoke_result_nocvref_t<F, error_type &&>()
+                : detail::invoke_result_nocvref_t<F, error_type &&>(
+                      detail::invoke(std::forward<F>(f), std::move(error())));
+        }
 
-    template <typename F nsel_REQUIRES_T(
-        detail::is_expected<
-            detail::invoke_result_nocvref_t<F, const error_type &&>>::value
-            &&std::is_void<typename detail::invoke_result_nocvref_t<
-                F, const error_type &&>::value_type>::value)>
-    nsel_constexpr detail::invoke_result_nocvref_t<F, const error_type &&>
-    or_else(F &&f) const && {
-      return has_value()
-                 ? detail::invoke_result_nocvref_t<F, const error_type &&>()
-                 : detail::invoke_result_nocvref_t<F, const error_type &&>(
-                       detail::invoke(std::forward<F>(f), std::move(error())));
-    }
+        template<typename F nsel_REQUIRES_T(
+            detail::is_expected<detail::invoke_result_nocvref_t<F, const error_type &&>>::value
+                &&std::is_void<typename detail::invoke_result_nocvref_t<F, const error_type &&>::value_type>::value)>
+        nsel_constexpr detail::invoke_result_nocvref_t<F, const error_type &&> or_else(F &&f) const &&
+        {
+            return has_value()
+                ? detail::invoke_result_nocvref_t<F, const error_type &&>()
+                : detail::invoke_result_nocvref_t<F, const error_type &&>(
+                      detail::invoke(std::forward<F>(f), std::move(error())));
+        }
 #endif
 
-    template <typename F nsel_REQUIRES_T(
-        std::is_constructible<error_type, error_type &>::value &&
-        !std::is_void<detail::transform_invoke_result_t<F>>::value)>
-    nsel_constexpr14 expected<detail::transform_invoke_result_t<F>, error_type>
-    transform(F &&f) & {
-      return has_value()
-                 ? expected<detail::transform_invoke_result_t<F>, error_type>(
-                       detail::invoke(std::forward<F>(f)))
-                 : make_unexpected(error());
-    }
+        template<typename F nsel_REQUIRES_T(std::is_constructible<error_type, error_type &>::value
+                                            && !std::is_void<detail::transform_invoke_result_t<F>>::value)>
+        nsel_constexpr14 expected<detail::transform_invoke_result_t<F>, error_type> transform(F &&f) &
+        {
+            return has_value()
+                ? expected<detail::transform_invoke_result_t<F>, error_type>(detail::invoke(std::forward<F>(f)))
+                : make_unexpected(error());
+        }
 
-    template <typename F nsel_REQUIRES_T(
-        std::is_constructible<error_type, error_type &>::value
-            &&std::is_void<detail::transform_invoke_result_t<F>>::value)>
-    nsel_constexpr14 expected<void, error_type> transform(F &&f) & {
-      return has_value() ? (detail::invoke(std::forward<F>(f)),
-                            expected<void, error_type>())
-                         : make_unexpected(error());
-    }
+        template<typename F nsel_REQUIRES_T(std::is_constructible<error_type, error_type &>::value
+                                                &&std::is_void<detail::transform_invoke_result_t<F>>::value)>
+        nsel_constexpr14 expected<void, error_type> transform(F &&f) &
+        {
+            return has_value() ? (detail::invoke(std::forward<F>(f)), expected<void, error_type>())
+                               : make_unexpected(error());
+        }
 
-    template <typename F nsel_REQUIRES_T(
-        std::is_constructible<error_type, const error_type &>::value &&
-        !std::is_void<detail::transform_invoke_result_t<F>>::value)>
-    nsel_constexpr expected<detail::transform_invoke_result_t<F>, error_type>
-    transform(F &&f) const & {
-      return has_value()
-                 ? expected<detail::transform_invoke_result_t<F>, error_type>(
-                       detail::invoke(std::forward<F>(f)))
-                 : make_unexpected(error());
-    }
+        template<typename F nsel_REQUIRES_T(std::is_constructible<error_type, const error_type &>::value
+                                            && !std::is_void<detail::transform_invoke_result_t<F>>::value)>
+        nsel_constexpr expected<detail::transform_invoke_result_t<F>, error_type> transform(F &&f) const &
+        {
+            return has_value()
+                ? expected<detail::transform_invoke_result_t<F>, error_type>(detail::invoke(std::forward<F>(f)))
+                : make_unexpected(error());
+        }
 
-    template <typename F nsel_REQUIRES_T(
-        std::is_constructible<error_type, const error_type &>::value
-            &&std::is_void<detail::transform_invoke_result_t<F>>::value)>
-    nsel_constexpr expected<void, error_type> transform(F &&f) const & {
-      return has_value() ? (detail::invoke(std::forward<F>(f)),
-                            expected<void, error_type>())
-                         : make_unexpected(error());
-    }
+        template<typename F nsel_REQUIRES_T(std::is_constructible<error_type, const error_type &>::value
+                                                &&std::is_void<detail::transform_invoke_result_t<F>>::value)>
+        nsel_constexpr expected<void, error_type> transform(F &&f) const &
+        {
+            return has_value() ? (detail::invoke(std::forward<F>(f)), expected<void, error_type>())
+                               : make_unexpected(error());
+        }
 
 #if !nsel_COMPILER_GNUC_VERSION || nsel_COMPILER_GNUC_VERSION >= 490
-    template <typename F nsel_REQUIRES_T(
-        std::is_constructible<error_type, error_type &&>::value &&
-        !std::is_void<detail::transform_invoke_result_t<F>>::value)>
-    nsel_constexpr14 expected<detail::transform_invoke_result_t<F>, error_type>
-    transform(F &&f) && {
-      return has_value()
-                 ? expected<detail::transform_invoke_result_t<F>, error_type>(
-                       detail::invoke(std::forward<F>(f)))
-                 : make_unexpected(error());
-    }
+        template<typename F nsel_REQUIRES_T(std::is_constructible<error_type, error_type &&>::value
+                                            && !std::is_void<detail::transform_invoke_result_t<F>>::value)>
+        nsel_constexpr14 expected<detail::transform_invoke_result_t<F>, error_type> transform(F &&f) &&
+        {
+            return has_value()
+                ? expected<detail::transform_invoke_result_t<F>, error_type>(detail::invoke(std::forward<F>(f)))
+                : make_unexpected(error());
+        }
 
-    template <typename F nsel_REQUIRES_T(
-        std::is_constructible<error_type, error_type &&>::value
-            &&std::is_void<detail::transform_invoke_result_t<F>>::value)>
-    nsel_constexpr14 expected<void, error_type> transform(F &&f) && {
-      return has_value() ? (detail::invoke(std::forward<F>(f)),
-                            expected<void, error_type>())
-                         : make_unexpected(error());
-    }
+        template<typename F nsel_REQUIRES_T(std::is_constructible<error_type, error_type &&>::value
+                                                &&std::is_void<detail::transform_invoke_result_t<F>>::value)>
+        nsel_constexpr14 expected<void, error_type> transform(F &&f) &&
+        {
+            return has_value() ? (detail::invoke(std::forward<F>(f)), expected<void, error_type>())
+                               : make_unexpected(error());
+        }
 
-    template <typename F nsel_REQUIRES_T(
-        std::is_constructible<error_type, const error_type &&>::value &&
-        !std::is_void<detail::transform_invoke_result_t<F>>::value)>
-    nsel_constexpr expected<detail::transform_invoke_result_t<F>, error_type>
-    transform(F &&f) const && {
-      return has_value()
-                 ? expected<detail::transform_invoke_result_t<F>, error_type>(
-                       detail::invoke(std::forward<F>(f)))
-                 : make_unexpected(error());
-    }
+        template<typename F nsel_REQUIRES_T(std::is_constructible<error_type, const error_type &&>::value
+                                            && !std::is_void<detail::transform_invoke_result_t<F>>::value)>
+        nsel_constexpr expected<detail::transform_invoke_result_t<F>, error_type> transform(F &&f) const &&
+        {
+            return has_value()
+                ? expected<detail::transform_invoke_result_t<F>, error_type>(detail::invoke(std::forward<F>(f)))
+                : make_unexpected(error());
+        }
 
-    template <typename F nsel_REQUIRES_T(
-        std::is_constructible<error_type, const error_type &&>::value
-            &&std::is_void<detail::transform_invoke_result_t<F>>::value)>
-    nsel_constexpr expected<void, error_type> transform(F &&f) const && {
-      return has_value() ? (detail::invoke(std::forward<F>(f)),
-                            expected<void, error_type>())
-                         : make_unexpected(error());
-    }
+        template<typename F nsel_REQUIRES_T(std::is_constructible<error_type, const error_type &&>::value
+                                                &&std::is_void<detail::transform_invoke_result_t<F>>::value)>
+        nsel_constexpr expected<void, error_type> transform(F &&f) const &&
+        {
+            return has_value() ? (detail::invoke(std::forward<F>(f)), expected<void, error_type>())
+                               : make_unexpected(error());
+        }
 #endif
 
-    template <typename F nsel_REQUIRES_T(
-        detail::valid_unexpected_type<
-            detail::transform_invoke_result_t<F, error_type &>>::value)>
-    nsel_constexpr14
-        expected<void, detail::transform_invoke_result_t<F, error_type &>>
-        transform_error(F &&f) & {
-      return has_value()
-                 ? expected<void, detail::transform_invoke_result_t<
-                                      F, error_type &>>()
-                 : make_unexpected(detail::invoke(std::forward<F>(f), error()));
-    }
+        template<typename F nsel_REQUIRES_T(
+            detail::valid_unexpected_type<detail::transform_invoke_result_t<F, error_type &>>::value)>
+        nsel_constexpr14 expected<void, detail::transform_invoke_result_t<F, error_type &>> transform_error(F &&f) &
+        {
+            return has_value() ? expected<void, detail::transform_invoke_result_t<F, error_type &>>()
+                               : make_unexpected(detail::invoke(std::forward<F>(f), error()));
+        }
 
-    template <typename F nsel_REQUIRES_T(
-        detail::valid_unexpected_type<
-            detail::transform_invoke_result_t<F, const error_type &>>::value)>
-    nsel_constexpr
-        expected<void, detail::transform_invoke_result_t<F, const error_type &>>
-        transform_error(F &&f) const & {
-      return has_value()
-                 ? expected<void, detail::transform_invoke_result_t<
-                                      F, const error_type &>>()
-                 : make_unexpected(detail::invoke(std::forward<F>(f), error()));
-    }
+        template<typename F nsel_REQUIRES_T(
+            detail::valid_unexpected_type<detail::transform_invoke_result_t<F, const error_type &>>::value)>
+        nsel_constexpr expected<void, detail::transform_invoke_result_t<F, const error_type &>>
+        transform_error(F &&f) const &
+        {
+            return has_value() ? expected<void, detail::transform_invoke_result_t<F, const error_type &>>()
+                               : make_unexpected(detail::invoke(std::forward<F>(f), error()));
+        }
 
 #if !nsel_COMPILER_GNUC_VERSION || nsel_COMPILER_GNUC_VERSION >= 490
-    template <typename F nsel_REQUIRES_T(
-        detail::valid_unexpected_type<
-            detail::transform_invoke_result_t<F, error_type &&>>::value)>
-    nsel_constexpr14
-        expected<void, detail::transform_invoke_result_t<F, error_type &&>>
-        transform_error(F &&f) && {
-      return has_value() ? expected<void, detail::transform_invoke_result_t<
-                                              F, error_type &&>>()
-                         : make_unexpected(detail::invoke(std::forward<F>(f),
-                                                          std::move(error())));
-    }
+        template<typename F nsel_REQUIRES_T(
+            detail::valid_unexpected_type<detail::transform_invoke_result_t<F, error_type &&>>::value)>
+        nsel_constexpr14 expected<void, detail::transform_invoke_result_t<F, error_type &&>> transform_error(F &&f) &&
+        {
+            return has_value() ? expected<void, detail::transform_invoke_result_t<F, error_type &&>>()
+                               : make_unexpected(detail::invoke(std::forward<F>(f), std::move(error())));
+        }
 
-    template <typename F nsel_REQUIRES_T(
-        detail::valid_unexpected_type<
-            detail::transform_invoke_result_t<F, const error_type &&>>::value)>
-    nsel_constexpr
-        expected<void,
-                 detail::transform_invoke_result_t<F, const error_type &&>>
-        transform_error(F &&f) const && {
-      return has_value() ? expected<void, detail::transform_invoke_result_t<
-                                              F, const error_type &&>>()
-                         : make_unexpected(detail::invoke(std::forward<F>(f),
-                                                          std::move(error())));
-    }
+        template<typename F nsel_REQUIRES_T(
+            detail::valid_unexpected_type<detail::transform_invoke_result_t<F, const error_type &&>>::value)>
+        nsel_constexpr expected<void, detail::transform_invoke_result_t<F, const error_type &&>>
+        transform_error(F &&f) const &&
+        {
+            return has_value() ? expected<void, detail::transform_invoke_result_t<F, const error_type &&>>()
+                               : make_unexpected(detail::invoke(std::forward<F>(f), std::move(error())));
+        }
 #endif
-#endif // nsel_P2505R >= 3
+#endif// nsel_P2505R >= 3
 
-    //  template constexpr 'see below' unwrap() const&;
-    //
-    //  template 'see below' unwrap() &&;
+        //  template constexpr 'see below' unwrap() const&;
+        //
+        //  template 'see below' unwrap() &&;
 
-    // factories
+        // factories
 
-    //  template< typename Ex, typename F>
-    //  expected<void,E> catch_exception(F&& f);
-    //
-    //  template< typename F>
-    //  expected<decltype(func()), E> map(F&& func) ;
-    //
-    //  template< typename F>
-    //  'see below' bind(F&& func) ;
-    //
-    //  template< typename F>
-    //  expected<void,E> catch_error(F&& f);
-    //
-    //  template< typename F>
-    //  'see below' then(F&& func);
+        //  template< typename Ex, typename F>
+        //  expected<void,E> catch_exception(F&& f);
+        //
+        //  template< typename F>
+        //  expected<decltype(func()), E> map(F&& func) ;
+        //
+        //  template< typename F>
+        //  'see below' bind(F&& func) ;
+        //
+        //  template< typename F>
+        //  expected<void,E> catch_error(F&& f);
+        //
+        //  template< typename F>
+        //  'see below' then(F&& func);
 
-  private:
-    detail::storage_t<void, E, std::is_copy_constructible<E>::value,
-                      std::is_move_constructible<E>::value>
-        contained;
-  };
+    private:
+        detail::storage_t<void, E, std::is_copy_constructible<E>::value, std::is_move_constructible<E>::value>
+            contained;
+    };
 
-  // x.x.4.6 expected<>: comparison operators
+    // x.x.4.6 expected<>: comparison operators
 
-  template <typename T1, typename E1, typename T2,
-            typename E2 nsel_REQUIRES_T(!std::is_void<T1>::value &&
-                                        !std::is_void<T2>::value)>
-  constexpr bool operator==(expected<T1, E1> const &x,
-                            expected<T2, E2> const &y) {
-    return bool(x) != bool(y) ? false
-           : bool(x)          ? *x == *y
-                              : x.error() == y.error();
-  }
+    template<typename T1,
+             typename E1,
+             typename T2,
+             typename E2 nsel_REQUIRES_T(!std::is_void<T1>::value && !std::is_void<T2>::value)>
+    constexpr bool operator==(expected<T1, E1> const &x, expected<T2, E2> const &y)
+    {
+        return bool(x) != bool(y) ? false : bool(x) ? *x == *y : x.error() == y.error();
+    }
 
-  template <typename T1, typename E1, typename T2,
-            typename E2 nsel_REQUIRES_T(
-                std::is_void<T1>::value &&std::is_void<T2>::value)>
-  constexpr bool operator==(expected<T1, E1> const &x,
-                            expected<T2, E2> const &y) {
-    return bool(x) != bool(y)
-               ? false
-               : bool(x) || static_cast<bool>(x.error() == y.error());
-  }
+    template<typename T1,
+             typename E1,
+             typename T2,
+             typename E2 nsel_REQUIRES_T(std::is_void<T1>::value &&std::is_void<T2>::value)>
+    constexpr bool operator==(expected<T1, E1> const &x, expected<T2, E2> const &y)
+    {
+        return bool(x) != bool(y) ? false : bool(x) || static_cast<bool>(x.error() == y.error());
+    }
 
-  template <typename T1, typename E1, typename T2, typename E2>
-  constexpr bool operator!=(expected<T1, E1> const &x,
-                            expected<T2, E2> const &y) {
-    return !(x == y);
-  }
+    template<typename T1, typename E1, typename T2, typename E2>
+    constexpr bool operator!=(expected<T1, E1> const &x, expected<T2, E2> const &y)
+    {
+        return !(x == y);
+    }
 
 #if nsel_P0323R <= 2
 
-  template <typename T, typename E>
-  constexpr bool operator<(expected<T, E> const &x, expected<T, E> const &y) {
-    return (!y) ? false : (!x) ? true : *x < *y;
-  }
+    template<typename T, typename E>
+    constexpr bool operator<(expected<T, E> const &x, expected<T, E> const &y)
+    {
+        return (!y) ? false : (!x) ? true : *x < *y;
+    }
 
-  template <typename T, typename E>
-  constexpr bool operator>(expected<T, E> const &x, expected<T, E> const &y) {
-    return (y < x);
-  }
+    template<typename T, typename E>
+    constexpr bool operator>(expected<T, E> const &x, expected<T, E> const &y)
+    {
+        return (y < x);
+    }
 
-  template <typename T, typename E>
-  constexpr bool operator<=(expected<T, E> const &x, expected<T, E> const &y) {
-    return !(y < x);
-  }
+    template<typename T, typename E>
+    constexpr bool operator<=(expected<T, E> const &x, expected<T, E> const &y)
+    {
+        return !(y < x);
+    }
 
-  template <typename T, typename E>
-  constexpr bool operator>=(expected<T, E> const &x, expected<T, E> const &y) {
-    return !(x < y);
-  }
+    template<typename T, typename E>
+    constexpr bool operator>=(expected<T, E> const &x, expected<T, E> const &y)
+    {
+        return !(x < y);
+    }
 
 #endif
 
-  // x.x.4.7 expected: comparison with T
+    // x.x.4.7 expected: comparison with T
 
-  template <typename T1, typename E1,
-            typename T2 nsel_REQUIRES_T(!std::is_void<T1>::value)>
-  constexpr bool operator==(expected<T1, E1> const &x, T2 const &v) {
-    return bool(x) ? *x == v : false;
-  }
+    template<typename T1, typename E1, typename T2 nsel_REQUIRES_T(!std::is_void<T1>::value)>
+    constexpr bool operator==(expected<T1, E1> const &x, T2 const &v)
+    {
+        return bool(x) ? *x == v : false;
+    }
 
-  template <typename T1, typename E1,
-            typename T2 nsel_REQUIRES_T(!std::is_void<T1>::value)>
-  constexpr bool operator==(T2 const &v, expected<T1, E1> const &x) {
-    return bool(x) ? v == *x : false;
-  }
+    template<typename T1, typename E1, typename T2 nsel_REQUIRES_T(!std::is_void<T1>::value)>
+    constexpr bool operator==(T2 const &v, expected<T1, E1> const &x)
+    {
+        return bool(x) ? v == *x : false;
+    }
 
-  template <typename T1, typename E1, typename T2>
-  constexpr bool operator!=(expected<T1, E1> const &x, T2 const &v) {
-    return bool(x) ? *x != v : true;
-  }
+    template<typename T1, typename E1, typename T2>
+    constexpr bool operator!=(expected<T1, E1> const &x, T2 const &v)
+    {
+        return bool(x) ? *x != v : true;
+    }
 
-  template <typename T1, typename E1, typename T2>
-  constexpr bool operator!=(T2 const &v, expected<T1, E1> const &x) {
-    return bool(x) ? v != *x : true;
-  }
+    template<typename T1, typename E1, typename T2>
+    constexpr bool operator!=(T2 const &v, expected<T1, E1> const &x)
+    {
+        return bool(x) ? v != *x : true;
+    }
 
 #if nsel_P0323R <= 2
 
-  template <typename T, typename E>
-  constexpr bool operator<(expected<T, E> const &x, T const &v) {
-    return bool(x) ? *x < v : true;
-  }
+    template<typename T, typename E>
+    constexpr bool operator<(expected<T, E> const &x, T const &v)
+    {
+        return bool(x) ? *x < v : true;
+    }
 
-  template <typename T, typename E>
-  constexpr bool operator<(T const &v, expected<T, E> const &x) {
-    return bool(x) ? v < *x : false;
-  }
+    template<typename T, typename E>
+    constexpr bool operator<(T const &v, expected<T, E> const &x)
+    {
+        return bool(x) ? v < *x : false;
+    }
 
-  template <typename T, typename E>
-  constexpr bool operator>(T const &v, expected<T, E> const &x) {
-    return bool(x) ? *x < v : false;
-  }
+    template<typename T, typename E>
+    constexpr bool operator>(T const &v, expected<T, E> const &x)
+    {
+        return bool(x) ? *x < v : false;
+    }
 
-  template <typename T, typename E>
-  constexpr bool operator>(expected<T, E> const &x, T const &v) {
-    return bool(x) ? v < *x : false;
-  }
+    template<typename T, typename E>
+    constexpr bool operator>(expected<T, E> const &x, T const &v)
+    {
+        return bool(x) ? v < *x : false;
+    }
 
-  template <typename T, typename E>
-  constexpr bool operator<=(T const &v, expected<T, E> const &x) {
-    return bool(x) ? !(*x < v) : false;
-  }
+    template<typename T, typename E>
+    constexpr bool operator<=(T const &v, expected<T, E> const &x)
+    {
+        return bool(x) ? !(*x < v) : false;
+    }
 
-  template <typename T, typename E>
-  constexpr bool operator<=(expected<T, E> const &x, T const &v) {
-    return bool(x) ? !(v < *x) : true;
-  }
+    template<typename T, typename E>
+    constexpr bool operator<=(expected<T, E> const &x, T const &v)
+    {
+        return bool(x) ? !(v < *x) : true;
+    }
 
-  template <typename T, typename E>
-  constexpr bool operator>=(expected<T, E> const &x, T const &v) {
-    return bool(x) ? !(*x < v) : false;
-  }
+    template<typename T, typename E>
+    constexpr bool operator>=(expected<T, E> const &x, T const &v)
+    {
+        return bool(x) ? !(*x < v) : false;
+    }
 
-  template <typename T, typename E>
-  constexpr bool operator>=(T const &v, expected<T, E> const &x) {
-    return bool(x) ? !(v < *x) : true;
-  }
+    template<typename T, typename E>
+    constexpr bool operator>=(T const &v, expected<T, E> const &x)
+    {
+        return bool(x) ? !(v < *x) : true;
+    }
 
-#endif // nsel_P0323R
+#endif// nsel_P0323R
 
-  // x.x.4.8 expected: comparison with unexpected_type
+    // x.x.4.8 expected: comparison with unexpected_type
 
-  template <typename T1, typename E1, typename E2>
-  constexpr bool operator==(expected<T1, E1> const &x,
-                            unexpected_type<E2> const &u) {
-    return (!x) ? x.get_unexpected() == u : false;
-  }
+    template<typename T1, typename E1, typename E2>
+    constexpr bool operator==(expected<T1, E1> const &x, unexpected_type<E2> const &u)
+    {
+        return (!x) ? x.get_unexpected() == u : false;
+    }
 
-  template <typename T1, typename E1, typename E2>
-  constexpr bool operator==(unexpected_type<E2> const &u,
-                            expected<T1, E1> const &x) {
-    return (x == u);
-  }
+    template<typename T1, typename E1, typename E2>
+    constexpr bool operator==(unexpected_type<E2> const &u, expected<T1, E1> const &x)
+    {
+        return (x == u);
+    }
 
-  template <typename T1, typename E1, typename E2>
-  constexpr bool operator!=(expected<T1, E1> const &x,
-                            unexpected_type<E2> const &u) {
-    return !(x == u);
-  }
+    template<typename T1, typename E1, typename E2>
+    constexpr bool operator!=(expected<T1, E1> const &x, unexpected_type<E2> const &u)
+    {
+        return !(x == u);
+    }
 
-  template <typename T1, typename E1, typename E2>
-  constexpr bool operator!=(unexpected_type<E2> const &u,
-                            expected<T1, E1> const &x) {
-    return !(x == u);
-  }
+    template<typename T1, typename E1, typename E2>
+    constexpr bool operator!=(unexpected_type<E2> const &u, expected<T1, E1> const &x)
+    {
+        return !(x == u);
+    }
 
 #if nsel_P0323R <= 2
 
-  template <typename T, typename E>
-  constexpr bool operator<(expected<T, E> const &x,
-                           unexpected_type<E> const &u) {
-    return (!x) ? (x.get_unexpected() < u) : false;
-  }
+    template<typename T, typename E>
+    constexpr bool operator<(expected<T, E> const &x, unexpected_type<E> const &u)
+    {
+        return (!x) ? (x.get_unexpected() < u) : false;
+    }
 
-  template <typename T, typename E>
-  constexpr bool operator<(unexpected_type<E> const &u,
-                           expected<T, E> const &x) {
-    return (!x) ? (u < x.get_unexpected()) : true;
-  }
+    template<typename T, typename E>
+    constexpr bool operator<(unexpected_type<E> const &u, expected<T, E> const &x)
+    {
+        return (!x) ? (u < x.get_unexpected()) : true;
+    }
 
-  template <typename T, typename E>
-  constexpr bool operator>(expected<T, E> const &x,
-                           unexpected_type<E> const &u) {
-    return (u < x);
-  }
+    template<typename T, typename E>
+    constexpr bool operator>(expected<T, E> const &x, unexpected_type<E> const &u)
+    {
+        return (u < x);
+    }
 
-  template <typename T, typename E>
-  constexpr bool operator>(unexpected_type<E> const &u,
-                           expected<T, E> const &x) {
-    return (x < u);
-  }
+    template<typename T, typename E>
+    constexpr bool operator>(unexpected_type<E> const &u, expected<T, E> const &x)
+    {
+        return (x < u);
+    }
 
-  template <typename T, typename E>
-  constexpr bool operator<=(expected<T, E> const &x,
-                            unexpected_type<E> const &u) {
-    return !(u < x);
-  }
+    template<typename T, typename E>
+    constexpr bool operator<=(expected<T, E> const &x, unexpected_type<E> const &u)
+    {
+        return !(u < x);
+    }
 
-  template <typename T, typename E>
-  constexpr bool operator<=(unexpected_type<E> const &u,
-                            expected<T, E> const &x) {
-    return !(x < u);
-  }
+    template<typename T, typename E>
+    constexpr bool operator<=(unexpected_type<E> const &u, expected<T, E> const &x)
+    {
+        return !(x < u);
+    }
 
-  template <typename T, typename E>
-  constexpr bool operator>=(expected<T, E> const &x,
-                            unexpected_type<E> const &u) {
-    return !(u > x);
-  }
+    template<typename T, typename E>
+    constexpr bool operator>=(expected<T, E> const &x, unexpected_type<E> const &u)
+    {
+        return !(u > x);
+    }
 
-  template <typename T, typename E>
-  constexpr bool operator>=(unexpected_type<E> const &u,
-                            expected<T, E> const &x) {
-    return !(x > u);
-  }
+    template<typename T, typename E>
+    constexpr bool operator>=(unexpected_type<E> const &u, expected<T, E> const &x)
+    {
+        return !(x > u);
+    }
 
-#endif // nsel_P0323R
+#endif// nsel_P0323R
 
-  /// x.x.x Specialized algorithms
+    /// x.x.x Specialized algorithms
 
-  template <typename T,
-            typename E nsel_REQUIRES_T((std::is_void<T>::value ||
-                                        std::is_move_constructible<T>::value) &&
-                                       std::is_move_constructible<E>::value &&
-                                       std17::is_swappable<T>::value &&
-                                       std17::is_swappable<E>::value)>
-  void swap(expected<T, E> &x,
-            expected<T, E> &y) noexcept(noexcept(x.swap(y))) {
-    x.swap(y);
-  }
+    template<typename T,
+             typename E nsel_REQUIRES_T((std::is_void<T>::value || std::is_move_constructible<T>::value)
+                                        && std::is_move_constructible<E>::value && std17::is_swappable<T>::value
+                                        && std17::is_swappable<E>::value)>
+    void swap(expected<T, E> &x, expected<T, E> &y) noexcept(noexcept(x.swap(y)))
+    {
+        x.swap(y);
+    }
 
 #if nsel_P0323R <= 3
 
-  template <typename T>
-  constexpr auto
-  make_expected(T &&v) -> expected<typename std::decay<T>::type> {
-    return expected<typename std::decay<T>::type>(std::forward<T>(v));
-  }
-
-  // expected<void> specialization:
-
-  auto inline make_expected() -> expected<void> {
-    return expected<void>(in_place);
-  }
-
-  template <typename T>
-  constexpr auto make_expected_from_current_exception() -> expected<T> {
-    return expected<T>(make_unexpected_from_current_exception());
-  }
-
-  template <typename T>
-  auto make_expected_from_exception(std::exception_ptr v) -> expected<T> {
-    return expected<T>(unexpected_type<std::exception_ptr>(
-        std::forward<std::exception_ptr>(v)));
-  }
-
-  template <typename T, typename E>
-  constexpr auto
-  make_expected_from_error(E e) -> expected<T, typename std::decay<E>::type> {
-    return expected<T, typename std::decay<E>::type>(make_unexpected(e));
-  }
-
-  template <typename F nsel_REQUIRES_T(
-      !std::is_same<typename std::result_of<F()>::type, void>::value)>
-  /*nsel_constexpr14*/
-  auto
-  make_expected_from_call(F f) -> expected<typename std::result_of<F()>::type> {
-    try {
-      return make_expected(f());
-    } catch (...) {
-      return make_unexpected_from_current_exception();
+    template<typename T>
+    constexpr auto make_expected(T &&v) -> expected<typename std::decay<T>::type>
+    {
+        return expected<typename std::decay<T>::type>(std::forward<T>(v));
     }
-  }
 
-  template <typename F nsel_REQUIRES_T(
-      std::is_same<typename std::result_of<F()>::type, void>::value)>
-  /*nsel_constexpr14*/
-  auto make_expected_from_call(F f) -> expected<void> {
-    try {
-      f();
-      return make_expected();
-    } catch (...) {
-      return make_unexpected_from_current_exception();
+    // expected<void> specialization:
+
+    auto inline make_expected() -> expected<void> { return expected<void>(in_place); }
+
+    template<typename T>
+    constexpr auto make_expected_from_current_exception() -> expected<T>
+    {
+        return expected<T>(make_unexpected_from_current_exception());
     }
-  }
 
-#endif // nsel_P0323R
+    template<typename T>
+    auto make_expected_from_exception(std::exception_ptr v) -> expected<T>
+    {
+        return expected<T>(unexpected_type<std::exception_ptr>(std::forward<std::exception_ptr>(v)));
+    }
 
-  } // namespace expected_lite
+    template<typename T, typename E>
+    constexpr auto make_expected_from_error(E e) -> expected<T, typename std::decay<E>::type>
+    {
+        return expected<T, typename std::decay<E>::type>(make_unexpected(e));
+    }
 
-  using namespace expected_lite;
+    template<typename F nsel_REQUIRES_T(!std::is_same<typename std::result_of<F()>::type, void>::value)>
+    /*nsel_constexpr14*/
+    auto make_expected_from_call(F f) -> expected<typename std::result_of<F()>::type>
+    {
+        try {
+            return make_expected(f());
+        } catch (...) {
+            return make_unexpected_from_current_exception();
+        }
+    }
 
-  // using expected_lite::expected;
-  // using ...
+    template<typename F nsel_REQUIRES_T(std::is_same<typename std::result_of<F()>::type, void>::value)>
+    /*nsel_constexpr14*/
+    auto make_expected_from_call(F f) -> expected<void>
+    {
+        try {
+            f();
+            return make_expected();
+        } catch (...) {
+            return make_unexpected_from_current_exception();
+        }
+    }
 
-} // namespace nonstd
+#endif// nsel_P0323R
+
+    }// namespace expected_lite
+
+    using namespace expected_lite;
+
+    // using expected_lite::expected;
+    // using ...
+
+}// namespace nonstd
 
 namespace std {
 
 // expected: hash support
 
-template <typename T, typename E> struct hash<nonstd::expected<T, E>> {
-  using result_type = std::size_t;
-  using argument_type = nonstd::expected<T, E>;
+template<typename T, typename E>
+struct hash<nonstd::expected<T, E>> {
+    using result_type   = std::size_t;
+    using argument_type = nonstd::expected<T, E>;
 
-  constexpr result_type operator()(argument_type const &arg) const {
-    return arg ? std::hash<T>{}(*arg) : result_type{};
-  }
+    constexpr result_type operator()(argument_type const &arg) const
+    {
+        return arg ? std::hash<T>{}(*arg) : result_type{};
+    }
 };
 
 // TBD - ?? remove? see spec.
-template <typename T, typename E> struct hash<nonstd::expected<T &, E>> {
-  using result_type = std::size_t;
-  using argument_type = nonstd::expected<T &, E>;
+template<typename T, typename E>
+struct hash<nonstd::expected<T &, E>> {
+    using result_type   = std::size_t;
+    using argument_type = nonstd::expected<T &, E>;
 
-  constexpr result_type operator()(argument_type const &arg) const {
-    return arg ? std::hash<T>{}(*arg) : result_type{};
-  }
+    constexpr result_type operator()(argument_type const &arg) const
+    {
+        return arg ? std::hash<T>{}(*arg) : result_type{};
+    }
 };
 
 // TBD - implement
@@ -3039,19 +2868,21 @@ template <typename T, typename E> struct hash<nonstd::expected<T &, E>> {
 // otherwise it evaluates to an unspecified value if E is exception_ptr or
 // a combination of hashing false and hash<E>()(e.error()).
 
-template <typename E> struct hash<nonstd::expected<void, E>> {};
+template<typename E>
+struct hash<nonstd::expected<void, E>> {};
 
-} // namespace std
+}// namespace std
 
 namespace nonstd {
 
 // void unexpected() is deprecated && removed in C++17
 
 #if nsel_CPP17_OR_GREATER || nsel_COMPILER_MSVC_VERSION > 141
-template <typename E> using unexpected = unexpected_type<E>;
+template<typename E>
+using unexpected = unexpected_type<E>;
 #endif
 
-} // namespace nonstd
+}// namespace nonstd
 
 #undef nsel_REQUIRES
 #undef nsel_REQUIRES_0
@@ -3059,9 +2890,9 @@ template <typename E> using unexpected = unexpected_type<E>;
 
 nsel_RESTORE_WARNINGS()
 
-#endif // nsel_USES_STD_EXPECTED
+#endif// nsel_USES_STD_EXPECTED
 namespace std {
 using namespace nonstd;
 }
 
-#endif // NONSTD_EXPECTED_LITE_HPP
+#endif// NONSTD_EXPECTED_LITE_HPP
diff --git a/tile/base/exposed_var.cc b/tile/base/exposed_var.cc
index cd032e2..a33bc7f 100644
--- a/tile/base/exposed_var.cc
+++ b/tile/base/exposed_var.cc
@@ -8,293 +8,294 @@ namespace tile {
 // namespace exposed_var {
 
 namespace {
-#define CHECK_PATH(path)                                                       \
-  TILE_CHECK((path).size() <= 1 || (path).back() != '/',                       \
-             "Invalid path: [{}].", path);                                     \
-  TILE_CHECK((path).find("//") == tile::Slice::npos, "Invalid path: [{}].",    \
-             path);
+#define CHECK_PATH(path)                                                                                               \
+    TILE_CHECK((path).size() <= 1 || (path).back() != '/', "Invalid path: [{}].", path);                               \
+    TILE_CHECK((path).find("//") == tile::Slice::npos, "Invalid path: [{}].", path);
 
-#define CHECK_RELATIVE_PATH(path)                                              \
-  CHECK_PATH(path);                                                            \
-  TILE_CHECK((path).empty() || (path).front() != '/', "Invalid path: [{}].",   \
-             path);
+#define CHECK_RELATIVE_PATH(path)                                                                                      \
+    CHECK_PATH(path);                                                                                                  \
+    TILE_CHECK((path).empty() || (path).front() != '/', "Invalid path: [{}].", path);
 
-#define CHECK_ABSOLUTE_PATH(path)                                              \
-  CHECK_PATH(path);                                                            \
-  TILE_CHECK((path).empty() || (path).front() == '/', "Invalid path: [{}]",    \
-             path);
+#define CHECK_ABSOLUTE_PATH(path)                                                                                      \
+    CHECK_PATH(path);                                                                                                  \
+    TILE_CHECK((path).empty() || (path).front() == '/', "Invalid path: [{}]", path);
+
+std::pair<Slice, Slice>
+SplitFirstPart(Slice path)
+{
+    auto pos = path.find_first_of('/');
+    if (pos == tile::Slice::npos) {
+        return std::make_pair(path, "");
+    } else {
+        return std::make_pair(path.substr(0, pos), path.substr(pos + 1));
+    }
+}
+
+std::pair<Slice, Slice>
+SplitLastPart(Slice path)
+{
+    auto pos = path.find_last_of('/');
+    if (pos == tile::Slice::npos) { return std::make_pair("", path); }
 
-std::pair<Slice, Slice> SplitFirstPart(Slice path) {
-  auto pos = path.find_first_of('/');
-  if (pos == tile::Slice::npos) {
-    return std::make_pair(path, "");
-  } else {
     return std::make_pair(path.substr(0, pos), path.substr(pos + 1));
-  }
 }
 
-std::pair<Slice, Slice> SplitLastPart(Slice path) {
-  auto pos = path.find_last_of('/');
-  if (pos == tile::Slice::npos) {
-    return std::make_pair("", path);
-  }
+std::string
+JoinPath(Slice a, Slice b)
+{
+    if (EndsWith(b, "/")) { b.RemoveSuffix(1); }
 
-  return std::make_pair(path.substr(0, pos), path.substr(pos + 1));
+    if (EndsWith(a, "/")) { a.RemoveSuffix(1); }
+
+    if (b.empty()) { return a.ToString(); }
+    if (a.empty()) { return b.ToString(); }
+
+    return a.ToString() + "/" + b.ToString();
 }
 
-std::string JoinPath(Slice a, Slice b) {
-  if (EndsWith(b, "/")) {
-    b.RemoveSuffix(1);
-  }
-
-  if (EndsWith(a, "/")) {
-    a.RemoveSuffix(1);
-  }
-
-  if (b.empty()) {
-    return a.ToString();
-  }
-  if (a.empty()) {
-    return b.ToString();
-  }
-
-  return a.ToString() + "/" + b.ToString();
+std::string
+SubstituteEscapedSlashForZero(Slice path)
+{
+    TILE_CHECK(path.find('\0') == tile::Slice::npos);
+    return Replace(path, "\\/", '\0');
 }
 
-std::string SubstituteEscapedSlashForZero(Slice path) {
-  TILE_CHECK(path.find('\0') == tile::Slice::npos);
-  return Replace(path, "\\/", '\0');
+std::string
+SubstituteZeroForEscapedSlash(Slice path)
+{
+    return Replace(path, '\0', "\\/");
 }
 
-std::string SubstituteZeroForEscapedSlash(Slice path) {
-  return Replace(path, '\0', "\\/");
+std::string
+UnescapeZeroToPlainSlash(Slice path)
+{
+    return Replace(path, '\0', '/');
 }
 
-std::string UnescapeZeroToPlainSlash(Slice path) {
-  return Replace(path, '\0', '/');
-}
-
-} // namespace
+}// namespace
 
 // } // namespace exposed_var
 ExposedVarGroup::Handle
-ExposedVarGroup::Add(Slice rel_path, std::function<Json::Value()> value) {
+ExposedVarGroup::Add(Slice rel_path, std::function<Json::Value()> value)
+{
 
-  auto real_path = SubstituteEscapedSlashForZero(rel_path);
-  CHECK_RELATIVE_PATH(rel_path);
+    auto real_path = SubstituteEscapedSlashForZero(rel_path);
+    CHECK_RELATIVE_PATH(rel_path);
 
-  auto path_and_name = SplitLastPart(real_path);
-  auto name = path_and_name.second.ToString();
+    auto path_and_name = SplitLastPart(real_path);
+    auto name          = path_and_name.second.ToString();
 
-  auto moved_func = tile::MakeMoveOnCopy(value);
-  return CreateUpto(path_and_name.first)
-      ->AddDirect(
-          name,
-          [name, moved_func](Slice expected) -> std::optional<Json::Value> {
+    auto moved_func    = tile::MakeMoveOnCopy(value);
+    return CreateUpto(path_and_name.first)
+        ->AddDirect(name, [name, moved_func](Slice expected) -> std::optional<Json::Value> {
             auto jsv = moved_func.Ref()();
-            if (expected.empty()) {
-              return jsv;
-            }
+            if (expected.empty()) { return jsv; }
 
-            auto real_path = SubstituteEscapedSlashForZero(expected);
+            auto real_path   = SubstituteEscapedSlashForZero(expected);
             Json::Value *ptr = &jsv;
-            auto pieces = Split(real_path, '/');
+            auto pieces      = Split(real_path, '/');
 
             for (auto &&e : pieces) {
-              auto unescaped = UnescapeZeroToPlainSlash({e.data(), e.size()});
-              if (ptr->isObject()) {
-                if (ptr->isMember(unescaped)) {
-                  ptr = &(*ptr)[unescaped];
+                auto unescaped = UnescapeZeroToPlainSlash({e.data(), e.size()});
+                if (ptr->isObject()) {
+                    if (ptr->isMember(unescaped)) {
+                        ptr = &(*ptr)[unescaped];
+                    } else {
+                        return {};
+                    }
+                } else if (ptr->isArray()) {
+                    auto index = TryParse<std::size_t>(unescaped);
+                    if (index && *index < ptr->size()) {
+                        ptr = &(*ptr)[static_cast<Json::ArrayIndex>(*index)];
+                    } else {
+                        return {};
+                    }
                 } else {
-                  return {};
+                    return {};
                 }
-              } else if (ptr->isArray()) {
-                auto index = TryParse<std::size_t>(unescaped);
-                if (index && *index < ptr->size()) {
-                  ptr = &(*ptr)[static_cast<Json::ArrayIndex>(*index)];
-                } else {
-                  return {};
-                }
-              } else {
-                return {};
-              }
             }
 
             return *ptr;
-          });
+        });
 }
 
 ExposedVarGroup::Handle
-ExposedVarGroup::Add(Slice rel_path, ExposedVarDynamicTree *dynamic_tree) {
-  auto real_path = SubstituteEscapedSlashForZero(rel_path);
-  CHECK_RELATIVE_PATH(real_path);
-  auto path_and_name = SplitLastPart(real_path);
-  auto name = path_and_name.second.ToString();
+ExposedVarGroup::Add(Slice rel_path, ExposedVarDynamicTree *dynamic_tree)
+{
+    auto real_path = SubstituteEscapedSlashForZero(rel_path);
+    CHECK_RELATIVE_PATH(real_path);
+    auto path_and_name = SplitLastPart(real_path);
+    auto name          = path_and_name.second.ToString();
 
-  return CreateUpto(path_and_name.first)
-      ->AddDirect(name, [dynamic_tree](Slice inner_path) {
+    return CreateUpto(path_and_name.first)->AddDirect(name, [dynamic_tree](Slice inner_path) {
         return dynamic_tree->TryGet(inner_path);
-      });
+    });
 }
 
-ExposedVarGroup *ExposedVarGroup::FindOrCreate(Slice abs_path) {
-  auto real_path = SubstituteEscapedSlashForZero(abs_path);
-  CHECK_ABSOLUTE_PATH(real_path);
+ExposedVarGroup *
+ExposedVarGroup::FindOrCreate(Slice abs_path)
+{
+    auto real_path = SubstituteEscapedSlashForZero(abs_path);
+    CHECK_ABSOLUTE_PATH(real_path);
 
-  return Root()->CreateUpto(real_path.substr(1));
+    return Root()->CreateUpto(real_path.substr(1));
 }
-std::optional<Json::Value> ExposedVarGroup::TryGet(Slice abs_path) {
-  auto real_path = SubstituteEscapedSlashForZero(abs_path);
-  TILE_CHECK(!real_path.empty());
-  CHECK_ABSOLUTE_PATH(real_path);
 
-  if (real_path == "/") {
-    return Root()->Dump();
-  }
+std::optional<Json::Value>
+ExposedVarGroup::TryGet(Slice abs_path)
+{
+    auto real_path = SubstituteEscapedSlashForZero(abs_path);
+    TILE_CHECK(!real_path.empty());
+    CHECK_ABSOLUTE_PATH(real_path);
 
-  Slice left_path;
-  auto rel_path = real_path.substr(1);
-  auto parent = Root()->FindLowest(rel_path, &left_path);
+    if (real_path == "/") { return Root()->Dump(); }
 
-  auto name_and_rest = SplitFirstPart(left_path);
-  if (name_and_rest.first.empty()) {
-    return parent->Dump();
-  }
+    Slice left_path;
+    auto rel_path      = real_path.substr(1);
+    auto parent        = Root()->FindLowest(rel_path, &left_path);
 
-  auto s = name_and_rest.first.ToString();
-  std::lock_guard<std::mutex> lk(parent->lock_);
-  auto iter = parent->leaves_.find(s);
-  if (iter != parent->leaves_.end()) {
-    return iter->second(SubstituteZeroForEscapedSlash(name_and_rest.second));
-  } else {
-    auto iter = parent->nodes_.find(s);
-    if (iter != parent->nodes_.end()) {
-      return iter->second->Dump();
+    auto name_and_rest = SplitFirstPart(left_path);
+    if (name_and_rest.first.empty()) { return parent->Dump(); }
+
+    auto s = name_and_rest.first.ToString();
+    std::lock_guard<std::mutex> lk(parent->lock_);
+    auto iter = parent->leaves_.find(s);
+    if (iter != parent->leaves_.end()) {
+        return iter->second(SubstituteZeroForEscapedSlash(name_and_rest.second));
     } else {
-      return {};
+        auto iter = parent->nodes_.find(s);
+        if (iter != parent->nodes_.end()) {
+            return iter->second->Dump();
+        } else {
+            return {};
+        }
     }
-  }
 }
 
-ExposedVarGroup::ExposedVarGroup(std::string abs_path)
-    : abs_path_(std::move(abs_path)) {
-  CHECK_ABSOLUTE_PATH(abs_path);
+ExposedVarGroup::ExposedVarGroup(std::string abs_path) : abs_path_(std::move(abs_path))
+{
+    CHECK_ABSOLUTE_PATH(abs_path);
 }
 
-ExposedVarGroup *ExposedVarGroup::Root() {
-  static ExposedVarGroup evg("/");
-  return &evg;
+ExposedVarGroup *
+ExposedVarGroup::Root()
+{
+    static ExposedVarGroup evg("/");
+    return &evg;
 }
-const std::string &ExposedVarGroup::AbsolutePath() const { return abs_path_; }
 
-ExposedVarGroup *ExposedVarGroup::FindLowest(Slice rel_path, Slice *left) {
-  CHECK_RELATIVE_PATH(rel_path);
-  auto current = this;
+const std::string &
+ExposedVarGroup::AbsolutePath() const
+{
+    return abs_path_;
+}
 
-  while (!rel_path.empty()) {
-    auto name_and_rest = SplitFirstPart(rel_path);
+ExposedVarGroup *
+ExposedVarGroup::FindLowest(Slice rel_path, Slice *left)
+{
+    CHECK_RELATIVE_PATH(rel_path);
+    auto current = this;
 
-    std::lock_guard<std::mutex> lk(current->lock_);
-    auto iter = current->nodes_.find(name_and_rest.first.ToString());
-    if (iter == current->nodes_.end()) {
-      break;
-    } else {
-      current = &*iter->second;
+    while (!rel_path.empty()) {
+        auto name_and_rest = SplitFirstPart(rel_path);
+
+        std::lock_guard<std::mutex> lk(current->lock_);
+        auto iter = current->nodes_.find(name_and_rest.first.ToString());
+        if (iter == current->nodes_.end()) {
+            break;
+        } else {
+            current = &*iter->second;
+        }
+
+        rel_path = name_and_rest.second;
     }
 
-    rel_path = name_and_rest.second;
-  }
-
-  if (left) {
-    *left = rel_path;
-  }
-  return current;
+    if (left) { *left = rel_path; }
+    return current;
 }
 
-ExposedVarGroup *ExposedVarGroup::CreateUpto(Slice rel_path) {
-  CHECK_RELATIVE_PATH(rel_path);
+ExposedVarGroup *
+ExposedVarGroup::CreateUpto(Slice rel_path)
+{
+    CHECK_RELATIVE_PATH(rel_path);
 
-  Slice left_path;
-  auto current = FindLowest(rel_path, &left_path);
+    Slice left_path;
+    auto current = FindLowest(rel_path, &left_path);
 
-  auto pieces = Split(left_path, '/');
+    auto pieces  = Split(left_path, '/');
 
-  for (auto &&e : pieces) {
-    auto s = e.ToString();
+    for (auto &&e : pieces) {
+        auto s = e.ToString();
 
-    std::lock_guard<std::mutex> lk(current->lock_);
-    auto p = JoinPath(current->AbsolutePath(), s);
+        std::lock_guard<std::mutex> lk(current->lock_);
+        auto p = JoinPath(current->AbsolutePath(), s);
 
-    TILE_CHECK(
-        current->leaves_.find(s) == current->leaves_.end(),
-        "Path [{}] has already been used: A value is registered at [{}].",
-        rel_path, p);
+        TILE_CHECK(current->leaves_.find(s) == current->leaves_.end(),
+                   "Path [{}] has already been used: A value is registered at [{}].", rel_path, p);
 
-    TILE_CHECK(current->nodes_.find(s) == current->nodes_.end());
-    auto evg = std::unique_ptr<ExposedVarGroup>(new ExposedVarGroup(p));
-    current->nodes_[s] = std::move(evg);
-    current = &*(current->nodes_[s]);
-  }
+        TILE_CHECK(current->nodes_.find(s) == current->nodes_.end());
+        auto evg           = std::unique_ptr<ExposedVarGroup>(new ExposedVarGroup(p));
+        current->nodes_[s] = std::move(evg);
+        current            = &*(current->nodes_[s]);
+    }
 
-  TILE_CHECK(EndsWith(current->AbsolutePath(), rel_path), "[{}] vs [{}]",
-             current->AbsolutePath(), rel_path);
-  return current;
+    TILE_CHECK(EndsWith(current->AbsolutePath(), rel_path), "[{}] vs [{}]", current->AbsolutePath(), rel_path);
+    return current;
 }
 
-ExposedVarGroup::Handle ExposedVarGroup::AddDirect(Slice name, Getter value) {
-  auto s = name.ToString();
-  std::lock_guard<std::mutex> lk(lock_);
-
-  TILE_CHECK(leaves_.find(s) == leaves_.end(),
-             "Value [{}] has already been registered at [{}].", name,
-             AbsolutePath());
-  TILE_CHECK(nodes_.find(s) == nodes_.end(), "Path [{}] has already been used.",
-             JoinPath(AbsolutePath(), name));
-  leaves_[s] = std::move(value);
-
-  return Deferred([this, s] {
+ExposedVarGroup::Handle
+ExposedVarGroup::AddDirect(Slice name, Getter value)
+{
+    auto s = name.ToString();
     std::lock_guard<std::mutex> lk(lock_);
-    TILE_CHECK_EQ(leaves_.erase(s), 1);
-  });
+
+    TILE_CHECK(leaves_.find(s) == leaves_.end(), "Value [{}] has already been registered at [{}].", name,
+               AbsolutePath());
+    TILE_CHECK(nodes_.find(s) == nodes_.end(), "Path [{}] has already been used.", JoinPath(AbsolutePath(), name));
+    leaves_[s] = std::move(value);
+
+    return Deferred([this, s] {
+        std::lock_guard<std::mutex> lk(lock_);
+        TILE_CHECK_EQ(leaves_.erase(s), 1);
+    });
 }
 
-Json::Value ExposedVarGroup::Dump() const {
-  std::lock_guard<std::mutex> lk(lock_);
-  Json::Value jsv;
-  for (auto &&node : nodes_) {
-    jsv[UnescapeZeroToPlainSlash(node.first)] = node.second->Dump();
-  }
+Json::Value
+ExposedVarGroup::Dump() const
+{
+    std::lock_guard<std::mutex> lk(lock_);
+    Json::Value jsv;
+    for (auto &&node : nodes_) { jsv[UnescapeZeroToPlainSlash(node.first)] = node.second->Dump(); }
 
-  for (auto &&leave : leaves_) {
-    jsv[UnescapeZeroToPlainSlash(leave.first)] = *leave.second("");
-  }
+    for (auto &&leave : leaves_) { jsv[UnescapeZeroToPlainSlash(leave.first)] = *leave.second(""); }
 
-  return jsv;
+    return jsv;
 }
 
-ExposedVarDynamicTree::ExposedVarDynamicTree(
-    Slice rel_path, std::function<Json::Value()> getter,
-    ExposedVarGroup *parent)
-    : getter_(std::move(getter)) {
-  handle_ = parent->Add(rel_path, this);
+ExposedVarDynamicTree::ExposedVarDynamicTree(Slice rel_path,
+                                             std::function<Json::Value()> getter,
+                                             ExposedVarGroup *parent)
+    : getter_(std::move(getter))
+{
+    handle_ = parent->Add(rel_path, this);
 }
 
-std::optional<Json::Value> ExposedVarDynamicTree::TryGet(Slice rel_path) const {
-  auto real_path = SubstituteEscapedSlashForZero(rel_path);
-  auto jsv = getter_();
-  Json::Value *ptr = &jsv;
+std::optional<Json::Value>
+ExposedVarDynamicTree::TryGet(Slice rel_path) const
+{
+    auto real_path   = SubstituteEscapedSlashForZero(rel_path);
+    auto jsv         = getter_();
+    Json::Value *ptr = &jsv;
 
-  auto pieces = Split(real_path, '/');
-  for (auto &&e : pieces) {
-    auto unescaped = UnescapeZeroToPlainSlash({e.data(), e.size()});
-    ptr = &(*ptr)[unescaped];
-  }
+    auto pieces      = Split(real_path, '/');
+    for (auto &&e : pieces) {
+        auto unescaped = UnescapeZeroToPlainSlash({e.data(), e.size()});
+        ptr            = &(*ptr)[unescaped];
+    }
 
-  if (ptr->isNull()) {
-    return {};
-  }
+    if (ptr->isNull()) { return {}; }
 
-  return *ptr;
+    return *ptr;
 }
 
-} // namespace tile
+}// namespace tile
diff --git a/tile/base/exposed_var.h b/tile/base/exposed_var.h
index 85d347c..1c91ec0 100644
--- a/tile/base/exposed_var.h
+++ b/tile/base/exposed_var.h
@@ -15,179 +15,188 @@
 namespace tile {
 namespace exposed_var {
 
-template <typename T>
-auto ToJsonValue(const T &t)
-    -> enable_if_t<std::is_same<T, Json::Value>::value, Json::Value> {
-  return t;
+template<typename T>
+auto
+ToJsonValue(const T &t) -> enable_if_t<std::is_same<T, Json::Value>::value, Json::Value>
+{
+    return t;
 }
 
-template <typename T>
-auto ToJsonValue(const T &t)
-    -> enable_if_t<std::is_integral<T>::value && std::is_unsigned<T>::value,
-                   Json::Value> {
-  return Json::Value(static_cast<Json::UInt64>(t));
+template<typename T>
+auto
+ToJsonValue(const T &t) -> enable_if_t<std::is_integral<T>::value && std::is_unsigned<T>::value, Json::Value>
+{
+    return Json::Value(static_cast<Json::UInt64>(t));
 }
 
-template <typename T>
-auto ToJsonValue(const T &t)
-    -> enable_if_t<std::is_integral<T>::value && !std::is_unsigned<T>::value,
-                   Json::Value> {
-  return Json::Value(static_cast<Json::Int64>(t));
+template<typename T>
+auto
+ToJsonValue(const T &t) -> enable_if_t<std::is_integral<T>::value && !std::is_unsigned<T>::value, Json::Value>
+{
+    return Json::Value(static_cast<Json::Int64>(t));
 }
 
-template <typename T>
-auto ToJsonValue(const T &t)
-    -> enable_if_t<std::is_floating_point<T>::value ||
-                       std::is_same<T, std::string>::value ||
-                       std::is_same<T, const char *>::value ||
-                       std::is_same<T, bool>::value,
-                   Json::Value> {
-  return Json::Value(t);
+template<typename T>
+auto
+ToJsonValue(const T &t) -> enable_if_t<std::is_floating_point<T>::value || std::is_same<T, std::string>::value
+                                           || std::is_same<T, const char *>::value || std::is_same<T, bool>::value,
+                                       Json::Value>
+{
+    return Json::Value(t);
 }
 
-template <typename T>
-auto ToJsonValue(const T &t)
-    -> enable_if_t<
-        !std::is_integral<T>::value && !std::is_floating_point<T>::value &&
-            !std::is_same<T, std::string>::value &&
-            !std::is_same<T, const char *>::value &&
-            !std::is_same<T, bool>::value &&
-            std::is_same<std::string,
-                         decltype(format_as(std::declval<T>()))>::value,
-        Json::Value> {
-  return Json::Value(format_as(t));
+template<typename T>
+auto
+ToJsonValue(const T &t) -> enable_if_t<!std::is_integral<T>::value && !std::is_floating_point<T>::value
+                                           && !std::is_same<T, std::string>::value
+                                           && !std::is_same<T, const char *>::value && !std::is_same<T, bool>::value
+                                           && std::is_same<std::string, decltype(format_as(std::declval<T>()))>::value,
+                                       Json::Value>
+{
+    return Json::Value(format_as(t));
 }
 
-template <class T> Json::Value ToJsonValue(const std::atomic<T> &v) {
-  return ToJsonValue(v.load(std::memory_order_relaxed));
+template<class T>
+Json::Value
+ToJsonValue(const std::atomic<T> &v)
+{
+    return ToJsonValue(v.load(std::memory_order_relaxed));
 }
-} // namespace exposed_var
+}// namespace exposed_var
 
 class ExposedVarDynamicTree;
 
 class ExposedVarGroup {
 public:
-  using Handle = Deferred;
+    using Handle = Deferred;
 
-  Handle Add(Slice rel_path, std::function<Json::Value()> value);
-  Handle Add(Slice rel_path, ExposedVarDynamicTree *dyanmic_tree);
-  static ExposedVarGroup *FindOrCreate(Slice abs_path);
-  static std::optional<Json::Value> TryGet(Slice abs_path);
+    Handle Add(Slice rel_path, std::function<Json::Value()> value);
+    Handle Add(Slice rel_path, ExposedVarDynamicTree *dyanmic_tree);
+    static ExposedVarGroup *FindOrCreate(Slice abs_path);
+    static std::optional<Json::Value> TryGet(Slice abs_path);
 
 private:
-  using Getter = std::function<std::optional<Json::Value>(Slice)>;
+    using Getter = std::function<std::optional<Json::Value>(Slice)>;
 
-  explicit ExposedVarGroup(std::string abs_path);
-  const std::string &AbsolutePath() const;
+    explicit ExposedVarGroup(std::string abs_path);
+    const std::string &AbsolutePath() const;
 
-  ExposedVarGroup *FindLowest(Slice rel_path, Slice *left);
-  ExposedVarGroup *CreateUpto(Slice rel_path);
-  Handle AddDirect(Slice name, Getter getter);
-  Json::Value Dump() const;
-  static ExposedVarGroup *Root();
+    ExposedVarGroup *FindLowest(Slice rel_path, Slice *left);
+    ExposedVarGroup *CreateUpto(Slice rel_path);
+    Handle AddDirect(Slice name, Getter getter);
+    Json::Value Dump() const;
+    static ExposedVarGroup *Root();
 
 private:
-  std::string abs_path_;
-  mutable std::mutex lock_;
+    std::string abs_path_;
+    mutable std::mutex lock_;
 
-  std::unordered_map<std::string, std::unique_ptr<ExposedVarGroup>> nodes_;
-  std::unordered_map<std::string, Getter> leaves_;
+    std::unordered_map<std::string, std::unique_ptr<ExposedVarGroup>> nodes_;
+    std::unordered_map<std::string, Getter> leaves_;
 };
 
-template <typename T> class ExposedVar {
+template<typename T>
+class ExposedVar {
 public:
-  ExposedVar(Slice rel_path) {
-    LinkToParent(rel_path, ExposedVarGroup::FindOrCreate("/"));
-  }
+    ExposedVar(Slice rel_path) { LinkToParent(rel_path, ExposedVarGroup::FindOrCreate("/")); }
 
-  template <typename U>
-  ExposedVar(Slice rel_path, U &&initial_value,
-             ExposedVarGroup *parent = ExposedVarGroup::FindOrCreate("/"))
-      : obj_(std::forward<U>(initial_value)) {
-    LinkToParent(rel_path, parent);
-  }
+    template<typename U>
+    ExposedVar(Slice rel_path, U &&initial_value, ExposedVarGroup *parent = ExposedVarGroup::FindOrCreate("/"))
+        : obj_(std::forward<U>(initial_value))
+    {
+        LinkToParent(rel_path, parent);
+    }
 
-  T *operator->() noexcept { return &obj_; }
-  T &operator*() noexcept { return obj_; }
+    T *operator->() noexcept { return &obj_; }
+
+    T &operator*() noexcept { return obj_; }
 
 private:
-  void LinkToParent(Slice rel_path, ExposedVarGroup *parent) {
-    handle_ = parent->Add(rel_path,
-                          [this] { return exposed_var::ToJsonValue(obj_); });
-  }
+    void LinkToParent(Slice rel_path, ExposedVarGroup *parent)
+    {
+        handle_ = parent->Add(rel_path, [this] { return exposed_var::ToJsonValue(obj_); });
+    }
 
 private:
-  T obj_{};
-  ExposedVarGroup::Handle handle_;
+    T obj_{};
+    ExposedVarGroup::Handle handle_;
 };
 
-template <typename T> class ExposedVarDynamic {
+template<typename T>
+class ExposedVarDynamic {
 public:
-  ExposedVarDynamic(
-      Slice rel_path, std::function<T()> getter,
-      ExposedVarGroup *parent = ExposedVarGroup::FindOrCreate("/"))
-      : getter_(std::move(getter)) {
-    handle_ = parent->Add(
-        rel_path, [this] { return exposed_var::ToJsonValue(getter_()); });
-  }
+    ExposedVarDynamic(Slice rel_path,
+                      std::function<T()> getter,
+                      ExposedVarGroup *parent = ExposedVarGroup::FindOrCreate("/"))
+        : getter_(std::move(getter))
+    {
+        handle_ = parent->Add(rel_path, [this] { return exposed_var::ToJsonValue(getter_()); });
+    }
 
 private:
-  std::function<T()> getter_;
-  ExposedVarGroup::Handle handle_;
+    std::function<T()> getter_;
+    ExposedVarGroup::Handle handle_;
 };
 
 class ExposedVarDynamicTree {
 public:
-  ExposedVarDynamicTree(
-      Slice rel_path, std::function<Json::Value()> getter,
-      ExposedVarGroup *parent = ExposedVarGroup::FindOrCreate("/"));
+    ExposedVarDynamicTree(Slice rel_path,
+                          std::function<Json::Value()> getter,
+                          ExposedVarGroup *parent = ExposedVarGroup::FindOrCreate("/"));
 
-  std::optional<Json::Value> TryGet(Slice rel_path) const;
+    std::optional<Json::Value> TryGet(Slice rel_path) const;
 
 private:
-  std::function<Json::Value()> getter_;
-  ExposedVarGroup::Handle handle_;
+    std::function<Json::Value()> getter_;
+    ExposedVarGroup::Handle handle_;
 };
 
 namespace detail {
-template <typename T> struct IdentityTime {
-  std::uint64_t operator()(const T &val) const {
-    return (ReadSteadyClock() - std::chrono::steady_clock::time_point()) /
-           std::chrono::nanoseconds(1);
-  }
+template<typename T>
+struct IdentityTime {
+    std::uint64_t operator()(const T &val) const
+    {
+        return (ReadSteadyClock() - std::chrono::steady_clock::time_point()) / std::chrono::nanoseconds(1);
+    }
 };
-} // namespace detail
+}// namespace detail
 
-template <typename T, typename F = detail::IdentityTime<T>>
+template<typename T, typename F = detail::IdentityTime<T>>
 class ExposedMetrics {
 public:
-  explicit ExposedMetrics(Slice rel_path) {
-    LinkToParent(rel_path, ExposedVarGroup::FindOrCreate("/"));
-  }
+    explicit ExposedMetrics(Slice rel_path) { LinkToParent(rel_path, ExposedVarGroup::FindOrCreate("/")); }
 
 private:
-  Json::Value ToJsonValue(const T &v) {
-    Json::Value result;
-    std::unordered_map<std::string, T> m = {{"1s", 1}};
-    for (auto &&item : m) {
+    Json::Value ToJsonValue(const T &v)
+    {
+        Json::Value result;
+        std::unordered_map<std::string, T> m = {
+            {"1s", 1}
+        };
+        for (auto &&item : m) {}
     }
-  }
 
-  void LinkToParent(Slice rel_path, ExposedVarGroup *parent) {
-    handle_ = parent->Add(rel_path, [this] { return ToJsonValue(obj_); });
-  }
+    void LinkToParent(Slice rel_path, ExposedVarGroup *parent)
+    {
+        handle_ = parent->Add(rel_path, [this] { return ToJsonValue(obj_); });
+    }
 
 private:
-  T obj_{};
-  ExposedVarGroup::Handle handle_;
+    T obj_{};
+    ExposedVarGroup::Handle handle_;
 };
 
-template <typename T> using ExposedCounter = ExposedVar<T>;
-template <typename T> using ExposedGauge = ExposedVar<T>;
-template <typename T> using ExposedMiner = ExposedVar<T>;
-template <typename T> using ExposedMaxer = ExposedVar<T>;
-template <typename T> using ExposedAverager = ExposedVar<T>;
+template<typename T>
+using ExposedCounter = ExposedVar<T>;
+template<typename T>
+using ExposedGauge = ExposedVar<T>;
+template<typename T>
+using ExposedMiner = ExposedVar<T>;
+template<typename T>
+using ExposedMaxer = ExposedVar<T>;
+template<typename T>
+using ExposedAverager = ExposedVar<T>;
 
-} // namespace tile
+}// namespace tile
 
-#endif // TILE_BASE_EXPOSED_VAR_H
+#endif// TILE_BASE_EXPOSED_VAR_H
diff --git a/tile/base/exposed_var_test.cc b/tile/base/exposed_var_test.cc
index 2c078c7..d1bc6c4 100644
--- a/tile/base/exposed_var_test.cc
+++ b/tile/base/exposed_var_test.cc
@@ -4,14 +4,19 @@
 #include "json/json.h"
 
 namespace tile {
-ExposedVarGroup *GetFancyGroup() {
-  return ExposedVarGroup::FindOrCreate("/a/b");
+ExposedVarGroup *
+GetFancyGroup()
+{
+    return ExposedVarGroup::FindOrCreate("/a/b");
 }
-Json::Value GetTree() {
-  Json::Value jsv;
-  jsv["dir"]["sub-dir"]["key"] = 5;
-  jsv["key"] = "6";
-  return jsv;
+
+Json::Value
+GetTree()
+{
+    Json::Value jsv;
+    jsv["dir"]["sub-dir"]["key"] = 5;
+    jsv["key"]                   = "6";
+    return jsv;
 }
 
 ExposedVar<int> v1("v1", 5);
@@ -21,18 +26,18 @@ ExposedVar<double> f1("f1", 6.2, ExposedVarGroup::FindOrCreate("/x/y/z"));
 auto GreatGroup = ExposedVarGroup::FindOrCreate("/a/b");
 
 // `/a/b/ds1`
-ExposedVarDynamic<std::string>
-    ds1("ds1", [] { return "test_str"; }, GetFancyGroup());
+ExposedVarDynamic<std::string> ds1("ds1", [] { return "test_str"; }, GetFancyGroup());
 
-TEST(ExposedVar, Mutate) {
-  auto opt = ExposedVarGroup::TryGet("/");
-  ASSERT_TRUE(opt);
-  auto &&jsv = *opt;
-  ASSERT_EQ(5, jsv["v1"].asInt());
-  *v1 = 6;
-  jsv = *ExposedVarGroup::TryGet("/");
-  ASSERT_EQ(6, jsv["v1"].asInt());
-  *v1 = 5;
+TEST(ExposedVar, Mutate)
+{
+    auto opt = ExposedVarGroup::TryGet("/");
+    ASSERT_TRUE(opt);
+    auto &&jsv = *opt;
+    ASSERT_EQ(5, jsv["v1"].asInt());
+    *v1 = 6;
+    jsv = *ExposedVarGroup::TryGet("/");
+    ASSERT_EQ(6, jsv["v1"].asInt());
+    *v1 = 5;
 }
 
-} // namespace tile
+}// namespace tile
diff --git a/tile/base/future.h b/tile/base/future.h
index 605ef06..a48cb99 100644
--- a/tile/base/future.h
+++ b/tile/base/future.h
@@ -22,6 +22,6 @@ using future::Split;
 using future::WhenAll;
 using future::WhenAny;
 
-} // namespace tile
+}// namespace tile
 
-#endif // TILE_BASE_FUTURE_H
+#endif// TILE_BASE_FUTURE_H
diff --git a/tile/base/future/basic.h b/tile/base/future/basic.h
index a07c501..1880930 100644
--- a/tile/base/future/basic.h
+++ b/tile/base/future/basic.h
@@ -10,54 +10,63 @@
 
 namespace tile {
 namespace future {
-template <typename... Ts>
-struct are_rvalue_refs
-    : internal::conjunction<std::is_rvalue_reference<Ts>...> {};
+template<typename... Ts>
+struct are_rvalue_refs : internal::conjunction<std::is_rvalue_reference<Ts>...> {};
+
 static_assert(are_rvalue_refs<int &&, char &&>::value, "");
 static_assert(!are_rvalue_refs<int, char &&>::value, "");
 
 // Rebinds `Ts...` in `TT<....>` to `UT<...>`
 // Example:
 // rebind_t<Future<int, double>, Promise<>> -> Promise<int, double>
-template <typename T, template <typename...> class To> struct rebind;
-template <template <typename...> class From, typename... Ts,
-          template <typename...> class To>
+template<typename T, template<typename...> class To>
+struct rebind;
+
+template<template<typename...> class From, typename... Ts, template<typename...> class To>
 struct rebind<From<Ts...>, To> {
-  using type = To<Ts...>;
+    using type = To<Ts...>;
 };
-template <typename T, template <typename...> class To>
+template<typename T, template<typename...> class To>
 using rebind_t = typename rebind<T, To>::type;
 
-static_assert(std::is_same<rebind_t<std::common_type<>, Types>, Types<>>::value,
-              "");
-static_assert(std::is_same<rebind_t<std::common_type<int, char>, Types>,
-                           Types<int, char>>::value,
-              "");
+static_assert(std::is_same<rebind_t<std::common_type<>, Types>, Types<>>::value, "");
+static_assert(std::is_same<rebind_t<std::common_type<int, char>, Types>, Types<int, char>>::value, "");
 
 // Basic templates.
-template <typename... Ts> class Future;
-template <typename... Ts> class Promise;
-template <typename... Ts> class Boxed;
+template<typename... Ts>
+class Future;
+template<typename... Ts>
+class Promise;
+template<typename... Ts>
+class Boxed;
 
-template <typename T> struct is_future : std::false_type {};
-template <typename... Ts> struct is_future<Future<Ts...>> : std::true_type {};
+template<typename T>
+struct is_future : std::false_type {};
+
+template<typename... Ts>
+struct is_future<Future<Ts...>> : std::true_type {};
 
 static_assert(!is_future<char *>::value, "");
 static_assert(is_future<Future<>>::value, "");
 static_assert(is_future<Future<char *>>::value, "");
 static_assert(is_future<Future<char *, int>>::value, "");
 
-template <typename... Ts>
+template<typename... Ts>
 struct is_futures : internal::conjunction<is_future<Ts>...> {};
 
-template <typename... Ts> struct futurize {
-  using type = Future<Ts...>;
+template<typename... Ts>
+struct futurize {
+    using type = Future<Ts...>;
 };
 
-template <> struct futurize<void> : futurize<> {};
+template<>
+struct futurize<void> : futurize<> {};
 
-template <typename... Ts> struct futurize<Future<Ts...>> : futurize<Ts...> {};
-template <typename... Ts> using futurize_t = typename futurize<Ts...>::type;
+template<typename... Ts>
+struct futurize<Future<Ts...>> : futurize<Ts...> {};
+
+template<typename... Ts>
+using futurize_t = typename futurize<Ts...>::type;
 
 static_assert(std::is_same<futurize_t<int>, Future<int>>::value, "");
 static_assert(std::is_same<futurize_t<>, Future<>>::value, "");
@@ -66,41 +75,43 @@ static_assert(std::is_same<futurize_t<Future<int>>, Future<int>>::value, "");
 // Concatenate `Ts...` in multiple `Future<Ts...>`
 // Example:
 // flatten<Future<T1, T2>, Future<T3>> -> Future<T1, T2, T3>
-template <typename... Ts> struct flatten {
-  using type = rebind_t<types_cat_t<rebind_t<Ts, Types>...>, Future>;
+template<typename... Ts>
+struct flatten {
+    using type = rebind_t<types_cat_t<rebind_t<Ts, Types>...>, Future>;
 };
-template <typename... Ts> using flatten_t = typename flatten<Ts...>::type;
-static_assert(std::is_same<flatten_t<Future<void *>, Future<>, Future<char>>,
-                           Future<void *, char>>::value,
-              "");
 
-template <typename T> using as_boxed_t = rebind_t<T, Boxed>;
-template <typename T> using as_promise_t = rebind_t<T, Promise>;
+template<typename... Ts>
+using flatten_t = typename flatten<Ts...>::type;
+static_assert(std::is_same<flatten_t<Future<void *>, Future<>, Future<char>>, Future<void *, char>>::value, "");
+
+template<typename T>
+using as_boxed_t = rebind_t<T, Boxed>;
+template<typename T>
+using as_promise_t = rebind_t<T, Promise>;
 
 static_assert(std::is_same<as_boxed_t<Future<>>, Boxed<>>::value, "");
-static_assert(
-    std::is_same<as_boxed_t<Future<int, char>>, Boxed<int, char>>::value, "");
+static_assert(std::is_same<as_boxed_t<Future<int, char>>, Boxed<int, char>>::value, "");
 static_assert(std::is_same<as_promise_t<Future<>>, Promise<>>::value, "");
-static_assert(
-    std::is_same<as_promise_t<Future<int, char>>, Promise<int, char>>::value,
-    "");
+static_assert(std::is_same<as_promise_t<Future<int, char>>, Promise<int, char>>::value, "");
 
-template <typename... Ts> struct unboxed_type {
-  using type = typename internal::conditional_t<
-      sizeof...(Ts) == 0, std::common_type<void>,
-      internal::conditional_t<sizeof...(Ts) == 1, std::common_type<Ts...>,
-                              typename std::common_type<std::tuple<Ts...>>>>::
-      type;
+template<typename... Ts>
+struct unboxed_type {
+    using type =
+        typename internal::conditional_t<sizeof...(Ts) == 0,
+                                         std::common_type<void>,
+                                         internal::conditional_t<sizeof...(Ts) == 1,
+                                                                 std::common_type<Ts...>,
+                                                                 typename std::common_type<std::tuple<Ts...>>>>::type;
 };
-template <typename... Ts>
+
+template<typename... Ts>
 using unboxed_type_t = typename unboxed_type<Ts...>::type;
 
 static_assert(std::is_same<unboxed_type_t<>, void>::value, "");
 static_assert(std::is_same<unboxed_type_t<int>, int>::value, "");
-static_assert(
-    std::is_same<unboxed_type_t<int, char>, std::tuple<int, char>>::value, "");
+static_assert(std::is_same<unboxed_type_t<int, char>, std::tuple<int, char>>::value, "");
 
-} // namespace future
-} // namespace tile
+}// namespace future
+}// namespace tile
 
-#endif // TILE_BASE_FUTURE_BASIC_H
+#endif// TILE_BASE_FUTURE_BASIC_H
diff --git a/tile/base/future/boxed.h b/tile/base/future/boxed.h
index fb2c70c..8ad461f 100644
--- a/tile/base/future/boxed.h
+++ b/tile/base/future/boxed.h
@@ -13,159 +13,175 @@ namespace tile {
 namespace future {
 namespace detail {
 // T = Boxed<...>
-template <typename T> T RetrieveBoxed();
-} // namespace detail
+template<typename T>
+T RetrieveBoxed();
+}// namespace detail
+
 struct box_values_t {
-  explicit box_values_t() = default;
+    explicit box_values_t() = default;
 };
+
 constexpr auto box_values = box_values_t();
 
-template <typename... Ts> class Boxed {
+template<typename... Ts>
+class Boxed {
 
 public:
-  static_assert(!types_contains<Types<Ts...>, void>::value,
-                "Don't allow void in Boxed<Ts...>");
-  using value_type = std::tuple<Ts...>;
+    static_assert(!types_contains<Types<Ts...>, void>::value, "Don't allow void in Boxed<Ts...>");
+    using value_type = std::tuple<Ts...>;
 
-  using lvalue_ref = internal::add_lvalue_reference_t<unboxed_type_t<Ts...>>;
+    using lvalue_ref = internal::add_lvalue_reference_t<unboxed_type_t<Ts...>>;
 
-  using rvalue_ref = internal::add_rvalue_reference_t<unboxed_type_t<Ts...>>;
+    using rvalue_ref = internal::add_rvalue_reference_t<unboxed_type_t<Ts...>>;
 
-  template <typename... Us,
-            typename =
-                enable_if_t<std::is_constructible<value_type, Us &&...>::value>>
-  explicit Boxed(box_values_t, Us &&...imms);
-  template <typename... Us, typename = enable_if_t<std::is_constructible<
-                                value_type, std::tuple<Us &&...>>::value>>
-  Boxed(Boxed<Us...> boxed);
+    template<typename... Us, typename = enable_if_t<std::is_constructible<value_type, Us &&...>::value>>
+    explicit Boxed(box_values_t, Us &&...imms);
+    template<typename... Us, typename = enable_if_t<std::is_constructible<value_type, std::tuple<Us &&...>>::value>>
+    Boxed(Boxed<Us...> boxed);
 
-  lvalue_ref Get() &;
-  rvalue_ref Get() &&;
-  // internal::add_lvalue_reference_t<unboxed_type_t<Ts...>> Get() &;
-  // internal::add_rvalue_reference_t<unboxed_type_t<Ts...>> Get() &&;
+    lvalue_ref Get() &;
+    rvalue_ref Get() &&;
+    // internal::add_lvalue_reference_t<unboxed_type_t<Ts...>> Get() &;
+    // internal::add_rvalue_reference_t<unboxed_type_t<Ts...>> Get() &&;
 
-  value_type &GetRaw() &;
-  value_type &&GetRaw() &&;
+    value_type &GetRaw() &;
+    value_type &&GetRaw() &&;
 
 private:
-  template <typename T> friend T detail::RetrieveBoxed();
-  template <typename... Us> friend class Boxed;
+    template<typename T>
+    friend T detail::RetrieveBoxed();
+    template<typename... Us>
+    friend class Boxed;
 
-  static constexpr std::size_t kEmpty = 0;
-  static constexpr std::size_t kValue = 1;
+    static constexpr std::size_t kEmpty = 0;
+    static constexpr std::size_t kValue = 1;
 
-  Boxed() = default;
+    Boxed()                             = default;
 
-  template <typename... Us>
-  enable_if_t<sizeof...(Us) == 0, lvalue_ref> GetImpl() & {
-    return (void)GetRaw();
-  }
+    template<typename... Us>
+    enable_if_t<sizeof...(Us) == 0, lvalue_ref> GetImpl() &
+    {
+        return (void) GetRaw();
+    }
 
-  template <typename... Us>
-  enable_if_t<sizeof...(Us) == 1, lvalue_ref> GetImpl() & {
-    return std::get<0>(GetRaw());
-  }
+    template<typename... Us>
+    enable_if_t<sizeof...(Us) == 1, lvalue_ref> GetImpl() &
+    {
+        return std::get<0>(GetRaw());
+    }
 
-  template <typename... Us>
-  enable_if_t<(sizeof...(Us) > 1), lvalue_ref> GetImpl() & {
-    return GetRaw();
-  }
+    template<typename... Us>
+    enable_if_t<(sizeof...(Us) > 1), lvalue_ref> GetImpl() &
+    {
+        return GetRaw();
+    }
 
-  template <typename... Us>
-  enable_if_t<std::is_void<decltype(std::declval<Boxed<Us...>>().Get())>::value,
-              rvalue_ref>
-  GetMoveImpl() & {
-    return Get();
-  }
-  template <typename... Us>
-  enable_if_t<
-      !std::is_void<decltype(std::declval<Boxed<Us...>>().Get())>::value,
-      rvalue_ref>
-  GetMoveImpl() & {
-    return std::move(Get());
-  }
+    template<typename... Us>
+    enable_if_t<std::is_void<decltype(std::declval<Boxed<Us...>>().Get())>::value, rvalue_ref> GetMoveImpl() &
+    {
+        return Get();
+    }
+
+    template<typename... Us>
+    enable_if_t<!std::is_void<decltype(std::declval<Boxed<Us...>>().Get())>::value, rvalue_ref> GetMoveImpl() &
+    {
+        return std::move(Get());
+    }
 
 private:
-  std::variant<mpark::monostate, value_type> holding_;
+    std::variant<mpark::monostate, value_type> holding_;
 };
 
 static_assert(std::is_void<decltype(std::declval<Boxed<>>().Get())>::value, "");
-static_assert(!std::is_void<decltype(std::declval<Boxed<int>>().Get())>::value,
-              "");
-static_assert(
-    !std::is_void<decltype(std::declval<Boxed<int, char>>().Get())>::value, "");
+static_assert(!std::is_void<decltype(std::declval<Boxed<int>>().Get())>::value, "");
+static_assert(!std::is_void<decltype(std::declval<Boxed<int, char>>().Get())>::value, "");
 
-static_assert(
-    std::is_constructible<Boxed<int, double>, box_values_t, int, char>::value,
-    "");
-static_assert(
-    std::is_constructible<Boxed<int, double>, Boxed<double, float>>::value, "");
+static_assert(std::is_constructible<Boxed<int, double>, box_values_t, int, char>::value, "");
+static_assert(std::is_constructible<Boxed<int, double>, Boxed<double, float>>::value, "");
 
 namespace detail {
-template <typename T> T RetrieveBoxed() { return T(); }
-} // namespace detail
+template<typename T>
+T
+RetrieveBoxed()
+{
+    return T();
+}
+}// namespace detail
 
-template <typename... Ts>
-template <typename... Us, typename>
-Boxed<Ts...>::Boxed(box_values_t, Us &&...imms)
-    : holding_(std::in_place_index_t<kValue>(), std::forward<Us>(imms)...) {}
+template<typename... Ts>
+template<typename... Us, typename>
+Boxed<Ts...>::Boxed(box_values_t, Us &&...imms) : holding_(std::in_place_index_t<kValue>(), std::forward<Us>(imms)...)
+{}
 
-template <typename... Ts>
-template <typename... Us, typename>
-Boxed<Ts...>::Boxed(Boxed<Us...> boxed) {
-  holding_.template emplace<kValue>(
-      mpark::get<kValue>(std::move(boxed).holding_));
+template<typename... Ts>
+template<typename... Us, typename>
+Boxed<Ts...>::Boxed(Boxed<Us...> boxed)
+{
+    holding_.template emplace<kValue>(mpark::get<kValue>(std::move(boxed).holding_));
 }
 
-template <class... Ts> typename Boxed<Ts...>::lvalue_ref Boxed<Ts...>::Get() & {
-  TILE_CHECK_NE(holding_.index(), kEmpty);
-  return GetImpl<Ts...>();
-}
-template <class... Ts>
-typename Boxed<Ts...>::rvalue_ref Boxed<Ts...>::Get() && {
-  return GetMoveImpl<Ts...>();
+template<class... Ts>
+typename Boxed<Ts...>::lvalue_ref
+Boxed<Ts...>::Get() &
+{
+    TILE_CHECK_NE(holding_.index(), kEmpty);
+    return GetImpl<Ts...>();
 }
 
-template <class... Ts>
-typename Boxed<Ts...>::value_type &Boxed<Ts...>::GetRaw() & {
-  TILE_CHECK_NE(holding_.index(), kEmpty);
-  return mpark::get<kValue>(holding_);
+template<class... Ts>
+typename Boxed<Ts...>::rvalue_ref
+Boxed<Ts...>::Get() &&
+{
+    return GetMoveImpl<Ts...>();
 }
 
-template <class... Ts>
-typename Boxed<Ts...>::value_type &&Boxed<Ts...>::GetRaw() && {
-  return std::move(GetRaw());
+template<class... Ts>
+typename Boxed<Ts...>::value_type &
+Boxed<Ts...>::GetRaw() &
+{
+    TILE_CHECK_NE(holding_.index(), kEmpty);
+    return mpark::get<kValue>(holding_);
 }
 
-} // namespace future
-} // namespace tile
+template<class... Ts>
+typename Boxed<Ts...>::value_type &&
+Boxed<Ts...>::GetRaw() &&
+{
+    return std::move(GetRaw());
+}
+
+}// namespace future
+}// namespace tile
 
 namespace tile {
 namespace future {
 
 // callable by unboxed
-template <typename F, typename... Ts>
-auto CallByBoxed(F &&f, Boxed<Ts...> &&boxed)
-    -> enable_if_t<is_invocable<F, Ts...>::value, invoke_result_t<F, Ts...>> {
-  return apply(std::forward<F>(f), std::move(boxed.GetRaw()));
+template<typename F, typename... Ts>
+auto
+CallByBoxed(F &&f, Boxed<Ts...> &&boxed) -> enable_if_t<is_invocable<F, Ts...>::value, invoke_result_t<F, Ts...>>
+{
+    return apply(std::forward<F>(f), std::move(boxed.GetRaw()));
 }
 
 // callable by boxed
-template <typename F, typename... Ts>
-auto CallByBoxed(F &&f, Boxed<Ts...> &&boxed)
-    -> enable_if_t<is_invocable<F, Boxed<Ts...>>::value,
-                   invoke_result_t<F, Boxed<Ts...>>> {
-  return invoke(f, std::move(boxed));
+template<typename F, typename... Ts>
+auto
+CallByBoxed(F &&f,
+            Boxed<Ts...> &&boxed) -> enable_if_t<is_invocable<F, Boxed<Ts...>>::value, invoke_result_t<F, Boxed<Ts...>>>
+{
+    return invoke(f, std::move(boxed));
 }
 
-template <typename F, typename... Ts> struct call_by_boxed {
-  using type =
-      decltype(CallByBoxed(std::declval<F>(), std::declval<Boxed<Ts...> &&>()));
+template<typename F, typename... Ts>
+struct call_by_boxed {
+    using type = decltype(CallByBoxed(std::declval<F>(), std::declval<Boxed<Ts...> &&>()));
 };
-template <typename F, typename... Ts>
+
+template<typename F, typename... Ts>
 using call_by_boxed_t = typename call_by_boxed<F, Ts...>::type;
 
-} // namespace future
-} // namespace tile
+}// namespace future
+}// namespace tile
 
-#endif // TILE_BASE_FUTURE_BOXED_H
+#endif// TILE_BASE_FUTURE_BOXED_H
diff --git a/tile/base/future/boxed_test.cc b/tile/base/future/boxed_test.cc
index cb88fb1..10742e0 100644
--- a/tile/base/future/boxed_test.cc
+++ b/tile/base/future/boxed_test.cc
@@ -6,61 +6,64 @@ namespace tile {
 namespace future {
 namespace detail {
 
-TEST(Boxed, Construct) {
-  Boxed<> box1(box_values);
-  static_assert(std::is_same<decltype(box1.Get()), void>::value, "");
+TEST(Boxed, Construct)
+{
+    Boxed<> box1(box_values);
+    static_assert(std::is_same<decltype(box1.Get()), void>::value, "");
 
-  static_assert(std::is_void<decltype(std::declval<Boxed<>>().Get())>::value,
-                "");
+    static_assert(std::is_void<decltype(std::declval<Boxed<>>().Get())>::value, "");
 
-  Boxed<int> box2(box_values, 1);
-  EXPECT_EQ(box2.Get(), 1);
+    Boxed<int> box2(box_values, 1);
+    EXPECT_EQ(box2.Get(), 1);
 
-  Boxed<int> box3(box2);
-  EXPECT_EQ(box3.Get(), 1);
-  EXPECT_EQ(box3.GetRaw(), std::make_tuple(1));
+    Boxed<int> box3(box2);
+    EXPECT_EQ(box3.Get(), 1);
+    EXPECT_EQ(box3.GetRaw(), std::make_tuple(1));
 
-  Boxed<int, char> box4(box_values, 1, 'a');
-  EXPECT_EQ(box4.Get(), std::make_tuple(1, 'a'));
+    Boxed<int, char> box4(box_values, 1, 'a');
+    EXPECT_EQ(box4.Get(), std::make_tuple(1, 'a'));
 }
 
-TEST(Apply, All) {
-  auto f1 = []() { return 1; };
-  auto f2 = [](int x) { return x + 1; };
-  auto f3 = [](int x, int y) { return x + y; };
-  auto t1 = std::make_tuple();
-  auto t2 = std::make_tuple(1);
-  auto t3 = std::make_tuple(1, 2);
-  class ApplyTest {
-  public:
-    static void Test() {};
-    static void Test(int) {};
-    static void Test(int, int) {};
-    void MTest() {};
-    void MTest(int) {};
-    void MTest(int, int) {};
-  } at;
+TEST(Apply, All)
+{
+    auto f1 = []() { return 1; };
+    auto f2 = [](int x) { return x + 1; };
+    auto f3 = [](int x, int y) { return x + y; };
+    auto t1 = std::make_tuple();
+    auto t2 = std::make_tuple(1);
+    auto t3 = std::make_tuple(1, 2);
 
-  // internal::apply(f1, t1);
-  // internal::apply(f2, t2);
-  // internal::apply(f3, t3);
-  // internal::apply(&ApplyTest::Test, t1);
+    class ApplyTest {
+    public:
+        static void Test() {};
+        static void Test(int) {};
+        static void Test(int, int) {};
+        void MTest() {};
+        void MTest(int) {};
+        void MTest(int, int) {};
+    } at;
+
+    // internal::apply(f1, t1);
+    // internal::apply(f2, t2);
+    // internal::apply(f3, t3);
+    // internal::apply(&ApplyTest::Test, t1);
 }
 
-template <typename... Ts>
-void Consume(std::function<void(Boxed<Ts...> &&) noexcept> &&action,
-             Boxed<Ts...> &&val) {
-  action(std::move(val));
+template<typename... Ts>
+void
+Consume(std::function<void(Boxed<Ts...> &&) noexcept> &&action, Boxed<Ts...> &&val)
+{
+    action(std::move(val));
 }
 
-TEST(Boxed, Consume) {
-  Boxed<int> box(box_values, 1);
-  std::function<void(Boxed<int> &&) noexcept> l1 = [](Boxed<int> &&) noexcept {
-  };
-  auto l2 = [](Boxed<int> &&) noexcept {};
-  Consume(std::move(l1), std::move(box));
+TEST(Boxed, Consume)
+{
+    Boxed<int> box(box_values, 1);
+    std::function<void(Boxed<int> &&) noexcept> l1 = [](Boxed<int> &&) noexcept {};
+    auto l2                                        = [](Boxed<int> &&) noexcept {};
+    Consume(std::move(l1), std::move(box));
 }
 
-} // namespace detail
-} // namespace future
-} // namespace tile
+}// namespace detail
+}// namespace future
+}// namespace tile
diff --git a/tile/base/future/core.h b/tile/base/future/core.h
index 077397f..e10e8db 100644
--- a/tile/base/future/core.h
+++ b/tile/base/future/core.h
@@ -12,88 +12,87 @@
 
 namespace tile {
 namespace future {
-template <typename... Ts> class Core {
+template<typename... Ts>
+class Core {
 public:
-  using value_type = Boxed<Ts...>;
-  using action_type = std::function<void(value_type &&) noexcept>;
+    using value_type  = Boxed<Ts...>;
+    using action_type = std::function<void(value_type &&) noexcept>;
 
-  explicit Core(Executor executor) : executor_(std::move(executor)) {}
+    explicit Core(Executor executor) : executor_(std::move(executor)) {}
 
-  void SetBoxed(value_type &&value) noexcept;
-  void ChainAction(action_type action) noexcept;
-  Executor GetExecutor() const noexcept;
+    void SetBoxed(value_type &&value) noexcept;
+    void ChainAction(action_type action) noexcept;
+    Executor GetExecutor() const noexcept;
 
 private:
-  struct WaitingForSingleObject {
-    WaitingForSingleObject() {}
-    WaitingForSingleObject(action_type &&action)
-        : on_satisfied(std::move(action)) {}
-    action_type on_satisfied;
-  };
+    struct WaitingForSingleObject {
+        WaitingForSingleObject() {}
 
-  struct Satisfied {
-    Satisfied(value_type &&v, bool e)
-        : value(std::move(v)), ever_called_continuation(e) {}
+        WaitingForSingleObject(action_type &&action) : on_satisfied(std::move(action)) {}
 
-    value_type value;
-    bool ever_called_continuation{false};
-  };
+        action_type on_satisfied;
+    };
+
+    struct Satisfied {
+        Satisfied(value_type &&v, bool e) : value(std::move(v)), ever_called_continuation(e) {}
+
+        value_type value;
+        bool ever_called_continuation{false};
+    };
 
 private:
-  // std::mutex lock_;
-  Mutex lock_;
-  std::variant<WaitingForSingleObject, Satisfied> state_;
-  Executor executor_;
+    // std::mutex lock_;
+    Mutex lock_;
+    std::variant<WaitingForSingleObject, Satisfied> state_;
+    Executor executor_;
 };
 
-template <typename... Ts>
-void Core<Ts...>::SetBoxed(value_type &&value) noexcept {
-  UniqueLock<Mutex> lk(lock_);
-  action_type action =
-      std::move(mpark::get<WaitingForSingleObject>(state_).on_satisfied);
+template<typename... Ts>
+void
+Core<Ts...>::SetBoxed(value_type &&value) noexcept
+{
+    UniqueLock<Mutex> lk(lock_);
+    action_type action = std::move(mpark::get<WaitingForSingleObject>(state_).on_satisfied);
 
-  state_.template emplace<Satisfied>(Satisfied{std::move(value), !!action});
+    state_.template emplace<Satisfied>(Satisfied{std::move(value), !!action});
 
-  if (action) {
-    lk.Unlock();
+    if (action) {
+        lk.Unlock();
 
-    auto moved_action = MakeMoveOnCopy(std::move(action));
-    auto moved_value =
-        MakeMoveOnCopy(std::move(mpark::get<Satisfied>(state_).value));
-    executor_.Execute([moved_action, moved_value]() mutable noexcept {
-      moved_action.Ref()(moved_value.Move());
-    });
-  }
+        auto moved_action = MakeMoveOnCopy(std::move(action));
+        auto moved_value  = MakeMoveOnCopy(std::move(mpark::get<Satisfied>(state_).value));
+        executor_.Execute([moved_action, moved_value]() mutable noexcept { moved_action.Ref()(moved_value.Move()); });
+    }
 }
 
-template <typename... Ts>
-void Core<Ts...>::ChainAction(action_type action) noexcept {
-  UniqueLock<Mutex> lk(lock_);
-  if (state_.index() == 0) {
-    // waiting for value
-    state_.template emplace<WaitingForSingleObject>(
-        WaitingForSingleObject{std::move(action)});
-  } else {
-    TILE_CHECK_EQ(state_.index(), 1);
-    auto &&s = mpark::get<Satisfied>(state_);
-    TILE_CHECK(!s.ever_called_continuation,
-               "Action may not be chained for multiple times.");
+template<typename... Ts>
+void
+Core<Ts...>::ChainAction(action_type action) noexcept
+{
+    UniqueLock<Mutex> lk(lock_);
+    if (state_.index() == 0) {
+        // waiting for value
+        state_.template emplace<WaitingForSingleObject>(WaitingForSingleObject{std::move(action)});
+    } else {
+        TILE_CHECK_EQ(state_.index(), 1);
+        auto &&s = mpark::get<Satisfied>(state_);
+        TILE_CHECK(!s.ever_called_continuation, "Action may not be chained for multiple times.");
 
-    s.ever_called_continuation = true;
-    lk.Unlock();
-    auto moved_action = MakeMoveOnCopy(std::move(action));
-    auto moved_value = MakeMoveOnCopy(std::move(s.value));
-    executor_.Execute([moved_action, moved_value]() mutable noexcept {
-      moved_action.Ref()(moved_value.Move());
-    });
-  }
+        s.ever_called_continuation = true;
+        lk.Unlock();
+        auto moved_action = MakeMoveOnCopy(std::move(action));
+        auto moved_value  = MakeMoveOnCopy(std::move(s.value));
+        executor_.Execute([moved_action, moved_value]() mutable noexcept { moved_action.Ref()(moved_value.Move()); });
+    }
 }
 
-template <typename... Ts>
-inline Executor Core<Ts...>::GetExecutor() const noexcept {
-  return executor_;
+template<typename... Ts>
+inline Executor
+Core<Ts...>::GetExecutor() const noexcept
+{
+    return executor_;
 }
-} // namespace future
-} // namespace tile
+}// namespace future
+}// namespace tile
 
-#endif // TILE_BASE_FUTURE_CORE_H
+#endif// TILE_BASE_FUTURE_CORE_H
diff --git a/tile/base/future/executor.h b/tile/base/future/executor.h
index fa83454..df757a7 100644
--- a/tile/base/future/executor.h
+++ b/tile/base/future/executor.h
@@ -15,91 +15,96 @@ namespace tile {
 namespace future {
 class Executor {
 public:
-  constexpr Executor() = default;
+    constexpr Executor() = default;
 
-  // Copy & move
-  Executor(const Executor &other) : impl_(other.impl_->Clone()) {}
-  Executor &operator=(const Executor &e) {
-    impl_ = e.impl_->Clone();
-    return *this;
-  }
-  Executor(Executor &&other) = default;
-  Executor &operator=(Executor &&) = default;
+    // Copy & move
+    Executor(const Executor &other) : impl_(other.impl_->Clone()) {}
 
-  // Base Executor, Has Execute function
-  template <typename T,
-            typename = enable_if_t<!std::is_same<Executor, decay_t<T>>::value>,
-            typename = decltype(std::declval<T &&>().Execute(
-                std::declval<std::function<void()>>()))>
-  Executor(T &&executor) {
-    impl_ = EraseExecutorType(std::forward<T>(executor));
-  }
+    Executor &operator=(const Executor &e)
+    {
+        impl_ = e.impl_->Clone();
+        return *this;
+    }
 
-  template <typename T> void Execute(T &&job) {
-    job();
-    // impl_->Execute(std::forward<T>(job));
-  }
+    Executor(Executor &&other)       = default;
+    Executor &operator=(Executor &&) = default;
+
+    // Base Executor, Has Execute function
+    template<typename T,
+             typename = enable_if_t<!std::is_same<Executor, decay_t<T>>::value>,
+             typename = decltype(std::declval<T &&>().Execute(std::declval<std::function<void()>>()))>
+    Executor(T &&executor)
+    {
+        impl_ = EraseExecutorType(std::forward<T>(executor));
+    }
+
+    template<typename T>
+    void Execute(T &&job)
+    {
+        job();
+        // impl_->Execute(std::forward<T>(job));
+    }
 
 private:
-  class ConcreteExecutor {
-  public:
-    virtual ~ConcreteExecutor() = default;
-    virtual void Execute(std::function<void()> job) = 0;
-    virtual std::unique_ptr<ConcreteExecutor> Clone() = 0;
-  };
+    class ConcreteExecutor {
+    public:
+        virtual ~ConcreteExecutor()                       = default;
+        virtual void Execute(std::function<void()> job)   = 0;
+        virtual std::unique_ptr<ConcreteExecutor> Clone() = 0;
+    };
 
-  template <typename T> class ConcreteExecutorImpl : public ConcreteExecutor {
-  public:
-    template <typename U, typename = decltype(std::declval<U>().Execute(
-                              std::declval<std::function<void()>>()))>
-    explicit ConcreteExecutorImpl(U &&e) : impl_(std::forward<U>(e)) {}
+    template<typename T>
+    class ConcreteExecutorImpl : public ConcreteExecutor {
+    public:
+        template<typename U, typename = decltype(std::declval<U>().Execute(std::declval<std::function<void()>>()))>
+        explicit ConcreteExecutorImpl(U &&e) : impl_(std::forward<U>(e))
+        {}
 
-    void Execute(std::function<void()> job) override {
-      impl_.Execute(std::move(job));
+        void Execute(std::function<void()> job) override { impl_.Execute(std::move(job)); }
+
+        std::unique_ptr<ConcreteExecutor> Clone() override { return make_unique<ConcreteExecutorImpl>(impl_); }
+
+    private:
+        T impl_;
+    };
+
+    template<typename T>
+    std::unique_ptr<ConcreteExecutor> EraseExecutorType(T &&executor)
+    {
+        return make_unique<ConcreteExecutorImpl<typename std::decay<T>::type>>(std::forward<T>(executor));
     }
 
-    std::unique_ptr<ConcreteExecutor> Clone() override {
-      return make_unique<ConcreteExecutorImpl>(impl_);
-    }
-
-  private:
-    T impl_;
-  };
-
-  template <typename T>
-  std::unique_ptr<ConcreteExecutor> EraseExecutorType(T &&executor) {
-    return make_unique<ConcreteExecutorImpl<typename std::decay<T>::type>>(
-        std::forward<T>(executor));
-  }
-
-  std::unique_ptr<ConcreteExecutor> impl_;
+    std::unique_ptr<ConcreteExecutor> impl_;
 };
 
 class InlineExecutor {
 public:
-  void Execute(std::function<void()> job) { job(); }
+    void Execute(std::function<void()> job) { job(); }
 };
 
 namespace detail {
-inline std::shared_ptr<Executor> &DefaultExecutorPtr() {
-  static std::shared_ptr<Executor> default_executor =
-      std::make_shared<Executor>(InlineExecutor());
-  return default_executor;
+inline std::shared_ptr<Executor> &
+DefaultExecutorPtr()
+{
+    static std::shared_ptr<Executor> default_executor = std::make_shared<Executor>(InlineExecutor());
+    return default_executor;
 }
-} // namespace detail
+}// namespace detail
 
-inline Executor GetDefaultExecutor() {
-  return *std::atomic_load_explicit(&detail::DefaultExecutorPtr(),
-                                    std::memory_order_acquire);
+inline Executor
+GetDefaultExecutor()
+{
+    return *std::atomic_load_explicit(&detail::DefaultExecutorPtr(), std::memory_order_acquire);
 }
 
-inline Executor SetDefaultExecutor(Executor exec) {
-  auto ptr = std::make_shared<Executor>(std::move(exec));
-  return *std::atomic_exchange_explicit(&detail::DefaultExecutorPtr(), ptr,
-                                        std::memory_order_release);
+inline Executor
+SetDefaultExecutor(Executor exec)
+{
+    auto ptr = std::make_shared<Executor>(std::move(exec));
+    return *std::atomic_exchange_explicit(&detail::DefaultExecutorPtr(), ptr, std::memory_order_release);
 }
 
-} // namespace future
-} // namespace tile
+}// namespace future
+}// namespace tile
 
-#endif // TILE_BASE_FUTURE_EXECUTOR_H
+#endif// TILE_BASE_FUTURE_EXECUTOR_H
diff --git a/tile/base/future/future-impl.h b/tile/base/future/future-impl.h
index 604342b..83a64e8 100644
--- a/tile/base/future/future-impl.h
+++ b/tile/base/future/future-impl.h
@@ -8,124 +8,122 @@
 
 namespace tile {
 namespace future {
-template <typename... Ts>
-template <typename... Us, typename>
-Future<Ts...>::Future(futurize_values_t, Us &&...imms)
-    : core_(std::make_shared<Core<Ts...>>(GetDefaultExecutor())) {
-  core_->SetBoxed(Boxed<Ts...>(box_values, std::forward<Us>(imms)...));
+template<typename... Ts>
+template<typename... Us, typename>
+Future<Ts...>::Future(futurize_values_t, Us &&...imms) : core_(std::make_shared<Core<Ts...>>(GetDefaultExecutor()))
+{
+    core_->SetBoxed(Boxed<Ts...>(box_values, std::forward<Us>(imms)...));
 }
 
-template <typename... Ts>
-template <typename... Us, typename>
+template<typename... Ts>
+template<typename... Us, typename>
 Future<Ts...>::Future(futurize_tuple_t, std::tuple<Us...> values)
-    : core_(std::make_shared<Core<Ts...>>(GetDefaultExecutor())) {
-  core_->SetBoxed(Boxed<Ts...>(box_values, std::move(values)));
+    : core_(std::make_shared<Core<Ts...>>(GetDefaultExecutor()))
+{
+    core_->SetBoxed(Boxed<Ts...>(box_values, std::move(values)));
 }
 
-template <class... Ts>
-template <class U, class>
-Future<Ts...>::Future(U &&value)
-    : core_(std::make_shared<Core<Ts...>>(GetDefaultExecutor())) {
-  static_assert(sizeof...(Ts) == 1, "");
-  core_->SetBoxed(Boxed<Ts...>(box_values, std::forward<U>(value)));
+template<class... Ts>
+template<class U, class>
+Future<Ts...>::Future(U &&value) : core_(std::make_shared<Core<Ts...>>(GetDefaultExecutor()))
+{
+    static_assert(sizeof...(Ts) == 1, "");
+    core_->SetBoxed(Boxed<Ts...>(box_values, std::forward<U>(value)));
 }
 
-template <class... Ts>
-template <class... Us, class>
-Future<Ts...>::Future(Future<Us...> &&future) {
-  Promise<Ts...> p;
+template<class... Ts>
+template<class... Us, class>
+Future<Ts...>::Future(Future<Us...> &&future)
+{
+    Promise<Ts...> p;
 
-  // Here we "steal" `p.GetFuture()`'s core and "install" it into ourself,
-  // thus once `p` is satisfied, we're satisfied as well.
-  core_ = p.GetFuture().core_;
-  auto moved_promise = MakeMoveOnCopy(std::move(p));
-  std::move(future).Then([moved_promise](Boxed<Us...> boxed) mutable noexcept {
-    moved_promise->SetBoxed(std::move(boxed));
-  });
+    // Here we "steal" `p.GetFuture()`'s core and "install" it into ourself,
+    // thus once `p` is satisfied, we're satisfied as well.
+    core_              = p.GetFuture().core_;
+    auto moved_promise = MakeMoveOnCopy(std::move(p));
+    std::move(future).Then([moved_promise](Boxed<Us...> boxed) mutable noexcept {
+        moved_promise->SetBoxed(std::move(boxed));
+    });
 }
-template <typename... Ts>
-template <typename F, typename R>
-auto Future<Ts...>::Then(F &&fun)
-    -> enable_if_t<std::is_void<R>::value, Future<>> {
-  using NewFuture = futurize_t<R>;
-  as_promise_t<NewFuture> promise(core_->GetExecutor());
 
-  auto rc = promise.GetFuture();
+template<typename... Ts>
+template<typename F, typename R>
+auto
+Future<Ts...>::Then(F &&fun) -> enable_if_t<std::is_void<R>::value, Future<>>
+{
+    using NewFuture = futurize_t<R>;
+    as_promise_t<NewFuture> promise(core_->GetExecutor());
 
-  auto moved_promise = MakeMoveOnCopy(promise);
-  auto moved_fun = MakeMoveOnCopy(std::forward<F>(fun));
+    auto rc            = promise.GetFuture();
 
-  std::function<void(Boxed<Ts...> &&) noexcept> cont =
-      [moved_promise, moved_fun](Boxed<Ts...> &&value) mutable noexcept {
-        CallByBoxed(moved_fun.Move(), std::move(value));
+    auto moved_promise = MakeMoveOnCopy(promise);
+    auto moved_fun     = MakeMoveOnCopy(std::forward<F>(fun));
 
-        moved_promise->SetBoxed(Boxed<>(box_values));
-      };
+    std::function<void(Boxed<Ts...> &&) noexcept> cont =
+        [moved_promise, moved_fun](Boxed<Ts...> &&value) mutable noexcept {
+            CallByBoxed(moved_fun.Move(), std::move(value));
 
-  core_->ChainAction(std::move(cont));
+            moved_promise->SetBoxed(Boxed<>(box_values));
+        };
 
-  return rc;
+    core_->ChainAction(std::move(cont));
+
+    return rc;
 }
 
 // if R is `Future<...>`
-template <typename... Ts>
-template <typename F, typename R>
-auto Future<Ts...>::Then(F &&fun)
-    -> enable_if_t<!std::is_void<R>::value && is_future<R>::value,
-                   futurize_t<R>> {
-  using NewFuture = futurize_t<R>;
-  as_promise_t<NewFuture> promise(core_->GetExecutor());
+template<typename... Ts>
+template<typename F, typename R>
+auto
+Future<Ts...>::Then(F &&fun) -> enable_if_t<!std::is_void<R>::value && is_future<R>::value, futurize_t<R>>
+{
+    using NewFuture = futurize_t<R>;
+    as_promise_t<NewFuture> promise(core_->GetExecutor());
 
-  auto rc = promise.GetFuture();
+    auto rc            = promise.GetFuture();
 
-  auto moved_promise = MakeMoveOnCopy(promise);
-  auto moved_fun = MakeMoveOnCopy(std::forward<F>(fun));
+    auto moved_promise = MakeMoveOnCopy(promise);
+    auto moved_fun     = MakeMoveOnCopy(std::forward<F>(fun));
 
-  auto cont = [moved_promise,
-               moved_fun](Boxed<Ts...> &&value) mutable noexcept {
-    auto future = CallByBoxed(moved_fun.Move(), std::move(value));
-    // R is Future<Us...>
-    // build a lambda to set the value of the promise
+    auto cont          = [moved_promise, moved_fun](Boxed<Ts...> &&value) mutable noexcept {
+        auto future = CallByBoxed(moved_fun.Move(), std::move(value));
+        // R is Future<Us...>
+        // build a lambda to set the value of the promise
 
-    future.core_->ChainAction(
-        [moved_promise](as_boxed_t<NewFuture> &&nested_v) mutable noexcept {
-          static_assert(
-              std::is_same<as_boxed_t<NewFuture>,
-                           remove_reference_t<decltype(nested_v)>>::value,
-              "");
-          moved_promise->SetBoxed(std::move(nested_v));
+        future.core_->ChainAction([moved_promise](as_boxed_t<NewFuture> &&nested_v) mutable noexcept {
+            static_assert(std::is_same<as_boxed_t<NewFuture>, remove_reference_t<decltype(nested_v)>>::value, "");
+            moved_promise->SetBoxed(std::move(nested_v));
         });
-  };
+    };
 
-  core_->ChainAction(std::move(cont));
+    core_->ChainAction(std::move(cont));
 
-  return rc;
+    return rc;
 }
 
-template <typename... Ts>
-template <typename F, typename R>
-auto Future<Ts...>::Then(F &&fun)
-    -> enable_if_t<!std::is_void<R>::value && !is_future<R>::value,
-                   futurize_t<R>> {
-  using NewFuture = futurize_t<R>;
-  as_promise_t<NewFuture> promise(core_->GetExecutor());
+template<typename... Ts>
+template<typename F, typename R>
+auto
+Future<Ts...>::Then(F &&fun) -> enable_if_t<!std::is_void<R>::value && !is_future<R>::value, futurize_t<R>>
+{
+    using NewFuture = futurize_t<R>;
+    as_promise_t<NewFuture> promise(core_->GetExecutor());
 
-  auto rc = promise.GetFuture();
+    auto rc            = promise.GetFuture();
 
-  auto moved_promise = MakeMoveOnCopy(promise);
-  auto moved_fun = MakeMoveOnCopy(std::forward<F>(fun));
+    auto moved_promise = MakeMoveOnCopy(promise);
+    auto moved_fun     = MakeMoveOnCopy(std::forward<F>(fun));
 
-  auto cont = [moved_promise, moved_fun](Boxed<Ts...> &&value) mutable {
-    as_boxed_t<NewFuture> boxed_value(
-        box_values, CallByBoxed(moved_fun.Move(), std::move(value)));
-    moved_promise->SetBoxed(std::move(boxed_value));
-  };
+    auto cont          = [moved_promise, moved_fun](Boxed<Ts...> &&value) mutable {
+        as_boxed_t<NewFuture> boxed_value(box_values, CallByBoxed(moved_fun.Move(), std::move(value)));
+        moved_promise->SetBoxed(std::move(boxed_value));
+    };
 
-  core_->ChainAction(std::move(cont));
-  return rc;
+    core_->ChainAction(std::move(cont));
+    return rc;
 }
 
-} // namespace future
-} // namespace tile
+}// namespace future
+}// namespace tile
 
-#endif // TILE_BASE_FUTURE_FUTURE_IMPL_H
+#endif// TILE_BASE_FUTURE_FUTURE_IMPL_H
diff --git a/tile/base/future/future.h b/tile/base/future/future.h
index 0ad84f7..d5f1fc8 100644
--- a/tile/base/future/future.h
+++ b/tile/base/future/future.h
@@ -10,75 +10,70 @@
 namespace tile {
 namespace future {
 struct futurize_values_t {
-  explicit futurize_values_t() = default;
+    explicit futurize_values_t() = default;
 };
+
 struct futurize_tuple_t {
-  explicit futurize_tuple_t() = default;
+    explicit futurize_tuple_t() = default;
 };
 
 constexpr auto futurize_values = futurize_values_t();
-constexpr auto futurize_tuple = futurize_tuple_t();
+constexpr auto futurize_tuple  = futurize_tuple_t();
 
-template <typename... Ts> class Future {
+template<typename... Ts>
+class Future {
 public:
-  using action_type = typename Core<Ts...>::action_type;
-  template <typename... Us, typename = enable_if_t<std::is_constructible<
-                                Boxed<Ts...>, box_values_t, Us &&...>::value>>
-  explicit Future(futurize_values_t, Us &&...imms);
+    using action_type = typename Core<Ts...>::action_type;
+    template<typename... Us, typename = enable_if_t<std::is_constructible<Boxed<Ts...>, box_values_t, Us &&...>::value>>
+    explicit Future(futurize_values_t, Us &&...imms);
 
-  template <typename... Us, typename = enable_if_t<std::is_constructible<
-                                Boxed<Ts...>, Boxed<Us...>>::value>>
-  Future(futurize_tuple_t, std::tuple<Us...> values);
+    template<typename... Us, typename = enable_if_t<std::is_constructible<Boxed<Ts...>, Boxed<Us...>>::value>>
+    Future(futurize_tuple_t, std::tuple<Us...> values);
 
-  template <
-      typename U,
-      typename = enable_if_t<
-          std::is_constructible<typename internal::conditional_t<
-                                    sizeof...(Ts) == 1, std::common_type<Ts...>,
-                                    std::common_type<void>>::type,
-                                U>::value &&
-          !is_future<U>::value>>
-  Future(U &&value);
+    template<
+        typename U,
+        typename = enable_if_t<std::is_constructible<typename internal::conditional_t<sizeof...(Ts) == 1,
+                                                                                      std::common_type<Ts...>,
+                                                                                      std::common_type<void>>::type,
+                                                     U>::value
+                               && !is_future<U>::value>>
+    Future(U &&value);
 
-  template <typename... Us, typename = enable_if_t<std::is_constructible<
-                                Boxed<Ts...>, Boxed<Us...>>::value>>
-  Future(Future<Us...> &&future);
+    template<typename... Us, typename = enable_if_t<std::is_constructible<Boxed<Ts...>, Boxed<Us...>>::value>>
+    Future(Future<Us...> &&future);
 
-  Future() = default;
+    Future()                          = default;
 
-  Future(const Future &) = delete;
-  Future &operator=(const Future &) = delete;
+    Future(const Future &)            = delete;
+    Future &operator=(const Future &) = delete;
 
-  Future(Future &&) = default;
-  Future &operator=(Future &&) = default;
+    Future(Future &&)                 = default;
+    Future &operator=(Future &&)      = default;
 
-  static_assert(
-      !types_contains<Types<Ts...>, void>::value,
-      "There's no point in specifying `void` `Ts...`, "
-      "use `Future<>` if you meant to declare a future with no value.");
+    static_assert(!types_contains<Types<Ts...>, void>::value,
+                  "There's no point in specifying `void` `Ts...`, "
+                  "use `Future<>` if you meant to declare a future with no value.");
 
-  template <typename F, typename R = call_by_boxed_t<F, Ts...>>
-  auto Then(F &&fun) -> enable_if_t<std::is_void<R>::value, Future<>>;
+    template<typename F, typename R = call_by_boxed_t<F, Ts...>>
+    auto Then(F &&fun) -> enable_if_t<std::is_void<R>::value, Future<>>;
 
-  template <typename F, typename R = call_by_boxed_t<F, Ts...>>
-  auto
-  Then(F &&fun) -> enable_if_t<!std::is_void<R>::value && is_future<R>::value,
-                               futurize_t<R>>;
+    template<typename F, typename R = call_by_boxed_t<F, Ts...>>
+    auto Then(F &&fun) -> enable_if_t<!std::is_void<R>::value && is_future<R>::value, futurize_t<R>>;
 
-  template <typename F, typename R = call_by_boxed_t<F, Ts...>>
-  auto
-  Then(F &&fun) -> enable_if_t<!std::is_void<R>::value && !is_future<R>::value,
-                               futurize_t<R>>;
+    template<typename F, typename R = call_by_boxed_t<F, Ts...>>
+    auto Then(F &&fun) -> enable_if_t<!std::is_void<R>::value && !is_future<R>::value, futurize_t<R>>;
 
 private:
-  friend class Promise<Ts...>;
-  template <typename... Us> friend class Future;
+    friend class Promise<Ts...>;
+    template<typename... Us>
+    friend class Future;
 
-  explicit Future(std::shared_ptr<Core<Ts...>> core) : core_(std::move(core)) {}
-  std::shared_ptr<Core<Ts...>> core_;
+    explicit Future(std::shared_ptr<Core<Ts...>> core) : core_(std::move(core)) {}
+
+    std::shared_ptr<Core<Ts...>> core_;
 };
 
-} // namespace future
-} // namespace tile
+}// namespace future
+}// namespace tile
 
-#endif // TILE_BASE_FUTURE_FUTURE_H
+#endif// TILE_BASE_FUTURE_FUTURE_H
diff --git a/tile/base/future/future_test.cc b/tile/base/future/future_test.cc
index 0f7ddb4..6629679 100644
--- a/tile/base/future/future_test.cc
+++ b/tile/base/future/future_test.cc
@@ -27,287 +27,284 @@ static_assert(std::is_move_assignable<Promise<>>::value, "");
 static_assert(std::is_move_constructible<Promise<int, double>>::value, "");
 static_assert(std::is_move_assignable<Promise<int, double>>::value, "");
 
-static_assert(!std::is_copy_constructible<future::Boxed<MoveOnlyType>>::value,
-              "");
+static_assert(!std::is_copy_constructible<future::Boxed<MoveOnlyType>>::value, "");
 static_assert(!std::is_copy_assignable<future::Boxed<MoveOnlyType>>::value, "");
-static_assert(std::is_move_constructible<future::Boxed<MoveOnlyType>>::value,
-              "");
+static_assert(std::is_move_constructible<future::Boxed<MoveOnlyType>>::value, "");
 static_assert(std::is_move_assignable<future::Boxed<MoveOnlyType>>::value, "");
 
-template <typename T> using resource_ptr = std::unique_ptr<T, void (*)(T *)>;
+template<typename T>
+using resource_ptr = std::unique_ptr<T, void (*)(T *)>;
 
 struct NoCopy {
-  NoCopy() = default;
-  NoCopy(const NoCopy &) = delete;
-  NoCopy &operator=(const NoCopy &) = delete;
-  NoCopy(NoCopy &&) = default;
-  NoCopy &operator=(NoCopy &&) = default;
+    NoCopy()                          = default;
+    NoCopy(const NoCopy &)            = delete;
+    NoCopy &operator=(const NoCopy &) = delete;
+    NoCopy(NoCopy &&)                 = default;
+    NoCopy &operator=(NoCopy &&)      = default;
 };
 
-Future<resource_ptr<void>, int> AcquireXxxAsync() {
-  Promise<resource_ptr<void>, int> p;
-  auto rc = p.GetFuture();
+Future<resource_ptr<void>, int>
+AcquireXxxAsync()
+{
+    Promise<resource_ptr<void>, int> p;
+    auto rc = p.GetFuture();
 
-  NoCopy nc;
-  auto moved_nc = MakeMoveOnCopy(std::move(nc));
-  auto moved_promise = MakeMoveOnCopy(p);
-  std::thread([moved_promise]() mutable {
-    std::this_thread::sleep_for(std::chrono::milliseconds(10));
-    auto v1 = resource_ptr<void>(reinterpret_cast<void *>(1), [](void *) {});
-    // moved_promise->SetValue(
-    //     resource_ptr<void>(reinterpret_cast<void *>(1), [](void *) {}), 0);
-    moved_promise->SetValue(std::move(v1), 0);
-  }).detach();
+    NoCopy nc;
+    auto moved_nc      = MakeMoveOnCopy(std::move(nc));
+    auto moved_promise = MakeMoveOnCopy(p);
+    std::thread([moved_promise]() mutable {
+        std::this_thread::sleep_for(std::chrono::milliseconds(10));
+        auto v1 = resource_ptr<void>(reinterpret_cast<void *>(1), [](void *) {});
+        // moved_promise->SetValue(
+        //     resource_ptr<void>(reinterpret_cast<void *>(1), [](void *) {}), 0);
+        moved_promise->SetValue(std::move(v1), 0);
+    }).detach();
 
-  return rc;
+    return rc;
 }
 
-TEST(Future, Initialization) {
-  // Uninitialized future
-  Future<> uf1;
-  Future<int, double> uf2;
+TEST(Future, Initialization)
+{
+    // Uninitialized future
+    Future<> uf1;
+    Future<int, double> uf2;
 
-  // Ready future
-  Future<> vf1(futurize_values);
-  Future<> tf1(futurize_tuple, std::make_tuple());
-  Future<int> fi(10);
-  Future<int, double> fid(futurize_values, 1, 2.0);
-  Future<int, float> f2(std::move(fid));
+    // Ready future
+    Future<> vf1(futurize_values);
+    Future<> tf1(futurize_tuple, std::make_tuple());
+    Future<int> fi(10);
+    Future<int, double> fid(futurize_values, 1, 2.0);
+    Future<int, float> f2(std::move(fid));
 
-  auto vf = MakeReadyFuture();
-  auto mf = MakeReadyFuture(1, 2.0);
+    auto vf = MakeReadyFuture();
+    auto mf = MakeReadyFuture(1, 2.0);
 
-  ASSERT_EQ(10, BlockingGet(std::move(fi)));
-  ASSERT_EQ(2.0, std::get<1>(BlockingGet(std::move(f2))));
-  ASSERT_EQ(2.0, std::get<1>(BlockingGet(std::move(mf))));
+    ASSERT_EQ(10, BlockingGet(std::move(fi)));
+    ASSERT_EQ(2.0, std::get<1>(BlockingGet(std::move(f2))));
+    ASSERT_EQ(2.0, std::get<1>(BlockingGet(std::move(mf))));
 }
 
-TEST(Future, WhenAll) {
-  static FILE *const kDummyFile = reinterpret_cast<FILE *>(0x10000123);
+TEST(Future, WhenAll)
+{
+    static FILE *const kDummyFile = reinterpret_cast<FILE *>(0x10000123);
 
-  Future<FILE *, int> async_file(futurize_values, kDummyFile, 0);
-  Future<FILE *, int> failure_file(futurize_values, nullptr, -1);
-  Future<resource_ptr<FILE>, int> move_only_file{
-      futurize_values, resource_ptr<FILE>{nullptr, nullptr}, -2};
+    Future<FILE *, int> async_file(futurize_values, kDummyFile, 0);
+    Future<FILE *, int> failure_file(futurize_values, nullptr, -1);
+    Future<resource_ptr<FILE>, int> move_only_file{
+        futurize_values, resource_ptr<FILE>{nullptr, nullptr},
+         -2
+    };
 
-  Future<> void_op(futurize_values);
+    Future<> void_op(futurize_values);
 
-  bool called = false;
-
-  WhenAll(std::move(async_file), std::move(failure_file), std::move(void_op),
-          std::move(move_only_file))
-      .Then([&](std::tuple<FILE *, int> af, std::tuple<FILE *, int> ff,
-                std::tuple<resource_ptr<FILE>, int> mof) {
-        ASSERT_EQ(kDummyFile, std::get<0>(af));
-        ASSERT_EQ(0, std::get<1>(af));
-        ASSERT_EQ(nullptr, std::get<0>(ff));
-        ASSERT_EQ(-1, std::get<1>(ff));
-        ASSERT_EQ(nullptr, std::get<0>(mof));
-        ASSERT_EQ(-2, std::get<1>(mof));
-
-        called = true;
-      });
-
-  ASSERT_TRUE(called);
-}
-
-TEST(Future, WhenAllForOtherThread) {
-  bool called = false;
-  BlockingGet(WhenAll(AcquireXxxAsync(), AcquireXxxAsync())
-                  .Then([&](std::tuple<resource_ptr<void>, int> a,
-                            std::tuple<resource_ptr<void>, int> b) {
-                    ASSERT_NE(nullptr, std::get<0>(a));
-                    ASSERT_EQ(0, std::get<1>(a));
-                    ASSERT_NE(nullptr, std::get<0>(b));
-                    ASSERT_EQ(0, std::get<1>(b));
-                    called = true;
-                  }));
-  ASSERT_TRUE(called);
-}
-
-TEST(Future, WhenAllMultiThreaded) {
-  for (int i = 0; i != 100; ++i) {
     bool called = false;
-    Promise<std::unique_ptr<int>, std::unique_ptr<char>> p1;
-    Promise<> p2;
-    Latch latch(2 + 1);
 
-    auto all =
-        WhenAll(p1.GetFuture(), p2.GetFuture())
-            .Then([&](std::tuple<std::unique_ptr<int>, std::unique_ptr<char>>
-                          &&p) {
-              ASSERT_NE(nullptr, std::get<0>(p));
-              ASSERT_EQ(nullptr, std::get<1>(p));
+    WhenAll(std::move(async_file), std::move(failure_file), std::move(void_op), std::move(move_only_file))
+        .Then([&](std::tuple<FILE *, int> af, std::tuple<FILE *, int> ff, std::tuple<resource_ptr<FILE>, int> mof) {
+            ASSERT_EQ(kDummyFile, std::get<0>(af));
+            ASSERT_EQ(0, std::get<1>(af));
+            ASSERT_EQ(nullptr, std::get<0>(ff));
+            ASSERT_EQ(-1, std::get<1>(ff));
+            ASSERT_EQ(nullptr, std::get<0>(mof));
+            ASSERT_EQ(-2, std::get<1>(mof));
 
-              called = true;
+            called = true;
+        });
+
+    ASSERT_TRUE(called);
+}
+
+TEST(Future, WhenAllForOtherThread)
+{
+    bool called = false;
+    BlockingGet(WhenAll(AcquireXxxAsync(), AcquireXxxAsync())
+                    .Then([&](std::tuple<resource_ptr<void>, int> a, std::tuple<resource_ptr<void>, int> b) {
+                        ASSERT_NE(nullptr, std::get<0>(a));
+                        ASSERT_EQ(0, std::get<1>(a));
+                        ASSERT_NE(nullptr, std::get<0>(b));
+                        ASSERT_EQ(0, std::get<1>(b));
+                        called = true;
+                    }));
+    ASSERT_TRUE(called);
+}
+
+TEST(Future, WhenAllMultiThreaded)
+{
+    for (int i = 0; i != 100; ++i) {
+        bool called = false;
+        Promise<std::unique_ptr<int>, std::unique_ptr<char>> p1;
+        Promise<> p2;
+        Latch latch(2 + 1);
+
+        auto all = WhenAll(p1.GetFuture(), p2.GetFuture())
+                       .Then([&](std::tuple<std::unique_ptr<int>, std::unique_ptr<char>> &&p) {
+                           ASSERT_NE(nullptr, std::get<0>(p));
+                           ASSERT_EQ(nullptr, std::get<1>(p));
+
+                           called = true;
+                       });
+
+        auto t1 = std::thread([&] {
+            latch.ArriveAndWait();
+            // set <ptr, null>
+            p1.SetValue(make_unique<int>(), std::unique_ptr<char>());
+        });
+        auto t2 = std::thread([&] {
+            latch.ArriveAndWait();
+
+            p2.SetValue();
+        });
+
+        ASSERT_FALSE(called);
+        latch.CountDown();
+        BlockingGet(std::move(all));
+        ASSERT_TRUE(called);
+
+        t1.join();
+        t2.join();
+    }
+}
+
+TEST(Future, WhenAllcollectionMultiThreaded)
+{
+    for (int i = 0; i != 100; ++i) {
+        constexpr auto kCount = 100;
+
+        std::vector<Promise<bool>> vps(kCount);
+        std::vector<Future<bool>> vfs;
+        std::vector<std::thread> ts(kCount);
+
+        Latch latch(kCount + 1);
+        std::atomic<bool> called{false};
+        for (auto &p : vps) { vfs.emplace_back(p.GetFuture()); }
+
+        WhenAll(&vfs).Then([&](std::vector<bool> v) {
+            ASSERT_TRUE(std::all_of(v.begin(), v.end(), [&](bool v) { return v; }));
+            called = true;
+        });
+
+        for (int i = 0; i != kCount; ++i) {
+            ts[i] = std::thread([&latch, &vps, i] {
+                latch.ArriveAndWait();
+                vps[i].SetValue(true);
             });
-
-    auto t1 = std::thread([&] {
-      latch.ArriveAndWait();
-      // set <ptr, null>
-      p1.SetValue(make_unique<int>(), std::unique_ptr<char>());
-    });
-    auto t2 = std::thread([&] {
-      latch.ArriveAndWait();
-
-      p2.SetValue();
-    });
-
-    ASSERT_FALSE(called);
-    latch.CountDown();
-    BlockingGet(std::move(all));
-    ASSERT_TRUE(called);
-
-    t1.join();
-    t2.join();
-  }
+        }
+        ASSERT_FALSE(called);
+        latch.CountDown();
+        for (auto &&e : ts) { e.join(); }
+        ASSERT_TRUE(called);
+    }
 }
 
-TEST(Future, WhenAllcollectionMultiThreaded) {
-  for (int i = 0; i != 100; ++i) {
-    constexpr auto kCount = 100;
-
-    std::vector<Promise<bool>> vps(kCount);
-    std::vector<Future<bool>> vfs;
-    std::vector<std::thread> ts(kCount);
-
-    Latch latch(kCount + 1);
-    std::atomic<bool> called{false};
-    for (auto &p : vps) {
-      vfs.emplace_back(p.GetFuture());
+TEST(Future, WhenAllCollectionEmpty)
+{
+    {
+        std::vector<Future<>> vfs;
+        int x{};
+        WhenAll(std::move(vfs)).Then([&] { x = 10; });
+        ASSERT_EQ(10, x);
     }
 
-    WhenAll(&vfs).Then([&](std::vector<bool> v) {
-      ASSERT_TRUE(std::all_of(v.begin(), v.end(), [&](bool v) { return v; }));
-      called = true;
-    });
-
-    for (int i = 0; i != kCount; ++i) {
-      ts[i] = std::thread([&latch, &vps, i] {
-        latch.ArriveAndWait();
-        vps[i].SetValue(true);
-      });
+    {
+        std::vector<Future<int>> vfs;
+        int x{};
+        WhenAll(std::move(vfs)).Then([&](std::vector<int> &&) { x = 10; });
+        ASSERT_EQ(10, x);
     }
-    ASSERT_FALSE(called);
-    latch.CountDown();
-    for (auto &&e : ts) {
-      e.join();
-    }
-    ASSERT_TRUE(called);
-  }
 }
 
-TEST(Future, WhenAllCollectionEmpty) {
-  {
+TEST(Future, WhenAllForCollectionOfEmptyFuture)
+{
     std::vector<Future<>> vfs;
-    int x{};
-    WhenAll(std::move(vfs)).Then([&] { x = 10; });
-    ASSERT_EQ(10, x);
-  }
+    bool cont_called = false;
 
-  {
-    std::vector<Future<int>> vfs;
-    int x{};
-    WhenAll(std::move(vfs)).Then([&](std::vector<int> &&) { x = 10; });
-    ASSERT_EQ(10, x);
-  }
+    for (int i = 0; i != 1000; ++i) { vfs.emplace_back(futurize_values); }
+
+    // std::vector<Future<>> is special, the continuation is called with
+    // no argument.
+    WhenAll(std::move(vfs)).Then([&] { cont_called = true; });
+    ASSERT_TRUE(cont_called);
 }
 
-TEST(Future, WhenAllForCollectionOfEmptyFuture) {
-  std::vector<Future<>> vfs;
-  bool cont_called = false;
+TEST(Future, WhenAnyCollectionOfEmptyFuture)
+{
+    std::vector<Future<>> vfs;
+    bool called = false;
+    for (int i = 0; i != 1000; ++i) { vfs.emplace_back(futurize_values); }
 
-  for (int i = 0; i != 1000; ++i) {
-    vfs.emplace_back(futurize_values);
-  }
-
-  // std::vector<Future<>> is special, the continuation is called with
-  // no argument.
-  WhenAll(std::move(vfs)).Then([&] { cont_called = true; });
-  ASSERT_TRUE(cont_called);
+    WhenAny(std::move(vfs)).Then([&](std::size_t index) { called = true; });
+    ASSERT_TRUE(called);
 }
 
-TEST(Future, WhenAnyCollectionOfEmptyFuture) {
-  std::vector<Future<>> vfs;
-  bool called = false;
-  for (int i = 0; i != 1000; ++i) {
-    vfs.emplace_back(futurize_values);
-  }
+TEST(Future, WhenAnyCollectionMultiThreaded)
+{
+    for (int i = 0; i != 100; ++i) {
+        constexpr auto kCount = 100;
+        std::vector<Promise<std::unique_ptr<int>, char>> vps(kCount);
+        std::vector<Future<int>> vfs;
+        std::vector<std::thread> ts;
+        Latch latch(kCount + 1);
+        std::atomic<int> x{};
 
-  WhenAny(std::move(vfs)).Then([&](std::size_t index) { called = true; });
-  ASSERT_TRUE(called);
-}
+        for (auto &&e : vps) {
+            vfs.emplace_back(e.GetFuture().Then([&](std::unique_ptr<int> &&setter_index, char &&) {
+                ++x;
+                return *setter_index;
+            }));
+        }
 
-TEST(Future, WhenAnyCollectionMultiThreaded) {
-  for (int i = 0; i != 100; ++i) {
-    constexpr auto kCount = 100;
-    std::vector<Promise<std::unique_ptr<int>, char>> vps(kCount);
-    std::vector<Future<int>> vfs;
-    std::vector<std::thread> ts;
-    Latch latch(kCount + 1);
-    std::atomic<int> x{};
+        auto all = WhenAny(std::move(vfs));
+        ASSERT_EQ(0, x);
 
-    for (auto &&e : vps) {
-      vfs.emplace_back(
-          e.GetFuture().Then([&](std::unique_ptr<int> &&setter_index, char &&) {
-            ++x;
-            return *setter_index;
-          }));
+        for (int i = 0; i != vps.size(); ++i) {
+            auto ep = &vps[i];
+            ts.push_back(std::thread([&, ep, i] {
+                latch.ArriveAndWait();
+                ep->SetValue(make_unique<int>(i), 'a');
+            }));
+        }
+        ASSERT_EQ(0, x);
+
+        std::thread starter([&] {
+            std::this_thread::sleep_for(std::chrono::milliseconds(10));
+            latch.CountDown();
+        });
+
+        auto &&res   = BlockingGet(&all);
+        auto &&index = std::get<0>(res);
+        auto &&value = std::get<1>(res);
+
+        ASSERT_GE(kCount, index);
+        ASSERT_LE(0, index);
+        ASSERT_EQ(index, value);
+
+        for (auto &&e : ts) { e.join(); }
+        starter.join();
+        ASSERT_EQ(kCount, x);
     }
-
-    auto all = WhenAny(std::move(vfs));
-    ASSERT_EQ(0, x);
-
-    for (int i = 0; i != vps.size(); ++i) {
-      auto ep = &vps[i];
-      ts.push_back(std::thread([&, ep, i] {
-        latch.ArriveAndWait();
-        ep->SetValue(make_unique<int>(i), 'a');
-      }));
-    }
-    ASSERT_EQ(0, x);
-
-    std::thread starter([&] {
-      std::this_thread::sleep_for(std::chrono::milliseconds(10));
-      latch.CountDown();
-    });
-
-    auto &&res = BlockingGet(&all);
-    auto &&index = std::get<0>(res);
-    auto &&value = std::get<1>(res);
-
-    ASSERT_GE(kCount, index);
-    ASSERT_LE(0, index);
-    ASSERT_EQ(index, value);
-
-    for (auto &&e : ts) {
-      e.join();
-    }
-    starter.join();
-    ASSERT_EQ(kCount, x);
-  }
 }
 
-TEST(Future, DurationTimeout) {
-  auto one_sec = std::chrono::seconds(1);
-  {
-    Promise<int> p;
-    auto rc = BlockingTryGet(p.GetFuture(), one_sec);
-    ASSERT_FALSE(rc);
-    p.SetValue(10);
-  }
-  {
-    Promise<int> p;
-    auto f = p.GetFuture();
-    auto rc = BlockingTryGet(&f, one_sec);
-    ASSERT_FALSE(rc);
-  }
-  {
-    Promise<> p;
-    auto f = p.GetFuture();
-    auto rc = BlockingTryGet(&f, one_sec);
-    ASSERT_FALSE(rc);
-  }
+TEST(Future, DurationTimeout)
+{
+    auto one_sec = std::chrono::seconds(1);
+    {
+        Promise<int> p;
+        auto rc = BlockingTryGet(p.GetFuture(), one_sec);
+        ASSERT_FALSE(rc);
+        p.SetValue(10);
+    }
+    {
+        Promise<int> p;
+        auto f  = p.GetFuture();
+        auto rc = BlockingTryGet(&f, one_sec);
+        ASSERT_FALSE(rc);
+    }
+    {
+        Promise<> p;
+        auto f  = p.GetFuture();
+        auto rc = BlockingTryGet(&f, one_sec);
+        ASSERT_FALSE(rc);
+    }
 }
 
-} // namespace tile
+}// namespace tile
diff --git a/tile/base/future/impls.h b/tile/base/future/impls.h
index a4cdf8a..f422e9b 100644
--- a/tile/base/future/impls.h
+++ b/tile/base/future/impls.h
@@ -11,32 +11,41 @@
 namespace tile {
 namespace future {
 namespace detail {
-template <std::size_t I, typename F> void for_each_indexed_impl(F &&) {}
+template<std::size_t I, typename F>
+void
+for_each_indexed_impl(F &&)
+{}
 
-template <std::size_t I, typename F, typename T>
-void for_each_indexed_impl(F &&f, T &&t) {
-  f(std::forward<T>(t), std::integral_constant<std::size_t, I>());
+template<std::size_t I, typename F, typename T>
+void
+for_each_indexed_impl(F &&f, T &&t)
+{
+    f(std::forward<T>(t), std::integral_constant<std::size_t, I>());
 }
 
-template <std::size_t I, typename F, typename T, typename... Ts>
-void for_each_indexed_impl(F &&f, T &&t, Ts &&...ts) {
-  f(std::forward<T>(t), std::integral_constant<std::size_t, I>());
+template<std::size_t I, typename F, typename T, typename... Ts>
+void
+for_each_indexed_impl(F &&f, T &&t, Ts &&...ts)
+{
+    f(std::forward<T>(t), std::integral_constant<std::size_t, I>());
 
-  for_each_indexed_impl<I + 1>(std::forward<F>(f), std::forward<Ts>(ts)...);
+    for_each_indexed_impl<I + 1>(std::forward<F>(f), std::forward<Ts>(ts)...);
 }
 
-template <template <typename...> class TT, typename T>
+template<template<typename...> class TT, typename T>
 struct is_template_t : std::false_type {};
 
-template <template <typename...> class TT, typename... T>
+template<template<typename...> class TT, typename... T>
 struct is_template_t<TT, TT<T...>> : std::true_type {};
 
-template <typename T> struct is_duration {
-  static constexpr bool value = is_template_t<std::chrono::duration, T>::value;
+template<typename T>
+struct is_duration {
+    static constexpr bool value = is_template_t<std::chrono::duration, T>::value;
 };
-template <typename T> struct is_time_point {
-  static constexpr bool value =
-      is_template_t<std::chrono::time_point, T>::value;
+
+template<typename T>
+struct is_time_point {
+    static constexpr bool value = is_template_t<std::chrono::time_point, T>::value;
 };
 
 static_assert(is_duration<std::chrono::steady_clock::duration>::value, "");
@@ -44,23 +53,29 @@ static_assert(!is_duration<std::chrono::steady_clock::time_point>::value, "");
 static_assert(!is_time_point<std::chrono::steady_clock::duration>::value, "");
 static_assert(is_time_point<std::chrono::steady_clock::time_point>::value, "");
 
-template <typename T> struct optional_or_bool {
-  using type = std::optional<T>;
-};
-template <> struct optional_or_bool<void> {
-  using type = bool;
+template<typename T>
+struct optional_or_bool {
+    using type = std::optional<T>;
 };
 
-template <typename T>
+template<>
+struct optional_or_bool<void> {
+    using type = bool;
+};
+
+template<typename T>
 using optional_or_bool_t = typename optional_or_bool<T>::type;
 
-} // namespace detail
+}// namespace detail
 
-template <typename F, typename... Ts> void for_each_indexed(F &&f, Ts &&...ts) {
-  detail::for_each_indexed_impl<0>(std::forward<F>(f), std::forward<Ts>(ts)...);
+template<typename F, typename... Ts>
+void
+for_each_indexed(F &&f, Ts &&...ts)
+{
+    detail::for_each_indexed_impl<0>(std::forward<F>(f), std::forward<Ts>(ts)...);
 }
 
-} // namespace future
-} // namespace tile
+}// namespace future
+}// namespace tile
 
-#endif // TILE_BASE_FUTURE_IMPLS_H
+#endif// TILE_BASE_FUTURE_IMPLS_H
diff --git a/tile/base/future/promise-impl.h b/tile/base/future/promise-impl.h
index 8902e27..ee6c54e 100644
--- a/tile/base/future/promise-impl.h
+++ b/tile/base/future/promise-impl.h
@@ -13,29 +13,37 @@
 
 namespace tile {
 namespace future {
-template <class... Ts>
-Promise<Ts...>::Promise()
-    : core_(std::make_shared<Core<Ts...>>(GetDefaultExecutor())) {}
+template<class... Ts>
+Promise<Ts...>::Promise() : core_(std::make_shared<Core<Ts...>>(GetDefaultExecutor()))
+{}
 
-template <class... Ts> Future<Ts...> Promise<Ts...>::GetFuture() {
-  return Future<Ts...>(core_);
+template<class... Ts>
+Future<Ts...>
+Promise<Ts...>::GetFuture()
+{
+    return Future<Ts...>(core_);
 }
 
-template <class... Ts>
-template <class... Us, class>
-void Promise<Ts...>::SetValue(Us &&...values) {
-  core_->SetBoxed(Boxed<Ts...>(box_values, std::forward<Us>(values)...));
+template<class... Ts>
+template<class... Us, class>
+void
+Promise<Ts...>::SetValue(Us &&...values)
+{
+    core_->SetBoxed(Boxed<Ts...>(box_values, std::forward<Us>(values)...));
 }
 
-template <class... Ts> void Promise<Ts...>::SetBoxed(Boxed<Ts...> boxed) {
-  core_->SetBoxed(std::move(boxed));
+template<class... Ts>
+void
+Promise<Ts...>::SetBoxed(Boxed<Ts...> boxed)
+{
+    core_->SetBoxed(std::move(boxed));
 }
 
-template <class... Ts>
-Promise<Ts...>::Promise(Executor executor)
-    : core_(std::make_shared<Core<Ts...>>(std::move(executor))) {}
+template<class... Ts>
+Promise<Ts...>::Promise(Executor executor) : core_(std::make_shared<Core<Ts...>>(std::move(executor)))
+{}
 
-} // namespace future
-} // namespace tile
+}// namespace future
+}// namespace tile
 
-#endif // TILE_BASE_FUTURE_PROMISE_IMPL_H
+#endif// TILE_BASE_FUTURE_PROMISE_IMPL_H
diff --git a/tile/base/future/promise.h b/tile/base/future/promise.h
index 4e646e3..8b41ba5 100644
--- a/tile/base/future/promise.h
+++ b/tile/base/future/promise.h
@@ -9,39 +9,39 @@
 namespace tile {
 namespace future {
 
-template <typename... Ts> class Promise {
+template<typename... Ts>
+class Promise {
 public:
-  using value_type = std::tuple<Ts...>;
+    using value_type = std::tuple<Ts...>;
 
-  Promise();
-  // Non-copyable
-  Promise(const Promise &) = delete;
-  Promise &operator=(const Promise &) = delete;
+    Promise();
+    // Non-copyable
+    Promise(const Promise &)            = delete;
+    Promise &operator=(const Promise &) = delete;
 
-  // Movable.
-  Promise(Promise &&) = default;
-  Promise &operator=(Promise &&) = default;
+    // Movable.
+    Promise(Promise &&)            = default;
+    Promise &operator=(Promise &&) = default;
 
-  static_assert(!types_contains<Types<Ts...>, void>::value,
-                "There's no point in specifying `void` in `Ts...`, use "
-                "`Promise<>` if you meant to declare a future with no value.");
+    static_assert(!types_contains<Types<Ts...>, void>::value,
+                  "There's no point in specifying `void` in `Ts...`, use "
+                  "`Promise<>` if you meant to declare a future with no value.");
 
-  Future<Ts...> GetFuture();
-  template <typename... Us,
-            typename =
-                enable_if_t<std::is_constructible<value_type, Us &&...>::value>>
-  void SetValue(Us &&...values);
+    Future<Ts...> GetFuture();
+    template<typename... Us, typename = enable_if_t<std::is_constructible<value_type, Us &&...>::value>>
+    void SetValue(Us &&...values);
 
-  void SetBoxed(Boxed<Ts...> boxed);
+    void SetBoxed(Boxed<Ts...> boxed);
 
 private:
-  template <typename... Us> friend class Future;
+    template<typename... Us>
+    friend class Future;
 
-  explicit Promise(Executor executor);
-  std::shared_ptr<Core<Ts...>> core_;
+    explicit Promise(Executor executor);
+    std::shared_ptr<Core<Ts...>> core_;
 };
 
-} // namespace future
-} // namespace tile
+}// namespace future
+}// namespace tile
 
-#endif // TILE_BASE_FUTURE_PROMISE_H
+#endif// TILE_BASE_FUTURE_PROMISE_H
diff --git a/tile/base/future/split.h b/tile/base/future/split.h
index ac3168a..6ba8a1c 100644
--- a/tile/base/future/split.h
+++ b/tile/base/future/split.h
@@ -13,52 +13,52 @@ namespace tile {
 namespace future {
 namespace detail {
 
-template <typename... Ts>
-auto SplitImpl(Future<Ts...> *future)
-    -> enable_if_t<(sizeof...(Ts) > 0), Future<Ts...>> {
-  Promise<Ts...> promise;
-  auto rc = promise.GetFuture();
+template<typename... Ts>
+auto
+SplitImpl(Future<Ts...> *future) -> enable_if_t<(sizeof...(Ts) > 0), Future<Ts...>>
+{
+    Promise<Ts...> promise;
+    auto rc            = promise.GetFuture();
 
-  auto moved_promise = MakeMoveOnCopy(promise);
-  *future =
-      std::move(*future).Then([moved_promise](Boxed<Ts...> boxed) mutable {
+    auto moved_promise = MakeMoveOnCopy(promise);
+    *future            = std::move(*future).Then([moved_promise](Boxed<Ts...> boxed) mutable {
         moved_promise->SetBoxed(boxed);
 
         return std::move(boxed.Get());
-      });
-  return rc;
+    });
+    return rc;
 }
 
-template <typename... Ts>
-auto SplitImpl(Future<Ts...> *future)
-    -> enable_if_t<(sizeof...(Ts) == 0), Future<Ts...>> {
-  Promise<Ts...> promise;
-  auto rc = promise.GetFuture();
+template<typename... Ts>
+auto
+SplitImpl(Future<Ts...> *future) -> enable_if_t<(sizeof...(Ts) == 0), Future<Ts...>>
+{
+    Promise<Ts...> promise;
+    auto rc            = promise.GetFuture();
 
-  auto moved_promise = MakeMoveOnCopy(promise);
-  *future =
-      std::move(*future).Then([moved_promise](Boxed<Ts...> boxed) mutable {
-        moved_promise->SetBoxed(boxed);
-      });
+    auto moved_promise = MakeMoveOnCopy(promise);
+    *future = std::move(*future).Then([moved_promise](Boxed<Ts...> boxed) mutable { moved_promise->SetBoxed(boxed); });
 
-  return rc;
+    return rc;
 }
-} // namespace detail
+}// namespace detail
 
-template <typename... Ts, typename = enable_if_t<
-                              std::is_copy_constructible<Boxed<Ts...>>::value>>
-std::pair<Future<Ts...>, Future<Ts...>> Split(Future<Ts...> *future) {
-  auto new_f = detail::SplitImpl(future);
-  return std::make_pair(std::move(new_f), std::move(*future));
+template<typename... Ts, typename = enable_if_t<std::is_copy_constructible<Boxed<Ts...>>::value>>
+std::pair<Future<Ts...>, Future<Ts...>>
+Split(Future<Ts...> *future)
+{
+    auto new_f = detail::SplitImpl(future);
+    return std::make_pair(std::move(new_f), std::move(*future));
 }
 
-template <typename... Ts, typename = enable_if_t<
-                              std::is_copy_constructible<Boxed<Ts...>>::value>>
-std::pair<Future<Ts...>, Future<Ts...>> Split(Future<Ts...> &&future) {
-  return Split(&future);
+template<typename... Ts, typename = enable_if_t<std::is_copy_constructible<Boxed<Ts...>>::value>>
+std::pair<Future<Ts...>, Future<Ts...>>
+Split(Future<Ts...> &&future)
+{
+    return Split(&future);
 }
 
-} // namespace future
-} // namespace tile
+}// namespace future
+}// namespace tile
 
-#endif // TILE_BASE_FUTURE_SPLIT_H
+#endif// TILE_BASE_FUTURE_SPLIT_H
diff --git a/tile/base/future/types.h b/tile/base/future/types.h
index 91f4c19..d627875 100644
--- a/tile/base/future/types.h
+++ b/tile/base/future/types.h
@@ -8,69 +8,82 @@
 
 namespace tile {
 namespace future {
-template <typename... Ts> struct Types {};
+template<typename... Ts>
+struct Types {};
 
 // Get type at the specify location
-template <typename T, std::size_t I> struct types_at;
-template <typename T, typename... Ts> struct types_at<Types<T, Ts...>, 0> {
-  using type = T;
+template<typename T, std::size_t I>
+struct types_at;
+
+template<typename T, typename... Ts>
+struct types_at<Types<T, Ts...>, 0> {
+    using type = T;
 };
-template <std::size_t I, typename T, typename... Ts>
+
+template<std::size_t I, typename T, typename... Ts>
 struct types_at<Types<T, Ts...>, I> : types_at<Types<Ts...>, I - 1> {};
 
-template <typename T, std::size_t I>
+template<typename T, std::size_t I>
 using types_at_t = typename types_at<T, I>::type;
-static_assert(std::is_same<types_at_t<Types<int, char, void>, 1>, char>::value,
-              "Compiler support error: types_at_t");
+static_assert(std::is_same<types_at_t<Types<int, char, void>, 1>, char>::value, "Compiler support error: types_at_t");
 
-template <typename... Ts> struct types_cat;
+template<typename... Ts>
+struct types_cat;
 
-template <> struct types_cat<> {
-  using type = Types<>;
+template<>
+struct types_cat<> {
+    using type = Types<>;
 };
-template <typename... Ts> struct types_cat<Types<Ts...>> {
-  using type = Types<Ts...>;
+
+template<typename... Ts>
+struct types_cat<Types<Ts...>> {
+    using type = Types<Ts...>;
 };
-template <typename... Ts, typename... Us, typename... Vs>
-struct types_cat<Types<Ts...>, Types<Us...>, Vs...>
-    : types_cat<Types<Ts..., Us...>, Vs...> {};
 
-template <typename... Ts> using types_cat_t = typename types_cat<Ts...>::type;
+template<typename... Ts, typename... Us, typename... Vs>
+struct types_cat<Types<Ts...>, Types<Us...>, Vs...> : types_cat<Types<Ts..., Us...>, Vs...> {};
 
-template <typename T, typename U> struct types_contains;
-template <typename U> struct types_contains<Types<>, U> : std::false_type {};
-template <typename T, typename U>
+template<typename... Ts>
+using types_cat_t = typename types_cat<Ts...>::type;
+
+template<typename T, typename U>
+struct types_contains;
+
+template<typename U>
+struct types_contains<Types<>, U> : std::false_type {};
+
+template<typename T, typename U>
 struct types_contains<Types<T>, U> : std::is_same<T, U> {};
-template <typename T, typename U, typename... Ts>
+
+template<typename T, typename U, typename... Ts>
 struct types_contains<Types<T, Ts...>, U>
-    : std::conditional<std::is_same<T, U>::value, std::true_type,
-                       types_contains<Types<Ts...>, U>>::type {};
+    : std::conditional<std::is_same<T, U>::value, std::true_type, types_contains<Types<Ts...>, U>>::type {};
 
 static_assert(types_contains<Types<int, char>, char>::value, "");
 static_assert(!types_contains<Types<int, char>, char *>::value, "");
 
 // Erase all occurrance of give type from Types<...>
-template <typename T, typename U> struct types_erase;
-template <typename U> struct types_erase<Types<>, U> {
-  using type = Types<>;
+template<typename T, typename U>
+struct types_erase;
+
+template<typename U>
+struct types_erase<Types<>, U> {
+    using type = Types<>;
 };
-template <typename T, typename U, typename... Ts>
+
+template<typename T, typename U, typename... Ts>
 struct types_erase<Types<T, Ts...>, U>
-    : types_cat<internal::conditional_t<!std::is_same<T, U>::value, Types<T>,
-                                        Types<>>,
+    : types_cat<internal::conditional_t<!std::is_same<T, U>::value, Types<T>, Types<>>,
                 typename types_erase<Types<Ts...>, U>::type> {};
-template <typename T, typename U>
+
+template<typename T, typename U>
 using types_erase_t = typename types_erase<T, U>::type;
 
-static_assert(std::is_same<types_erase_t<Types<int, void, char>, void>,
-                           Types<int, char>>::value,
-              "");
+static_assert(std::is_same<types_erase_t<Types<int, void, char>, void>, Types<int, char>>::value, "");
 static_assert(std::is_same<types_erase_t<Types<>, void>, Types<>>::value, "");
-static_assert(std::is_same<types_erase_t<Types<int, char>, void>,
-                           Types<int, char>>::value,
-              "");
+static_assert(std::is_same<types_erase_t<Types<int, char>, void>, Types<int, char>>::value, "");
 
-} // namespace future
-} // namespace tile
+}// namespace future
+}// namespace tile
 
-#endif // TILE_BASE_FUTURE_TYPES_H
+#endif// TILE_BASE_FUTURE_TYPES_H
diff --git a/tile/base/future/utils.h b/tile/base/future/utils.h
index c80a535..5dec9c9 100644
--- a/tile/base/future/utils.h
+++ b/tile/base/future/utils.h
@@ -20,136 +20,151 @@
 namespace tile {
 namespace future {
 namespace detail {
-template <typename LockType, typename DurationOrTimePoint>
-auto WaitLockByCondVar(CondVar &cv, LockType &lk,
-                       const DurationOrTimePoint &timeout)
-    -> enable_if_t<future::detail::is_duration<DurationOrTimePoint>::value,
-                   bool> {
-  return cv.WaitFor(lk, timeout);
+template<typename LockType, typename DurationOrTimePoint>
+auto
+WaitLockByCondVar(CondVar &cv, LockType &lk, const DurationOrTimePoint &timeout)
+    -> enable_if_t<future::detail::is_duration<DurationOrTimePoint>::value, bool>
+{
+    return cv.WaitFor(lk, timeout);
 }
 
-template <typename LockType, typename DurationOrTimePoint>
-auto WaitLockByCondVar(CondVar &cv, LockType &lk,
-                       const DurationOrTimePoint &timeout)
-    -> enable_if_t<future::detail::is_time_point<DurationOrTimePoint>::value,
-                   bool> {
-  return cv.WaitUntil(lk, timeout);
+template<typename LockType, typename DurationOrTimePoint>
+auto
+WaitLockByCondVar(CondVar &cv, LockType &lk, const DurationOrTimePoint &timeout)
+    -> enable_if_t<future::detail::is_time_point<DurationOrTimePoint>::value, bool>
+{
+    return cv.WaitUntil(lk, timeout);
 }
 
-template <typename... Ts, typename DurationOrTimePoint>
+template<typename... Ts, typename DurationOrTimePoint>
 auto BlockingTryGet(Future<Ts...> &&future, const DurationOrTimePoint &timeout)
     -> enable_if_t<std::is_void<unboxed_type_t<Ts...>>::value, bool>;
 
-template <typename... Ts, typename DurationOrTimePoint>
+template<typename... Ts, typename DurationOrTimePoint>
 auto BlockingTryGet(Future<Ts...> &&future, const DurationOrTimePoint &timeout)
-    -> enable_if_t<!std::is_void<unboxed_type_t<Ts...>>::value,
-                   std::optional<unboxed_type_t<Ts...>>>;
+    -> enable_if_t<!std::is_void<unboxed_type_t<Ts...>>::value, std::optional<unboxed_type_t<Ts...>>>;
 
-template <typename... Ts>
+template<typename... Ts>
 auto BlockingGetPreservingErrors(Future<Ts...> &&future) -> Boxed<Ts...>;
 
-template <typename... Ts, typename DurationOrTimePoint>
+template<typename... Ts, typename DurationOrTimePoint>
 auto BlockingTryGetPreservingErrors(Future<Ts...> &&future,
-                                    const DurationOrTimePoint &timeout)
-    -> std::optional<Boxed<Ts...>>;
+                                    const DurationOrTimePoint &timeout) -> std::optional<Boxed<Ts...>>;
 
-} // namespace detail
+}// namespace detail
 
-template <typename... Ts> Future<decay_t<Ts>...> MakeReadyFuture(Ts &&...args);
+template<typename... Ts>
+Future<decay_t<Ts>...> MakeReadyFuture(Ts &&...args);
 
-template <typename... Ts>
+template<typename... Ts>
 auto BlockingGet(Future<Ts...> &&future) -> unboxed_type_t<Ts...>;
 
-template <typename... Ts>
-auto BlockingGet(Future<Ts...> *future) -> unboxed_type_t<Ts...> {
-  return BlockingGet(std::move(*future));
+template<typename... Ts>
+auto
+BlockingGet(Future<Ts...> *future) -> unboxed_type_t<Ts...>
+{
+    return BlockingGet(std::move(*future));
 }
 
-template <typename... Ts, typename DurationOrTimePoint>
-auto BlockingTryGet(Future<Ts...> future, const DurationOrTimePoint &timeout)
-    -> future::detail::optional_or_bool_t<unboxed_type_t<Ts...>> {
-  return future::detail::BlockingTryGet(std::move(future), timeout);
+template<typename... Ts, typename DurationOrTimePoint>
+auto
+BlockingTryGet(Future<Ts...> future,
+               const DurationOrTimePoint &timeout) -> future::detail::optional_or_bool_t<unboxed_type_t<Ts...>>
+{
+    return future::detail::BlockingTryGet(std::move(future), timeout);
 }
 
-template <typename... Ts, typename DurationOrTimePoint>
-auto BlockingTryGet(Future<Ts...> *future, const DurationOrTimePoint &timeout)
-    -> detail::optional_or_bool_t<unboxed_type_t<Ts...>> {
-  return BlockingTryGet(std::move(*future), timeout);
+template<typename... Ts, typename DurationOrTimePoint>
+auto
+BlockingTryGet(Future<Ts...> *future,
+               const DurationOrTimePoint &timeout) -> detail::optional_or_bool_t<unboxed_type_t<Ts...>>
+{
+    return BlockingTryGet(std::move(*future), timeout);
 }
 
-} // namespace future
-} // namespace tile
+}// namespace future
+}// namespace tile
 
 namespace tile {
 namespace future {
 namespace detail {
-template <typename... Ts>
-auto BlockingGetPreservingErrors(Future<Ts...> &&future) -> Boxed<Ts...> {
-  Mutex lock;
-  CondVar cv;
-  std::optional<Boxed<Ts...>> receiver;
-
-  std::move(future).Then([&](Boxed<Ts...> &&boxed) {
-    ScopedLock lk(lock);
-    receiver.emplace(std::move(boxed));
-    cv.NotifyOne();
-  });
-  ScopedLock lk(lock);
-  cv.Wait(lk, [&] { return receiver.has_value(); });
-
-  return std::move(*receiver);
-}
-
-template <typename... Ts, typename DurationOrTimePoint>
-auto BlockingTryGet(Future<Ts...> &&future, const DurationOrTimePoint &timeout)
-    -> enable_if_t<std::is_void<unboxed_type_t<Ts...>>::value, bool> {
-  return !!BlockingTryGetPreservingErrors(std::move(future), timeout);
-}
-
-template <typename... Ts, typename DurationOrTimePoint>
-auto BlockingTryGet(Future<Ts...> &&future, const DurationOrTimePoint &timeout)
-    -> enable_if_t<!std::is_void<unboxed_type_t<Ts...>>::value,
-                   std::optional<unboxed_type_t<Ts...>>> {
-  auto rc = BlockingTryGetPreservingErrors(std::move(future), timeout);
-  if (rc) {
-    return std::move(rc->Get());
-  }
-  return std::nullopt;
-}
-template <typename... Ts, typename DurationOrTimePoint>
-auto BlockingTryGetPreservingErrors(Future<Ts...> &&future,
-                                    const DurationOrTimePoint &timeout)
-    -> std::optional<Boxed<Ts...>> {
-  struct State {
-    CondVar cv;
+template<typename... Ts>
+auto
+BlockingGetPreservingErrors(Future<Ts...> &&future) -> Boxed<Ts...>
+{
     Mutex lock;
+    CondVar cv;
     std::optional<Boxed<Ts...>> receiver;
-  };
 
-  auto state = std::make_shared<State>();
+    std::move(future).Then([&](Boxed<Ts...> &&boxed) {
+        ScopedLock lk(lock);
+        receiver.emplace(std::move(boxed));
+        cv.NotifyOne();
+    });
+    ScopedLock lk(lock);
+    cv.Wait(lk, [&] { return receiver.has_value(); });
+
+    return std::move(*receiver);
+}
+
+template<typename... Ts, typename DurationOrTimePoint>
+auto
+BlockingTryGet(Future<Ts...> &&future,
+               const DurationOrTimePoint &timeout) -> enable_if_t<std::is_void<unboxed_type_t<Ts...>>::value, bool>
+{
+    return !!BlockingTryGetPreservingErrors(std::move(future), timeout);
+}
+
+template<typename... Ts, typename DurationOrTimePoint>
+auto
+BlockingTryGet(Future<Ts...> &&future, const DurationOrTimePoint &timeout)
+    -> enable_if_t<!std::is_void<unboxed_type_t<Ts...>>::value, std::optional<unboxed_type_t<Ts...>>>
+{
+    auto rc = BlockingTryGetPreservingErrors(std::move(future), timeout);
+    if (rc) { return std::move(rc->Get()); }
+    return std::nullopt;
+}
+
+template<typename... Ts, typename DurationOrTimePoint>
+auto
+BlockingTryGetPreservingErrors(Future<Ts...> &&future,
+                               const DurationOrTimePoint &timeout) -> std::optional<Boxed<Ts...>>
+{
+    struct State {
+        CondVar cv;
+        Mutex lock;
+        std::optional<Boxed<Ts...>> receiver;
+    };
+
+    auto state = std::make_shared<State>();
+
+    std::move(future).Then([state](Boxed<Ts...> boxed) noexcept {
+        ScopedLock lk(state->lock);
+        state->receiver.emplace(std::move(boxed));
+        state->cv.NotifyOne();
+    });
 
-  std::move(future).Then([state](Boxed<Ts...> boxed) noexcept {
     ScopedLock lk(state->lock);
-    state->receiver.emplace(std::move(boxed));
-    state->cv.NotifyOne();
-  });
-
-  ScopedLock lk(state->lock);
-  future::detail::WaitLockByCondVar(state->cv, lk, timeout);
-  return std::move(state->receiver);
+    future::detail::WaitLockByCondVar(state->cv, lk, timeout);
+    return std::move(state->receiver);
 }
 
-} // namespace detail
+}// namespace detail
 
-template <typename... Ts> Future<decay_t<Ts>...> MakeReadyFuture(Ts &&...args) {
-  return Future<decay_t<Ts>...>(futurize_values, std::forward<Ts>(args)...);
+template<typename... Ts>
+Future<decay_t<Ts>...>
+MakeReadyFuture(Ts &&...args)
+{
+    return Future<decay_t<Ts>...>(futurize_values, std::forward<Ts>(args)...);
 }
 
-template <typename... Ts>
-auto BlockingGet(Future<Ts...> &&future) -> unboxed_type_t<Ts...> {
-  return future::detail::BlockingGetPreservingErrors(std::move(future)).Get();
+template<typename... Ts>
+auto
+BlockingGet(Future<Ts...> &&future) -> unboxed_type_t<Ts...>
+{
+    return future::detail::BlockingGetPreservingErrors(std::move(future)).Get();
 }
 
-} // namespace future
-} // namespace tile
-#endif // TILE_BASE_FUTURE_UTILS_H
+}// namespace future
+}// namespace tile
+#endif// TILE_BASE_FUTURE_UTILS_H
diff --git a/tile/base/future/when_all.h b/tile/base/future/when_all.h
index 51980cf..b290a3b 100644
--- a/tile/base/future/when_all.h
+++ b/tile/base/future/when_all.h
@@ -16,179 +16,171 @@ namespace future {
 namespace detail {
 
 struct Flatten {
-  template <typename T,
-            typename R = internal::conditional_t<
-                (std::tuple_size<T>::value >= 2), std::tuple<T &&>, T>>
-  static auto Rebox(T &&t) -> R {
-    return R(std::forward<T>(t));
-  };
+    template<typename T, typename R = internal::conditional_t<(std::tuple_size<T>::value >= 2), std::tuple<T &&>, T>>
+    static auto Rebox(T &&t) -> R
+    {
+        return R(std::forward<T>(t));
+    };
 
-  template <typename T, int... Is,
-            typename R = decltype(std::tuple_cat(
-                Rebox(std::move(std::get<Is>(std::declval<T>()).GetRaw()))...))>
-  auto operator()(T &&t, index_sequence<Is...>) -> R {
-    return std::tuple_cat(Rebox(std::move(std::get<Is>(t).GetRaw()))...);
-  }
+    template<typename T,
+             int... Is,
+             typename R = decltype(std::tuple_cat(Rebox(std::move(std::get<Is>(std::declval<T>()).GetRaw()))...))>
+    auto operator()(T &&t, index_sequence<Is...>) -> R
+    {
+        return std::tuple_cat(Rebox(std::move(std::get<Is>(t).GetRaw()))...);
+    }
 };
 
-template <typename... Ts>
+template<typename... Ts>
 struct WhenAllImpl : public std::enable_shared_from_this<WhenAllImpl<Ts...>> {
-  struct Context {
-    Promise<as_boxed_t<Ts>...> promise;
-    std::tuple<as_boxed_t<Ts>...> receiver{
-        future::detail::RetrieveBoxed<as_boxed_t<Ts>>()...};
-    std::atomic<std::size_t> left{sizeof...(Ts)};
-  };
+    struct Context {
+        Promise<as_boxed_t<Ts>...> promise;
+        std::tuple<as_boxed_t<Ts>...> receiver{future::detail::RetrieveBoxed<as_boxed_t<Ts>>()...};
+        std::atomic<std::size_t> left{sizeof...(Ts)};
+    };
 
-  std::shared_ptr<Context> context{nullptr};
+    std::shared_ptr<Context> context{nullptr};
 
-  // template <int I, typename...> void ForEach() {}
+    // template <int I, typename...> void ForEach() {}
 
-  template <int I, typename T> void ForEach(T &&future) {
-    auto self = this->shared_from_this();
-    std::move(future).Then(
-        [self, this](
-            as_boxed_t<internal::remove_reference_t<decltype(future)>> boxed) {
-          std::get<I>(context->receiver) = std::move(boxed);
-          if (context->left.fetch_sub(1) == 1) {
-            context->promise.SetValue(std::move(context->receiver));
-          }
+    template<int I, typename T>
+    void ForEach(T &&future)
+    {
+        auto self = this->shared_from_this();
+        std::move(future).Then([self, this](as_boxed_t<internal::remove_reference_t<decltype(future)>> boxed) {
+            std::get<I>(context->receiver) = std::move(boxed);
+            if (context->left.fetch_sub(1) == 1) { context->promise.SetValue(std::move(context->receiver)); }
         });
-  }
-
-  template <int I, typename T, typename... Us>
-  void ForEach(T &&future, Us &&...futures) {
-    ForEach<I>(std::move(future));
-    ForEach<I + 1>(std::move(futures)...);
-  }
-
-  template <
-      typename = enable_if_t<(sizeof...(Ts) > 0) && is_futures<Ts...>::value &&
-                             are_rvalue_refs<Ts &&...>::value>>
-  auto WhenAllPreservingErrors(Ts &&...futures) -> Future<as_boxed_t<Ts>...> {
-    context = std::make_shared<Context>();
-    ForEach<0>(std::move(futures)...);
-    return context->promise.GetFuture();
-  }
-
-  template <
-      typename = enable_if_t<(sizeof...(Ts) > 0) && is_futures<Ts...>::value &&
-                             are_rvalue_refs<Ts &&...>::value>,
-      typename R = rebind_t<
-          types_erase_t<Types<decltype(BlockingGet(std::declval<Ts>()))...>,
-                        void>,
-          Future>>
-  auto WhenAll(Ts &&...futures) -> R {
-    // Future<...>, Future<...>, ...
-    return WhenAllPreservingErrors(std::move(futures)...)
-        .Then([](Boxed<as_boxed_t<Ts>...> boxes) -> R {
-          // std::tuple<Boxed<...>, Boxed<...>, ...>
-          auto &&raw = boxes.GetRaw();
-
-          auto &&flattened =
-              detail::Flatten()(raw, index_sequence_for<Ts...>());
-
-          return R(futurize_tuple, std::move(flattened));
-        });
-  }
-};
-
-template <template <typename...> class C, typename... Ts> struct WhenAllCImpl {
-  // Collection of futures
-  struct Context {
-    Promise<C<Boxed<Ts...>>> promise;
-    C<Boxed<Ts...>> values;
-    std::atomic<std::size_t> left;
-  };
-
-  static auto WhenAllPreservingErrors(C<Future<Ts...>> &&futures)
-      -> Future<C<Boxed<Ts...>>> {
-    using NewFuture = Future<C<Boxed<Ts...>>>;
-    if (futures.empty()) {
-      return NewFuture(futurize_values, C<Boxed<Ts...>>());
     }
 
-    auto context = std::make_shared<Context>();
-    context->values.reserve(futures.size());
-    context->left.store(futures.size());
+    template<int I, typename T, typename... Us>
+    void ForEach(T &&future, Us &&...futures)
+    {
+        ForEach<I>(std::move(future));
+        ForEach<I + 1>(std::move(futures)...);
+    }
 
-    for (std::size_t index = 0; index != futures.size(); ++index) {
-      std::move(futures[index]).Then([=](Boxed<Ts...> boxed) mutable {
-        context->values[index] = std::move(boxed);
-        if (context->left.fetch_sub(1) == 1) {
-          context->promise.SetValue(std::move(context->values));
+    template<
+        typename = enable_if_t<(sizeof...(Ts) > 0) && is_futures<Ts...>::value && are_rvalue_refs<Ts &&...>::value>>
+    auto WhenAllPreservingErrors(Ts &&...futures) -> Future<as_boxed_t<Ts>...>
+    {
+        context = std::make_shared<Context>();
+        ForEach<0>(std::move(futures)...);
+        return context->promise.GetFuture();
+    }
+
+    template<
+        typename   = enable_if_t<(sizeof...(Ts) > 0) && is_futures<Ts...>::value && are_rvalue_refs<Ts &&...>::value>,
+        typename R = rebind_t<types_erase_t<Types<decltype(BlockingGet(std::declval<Ts>()))...>, void>, Future>>
+    auto WhenAll(Ts &&...futures) -> R
+    {
+        // Future<...>, Future<...>, ...
+        return WhenAllPreservingErrors(std::move(futures)...).Then([](Boxed<as_boxed_t<Ts>...> boxes) -> R {
+            // std::tuple<Boxed<...>, Boxed<...>, ...>
+            auto &&raw       = boxes.GetRaw();
+
+            auto &&flattened = detail::Flatten()(raw, index_sequence_for<Ts...>());
+
+            return R(futurize_tuple, std::move(flattened));
+        });
+    }
+};
+
+template<template<typename...> class C, typename... Ts>
+struct WhenAllCImpl {
+    // Collection of futures
+    struct Context {
+        Promise<C<Boxed<Ts...>>> promise;
+        C<Boxed<Ts...>> values;
+        std::atomic<std::size_t> left;
+    };
+
+    static auto WhenAllPreservingErrors(C<Future<Ts...>> &&futures) -> Future<C<Boxed<Ts...>>>
+    {
+        using NewFuture = Future<C<Boxed<Ts...>>>;
+        if (futures.empty()) { return NewFuture(futurize_values, C<Boxed<Ts...>>()); }
+
+        auto context = std::make_shared<Context>();
+        context->values.reserve(futures.size());
+        context->left.store(futures.size());
+
+        for (std::size_t index = 0; index != futures.size(); ++index) {
+            std::move(futures[index]).Then([=](Boxed<Ts...> boxed) mutable {
+                context->values[index] = std::move(boxed);
+                if (context->left.fetch_sub(1) == 1) { context->promise.SetValue(std::move(context->values)); }
+            });
         }
-      });
+
+        return context->promise.GetFuture();
     }
 
-    return context->promise.GetFuture();
-  }
+    template<typename R = internal::
+                 conditional_t<std::is_void<unboxed_type_t<Ts...>>::value, Future<>, Future<C<unboxed_type_t<Ts...>>>>>
+    static auto WhenAll(C<Future<Ts...>> &&futures) -> enable_if_t<!std::is_void<unboxed_type_t<Ts...>>::value, R>
+    {
 
-  template <typename R = internal::conditional_t<
-                std::is_void<unboxed_type_t<Ts...>>::value, Future<>,
-                Future<C<unboxed_type_t<Ts...>>>>>
-  static auto WhenAll(C<Future<Ts...>> &&futures)
-      -> enable_if_t<!std::is_void<unboxed_type_t<Ts...>>::value, R> {
+        return WhenAllPreservingErrors(std::move(futures)).Then([](C<Boxed<Ts...>> boxed_values) {
+            C<unboxed_type_t<Ts...>> result;
+            result.reserve(boxed_values.size());
+            for (auto &&e : boxed_values) {
+                // Mac C++11 can't support empalce_back
+                result.push_back(std::move(e).Get());
+            }
 
-    return WhenAllPreservingErrors(std::move(futures))
-        .Then([](C<Boxed<Ts...>> boxed_values) {
-          C<unboxed_type_t<Ts...>> result;
-          result.reserve(boxed_values.size());
-          for (auto &&e : boxed_values) {
-            // Mac C++11 can't support empalce_back
-            result.push_back(std::move(e).Get());
-          }
-
-          return result;
+            return result;
         });
-  }
-  template <typename R = internal::conditional_t<
-                std::is_void<unboxed_type_t<Ts...>>::value, Future<>,
-                Future<C<unboxed_type_t<Ts...>>>>>
-  static auto WhenAll(C<Future<Ts...>> &&futures)
-      -> enable_if_t<std::is_void<unboxed_type_t<Ts...>>::value, R> {
-    return WhenAllPreservingErrors(std::move(futures))
-        .Then([](C<Boxed<Ts...>> boxed_values) {
-          (void)boxed_values;
-          return;
+    }
+
+    template<typename R = internal::
+                 conditional_t<std::is_void<unboxed_type_t<Ts...>>::value, Future<>, Future<C<unboxed_type_t<Ts...>>>>>
+    static auto WhenAll(C<Future<Ts...>> &&futures) -> enable_if_t<std::is_void<unboxed_type_t<Ts...>>::value, R>
+    {
+        return WhenAllPreservingErrors(std::move(futures)).Then([](C<Boxed<Ts...>> boxed_values) {
+            (void) boxed_values;
+            return;
         });
-  }
+    }
 };
 
-} // namespace detail
-} // namespace future
-} // namespace tile
+}// namespace detail
+}// namespace future
+}// namespace tile
 
 namespace tile {
 namespace future {
-template <typename... Ts,
-          typename = enable_if_t<tile::future::is_futures<Ts...>::value>>
-auto WhenAll(Ts &&...futures)
-    -> decltype(std::declval<future::detail::WhenAllImpl<Ts...>>().WhenAll(
-        std::move(futures)...)) {
-  auto impl = std::make_shared<future::detail::WhenAllImpl<Ts...>>();
-  return impl->WhenAll(std::move(futures)...);
-}
-template <class... Ts,
-          class = enable_if_t<tile::future::is_futures<Ts...>::value>>
-auto WhenAll(Ts *...futures) -> decltype(WhenAll(std::move(*futures)...)) {
-  return WhenAll(std::move(*futures)...);
-}
-template <template <typename...> class C, class... Ts,
-          typename R = internal::conditional_t<
-              std::is_void<tile::future::unboxed_type_t<Ts...>>::value,
-              tile::future::Future<>,
-              tile::future::Future<C<tile::future::unboxed_type_t<Ts...>>>>>
-
-auto WhenAll(C<tile::future::Future<Ts...>> &&futures) -> R {
-  return future::detail::WhenAllCImpl<C, Ts...>::WhenAll(std::move(futures));
+template<typename... Ts, typename = enable_if_t<tile::future::is_futures<Ts...>::value>>
+auto
+WhenAll(Ts &&...futures) -> decltype(std::declval<future::detail::WhenAllImpl<Ts...>>().WhenAll(std::move(futures)...))
+{
+    auto impl = std::make_shared<future::detail::WhenAllImpl<Ts...>>();
+    return impl->WhenAll(std::move(futures)...);
 }
 
-template <template <typename...> class C, class... Ts>
-auto WhenAll(C<tile::future::Future<Ts...>> *futures)
-    -> decltype(WhenAll(std::move(*futures))) {
-  return WhenAll(std::move(*futures));
+template<class... Ts, class = enable_if_t<tile::future::is_futures<Ts...>::value>>
+auto
+WhenAll(Ts *...futures) -> decltype(WhenAll(std::move(*futures)...))
+{
+    return WhenAll(std::move(*futures)...);
 }
-} // namespace future
-} // namespace tile
-#endif // TILE_BASE_FUTURE_WHEN_ALL_H
+
+template<template<typename...> class C,
+         class... Ts,
+         typename R = internal::conditional_t<std::is_void<tile::future::unboxed_type_t<Ts...>>::value,
+                                              tile::future::Future<>,
+                                              tile::future::Future<C<tile::future::unboxed_type_t<Ts...>>>>>
+
+auto
+WhenAll(C<tile::future::Future<Ts...>> &&futures) -> R
+{
+    return future::detail::WhenAllCImpl<C, Ts...>::WhenAll(std::move(futures));
+}
+
+template<template<typename...> class C, class... Ts>
+auto
+WhenAll(C<tile::future::Future<Ts...>> *futures) -> decltype(WhenAll(std::move(*futures)))
+{
+    return WhenAll(std::move(*futures));
+}
+}// namespace future
+}// namespace tile
+#endif// TILE_BASE_FUTURE_WHEN_ALL_H
diff --git a/tile/base/future/when_any.h b/tile/base/future/when_any.h
index 128bec0..4e19be9 100644
--- a/tile/base/future/when_any.h
+++ b/tile/base/future/when_any.h
@@ -10,62 +10,63 @@
 
 namespace tile {
 namespace future {
-template <template <typename...> class C, typename... Ts>
-auto WhenAnyPreservingErrors(C<Future<Ts...>> &&futures)
-    -> Future<std::size_t, Boxed<Ts...>> {
-  TILE_CHECK(!futures.empty(),
-             "Cannot wait for any future from an empty list.");
+template<template<typename...> class C, typename... Ts>
+auto
+WhenAnyPreservingErrors(C<Future<Ts...>> &&futures) -> Future<std::size_t, Boxed<Ts...>>
+{
+    TILE_CHECK(!futures.empty(), "Cannot wait for any future from an empty list.");
 
-  struct Context {
-    Promise<std::size_t, Boxed<Ts...>> promise;
-    std::atomic<bool> ever_satisfied{false};
-  };
+    struct Context {
+        Promise<std::size_t, Boxed<Ts...>> promise;
+        std::atomic<bool> ever_satisfied{false};
+    };
 
-  auto context = std::make_shared<Context>();
+    auto context = std::make_shared<Context>();
 
-  for (std::size_t index = 0; index < futures.size(); ++index) {
-    std::move(futures[index]).Then([context, index](Boxed<Ts...> boxed) {
-      if (!context->ever_satisfied.exchange(true)) {
-        context->promise.SetValue(index, std::move(boxed));
-      }
-    });
-  }
+    for (std::size_t index = 0; index < futures.size(); ++index) {
+        std::move(futures[index]).Then([context, index](Boxed<Ts...> boxed) {
+            if (!context->ever_satisfied.exchange(true)) { context->promise.SetValue(index, std::move(boxed)); }
+        });
+    }
 
-  return context->promise.GetFuture();
+    return context->promise.GetFuture();
 }
 
-template <template <typename...> class C, typename... Ts,
-          typename R = internal::conditional_t<
-              std::is_void<unboxed_type_t<Ts...>>::value, Future<std::size_t>,
-              Future<std::size_t, unboxed_type_t<Ts...>>>>
-auto WhenAny(C<Future<Ts...>> &&futures)
-    -> enable_if_t<(sizeof...(Ts) == 0), R> {
-  return WhenAnyPreservingErrors(std::move(futures))
-      .Then([](std::size_t index, Boxed<Ts...> values) {
-        (void)values;
+template<template<typename...> class C,
+         typename... Ts,
+         typename R = internal::conditional_t<std::is_void<unboxed_type_t<Ts...>>::value,
+                                              Future<std::size_t>,
+                                              Future<std::size_t, unboxed_type_t<Ts...>>>>
+auto
+WhenAny(C<Future<Ts...>> &&futures) -> enable_if_t<(sizeof...(Ts) == 0), R>
+{
+    return WhenAnyPreservingErrors(std::move(futures)).Then([](std::size_t index, Boxed<Ts...> values) {
+        (void) values;
         return index;
-      });
+    });
 }
 
-template <template <typename...> class C, typename... Ts,
-          typename R = internal::conditional_t<
-              std::is_void<unboxed_type_t<Ts...>>::value, Future<std::size_t>,
-              Future<std::size_t, unboxed_type_t<Ts...>>>>
-auto WhenAny(C<Future<Ts...>> &&futures)
-    -> enable_if_t<(sizeof...(Ts) != 0), R> {
-  return WhenAnyPreservingErrors(std::move(futures))
-      .Then([](std::size_t index, Boxed<Ts...> values) {
+template<template<typename...> class C,
+         typename... Ts,
+         typename R = internal::conditional_t<std::is_void<unboxed_type_t<Ts...>>::value,
+                                              Future<std::size_t>,
+                                              Future<std::size_t, unboxed_type_t<Ts...>>>>
+auto
+WhenAny(C<Future<Ts...>> &&futures) -> enable_if_t<(sizeof...(Ts) != 0), R>
+{
+    return WhenAnyPreservingErrors(std::move(futures)).Then([](std::size_t index, Boxed<Ts...> values) {
         return R(futurize_values, index, values.Get());
-      });
+    });
 }
 
-template <template <class...> class C, class... Ts>
-auto WhenAny(C<Future<Ts...>> *futures)
-    -> decltype(WhenAny(std::move(*futures))) {
-  return WhenAny(std::move(*futures));
+template<template<class...> class C, class... Ts>
+auto
+WhenAny(C<Future<Ts...>> *futures) -> decltype(WhenAny(std::move(*futures)))
+{
+    return WhenAny(std::move(*futures));
 }
 
-} // namespace future
-} // namespace tile
+}// namespace future
+}// namespace tile
 
-#endif // TILE_BASE_FUTURE_WHEN_ANY_H
+#endif// TILE_BASE_FUTURE_WHEN_ANY_H
diff --git a/tile/base/handle.h b/tile/base/handle.h
index 71419a4..4bb24cc 100644
--- a/tile/base/handle.h
+++ b/tile/base/handle.h
@@ -10,84 +10,95 @@
 namespace tile {
 namespace detail {
 struct HandleDeleter {
-  void operator()(int fd) const noexcept {
-    if (fd == 0 || fd == -1) {
-      return;
+    void operator()(int fd) const noexcept
+    {
+        if (fd == 0 || fd == -1) { return; }
+        TILE_PCHECK(::close(fd) == 0);
     }
-    TILE_PCHECK(::close(fd) == 0);
-  }
 };
 
 namespace handle {
-template <typename T, typename... Args>
-constexpr T GetFirstArg(T first, Args...) {
-  return first;
+template<typename T, typename... Args>
+constexpr T
+GetFirstArg(T first, Args...)
+{
+    return first;
 }
 
-template <typename T> constexpr bool NotEqualToAnd(T val, T first) {
-  return val != first;
+template<typename T>
+constexpr bool
+NotEqualToAnd(T val, T first)
+{
+    return val != first;
 }
 
-template <typename T, typename... Args>
-constexpr bool NotEqualToAnd(T val, T first, Args... args) {
-  return val != first && NotEqualToAnd(val, std::forward<Args>(args)...);
+template<typename T, typename... Args>
+constexpr bool
+NotEqualToAnd(T val, T first, Args... args)
+{
+    return val != first && NotEqualToAnd(val, std::forward<Args>(args)...);
 }
 
-} // namespace handle
+}// namespace handle
 
-template <typename T, typename Deleter, T... kInvalidHandles>
+template<typename T, typename Deleter, T... kInvalidHandles>
 class GenericHandle : private Deleter {
-  static constexpr T kDefaultInvalid =
-      ::tile::detail::handle::GetFirstArg(kInvalidHandles...);
+    static constexpr T kDefaultInvalid = ::tile::detail::handle::GetFirstArg(kInvalidHandles...);
 
 public:
-  GenericHandle() = default;
-  constexpr explicit GenericHandle(T handle) noexcept : handle_(handle) {}
-  ~GenericHandle() { Reset(); }
+    GenericHandle() = default;
 
-  GenericHandle(GenericHandle &&h) noexcept {
-    handle_ = h.handle_;
-    h.handle_ = kDefaultInvalid;
-  }
+    constexpr explicit GenericHandle(T handle) noexcept : handle_(handle) {}
 
-  GenericHandle &operator=(GenericHandle &&h) noexcept {
-    if (&h == this) {
-      return *this;
+    ~GenericHandle() { Reset(); }
+
+    GenericHandle(GenericHandle &&h) noexcept
+    {
+        handle_   = h.handle_;
+        h.handle_ = kDefaultInvalid;
     }
 
-    handle_ = h.handle_;
-    h.handle_ = kDefaultInvalid;
-    return *this;
-  }
+    GenericHandle &operator=(GenericHandle &&h) noexcept
+    {
+        if (&h == this) { return *this; }
 
-  GenericHandle(const GenericHandle &) = delete;
-  GenericHandle &operator=(const GenericHandle &) = delete;
-
-  T *Retrieve() noexcept { return &handle_; }
-  constexpr T Get() const noexcept { return handle_; }
-  constexpr explicit operator bool() const noexcept {
-    return ::tile::detail::handle::NotEqualToAnd(handle_, kInvalidHandles...);
-  }
-
-  TILE_NODISCARD T Leak() noexcept {
-    int rc = handle_;
-    handle_ = kDefaultInvalid;
-    return rc;
-  }
-
-  void Reset(T new_value = kDefaultInvalid) noexcept {
-    if (operator bool()) {
-      Deleter::operator()(handle_);
+        handle_   = h.handle_;
+        h.handle_ = kDefaultInvalid;
+        return *this;
+    }
+
+    GenericHandle(const GenericHandle &)            = delete;
+    GenericHandle &operator=(const GenericHandle &) = delete;
+
+    T *Retrieve() noexcept { return &handle_; }
+
+    constexpr T Get() const noexcept { return handle_; }
+
+    constexpr explicit operator bool() const noexcept
+    {
+        return ::tile::detail::handle::NotEqualToAnd(handle_, kInvalidHandles...);
+    }
+
+    TILE_NODISCARD T Leak() noexcept
+    {
+        int rc  = handle_;
+        handle_ = kDefaultInvalid;
+        return rc;
+    }
+
+    void Reset(T new_value = kDefaultInvalid) noexcept
+    {
+        if (operator bool()) { Deleter::operator()(handle_); }
+        handle_ = new_value;
     }
-    handle_ = new_value;
-  }
 
 private:
-  T handle_ = kDefaultInvalid;
+    T handle_ = kDefaultInvalid;
 };
 
-} // namespace detail
-using Handle = detail::GenericHandle<int, detail::HandleDeleter, -1, 0>;
-} // namespace tile
+}// namespace detail
 
-#endif // TILE_BASE_HANDLE_H
+using Handle = detail::GenericHandle<int, detail::HandleDeleter, -1, 0>;
+}// namespace tile
+
+#endif// TILE_BASE_HANDLE_H
diff --git a/tile/base/handle_test.cc b/tile/base/handle_test.cc
index f599b1a..be6e07a 100644
--- a/tile/base/handle_test.cc
+++ b/tile/base/handle_test.cc
@@ -8,24 +8,26 @@
 
 namespace tile {
 
-TEST(Handle, InvalidValues) {
-  Handle h(0), h2(-1), h3(1);
-  ASSERT_FALSE(h);
-  ASSERT_FALSE(h2);
-  ASSERT_TRUE(h3);
-  auto holder = h3.Leak();
-  (void)holder;
+TEST(Handle, InvalidValues)
+{
+    Handle h(0), h2(-1), h3(1);
+    ASSERT_FALSE(h);
+    ASSERT_FALSE(h2);
+    ASSERT_TRUE(h3);
+    auto holder = h3.Leak();
+    (void) holder;
 }
 
-TEST(Handle, ValidHandle) {
-  int fd = 0;
-  {
-    Handle h(open("/dev/null", O_WRONLY));
-    fd = h.Get();
-    ASSERT_EQ(1, write(fd, "1", 1));
-    ASSERT_TRUE(h);
-  }
-  ASSERT_EQ(-1, write(fd, "1", 1));
+TEST(Handle, ValidHandle)
+{
+    int fd = 0;
+    {
+        Handle h(open("/dev/null", O_WRONLY));
+        fd = h.Get();
+        ASSERT_EQ(1, write(fd, "1", 1));
+        ASSERT_TRUE(h);
+    }
+    ASSERT_EQ(-1, write(fd, "1", 1));
 }
 
-} // namespace tile
+}// namespace tile
diff --git a/tile/base/id_alloc.h b/tile/base/id_alloc.h
index 4d46631..fea8680 100644
--- a/tile/base/id_alloc.h
+++ b/tile/base/id_alloc.h
@@ -8,78 +8,82 @@
 
 namespace tile {
 namespace id_alloc {
-template <typename Traits> class AllocImpl;
+template<typename Traits>
+class AllocImpl;
 
-template <typename Traits>
-inline auto Next() -> typename AllocImpl<Traits>::Type {
-  return AllocImpl<Traits>::Next();
+template<typename Traits>
+inline auto
+Next() -> typename AllocImpl<Traits>::Type
+{
+    return AllocImpl<Traits>::Next();
 };
 
-template <typename Traits> class AllocImpl {
+template<typename Traits>
+class AllocImpl {
 public:
-  using Type = typename Traits::Type;
+    using Type = typename Traits::Type;
 
-  static Type Next() {
-    if (TILE_LIKELY(current < max)) {
-      return current++;
+    static Type Next()
+    {
+        if (TILE_LIKELY(current < max)) { return current++; }
+
+        return SlowNext();
     }
 
-    return SlowNext();
-  }
+private:
+    static Type SlowNext();
 
 private:
-  static Type SlowNext();
-
-private:
-  static std::atomic<Type> global{Traits::kMin};
-  static thread_local Type current = 0;
-  static thread_local Type max = 0;
+    static std::atomic<Type> global{Traits::kMin};
+    static thread_local Type current = 0;
+    static thread_local Type max     = 0;
 };
 
-template <typename Traits>
+template<typename Traits>
 std::atomic<typename Traits::Type> AllocImpl<Traits>::global;
 
-template <typename Traits>
+template<typename Traits>
 thread_local typename Traits::Type AllocImpl<Traits>::current;
 
-template <typename Traits>
+template<typename Traits>
 thread_local typename Traits::Type AllocImpl<Traits>::max;
 
-template <typename Traits>
-typename AllocImpl<Traits>::Type AllocImpl<Traits>::SlowNext() {
-  static_assert(Traits::kMIn < Traits::kMax, "");
-  static_assert(Traits::kBatchSize > 0, "");
-  static_assert(Traits::kBatchSize + Traits::kMin < Traits::kMax, "");
-  static_assert(Traits::kBatchSize > 1, "");
+template<typename Traits>
+typename AllocImpl<Traits>::Type
+AllocImpl<Traits>::SlowNext()
+{
+    static_assert(Traits::kMIn < Traits::kMax, "");
+    static_assert(Traits::kBatchSize > 0, "");
+    static_assert(Traits::kBatchSize + Traits::kMin < Traits::kMax, "");
+    static_assert(Traits::kBatchSize > 1, "");
 
-  Type read = global.load(std::memory_order_relaxed);
-  Type next;
-  do {
-    TILE_CHECK_GE(read, Traits::kMin);
-    TILE_CHECK_LE(read, Traits::kMax);
+    Type read = global.load(std::memory_order_relaxed);
+    Type next;
+    do {
+        TILE_CHECK_GE(read, Traits::kMin);
+        TILE_CHECK_LE(read, Traits::kMax);
 
-    current = read;
-    if (read > Traits::kMax - Traits::kBatchSize) {
-      // Overflowing
-      next = Traits::kMin;
-      next = Traits::kMax;
-    } else {
-      next = read + Traits::kBatchSize;
-      max = next;
-    }
-  } while (
-      !global.compare_exchange_weak(read, next, std::memory_order_relaxed));
+        current = read;
+        if (read > Traits::kMax - Traits::kBatchSize) {
+            // Overflowing
+            next = Traits::kMin;
+            next = Traits::kMax;
+        } else {
+            next = read + Traits::kBatchSize;
+            max  = next;
+        }
+    } while (!global.compare_exchange_weak(read, next, std::memory_order_relaxed));
 
-  TILE_CHECK_GE(max, Traits::kMin);
-  TILE_CHECK_LE(max, Traits::kMax);
-  TILE_CHECK_LT(current, max);
-  TILE_CHECK_GE(current, Traits::kMin);
-  TILE_CHECK_LE(current, Traits::kMax);
+    TILE_CHECK_GE(max, Traits::kMin);
+    TILE_CHECK_LE(max, Traits::kMax);
+    TILE_CHECK_LT(current, max);
+    TILE_CHECK_GE(current, Traits::kMin);
+    TILE_CHECK_LE(current, Traits::kMax);
 
-  return Next();
+    return Next();
 }
 
-} // namespace id_alloc
-} // namespace tile
+}// namespace id_alloc
+}// namespace tile
 
-#endif // TILE_BASE_ID_ALLOC_H
+#endif// TILE_BASE_ID_ALLOC_H
diff --git a/tile/base/internal/background_task_host.cc b/tile/base/internal/background_task_host.cc
index eef3e1d..16c9e6f 100644
--- a/tile/base/internal/background_task_host.cc
+++ b/tile/base/internal/background_task_host.cc
@@ -10,50 +10,55 @@
 #include <utility>
 
 DEFINE_int32(tile_background_task_host_workers_per_node, 4, "");
-DEFINE_int32(tile_background_task_host_workers_nice_value, 5,
-             "Determines niceness of background host workers");
+DEFINE_int32(tile_background_task_host_workers_nice_value, 5, "Determines niceness of background host workers");
 
 namespace tile {
 namespace internal {
-namespace {} // namespace
+namespace {}// namespace
 
-BackgroundTaskHost *BackgroundTaskHost::Instance() {
-  static NeverDestroyedSingleton<BackgroundTaskHost> background_task_host;
-  return background_task_host.Get();
+BackgroundTaskHost *
+BackgroundTaskHost::Instance()
+{
+    static NeverDestroyedSingleton<BackgroundTaskHost> background_task_host;
+    return background_task_host.Get();
 }
 
-void BackgroundTaskHost::Start() {
-  auto logical_cpus = std::thread::hardware_concurrency();
-  if (logical_cpus == 0) {
-    logical_cpus = 1;
-    TILE_LOG_WARNING("hardware_concurrency() return 0");
-  }
-  std::vector<int> affinity;
+void
+BackgroundTaskHost::Start()
+{
+    auto logical_cpus = std::thread::hardware_concurrency();
+    if (logical_cpus == 0) {
+        logical_cpus = 1;
+        TILE_LOG_WARNING("hardware_concurrency() return 0");
+    }
+    std::vector<int> affinity;
 
-  pools_.resize(1);
-  pools_[0] = make_unique<ThreadPool>(
-      logical_cpus, affinity,
-      FLAGS_tile_background_task_host_workers_nice_value);
+    pools_.resize(1);
+    pools_[0] = make_unique<ThreadPool>(logical_cpus, affinity, FLAGS_tile_background_task_host_workers_nice_value);
 }
 
-void BackgroundTaskHost::Stop() {
-  for (auto &&e : pools_) {
-    e->Stop();
-  }
+void
+BackgroundTaskHost::Stop()
+{
+    for (auto &&e : pools_) { e->Stop(); }
 }
-void BackgroundTaskHost::Join() {
-  for (auto &&e : pools_) {
-    e->Join();
-  }
 
-  pools_.clear();
+void
+BackgroundTaskHost::Join()
+{
+    for (auto &&e : pools_) { e->Join(); }
+
+    pools_.clear();
 }
-void BackgroundTaskHost::Queue(std::function<void()> &&op) {
-  TILE_CHECK_GT(pools_.size(), 0);
-  pools_[Random() % pools_.size()]->QueueJob(std::move(op));
+
+void
+BackgroundTaskHost::Queue(std::function<void()> &&op)
+{
+    TILE_CHECK_GT(pools_.size(), 0);
+    pools_[Random() % pools_.size()]->QueueJob(std::move(op));
 }
 
 BackgroundTaskHost::BackgroundTaskHost() = default;
 
-} // namespace internal
-} // namespace tile
+}// namespace internal
+}// namespace tile
diff --git a/tile/base/internal/background_task_host.h b/tile/base/internal/background_task_host.h
index 6fcc558..165231d 100644
--- a/tile/base/internal/background_task_host.h
+++ b/tile/base/internal/background_task_host.h
@@ -14,21 +14,21 @@ namespace tile {
 namespace internal {
 class BackgroundTaskHost {
 public:
-  static BackgroundTaskHost *Instance();
-  void Start();
-  void Stop();
-  void Join();
+    static BackgroundTaskHost *Instance();
+    void Start();
+    void Stop();
+    void Join();
 
-  void Queue(std::function<void()> &&op);
+    void Queue(std::function<void()> &&op);
 
 private:
-  friend class NeverDestroyedSingleton<BackgroundTaskHost>;
-  BackgroundTaskHost();
+    friend class NeverDestroyedSingleton<BackgroundTaskHost>;
+    BackgroundTaskHost();
 
 private:
-  std::vector<std::unique_ptr<ThreadPool>> pools_;
+    std::vector<std::unique_ptr<ThreadPool>> pools_;
 };
-} // namespace internal
-} // namespace tile
+}// namespace internal
+}// namespace tile
 
-#endif // TILE_BASE_INTERNAL_BACKGROUND_TASK_HOST_H
+#endif// TILE_BASE_INTERNAL_BACKGROUND_TASK_HOST_H
diff --git a/tile/base/internal/background_task_host_test.cc b/tile/base/internal/background_task_host_test.cc
index bb9f1f6..0ed2abb 100644
--- a/tile/base/internal/background_task_host_test.cc
+++ b/tile/base/internal/background_task_host_test.cc
@@ -7,21 +7,22 @@
 namespace tile {
 namespace internal {
 
-TEST(BackgroundTaskHost, All) {
-  // BackgroundTaskHost::Instance()->Start();
-  for (int i = 0; i < 1000; ++i) {
-    int x = 1;
-    Latch latch(1);
-    BackgroundTaskHost::Instance()->Queue([&] {
-      x = 2;
-      latch.CountDown();
-    });
-    latch.Wait();
-    ASSERT_EQ(2, x);
-  }
-  // BackgroundTaskHost::Instance()->Stop();
-  // BackgroundTaskHost::Instance()->Join();
+TEST(BackgroundTaskHost, All)
+{
+    // BackgroundTaskHost::Instance()->Start();
+    for (int i = 0; i < 1000; ++i) {
+        int x = 1;
+        Latch latch(1);
+        BackgroundTaskHost::Instance()->Queue([&] {
+            x = 2;
+            latch.CountDown();
+        });
+        latch.Wait();
+        ASSERT_EQ(2, x);
+    }
+    // BackgroundTaskHost::Instance()->Stop();
+    // BackgroundTaskHost::Instance()->Join();
 }
 
-} // namespace internal
-} // namespace tile
+}// namespace internal
+}// namespace tile
diff --git a/tile/base/internal/case_insensitive_hash_map.h b/tile/base/internal/case_insensitive_hash_map.h
index 150567d..dcfd2c0 100644
--- a/tile/base/internal/case_insensitive_hash_map.h
+++ b/tile/base/internal/case_insensitive_hash_map.h
@@ -12,31 +12,27 @@ namespace tile {
 namespace internal {
 namespace detail {
 struct CaseInsensitiveHash {
-  std::size_t operator()(Slice s) const noexcept {
-    uint64_t hash = 5381;
-    for (auto &&c : s) {
-      hash += ((hash << 5) + hash) + ToLower(c);
+    std::size_t operator()(Slice s) const noexcept
+    {
+        uint64_t hash = 5381;
+        for (auto &&c : s) { hash += ((hash << 5) + hash) + ToLower(c); }
+        return hash;
     }
-    return hash;
-  }
 };
 
 struct CaseInsensitiveEqualTo {
-  bool operator()(Slice x, Slice y) const noexcept {
-    if (x.size() != y.size()) {
-      return false;
+    bool operator()(Slice x, Slice y) const noexcept
+    {
+        if (x.size() != y.size()) { return false; }
+
+        return EqualsIgnoreCase(x, y);
     }
-
-    return EqualsIgnoreCase(x, y);
-  }
 };
-} // namespace detail
+}// namespace detail
 
-template <typename K, typename V>
-using CaseInsensitiveHashMap =
-    std::unordered_map<K, V, detail::CaseInsensitiveHash,
-                       detail::CaseInsensitiveEqualTo>;
-} // namespace internal
-} // namespace tile
+template<typename K, typename V>
+using CaseInsensitiveHashMap = std::unordered_map<K, V, detail::CaseInsensitiveHash, detail::CaseInsensitiveEqualTo>;
+}// namespace internal
+}// namespace tile
 
-#endif // _TILE_BASE_INTERNAL_CASE_INSENSITIVE_HASH_MAP_H
+#endif// _TILE_BASE_INTERNAL_CASE_INSENSITIVE_HASH_MAP_H
diff --git a/tile/base/internal/case_insensitive_hash_map_test.cc b/tile/base/internal/case_insensitive_hash_map_test.cc
index 225b728..3bc1689 100644
--- a/tile/base/internal/case_insensitive_hash_map_test.cc
+++ b/tile/base/internal/case_insensitive_hash_map_test.cc
@@ -6,20 +6,21 @@
 
 namespace tile {
 namespace internal {
-TEST(CaseInsensitiveHashMap, Easy) {
-  CaseInsensitiveHashMap<std::string, std::string> m;
+TEST(CaseInsensitiveHashMap, Easy)
+{
+    CaseInsensitiveHashMap<std::string, std::string> m;
 
-  m["a"] = "1";
-  m["b"] = "10";
-  m["C"] = "-5";
-  m["c"] = "3"; // Overwrites "C"
+    m["a"] = "1";
+    m["b"] = "10";
+    m["C"] = "-5";
+    m["c"] = "3";// Overwrites "C"
 
-  ASSERT_EQ("1", m["a"]);
-  ASSERT_EQ("1", m["A"]);
-  ASSERT_EQ("3", m["C"]);
-  ASSERT_FALSE(m.count("d"));
-  ASSERT_EQ(3, m.size());
+    ASSERT_EQ("1", m["a"]);
+    ASSERT_EQ("1", m["A"]);
+    ASSERT_EQ("3", m["C"]);
+    ASSERT_FALSE(m.count("d"));
+    ASSERT_EQ(3, m.size());
 }
 
-} // namespace internal
-} // namespace tile
+}// namespace internal
+}// namespace tile
diff --git a/tile/base/internal/curl.cc b/tile/base/internal/curl.cc
index 502c7b0..c120137 100644
--- a/tile/base/internal/curl.cc
+++ b/tile/base/internal/curl.cc
@@ -22,132 +22,126 @@ HttpPostMockHandler s_http_post_mock_handler;
 
 HttpGetMockHandler s_http_get_mock_handler;
 
-size_t HttpWriteCallback(char *ptr, size_t size, size_t nmemb, void *pstr) {
-  auto bytes = size * nmemb;
-  // What ?
-  static_cast<std::string *>(pstr)->append(ptr, bytes);
-  return bytes;
+size_t
+HttpWriteCallback(char *ptr, size_t size, size_t nmemb, void *pstr)
+{
+    auto bytes = size * nmemb;
+    // What ?
+    static_cast<std::string *>(pstr)->append(ptr, bytes);
+    return bytes;
 }
 
-#define CURL_SHARE_SETOPT(handle, opt, val)                                    \
-  TILE_CHECK_EQ(CURLSHE_OK, curl_share_setopt(handle, opt, val))
+#define CURL_SHARE_SETOPT(handle, opt, val) TILE_CHECK_EQ(CURLSHE_OK, curl_share_setopt(handle, opt, val))
 
-static NeverDestroyed<std::array<Mutex, CURL_LOCK_DATA_LAST>>
-    share_handle_mutex;
+static NeverDestroyed<std::array<Mutex, CURL_LOCK_DATA_LAST>> share_handle_mutex;
 
-void AcquireLockOfShareHandle(CURL *handle, curl_lock_data data,
-                              curl_lock_access access, void *userptr) {
-  (*share_handle_mutex)[data].Lock();
-}
-void ReleaseLockOfShareHandle(CURL *handle, curl_lock_data data,
-                              void *userptr) {
-  (*share_handle_mutex)[data].Unlock();
+void
+AcquireLockOfShareHandle(CURL *handle, curl_lock_data data, curl_lock_access access, void *userptr)
+{
+    (*share_handle_mutex)[data].Lock();
 }
 
-CURLSH *GetCurlShareHandle() {
-  using Handle = std::unique_ptr<CURLSH, decltype(&curl_share_cleanup)>;
-  static NeverDestroyed<Handle> share([] {
-    Handle share{curl_share_init(), &curl_share_cleanup};
-    CURL_SHARE_SETOPT(share.get(), CURLSHOPT_SHARE, CURL_LOCK_DATA_DNS);
-    CURL_SHARE_SETOPT(share.get(), CURLSHOPT_SHARE, CURL_LOCK_DATA_SSL_SESSION);
-
-    CURL_SHARE_SETOPT(share.get(), CURLSHOPT_LOCKFUNC,
-                      AcquireLockOfShareHandle);
-    CURL_SHARE_SETOPT(share.get(), CURLSHOPT_UNLOCKFUNC,
-                      ReleaseLockOfShareHandle);
-
-    return share;
-  }());
-
-  return share->get();
+void
+ReleaseLockOfShareHandle(CURL *handle, curl_lock_data data, void *userptr)
+{
+    (*share_handle_mutex)[data].Unlock();
 }
 
-#define CURL_SETOPT(handle, opt, val)                                          \
-  TILE_CHECK_EQ(CURLE_OK, curl_easy_setopt(handle, opt, val))
+CURLSH *
+GetCurlShareHandle()
+{
+    using Handle = std::unique_ptr<CURLSH, decltype(&curl_share_cleanup)>;
+    static NeverDestroyed<Handle> share([] {
+        Handle share{curl_share_init(), &curl_share_cleanup};
+        CURL_SHARE_SETOPT(share.get(), CURLSHOPT_SHARE, CURL_LOCK_DATA_DNS);
+        CURL_SHARE_SETOPT(share.get(), CURLSHOPT_SHARE, CURL_LOCK_DATA_SSL_SESSION);
+
+        CURL_SHARE_SETOPT(share.get(), CURLSHOPT_LOCKFUNC, AcquireLockOfShareHandle);
+        CURL_SHARE_SETOPT(share.get(), CURLSHOPT_UNLOCKFUNC, ReleaseLockOfShareHandle);
+
+        return share;
+    }());
+
+    return share->get();
+}
+
+#define CURL_SETOPT(handle, opt, val) TILE_CHECK_EQ(CURLE_OK, curl_easy_setopt(handle, opt, val))
+
+}// namespace
 
-} // namespace
 std::expected<std::string, int>
-HttpPost(const std::string &uri, const std::vector<std::string> &headers,
-         const std::string &body, std::chrono::nanoseconds timeout) {
-  if (s_http_post_mock_handler) {
-    return s_http_post_mock_handler(uri, headers, body, timeout);
-  }
+HttpPost(const std::string &uri,
+         const std::vector<std::string> &headers,
+         const std::string &body,
+         std::chrono::nanoseconds timeout)
+{
+    if (s_http_post_mock_handler) { return s_http_post_mock_handler(uri, headers, body, timeout); }
 
-  std::string result;
-  curl_slist *hdrs = curl_slist_append(nullptr, "Expect:");
-  ScopedDeferred _{[&] { curl_slist_free_all(hdrs); }};
-  for (const auto &header : headers) {
-    hdrs = curl_slist_append(hdrs, header.c_str());
-  }
+    std::string result;
+    curl_slist *hdrs = curl_slist_append(nullptr, "Expect:");
+    ScopedDeferred _{[&] { curl_slist_free_all(hdrs); }};
+    for (const auto &header : headers) { hdrs = curl_slist_append(hdrs, header.c_str()); }
 
-  std::unique_ptr<CURL, decltype(&curl_easy_cleanup)> curl{curl_easy_init(),
-                                                           &curl_easy_cleanup};
+    std::unique_ptr<CURL, decltype(&curl_easy_cleanup)> curl{curl_easy_init(), &curl_easy_cleanup};
 
-  CURL_SETOPT(curl.get(), CURLOPT_URL, uri.c_str());
-  CURL_SETOPT(curl.get(), CURLOPT_POSTFIELDS, body.c_str());
-  CURL_SETOPT(curl.get(), CURLOPT_POSTFIELDSIZE_LARGE, body.size());
-  CURL_SETOPT(curl.get(), CURLOPT_HTTPHEADER, hdrs);
-  CURL_SETOPT(curl.get(), CURLOPT_WRITEFUNCTION, HttpWriteCallback);
-  CURL_SETOPT(curl.get(), CURLOPT_WRITEDATA, &result);
-  CURL_SETOPT(curl.get(), CURLOPT_NOSIGNAL, 1L);
-  CURL_SETOPT(curl.get(), CURLOPT_TIMEOUT_MS,
-              timeout / std::chrono::milliseconds(1));
-  CURL_SETOPT(curl.get(), CURLOPT_SHARE, GetCurlShareHandle());
-  // 10 min
-  CURL_SETOPT(curl.get(), CURLOPT_DNS_CACHE_TIMEOUT,
-              std::chrono::minutes(10) / std::chrono::seconds(1));
+    CURL_SETOPT(curl.get(), CURLOPT_URL, uri.c_str());
+    CURL_SETOPT(curl.get(), CURLOPT_POSTFIELDS, body.c_str());
+    CURL_SETOPT(curl.get(), CURLOPT_POSTFIELDSIZE_LARGE, body.size());
+    CURL_SETOPT(curl.get(), CURLOPT_HTTPHEADER, hdrs);
+    CURL_SETOPT(curl.get(), CURLOPT_WRITEFUNCTION, HttpWriteCallback);
+    CURL_SETOPT(curl.get(), CURLOPT_WRITEDATA, &result);
+    CURL_SETOPT(curl.get(), CURLOPT_NOSIGNAL, 1L);
+    CURL_SETOPT(curl.get(), CURLOPT_TIMEOUT_MS, timeout / std::chrono::milliseconds(1));
+    CURL_SETOPT(curl.get(), CURLOPT_SHARE, GetCurlShareHandle());
+    // 10 min
+    CURL_SETOPT(curl.get(), CURLOPT_DNS_CACHE_TIMEOUT, std::chrono::minutes(10) / std::chrono::seconds(1));
 
-  auto rc = curl_easy_perform(curl.get());
-  if (rc != CURLE_OK) {
-    TILE_LOG_WARNING_EVERY_SECOND("Failed to call [{}]: [#{}] {}", uri, (int)rc,
-                                  curl_easy_strerror(rc));
-    return std::make_unexpected(-rc);
-  }
+    auto rc = curl_easy_perform(curl.get());
+    if (rc != CURLE_OK) {
+        TILE_LOG_WARNING_EVERY_SECOND("Failed to call [{}]: [#{}] {}", uri, (int) rc, curl_easy_strerror(rc));
+        return std::make_unexpected(-rc);
+    }
 
-  long resp_code;
-  curl_easy_getinfo(curl.get(), CURLINFO_RESPONSE_CODE, &resp_code);
-  if (resp_code != 200) {
-    return std::make_unexpected(resp_code);
-  }
-  return result;
+    long resp_code;
+    curl_easy_getinfo(curl.get(), CURLINFO_RESPONSE_CODE, &resp_code);
+    if (resp_code != 200) { return std::make_unexpected(resp_code); }
+    return result;
 }
 
-std::expected<std::string, int> HttpGet(const std::string &uri,
-                                        std::chrono::nanoseconds timeout) {
-  if (s_http_get_mock_handler) {
-    return s_http_get_mock_handler(uri, timeout);
-  }
+std::expected<std::string, int>
+HttpGet(const std::string &uri, std::chrono::nanoseconds timeout)
+{
+    if (s_http_get_mock_handler) { return s_http_get_mock_handler(uri, timeout); }
 
-  std::string result;
-  std::unique_ptr<CURL, decltype(&curl_easy_cleanup)> curl{curl_easy_init(),
-                                                           &curl_easy_cleanup};
-  CURL_SETOPT(curl.get(), CURLOPT_URL, uri.c_str());
-  CURL_SETOPT(curl.get(), CURLOPT_WRITEFUNCTION, HttpWriteCallback);
-  CURL_SETOPT(curl.get(), CURLOPT_WRITEDATA, &result);
-  CURL_SETOPT(curl.get(), CURLOPT_NOSIGNAL, 1);
-  CURL_SETOPT(curl.get(), CURLOPT_TIMEOUT_MS,
-              timeout / std::chrono::milliseconds(1));
-  auto rc = curl_easy_perform(curl.get());
-  if (rc != CURLE_OK) {
-    TILE_LOG_WARNING_EVERY_SECOND("Failed to call [{}]: [#{}] {}", uri, (int)rc,
-                                  curl_easy_strerror(rc));
-    return std::make_unexpected(-rc);
-  }
-  long resp_code; // NOLINT: `CURLINFO_RESPONSE_CODE` needs a `long`..
-  curl_easy_getinfo(curl.get(), CURLINFO_RESPONSE_CODE, &resp_code);
-  if (resp_code != 200) {
-    return std::make_unexpected(resp_code);
-  }
-  return result;
+    std::string result;
+    std::unique_ptr<CURL, decltype(&curl_easy_cleanup)> curl{curl_easy_init(), &curl_easy_cleanup};
+    CURL_SETOPT(curl.get(), CURLOPT_URL, uri.c_str());
+    CURL_SETOPT(curl.get(), CURLOPT_WRITEFUNCTION, HttpWriteCallback);
+    CURL_SETOPT(curl.get(), CURLOPT_WRITEDATA, &result);
+    CURL_SETOPT(curl.get(), CURLOPT_NOSIGNAL, 1);
+    CURL_SETOPT(curl.get(), CURLOPT_TIMEOUT_MS, timeout / std::chrono::milliseconds(1));
+    auto rc = curl_easy_perform(curl.get());
+    if (rc != CURLE_OK) {
+        TILE_LOG_WARNING_EVERY_SECOND("Failed to call [{}]: [#{}] {}", uri, (int) rc, curl_easy_strerror(rc));
+        return std::make_unexpected(-rc);
+    }
+    long resp_code;// NOLINT: `CURLINFO_RESPONSE_CODE` needs a `long`..
+    curl_easy_getinfo(curl.get(), CURLINFO_RESPONSE_CODE, &resp_code);
+    if (resp_code != 200) { return std::make_unexpected(resp_code); }
+    return result;
 }
 
-void SetHttpPostMockHandler(HttpPostMockHandler &&http_post_mock_handler) {
-  s_http_post_mock_handler = std::move(http_post_mock_handler);
+void
+SetHttpPostMockHandler(HttpPostMockHandler &&http_post_mock_handler)
+{
+    s_http_post_mock_handler = std::move(http_post_mock_handler);
 }
 
-void SetHttpGetMockHandler(HttpGetMockHandler &&http_get_mock_handler) {
-  s_http_get_mock_handler = std::move(http_get_mock_handler);
+void
+SetHttpGetMockHandler(HttpGetMockHandler &&http_get_mock_handler)
+{
+    s_http_get_mock_handler = std::move(http_get_mock_handler);
 }
 
-} // namespace internal
-} // namespace tile
+}// namespace internal
+}// namespace tile
diff --git a/tile/base/internal/curl.h b/tile/base/internal/curl.h
index 68ca06a..490ceb9 100644
--- a/tile/base/internal/curl.h
+++ b/tile/base/internal/curl.h
@@ -12,23 +12,26 @@
 namespace tile {
 
 namespace internal {
-using HttpPostMockHandler = std::function<std::expected<std::string, int>(
-    const std::string &, const std::vector<std::string> &, const std::string &,
-    std::chrono::nanoseconds)>;
+using HttpPostMockHandler =
+    std::function<std::expected<std::string, int>(const std::string &,
+                                                  const std::vector<std::string> &,
+                                                  const std::string &,
+                                                  std::chrono::nanoseconds)>;
 
-using HttpGetMockHandler = std::function<std::expected<std::string, int>(
-    const std::string &, std::chrono::nanoseconds)>;
+using HttpGetMockHandler =
+    std::function<std::expected<std::string, int>(const std::string &, std::chrono::nanoseconds)>;
 
 std::expected<std::string, int>
-HttpPost(const std::string &uri, const std::vector<std::string> &headers,
-         const std::string &body, std::chrono::nanoseconds timeout);
-std::expected<std::string, int> HttpGet(const std::string &uri,
-                                        std::chrono::nanoseconds timeout);
+HttpPost(const std::string &uri,
+         const std::vector<std::string> &headers,
+         const std::string &body,
+         std::chrono::nanoseconds timeout);
+std::expected<std::string, int> HttpGet(const std::string &uri, std::chrono::nanoseconds timeout);
 
 void SetHttpPostMockHandler(HttpPostMockHandler &&handler);
 void SetHttpGetMockHandler(HttpGetMockHandler &&handler);
 
-} // namespace internal
+}// namespace internal
 
-} // namespace tile
-#endif // TILE_BASE_INTERNAL_CURL_H
+}// namespace tile
+#endif// TILE_BASE_INTERNAL_CURL_H
diff --git a/tile/base/internal/curl_test.cc b/tile/base/internal/curl_test.cc
index cdb2a28..07128b6 100644
--- a/tile/base/internal/curl_test.cc
+++ b/tile/base/internal/curl_test.cc
@@ -10,99 +10,101 @@ namespace tile {
 namespace internal {
 
 namespace {
-std::string HttpGetTestURI(int code) {
-  static const std::string kHttpCodeTestURI = "http://httpstat.us/";
-  return kHttpCodeTestURI + std::to_string(code);
+std::string
+HttpGetTestURI(int code)
+{
+    static const std::string kHttpCodeTestURI = "http://httpstat.us/";
+    return kHttpCodeTestURI + std::to_string(code);
 }
-constexpr auto kTimeout = std::chrono::seconds(5);
-} // namespace
 
-#define TEST_HTTP_GET_URI(uri, code)                                           \
-  do {                                                                         \
-    auto test_anonymous_http_res = HttpGet(uri, kTimeout);                     \
-    EXPECT_TRUE(code == 200 || !test_anonymous_http_res);                      \
-    if (!test_anonymous_http_res) {                                            \
-      EXPECT_EQ(test_anonymous_http_res.error(), code);                        \
-    }                                                                          \
-  } while (0);
+constexpr auto kTimeout = std::chrono::seconds(5);
+}// namespace
+
+#define TEST_HTTP_GET_URI(uri, code)                                                                                   \
+    do {                                                                                                               \
+        auto test_anonymous_http_res = HttpGet(uri, kTimeout);                                                         \
+        EXPECT_TRUE(code == 200 || !test_anonymous_http_res);                                                          \
+        if (!test_anonymous_http_res) { EXPECT_EQ(test_anonymous_http_res.error(), code); }                            \
+    } while (0);
 
 #define TEST_HTTP_GET(code) TEST_HTTP_GET_URI(HttpGetTestURI(code), code)
 
-TEST(CURL, Get) {
-  // TEST_HTTP_GET_URI("http://baidu.com/", 200);
-  // 1xx
-  TEST_HTTP_GET(100); // Continue
-  TEST_HTTP_GET(101); // Switching Protocols
-  TEST_HTTP_GET(102); // Processing
-  TEST_HTTP_GET(103); // Early Hints
+TEST(CURL, Get)
+{
+    // TEST_HTTP_GET_URI("http://baidu.com/", 200);
+    // 1xx
+    TEST_HTTP_GET(100);// Continue
+    TEST_HTTP_GET(101);// Switching Protocols
+    TEST_HTTP_GET(102);// Processing
+    TEST_HTTP_GET(103);// Early Hints
 
-  // 2xx
-  TEST_HTTP_GET(200); // OK
-  TEST_HTTP_GET(201); // Created
-  TEST_HTTP_GET(202); // Accepted
-  TEST_HTTP_GET(203); // Non-Authoritative Information
-  TEST_HTTP_GET(204); // No Content
-  TEST_HTTP_GET(205); // Reset Content
-  TEST_HTTP_GET(206); // Partial Content
-  TEST_HTTP_GET(207); // Multi-Status
-  TEST_HTTP_GET(208); // Already Reported
-  TEST_HTTP_GET(226); // IM Used
+    // 2xx
+    TEST_HTTP_GET(200);// OK
+    TEST_HTTP_GET(201);// Created
+    TEST_HTTP_GET(202);// Accepted
+    TEST_HTTP_GET(203);// Non-Authoritative Information
+    TEST_HTTP_GET(204);// No Content
+    TEST_HTTP_GET(205);// Reset Content
+    TEST_HTTP_GET(206);// Partial Content
+    TEST_HTTP_GET(207);// Multi-Status
+    TEST_HTTP_GET(208);// Already Reported
+    TEST_HTTP_GET(226);// IM Used
 
-  // 3xx
-  TEST_HTTP_GET(300); // Multiple Choices
-  TEST_HTTP_GET(301); // Moved Permanently
-  TEST_HTTP_GET(302); // Found
-  TEST_HTTP_GET(303); // See Other
-  TEST_HTTP_GET(304); // Not Modified
-  TEST_HTTP_GET(305); // Use Proxy
-  TEST_HTTP_GET(306); // Switch Proxy
-  TEST_HTTP_GET(307); // Temporary Redirect
-  TEST_HTTP_GET(308); // Permanent Redirect
+    // 3xx
+    TEST_HTTP_GET(300);// Multiple Choices
+    TEST_HTTP_GET(301);// Moved Permanently
+    TEST_HTTP_GET(302);// Found
+    TEST_HTTP_GET(303);// See Other
+    TEST_HTTP_GET(304);// Not Modified
+    TEST_HTTP_GET(305);// Use Proxy
+    TEST_HTTP_GET(306);// Switch Proxy
+    TEST_HTTP_GET(307);// Temporary Redirect
+    TEST_HTTP_GET(308);// Permanent Redirect
 
-  // 4xx
-  TEST_HTTP_GET(400); // Bad Request
-  TEST_HTTP_GET(401); // Unauthorized
-  TEST_HTTP_GET(402); // Payment Required
-  TEST_HTTP_GET(403); // Forbidden
-  TEST_HTTP_GET(404); // Not Found
-  TEST_HTTP_GET(405); // Method Not Allowed
-  TEST_HTTP_GET(406); // Not Acceptable
-  TEST_HTTP_GET(407); // Proxy Authentication Required
-  TEST_HTTP_GET(408); // Request Timeout
-  TEST_HTTP_GET(409); // Conflict
-  TEST_HTTP_GET(410); // Gone
-  TEST_HTTP_GET(411); // Length Required
-  TEST_HTTP_GET(412); // Precondition Failed
-  TEST_HTTP_GET(413); // Payload Too Large
-  TEST_HTTP_GET(414); // URI Too Long
-  TEST_HTTP_GET(415); // Unsupported Media Type
-  TEST_HTTP_GET(416); // Range Not Satisfiable
-  TEST_HTTP_GET(417); // Expectation Failed
-  TEST_HTTP_GET(418); // I'm a teapot
-  TEST_HTTP_GET(421); // Misdirected Request
-  TEST_HTTP_GET(422); // Unprocessable Entity
-  TEST_HTTP_GET(423); // Locked
-  TEST_HTTP_GET(424); // Failed Dependency
-  TEST_HTTP_GET(425); // Too Early
-  TEST_HTTP_GET(426); // Upgrade Required
-  TEST_HTTP_GET(428); // Precondition Required
-  TEST_HTTP_GET(429); // Too Many Requests
-  TEST_HTTP_GET(431); // Request Header Fields Too Large
-  TEST_HTTP_GET(451); // Unavailable For Legal Reasons
+    // 4xx
+    TEST_HTTP_GET(400);// Bad Request
+    TEST_HTTP_GET(401);// Unauthorized
+    TEST_HTTP_GET(402);// Payment Required
+    TEST_HTTP_GET(403);// Forbidden
+    TEST_HTTP_GET(404);// Not Found
+    TEST_HTTP_GET(405);// Method Not Allowed
+    TEST_HTTP_GET(406);// Not Acceptable
+    TEST_HTTP_GET(407);// Proxy Authentication Required
+    TEST_HTTP_GET(408);// Request Timeout
+    TEST_HTTP_GET(409);// Conflict
+    TEST_HTTP_GET(410);// Gone
+    TEST_HTTP_GET(411);// Length Required
+    TEST_HTTP_GET(412);// Precondition Failed
+    TEST_HTTP_GET(413);// Payload Too Large
+    TEST_HTTP_GET(414);// URI Too Long
+    TEST_HTTP_GET(415);// Unsupported Media Type
+    TEST_HTTP_GET(416);// Range Not Satisfiable
+    TEST_HTTP_GET(417);// Expectation Failed
+    TEST_HTTP_GET(418);// I'm a teapot
+    TEST_HTTP_GET(421);// Misdirected Request
+    TEST_HTTP_GET(422);// Unprocessable Entity
+    TEST_HTTP_GET(423);// Locked
+    TEST_HTTP_GET(424);// Failed Dependency
+    TEST_HTTP_GET(425);// Too Early
+    TEST_HTTP_GET(426);// Upgrade Required
+    TEST_HTTP_GET(428);// Precondition Required
+    TEST_HTTP_GET(429);// Too Many Requests
+    TEST_HTTP_GET(431);// Request Header Fields Too Large
+    TEST_HTTP_GET(451);// Unavailable For Legal Reasons
 
-  // txx
-  TEST_HTTP_GET(500); // Internal Server error
-  TEST_HTTP_GET(501); // Not Implemented
-  TEST_HTTP_GET(502); // Bad Gateway
-  TEST_HTTP_GET(503); // Service Unavailable
-  TEST_HTTP_GET(504); // Gateway Timeout
-  TEST_HTTP_GET(505); // HTTP Version Not Supported
-  TEST_HTTP_GET(506); // Variant Also Negotiates
-  TEST_HTTP_GET(507); // Insufficient Storage
-  TEST_HTTP_GET(508); // Loop Detected
-  TEST_HTTP_GET(510); // Not Extended
-  TEST_HTTP_GET(511); // Network Authentication Required
+    // txx
+    TEST_HTTP_GET(500);// Internal Server error
+    TEST_HTTP_GET(501);// Not Implemented
+    TEST_HTTP_GET(502);// Bad Gateway
+    TEST_HTTP_GET(503);// Service Unavailable
+    TEST_HTTP_GET(504);// Gateway Timeout
+    TEST_HTTP_GET(505);// HTTP Version Not Supported
+    TEST_HTTP_GET(506);// Variant Also Negotiates
+    TEST_HTTP_GET(507);// Insufficient Storage
+    TEST_HTTP_GET(508);// Loop Detected
+    TEST_HTTP_GET(510);// Not Extended
+    TEST_HTTP_GET(511);// Network Authentication Required
 }
 
-} // namespace internal
-} // namespace tile
+}// namespace internal
+}// namespace tile
diff --git a/tile/base/internal/early_init.h b/tile/base/internal/early_init.h
index 6b54194..0063a22 100644
--- a/tile/base/internal/early_init.h
+++ b/tile/base/internal/early_init.h
@@ -7,20 +7,24 @@
 namespace tile {
 namespace internal {
 namespace detail {
-template <typename T, typename Tag = void> struct EarlyInitInstance {
-  static NeverDestroyed<T> object;
+template<typename T, typename Tag = void>
+struct EarlyInitInstance {
+    static NeverDestroyed<T> object;
 };
 
-template <typename T, typename Tag>
+template<typename T, typename Tag>
 NeverDestroyed<T> EarlyInitInstance<T, Tag>::object;
 
-} // namespace detail
+}// namespace detail
 
-template <typename T, typename Tag = void> const T &EarlyInitConstant() {
-  return *detail::EarlyInitInstance<T, Tag>::object.Get();
+template<typename T, typename Tag = void>
+const T &
+EarlyInitConstant()
+{
+    return *detail::EarlyInitInstance<T, Tag>::object.Get();
 }
 
-} // namespace internal
-} // namespace tile
+}// namespace internal
+}// namespace tile
 
-#endif // _TILE_BASE_INTERNAL_EARLY_INIT_H
+#endif// _TILE_BASE_INTERNAL_EARLY_INIT_H
diff --git a/tile/base/internal/format.h b/tile/base/internal/format.h
index 877dc3a..bd89cd4 100644
--- a/tile/base/internal/format.h
+++ b/tile/base/internal/format.h
@@ -10,82 +10,86 @@
 
 namespace tile {
 namespace detail {
-template <typename S, typename T> struct is_streamable {
-  template <typename SS, typename TT>
-  static auto Test(int) -> decltype(std::declval<SS &>() << std::declval<TT>(),
-                                    std::true_type());
-  template <typename...> static auto Test(...) -> std::false_type;
-  static constexpr bool value = decltype(Test<S, T>(0))::value;
+template<typename S, typename T>
+struct is_streamable {
+    template<typename SS, typename TT>
+    static auto Test(int) -> decltype(std::declval<SS &>() << std::declval<TT>(), std::true_type());
+    template<typename...>
+    static auto Test(...) -> std::false_type;
+    static constexpr bool value = decltype(Test<S, T>(0))::value;
 };
 
-template <typename T> struct has_to_string {
-  template <typename U>
-  static auto Test(int) -> decltype(std::declval<U>().ToString(),
-                                    std::true_type());
-  template <typename...> static auto Test(...) -> std::false_type;
-  static constexpr bool value = decltype(Test<T>(0))::value;
+template<typename T>
+struct has_to_string {
+    template<typename U>
+    static auto Test(int) -> decltype(std::declval<U>().ToString(), std::true_type());
+    template<typename...>
+    static auto Test(...) -> std::false_type;
+    static constexpr bool value = decltype(Test<T>(0))::value;
 };
 
-template <typename T> struct can_to_string {
-  template <typename U>
-  static auto Test(int) -> decltype(ToString(std::declval<U>()),
-                                    std::true_type());
-  template <typename...> static auto Test(...) -> std::false_type;
-  static constexpr bool value = decltype(Test<T>(0))::value;
+template<typename T>
+struct can_to_string {
+    template<typename U>
+    static auto Test(int) -> decltype(ToString(std::declval<U>()), std::true_type());
+    template<typename...>
+    static auto Test(...) -> std::false_type;
+    static constexpr bool value = decltype(Test<T>(0))::value;
 };
 
-template <typename Rep, typename Period>
-std::string format_as_impl(const std::chrono::duration<Rep, Period> &val,
-                           const char *suffix) {
-  std::stringstream ss;
-  ss << val.count() << suffix;
-  return ss.str();
+template<typename Rep, typename Period>
+std::string
+format_as_impl(const std::chrono::duration<Rep, Period> &val, const char *suffix)
+{
+    std::stringstream ss;
+    ss << val.count() << suffix;
+    return ss.str();
 }
 
-} // namespace detail
-} // namespace tile
+}// namespace detail
+}// namespace tile
 
-template <typename T>
-auto format_as(const T &val)
-    -> tile::enable_if_t<
-        tile::detail::is_streamable<std::ostream, T>::value &&
-            !std::is_same<std::string,
-                          tile::internal::remove_cvref_t<T>>::value,
-        std::string> {
-  std::stringstream ss;
-  ss << val;
-  return ss.str();
+template<typename T>
+auto
+format_as(const T &val)
+    -> tile::enable_if_t<tile::detail::is_streamable<std::ostream, T>::value
+                             && !std::is_same<std::string, tile::internal::remove_cvref_t<T>>::value,
+                         std::string>
+{
+    std::stringstream ss;
+    ss << val;
+    return ss.str();
 }
 
-template <typename T>
-auto format_as(const T &val)
-    -> tile::enable_if_t<!tile::detail::is_streamable<std::ostream, T>::value &&
-                             tile::detail::has_to_string<T>::value &&
-                             !tile::detail::can_to_string<T>::value,
-                         std::string> {
-  return val.ToString();
+template<typename T>
+auto
+format_as(const T &val)
+    -> tile::enable_if_t<!tile::detail::is_streamable<std::ostream, T>::value && tile::detail::has_to_string<T>::value
+                             && !tile::detail::can_to_string<T>::value,
+                         std::string>
+{
+    return val.ToString();
 }
 
-template <typename T>
-auto format_as(const T &val)
-    -> tile::enable_if_t<!tile::detail::is_streamable<std::ostream, T>::value &&
-                             !tile::detail::has_to_string<T>::value &&
-                             tile::detail::can_to_string<T>::value,
-                         std::string> {
-  return ToString(val);
+template<typename T>
+auto
+format_as(const T &val)
+    -> tile::enable_if_t<!tile::detail::is_streamable<std::ostream, T>::value && !tile::detail::has_to_string<T>::value
+                             && tile::detail::can_to_string<T>::value,
+                         std::string>
+{
+    return ToString(val);
 }
 
-template <typename T>
-auto format_as(T *ptr)
-    -> tile::enable_if_t<!std::is_void<tile::remove_cvref_t<T>>::value,
-                         void *> {
-  return reinterpret_cast<void *>(ptr);
+template<typename T>
+auto
+format_as(T *ptr) -> tile::enable_if_t<!std::is_void<tile::remove_cvref_t<T>>::value, void *>
+{
+    return reinterpret_cast<void *>(ptr);
 }
 
-#define TILE_INSTANCE_CHRONO_FORMAT_AS(type, suffix)                           \
-  inline std::string format_as(const type &val) {                              \
-    return tile::detail::format_as_impl(val, suffix);                          \
-  }
+#define TILE_INSTANCE_CHRONO_FORMAT_AS(type, suffix)                                                                   \
+    inline std::string format_as(const type &val) { return tile::detail::format_as_impl(val, suffix); }
 
 TILE_INSTANCE_CHRONO_FORMAT_AS(std::chrono::nanoseconds, "ns")
 TILE_INSTANCE_CHRONO_FORMAT_AS(std::chrono::microseconds, "us")
@@ -118,4 +122,4 @@ TILE_INSTANCE_CHRONO_FORMAT_AS(std::chrono::years, "y")
 //   return os << fmt::format("{}", fmt::ptr(ptr));
 // }
 
-#endif // TILE_BASE_INTERNAL_FORMAT_H
+#endif// TILE_BASE_INTERNAL_FORMAT_H
diff --git a/tile/base/internal/format_test.cc b/tile/base/internal/format_test.cc
index edfe03d..757cd31 100644
--- a/tile/base/internal/format_test.cc
+++ b/tile/base/internal/format_test.cc
@@ -6,38 +6,42 @@
 
 #include <chrono>
 
-template <typename T> static std::string ChronoFormat(const T &val) {
-  return fmt::format("{}", val);
+template<typename T>
+static std::string
+ChronoFormat(const T &val)
+{
+    return fmt::format("{}", val);
 }
 
-TEST(Format, Chrono) {
-  EXPECT_EQ(ChronoFormat(std::chrono::nanoseconds(1)), "1ns");
-  EXPECT_EQ(ChronoFormat(std::chrono::microseconds(1)), "1us");
-  EXPECT_EQ(ChronoFormat(std::chrono::milliseconds(1)), "1ms");
-  EXPECT_EQ(ChronoFormat(std::chrono::seconds(1)), "1s");
-  EXPECT_EQ(ChronoFormat(std::chrono::minutes(1)), "1m");
-  EXPECT_EQ(ChronoFormat(std::chrono::hours(1)), "1h");
+TEST(Format, Chrono)
+{
+    EXPECT_EQ(ChronoFormat(std::chrono::nanoseconds(1)), "1ns");
+    EXPECT_EQ(ChronoFormat(std::chrono::microseconds(1)), "1us");
+    EXPECT_EQ(ChronoFormat(std::chrono::milliseconds(1)), "1ms");
+    EXPECT_EQ(ChronoFormat(std::chrono::seconds(1)), "1s");
+    EXPECT_EQ(ChronoFormat(std::chrono::minutes(1)), "1m");
+    EXPECT_EQ(ChronoFormat(std::chrono::hours(1)), "1h");
 }
 
-TEST(Format, ChronoRandom) {
-  for (int i = 0; i < 1000; ++i) {
-    int n = tile::Random(0, 1000000);
+TEST(Format, ChronoRandom)
+{
+    for (int i = 0; i < 1000; ++i) {
+        int n = tile::Random(0, 1000000);
 
-    EXPECT_EQ(ChronoFormat(std::chrono::nanoseconds(n)),
-              fmt::format("{}ns", n));
-    EXPECT_EQ(ChronoFormat(std::chrono::microseconds(n)),
-              fmt::format("{}us", n));
-    EXPECT_EQ(ChronoFormat(std::chrono::milliseconds(n)),
-              fmt::format("{}ms", n));
-    EXPECT_EQ(ChronoFormat(std::chrono::seconds(n)), fmt::format("{}s", n));
-    EXPECT_EQ(ChronoFormat(std::chrono::minutes(n)), fmt::format("{}m", n));
-    EXPECT_EQ(ChronoFormat(std::chrono::hours(n)), fmt::format("{}h", n));
-  }
+        EXPECT_EQ(ChronoFormat(std::chrono::nanoseconds(n)), fmt::format("{}ns", n));
+        EXPECT_EQ(ChronoFormat(std::chrono::microseconds(n)), fmt::format("{}us", n));
+        EXPECT_EQ(ChronoFormat(std::chrono::milliseconds(n)), fmt::format("{}ms", n));
+        EXPECT_EQ(ChronoFormat(std::chrono::seconds(n)), fmt::format("{}s", n));
+        EXPECT_EQ(ChronoFormat(std::chrono::minutes(n)), fmt::format("{}m", n));
+        EXPECT_EQ(ChronoFormat(std::chrono::hours(n)), fmt::format("{}h", n));
+    }
 }
 
-TEST(Format, HasToString) {
-  struct Foo {
-    std::string ToString() const { return "Foo"; }
-  };
-  EXPECT_EQ(fmt::format("{}", Foo()), "Foo");
+TEST(Format, HasToString)
+{
+    struct Foo {
+        std::string ToString() const { return "Foo"; }
+    };
+
+    EXPECT_EQ(fmt::format("{}", Foo()), "Foo");
 }
diff --git a/tile/base/internal/index_alloc.cc b/tile/base/internal/index_alloc.cc
index dd1846b..b709b01 100644
--- a/tile/base/internal/index_alloc.cc
+++ b/tile/base/internal/index_alloc.cc
@@ -4,20 +4,24 @@
 
 namespace tile {
 namespace internal {
-std::size_t IndexAlloc::Next() {
-  ScopedLock _(lock_);
-  if (!recycled_.empty()) {
-    auto rc = recycled_.back();
-    recycled_.pop_back();
-    return rc;
-  }
-  return current_++;
+std::size_t
+IndexAlloc::Next()
+{
+    ScopedLock _(lock_);
+    if (!recycled_.empty()) {
+        auto rc = recycled_.back();
+        recycled_.pop_back();
+        return rc;
+    }
+    return current_++;
 }
 
-void IndexAlloc::Free(std::size_t index) {
-  ScopedLock _(lock_);
-  recycled_.push_back(index);
+void
+IndexAlloc::Free(std::size_t index)
+{
+    ScopedLock _(lock_);
+    recycled_.push_back(index);
 }
 
-} // namespace internal
-} // namespace tile
+}// namespace internal
+}// namespace tile
diff --git a/tile/base/internal/index_alloc.h b/tile/base/internal/index_alloc.h
index af16b74..5fb48fb 100644
--- a/tile/base/internal/index_alloc.h
+++ b/tile/base/internal/index_alloc.h
@@ -11,26 +11,28 @@ namespace internal {
 
 class IndexAlloc {
 public:
-  template <typename Tag> static IndexAlloc *For() {
-    static NeverDestroyedSingleton<IndexAlloc> ia;
-    return ia.Get();
-  }
+    template<typename Tag>
+    static IndexAlloc *For()
+    {
+        static NeverDestroyedSingleton<IndexAlloc> ia;
+        return ia.Get();
+    }
 
-  std::size_t Next();
-  void Free(std::size_t index);
+    std::size_t Next();
+    void Free(std::size_t index);
 
 private:
-  friend class NeverDestroyedSingleton<IndexAlloc>;
-  IndexAlloc() = default;
-  ~IndexAlloc() = default;
+    friend class NeverDestroyedSingleton<IndexAlloc>;
+    IndexAlloc()  = default;
+    ~IndexAlloc() = default;
 
 private:
-  Mutex lock_;
-  std::size_t current_{};
-  std::vector<std::size_t> recycled_;
+    Mutex lock_;
+    std::size_t current_{};
+    std::vector<std::size_t> recycled_;
 };
 
-} // namespace internal
-} // namespace tile
+}// namespace internal
+}// namespace tile
 
-#endif // TILE_BASE_INTERNAL_INDEX_ALLOC_H
+#endif// TILE_BASE_INTERNAL_INDEX_ALLOC_H
diff --git a/tile/base/internal/lazy_init.h b/tile/base/internal/lazy_init.h
index e7b9960..4681a77 100644
--- a/tile/base/internal/lazy_init.h
+++ b/tile/base/internal/lazy_init.h
@@ -6,17 +6,23 @@
 
 namespace tile {
 namespace internal {
-template <typename T, typename Tag = void> T *LazyInit() {
-  static NeverDestroyed<T> t;
-  return t.Get();
+template<typename T, typename Tag = void>
+T *
+LazyInit()
+{
+    static NeverDestroyed<T> t;
+    return t.Get();
 };
 
-template <typename T, typename Tag = void> const T &LazyInitConstant() {
-  static NeverDestroyed<T> t;
-  return *t;
+template<typename T, typename Tag = void>
+const T &
+LazyInitConstant()
+{
+    static NeverDestroyed<T> t;
+    return *t;
 }
 
-} // namespace internal
-} // namespace tile
+}// namespace internal
+}// namespace tile
 
-#endif // TILE_BASE_INTERNAL_LAZY_INIT_H
+#endif// TILE_BASE_INTERNAL_LAZY_INIT_H
diff --git a/tile/base/internal/logging.cc b/tile/base/internal/logging.cc
index 746bbf4..5e05c06 100644
--- a/tile/base/internal/logging.cc
+++ b/tile/base/internal/logging.cc
@@ -6,182 +6,244 @@
 #include <mutex>
 
 namespace tile {
-bool VLogIsOn(int n) { return true; }
+bool
+VLogIsOn(int n)
+{
+    return true;
+}
+
 class LogMessage::Impl {
 public:
-  Impl(const char *file, int line, int severity) : lm_(file, line, severity) {}
-  std::ostream &stream() { return lm_.stream(); }
+    Impl(const char *file, int line, int severity) : lm_(file, line, severity) {}
+
+    std::ostream &stream() { return lm_.stream(); }
 
 private:
-  google::LogMessage lm_;
+    google::LogMessage lm_;
 };
 
 class LogMessageFatal::Impl {
 public:
-  Impl(const char *file, int line) : lm_(file, line) {}
-  std::ostream &stream() { return lm_.stream(); }
+    Impl(const char *file, int line) : lm_(file, line) {}
+
+    std::ostream &stream() { return lm_.stream(); }
 
 private:
-  google::LogMessageFatal lm_;
+    google::LogMessageFatal lm_;
 };
 
-LogMessage::LogMessage(const char *file, int line, int severity)
-    : impl_(new Impl(file, line, severity)) {}
+LogMessage::LogMessage(const char *file, int line, int severity) : impl_(new Impl(file, line, severity)) {}
+
 LogMessage::~LogMessage() = default;
-std::ostream &LogMessage::stream() { return impl_->stream(); }
 
-LogMessageFatal::LogMessageFatal(const char *file, int line)
-    : impl_(new Impl(file, line)) {}
+std::ostream &
+LogMessage::stream()
+{
+    return impl_->stream();
+}
+
+LogMessageFatal::LogMessageFatal(const char *file, int line) : impl_(new Impl(file, line)) {}
+
 LogMessageFatal::~LogMessageFatal() = default;
-std::ostream &LogMessageFatal::stream() { return impl_->stream(); }
 
-} // namespace tile
+std::ostream &
+LogMessageFatal::stream()
+{
+    return impl_->stream();
+}
+
+}// namespace tile
 
 namespace tile {
 namespace internal {
 namespace logging {
 namespace {
-std::vector<PrefixAppender *> *GetProviers() {
-  static std::vector<PrefixAppender *> providers;
-  return &providers;
+std::vector<PrefixAppender *> *
+GetProviers()
+{
+    static std::vector<PrefixAppender *> providers;
+    return &providers;
 }
-} // namespace
+}// namespace
+
 namespace details {
-std::string DescribeFormatArguments(const std::vector<std::string> &args) {
-  return fmt::format("{}", fmt::join(args.begin(), args.end(), ", "));
+std::string
+DescribeFormatArguments(const std::vector<std::string> &args)
+{
+    return fmt::format("{}", fmt::join(args.begin(), args.end(), ", "));
 }
 
-} // namespace details
-void InstallPrefixProvider(PrefixAppender *writer) {
-  GetProviers()->push_back(writer);
+}// namespace details
+
+void
+InstallPrefixProvider(PrefixAppender *writer)
+{
+    GetProviers()->push_back(writer);
 }
-void WritePrefixTo(std::string *to) {
-  for (auto &&appender : *GetProviers()) {
-    auto was = to->size();
-    appender(to);
-    if (to->size() != was) {
-      to->push_back(' ');
+
+void
+WritePrefixTo(std::string *to)
+{
+    for (auto &&appender : *GetProviers()) {
+        auto was = to->size();
+        appender(to);
+        if (to->size() != was) { to->push_back(' '); }
     }
-  }
 }
-} // namespace logging
-} // namespace internal
-} // namespace tile
+}// namespace logging
+}// namespace internal
+}// namespace tile
+
 namespace tile {
 
-LogMessageTime::LogMessageTime()
-    : time_struct_(), timestamp_(0), usecs_(0), gmtoffset_(0) {}
+LogMessageTime::LogMessageTime() : time_struct_(), timestamp_(0), usecs_(0), gmtoffset_(0) {}
 
-LogMessageTime::LogMessageTime(std::tm t) {
-  std::time_t timestamp = std::mktime(&t);
-  init(t, timestamp, 0);
+LogMessageTime::LogMessageTime(std::tm t)
+{
+    std::time_t timestamp = std::mktime(&t);
+    init(t, timestamp, 0);
 }
 
-LogMessageTime::LogMessageTime(std::time_t timestamp, WallTime now) {
-  std::tm t;
-  if (FLAGS_log_utc_time)
-    gmtime_r(&timestamp, &t);
-  else
-    localtime_r(&timestamp, &t);
-  init(t, timestamp, now);
+LogMessageTime::LogMessageTime(std::time_t timestamp, WallTime now)
+{
+    std::tm t;
+    if (FLAGS_log_utc_time)
+        gmtime_r(&timestamp, &t);
+    else
+        localtime_r(&timestamp, &t);
+    init(t, timestamp, now);
 }
 
-void LogMessageTime::init(const std::tm &t, std::time_t timestamp,
-                          WallTime now) {
-  time_struct_ = t;
-  timestamp_ = timestamp;
-  usecs_ = static_cast<std::int32_t>((now - timestamp) * 1000000);
+void
+LogMessageTime::init(const std::tm &t, std::time_t timestamp, WallTime now)
+{
+    time_struct_ = t;
+    timestamp_   = timestamp;
+    usecs_       = static_cast<std::int32_t>((now - timestamp) * 1000000);
 
-  CalcGmtOffset();
+    CalcGmtOffset();
 }
 
-void LogMessageTime::CalcGmtOffset() {
-  std::tm gmt_struct;
-  int isDst = 0;
-  if (FLAGS_log_utc_time) {
-    localtime_r(&timestamp_, &gmt_struct);
-    isDst = gmt_struct.tm_isdst;
-    gmt_struct = time_struct_;
-  } else {
-    isDst = time_struct_.tm_isdst;
-    gmtime_r(&timestamp_, &gmt_struct);
-  }
+void
+LogMessageTime::CalcGmtOffset()
+{
+    std::tm gmt_struct;
+    int isDst = 0;
+    if (FLAGS_log_utc_time) {
+        localtime_r(&timestamp_, &gmt_struct);
+        isDst      = gmt_struct.tm_isdst;
+        gmt_struct = time_struct_;
+    } else {
+        isDst = time_struct_.tm_isdst;
+        gmtime_r(&timestamp_, &gmt_struct);
+    }
 
-  time_t gmt_sec = mktime(&gmt_struct);
-  const long hour_secs = 3600;
-  // If the Daylight Saving Time(isDst) is active subtract an hour from the
-  // current timestamp.
-  gmtoffset_ =
-      static_cast<long int>(timestamp_ - gmt_sec + (isDst ? hour_secs : 0));
+    time_t gmt_sec       = mktime(&gmt_struct);
+    const long hour_secs = 3600;
+    // If the Daylight Saving Time(isDst) is active subtract an hour from the
+    // current timestamp.
+    gmtoffset_ = static_cast<long int>(timestamp_ - gmt_sec + (isDst ? hour_secs : 0));
 }
 
 LogSink::~LogSink() {}
-void LogSink::send(LogSeverity severity, const char *full_filename,
-                   const char *base_filename, int line,
-                   const LogMessageTime &logmsgtime, const char *message,
-                   size_t message_len) {
 
-  // do nothing
+void
+LogSink::send(LogSeverity severity,
+              const char *full_filename,
+              const char *base_filename,
+              int line,
+              const LogMessageTime &logmsgtime,
+              const char *message,
+              size_t message_len)
+{
+
+    // do nothing
 }
-void LogSink::WaitTillSent() {}
-std::string LogSink::ToString(LogSeverity severity, const char *file, int line,
-                              const LogMessageTime &logmsgtime,
-                              const char *message, size_t message_len) {
-  return google::LogSink::ToString(severity, file, line, logmsgtime.tm(),
-                                   message, message_len);
+
+void
+LogSink::WaitTillSent()
+{}
+
+std::string
+LogSink::ToString(LogSeverity severity,
+                  const char *file,
+                  int line,
+                  const LogMessageTime &logmsgtime,
+                  const char *message,
+                  size_t message_len)
+{
+    return google::LogSink::ToString(severity, file, line, logmsgtime.tm(), message, message_len);
 }
 
 class LogSinkWrapper : public google::LogSink {
 public:
-  LogSinkWrapper(tile::LogSink *dest) : dest_(dest) {}
-  ~LogSinkWrapper() override {}
-  void send(LogSeverity severity, const char *full_filename,
-            const char *base_filename, int line,
-            const google::LogMessageTime &logmsgtime, const char *message,
-            size_t message_len) override {
-    dest_->send(severity, full_filename, base_filename, line, logmsgtime.tm(),
-                message, message_len);
-  }
+    LogSinkWrapper(tile::LogSink *dest) : dest_(dest) {}
 
-  void WaitTillSent() override { dest_->WaitTillSent(); }
+    ~LogSinkWrapper() override {}
+
+    void send(LogSeverity severity,
+              const char *full_filename,
+              const char *base_filename,
+              int line,
+              const google::LogMessageTime &logmsgtime,
+              const char *message,
+              size_t message_len) override
+    {
+        dest_->send(severity, full_filename, base_filename, line, logmsgtime.tm(), message, message_len);
+    }
+
+    void WaitTillSent() override { dest_->WaitTillSent(); }
 
 private:
-  tile::LogSink *dest_;
+    tile::LogSink *dest_;
 };
 
 struct LogSinkPair {
-  struct LogSinWrapper *wrapper;
-  LogSink *sink;
+    struct LogSinWrapper *wrapper;
+    LogSink *sink;
 };
 
 static std::map<LogSink *, LogSinkWrapper *> sink_registry;
 static std::mutex sink_registry_mutex;
 
-void AddLogSink(LogSink *dest) {
-  std::lock_guard<std::mutex> lock(sink_registry_mutex);
-  if (sink_registry.find(dest) != sink_registry.end()) {
-    return;
-  }
+void
+AddLogSink(LogSink *dest)
+{
+    std::lock_guard<std::mutex> lock(sink_registry_mutex);
+    if (sink_registry.find(dest) != sink_registry.end()) { return; }
 
-  auto wrapper = new LogSinkWrapper(dest);
-  sink_registry[dest] = wrapper;
-  google::AddLogSink(wrapper);
+    auto wrapper        = new LogSinkWrapper(dest);
+    sink_registry[dest] = wrapper;
+    google::AddLogSink(wrapper);
 }
 
-void RemoveLogSink(LogSink *dest) {
-  std::lock_guard<std::mutex> lock(sink_registry_mutex);
-  auto iter = sink_registry.find(dest);
-  if (iter != sink_registry.end()) {
-    google::RemoveLogSink(iter->second);
-    sink_registry.erase(iter);
-    delete iter->second;
-  }
+void
+RemoveLogSink(LogSink *dest)
+{
+    std::lock_guard<std::mutex> lock(sink_registry_mutex);
+    auto iter = sink_registry.find(dest);
+    if (iter != sink_registry.end()) {
+        google::RemoveLogSink(iter->second);
+        sink_registry.erase(iter);
+        delete iter->second;
+    }
 }
-void SetStderrLogging(LogSeverity min_severity) {
-  google::SetStderrLogging(min_severity);
+
+void
+SetStderrLogging(LogSeverity min_severity)
+{
+    google::SetStderrLogging(min_severity);
 }
-void LogToStderr() { google::LogToStderr(); }
-const char *GetLogSeverityName(LogSeverity severity) {
-  return google::GetLogSeverityName(severity);
+
+void
+LogToStderr()
+{
+    google::LogToStderr();
 }
-} // namespace tile
+
+const char *
+GetLogSeverityName(LogSeverity severity)
+{
+    return google::GetLogSeverityName(severity);
+}
+}// namespace tile
diff --git a/tile/base/internal/logging.h b/tile/base/internal/logging.h
index 6c527d1..7b1ba76 100644
--- a/tile/base/internal/logging.h
+++ b/tile/base/internal/logging.h
@@ -24,72 +24,77 @@ bool VLogIsOn(int n);
 
 class LogMessage {
 public:
-  LogMessage(const char *file, int line, int severity);
-  ~LogMessage();
-  std::ostream &stream();
+    LogMessage(const char *file, int line, int severity);
+    ~LogMessage();
+    std::ostream &stream();
 
 private:
-  class Impl;
-  std::unique_ptr<Impl> impl_;
+    class Impl;
+    std::unique_ptr<Impl> impl_;
 };
 
 class LogMessageFatal {
 public:
-  LogMessageFatal(const char *file, int line);
-  ~LogMessageFatal();
-  std::ostream &stream();
+    LogMessageFatal(const char *file, int line);
+    ~LogMessageFatal();
+    std::ostream &stream();
 
 private:
-  class Impl;
-  std::unique_ptr<Impl> impl_;
+    class Impl;
+    std::unique_ptr<Impl> impl_;
 };
 
 class LogMessageVoidify {
 public:
-  LogMessageVoidify() {}
-  // This has to be an operator with a precedence lower than << but
-  // higher than ?:
-  void operator&(std::ostream &) {}
+    LogMessageVoidify() {}
+
+    // This has to be an operator with a precedence lower than << but
+    // higher than ?:
+    void operator&(std::ostream &) {}
 };
+
 class ErrnoLogMessage : public LogMessage {
 public:
-  ErrnoLogMessage(const char *file, int line, int severity, std::int64_t ctr,
-                  void (LogMessage::*send_method)());
+    ErrnoLogMessage(const char *file, int line, int severity, std::int64_t ctr, void (LogMessage::*send_method)());
 
-  // Postpends ": strerror(errno) [errno]".
-  ~ErrnoLogMessage();
+    // Postpends ": strerror(errno) [errno]".
+    ~ErrnoLogMessage();
 
 private:
-  ErrnoLogMessage(const ErrnoLogMessage &);
-  void operator=(const ErrnoLogMessage &);
+    ErrnoLogMessage(const ErrnoLogMessage &);
+    void operator=(const ErrnoLogMessage &);
 };
 
-template <typename T>
+template<typename T>
 inline auto
-GetRef(const T &t) -> enable_if_t<!std::is_integral<T>::value, const T &> {
-  return t;
-}
-template <typename T>
-inline auto
-GetRef(T t) -> enable_if_t<std::is_integral<T>::value, remove_cvref_t<T>> {
-  return t;
+GetRef(const T &t) -> enable_if_t<!std::is_integral<T>::value, const T &>
+{
+    return t;
 }
 
-#define DEFINE_CHECK_OP_IMPL(name, op)                                         \
-  template <typename T1, typename T2>                                          \
-  inline std::string *name##Impl(const T1 &v1, const T2 &v2,                   \
-                                 const char *exprtext) {                       \
-    if ((v1)op(v2)) {                                                          \
-      return nullptr;                                                          \
-    } else {                                                                   \
-      std::ostringstream oss;                                                  \
-      oss << exprtext << " (" << v1 << " vs. " << v2 << "). ";                 \
-      return new std::string(oss.str());                                       \
-    }                                                                          \
-  }                                                                            \
-  inline std::string *name##Impl(int v1, int v2, const char *exprtext) {       \
-    return name##Impl<int, int>(v1, v2, exprtext);                             \
-  }
+template<typename T>
+inline auto
+GetRef(T t) -> enable_if_t<std::is_integral<T>::value, remove_cvref_t<T>>
+{
+    return t;
+}
+
+#define DEFINE_CHECK_OP_IMPL(name, op)                                                                                 \
+    template<typename T1, typename T2>                                                                                 \
+    inline std::string *name##Impl(const T1 &v1, const T2 &v2, const char *exprtext)                                   \
+    {                                                                                                                  \
+        if ((v1) op(v2)) {                                                                                             \
+            return nullptr;                                                                                            \
+        } else {                                                                                                       \
+            std::ostringstream oss;                                                                                    \
+            oss << exprtext << " (" << v1 << " vs. " << v2 << "). ";                                                   \
+            return new std::string(oss.str());                                                                         \
+        }                                                                                                              \
+    }                                                                                                                  \
+    inline std::string *name##Impl(int v1, int v2, const char *exprtext)                                               \
+    {                                                                                                                  \
+        return name##Impl<int, int>(v1, v2, exprtext);                                                                 \
+    }
 
 DEFINE_CHECK_OP_IMPL(Check_EQ, ==)
 DEFINE_CHECK_OP_IMPL(Check_NE, !=)
@@ -99,198 +104,142 @@ DEFINE_CHECK_OP_IMPL(Check_GE, >=)
 DEFINE_CHECK_OP_IMPL(Check_GT, >)
 #undef DEFINE_CHECK_OP_IMPL
 
-} // namespace tile
+}// namespace tile
 
-#define TILE_INTERNAL_LOG_INFO()                                               \
-  ::tile::LogMessage(__FILE__, __LINE__, ::tile::TILE_INFO).stream()
-#define TILE_INTERNAL_LOG_WARNING()                                            \
-  ::tile::LogMessage(__FILE__, __LINE__, ::tile::TILE_WARNING).stream()
-#define TILE_INTERNAL_LOG_ERROR()                                              \
-  ::tile::LogMessage(__FILE__, __LINE__, ::tile::TILE_ERROR).stream()
-#define TILE_INTERNAL_LOG_FATAL()                                              \
-  ::tile::LogMessageFatal(__FILE__, __LINE__).stream()
+#define TILE_INTERNAL_LOG_INFO() ::tile::LogMessage(__FILE__, __LINE__, ::tile::TILE_INFO).stream()
+#define TILE_INTERNAL_LOG_WARNING() ::tile::LogMessage(__FILE__, __LINE__, ::tile::TILE_WARNING).stream()
+#define TILE_INTERNAL_LOG_ERROR() ::tile::LogMessage(__FILE__, __LINE__, ::tile::TILE_ERROR).stream()
+#define TILE_INTERNAL_LOG_FATAL() ::tile::LogMessageFatal(__FILE__, __LINE__).stream()
 
-#define TILE_INTERNAL_LOG_TILE_INFO()                                          \
-  ::tile::LogMessage(__FILE__, __LINE__, ::tile::TILE_INFO).stream()
-#define TILE_INTERNAL_LOG_TILE_WARNING()                                       \
-  ::tile::LogMessage(__FILE__, __LINE__, ::tile::TILE_WARNING).stream()
-#define TILE_INTERNAL_LOG_TILE_ERROR()                                         \
-  ::tile::LogMessage(__FILE__, __LINE__, ::tile::TILE_ERROR).stream()
-#define TILE_INTERNAL_LOG_TILE_FATAL()                                         \
-  ::tile::LogMessageFatal(__FILE__, __LINE__).stream()
+#define TILE_INTERNAL_LOG_TILE_INFO() ::tile::LogMessage(__FILE__, __LINE__, ::tile::TILE_INFO).stream()
+#define TILE_INTERNAL_LOG_TILE_WARNING() ::tile::LogMessage(__FILE__, __LINE__, ::tile::TILE_WARNING).stream()
+#define TILE_INTERNAL_LOG_TILE_ERROR() ::tile::LogMessage(__FILE__, __LINE__, ::tile::TILE_ERROR).stream()
+#define TILE_INTERNAL_LOG_TILE_FATAL() ::tile::LogMessageFatal(__FILE__, __LINE__).stream()
 
 #define TILE_INTERNAL_LOG_COMPACT(severity) TILE_INTERNAL_LOG_##severity()
 
 #define TILE_LOG(severity) TILE_INTERNAL_LOG_COMPACT(severity)
 
-#define TILE_LOG_IF(severity, condition, ...)                                  \
-  TILE_INTERNAL_LOG_IF(severity, (condition))                                  \
-      << ::tile::internal::logging::FormatLog(__FILE__, __LINE__,              \
-                                              ##__VA_ARGS__)
+#define TILE_LOG_IF(severity, condition, ...)                                                                          \
+    TILE_INTERNAL_LOG_IF(severity, (condition))                                                                        \
+        << ::tile::internal::logging::FormatLog(__FILE__, __LINE__, ##__VA_ARGS__)
 
-#define TILE_INTERNAL_LOG_IF(severity, condition)                              \
-  static_cast<void>(0), !(condition) ? (void)0                                 \
-                                     : tile::LogMessageVoidify() &             \
-                                           TILE_INTERNAL_LOG_COMPACT(severity)
+#define TILE_INTERNAL_LOG_IF(severity, condition)                                                                      \
+    static_cast<void>(0), !(condition) ? (void) 0 : tile::LogMessageVoidify() & TILE_INTERNAL_LOG_COMPACT(severity)
 #define TILE_VLOG_IS_ON(n) (::tile::VLogIsOn(n))
-#define TILE_VLOG(n, ...)                                                      \
-  TILE_LOG_IF(TILE_INFO, TILE_VLOG_IS_ON(n))                                   \
-      << ::tile::internal::logging::FormatLog(__FILE__, __LINE__,              \
-                                              ##__VA_ARGS__)
+#define TILE_VLOG(n, ...)                                                                                              \
+    TILE_LOG_IF(TILE_INFO, TILE_VLOG_IS_ON(n))                                                                         \
+        << ::tile::internal::logging::FormatLog(__FILE__, __LINE__, ##__VA_ARGS__)
 
-#define TILE_CHECK_OP_LOG(name, op, val1, val2, severity)                      \
-  while (std::string *_result = tile::Check##name##Impl(                       \
-             tile::GetRef(val1), tile::GetRef(val2), #val1 " " #op " " #val2)) \
-  TILE_INTERNAL_LOG_FATAL() << *_result
+#define TILE_CHECK_OP_LOG(name, op, val1, val2, severity)                                                              \
+    while (std::string *_result =                                                                                      \
+               tile::Check##name##Impl(tile::GetRef(val1), tile::GetRef(val2), #val1 " " #op " " #val2))               \
+    TILE_INTERNAL_LOG_FATAL() << *_result
 
-#define TILE_CHECK_OP(name, op, val1, val2)                                    \
-  TILE_CHECK_OP_LOG(name, op, val1, val2, tile::LogMessageFatal)
+#define TILE_CHECK_OP(name, op, val1, val2) TILE_CHECK_OP_LOG(name, op, val1, val2, tile::LogMessageFatal)
 
-#define TILE_CHECK(condition, ...)                                             \
-  TILE_INTERNAL_LOG_IF(TILE_FATAL, (!(condition)))                             \
-      << "Check failed: " #condition " "                                       \
-      << ::tile::internal::logging::FormatLog(__FILE__, __LINE__,              \
-                                              ##__VA_ARGS__)
+#define TILE_CHECK(condition, ...)                                                                                     \
+    TILE_INTERNAL_LOG_IF(TILE_FATAL, (!(condition)))                                                                   \
+        << "Check failed: " #condition " " << ::tile::internal::logging::FormatLog(__FILE__, __LINE__, ##__VA_ARGS__)
 
-#define TILE_CHECK_EQ(val1, val2, ...)                                         \
-  TILE_CHECK_OP(_EQ, ==, val1, val2) << ::tile::internal::logging::FormatLog(  \
-      __FILE__, __LINE__, ##__VA_ARGS__)
+#define TILE_CHECK_EQ(val1, val2, ...)                                                                                 \
+    TILE_CHECK_OP(_EQ, ==, val1, val2) << ::tile::internal::logging::FormatLog(__FILE__, __LINE__, ##__VA_ARGS__)
 
-#define TILE_CHECK_NE(val1, val2, ...)                                         \
-  TILE_CHECK_OP(_NE, !=, val1, val2) << ::tile::internal::logging::FormatLog(  \
-      __FILE__, __LINE__, ##__VA_ARGS__)
+#define TILE_CHECK_NE(val1, val2, ...)                                                                                 \
+    TILE_CHECK_OP(_NE, !=, val1, val2) << ::tile::internal::logging::FormatLog(__FILE__, __LINE__, ##__VA_ARGS__)
 
-#define TILE_CHECK_LE(val1, val2, ...)                                         \
-  TILE_CHECK_OP(_LE, <=, val1, val2) << ::tile::internal::logging::FormatLog(  \
-      __FILE__, __LINE__, ##__VA_ARGS__)
+#define TILE_CHECK_LE(val1, val2, ...)                                                                                 \
+    TILE_CHECK_OP(_LE, <=, val1, val2) << ::tile::internal::logging::FormatLog(__FILE__, __LINE__, ##__VA_ARGS__)
 
-#define TILE_CHECK_LT(val1, val2, ...)                                         \
-  TILE_CHECK_OP(_LT, <, val1, val2) << ::tile::internal::logging::FormatLog(   \
-      __FILE__, __LINE__, ##__VA_ARGS__)
+#define TILE_CHECK_LT(val1, val2, ...)                                                                                 \
+    TILE_CHECK_OP(_LT, <, val1, val2) << ::tile::internal::logging::FormatLog(__FILE__, __LINE__, ##__VA_ARGS__)
 
-#define TILE_CHECK_GE(val1, val2, ...)                                         \
-  TILE_CHECK_OP(_GE, >=, val1, val2) << ::tile::internal::logging::FormatLog(  \
-      __FILE__, __LINE__, ##__VA_ARGS__)
+#define TILE_CHECK_GE(val1, val2, ...)                                                                                 \
+    TILE_CHECK_OP(_GE, >=, val1, val2) << ::tile::internal::logging::FormatLog(__FILE__, __LINE__, ##__VA_ARGS__)
 
-#define TILE_CHECK_GT(val1, val2, ...)                                         \
-  TILE_CHECK_OP(_GE, >, val1, val2) << ::tile::internal::logging::FormatLog(   \
-      __FILE__, __LINE__, ##__VA_ARGS__)
+#define TILE_CHECK_GT(val1, val2, ...)                                                                                 \
+    TILE_CHECK_OP(_GE, >, val1, val2) << ::tile::internal::logging::FormatLog(__FILE__, __LINE__, ##__VA_ARGS__)
 
-#define TILE_CHECK_NEAR(val1, val2, margin, ...)                               \
-  do {                                                                         \
-    TILE_CHECK_LE((val1), (val2) + margin, ##__VA_ARGS__)                      \
-    TILE_CHECK_GE((val1), (val2) - margin, ##__VA_ARGS__)                      \
-  } while (0)
+#define TILE_CHECK_NEAR(val1, val2, margin, ...)                                                                       \
+    do {                                                                                                               \
+        TILE_CHECK_LE((val1), (val2) + margin, ##__VA_ARGS__)                                                          \
+        TILE_CHECK_GE((val1), (val2) - margin, ##__VA_ARGS__)                                                          \
+    } while (0)
 
-#define TILE_LOG_INFO(...)                                                     \
-  TILE_LOG(TILE_INFO) << ::tile::internal::logging::FormatLog(                 \
-      __FILE__, __LINE__, ##__VA_ARGS__)
-#define TILE_LOG_WARNING(...)                                                  \
-  TILE_LOG(TILE_WARNING) << ::tile::internal::logging::FormatLog(              \
-      __FILE__, __LINE__, ##__VA_ARGS__)
-#define TILE_LOG_ERROR(...)                                                    \
-  TILE_LOG(TILE_ERROR) << ::tile::internal::logging::FormatLog(                \
-      __FILE__, __LINE__, ##__VA_ARGS__)
-#define TILE_LOG_FATAL(...)                                                    \
-  TILE_LOG(TILE_FATAL) << ::tile::internal::logging::FormatLog(                \
-      __FILE__, __LINE__, ##__VA_ARGS__)
+#define TILE_LOG_INFO(...)                                                                                             \
+    TILE_LOG(TILE_INFO) << ::tile::internal::logging::FormatLog(__FILE__, __LINE__, ##__VA_ARGS__)
+#define TILE_LOG_WARNING(...)                                                                                          \
+    TILE_LOG(TILE_WARNING) << ::tile::internal::logging::FormatLog(__FILE__, __LINE__, ##__VA_ARGS__)
+#define TILE_LOG_ERROR(...)                                                                                            \
+    TILE_LOG(TILE_ERROR) << ::tile::internal::logging::FormatLog(__FILE__, __LINE__, ##__VA_ARGS__)
+#define TILE_LOG_FATAL(...)                                                                                            \
+    TILE_LOG(TILE_FATAL) << ::tile::internal::logging::FormatLog(__FILE__, __LINE__, ##__VA_ARGS__)
 
-#define TILE_LOG_INFO_IF(expr, ...)                                            \
-  TILE_INTERNAL_LOG_IF(TILE_INFO, (expr))                                      \
-      << ::tile::internal::logging::FormatLog(__FILE__, __LINE__,              \
-                                              ##__VA_ARGS__)
-#define TILE_LOG_WARNING_IF(expr, ...)                                         \
-  TILE_INTERNAL_LOG_IF(TILE_WARNING, (expr))                                   \
-      << ::tile::internal::logging::FormatLog(__FILE__, __LINE__,              \
-                                              ##__VA_ARGS__)
-#define TILE_LOG_ERROR_IF(expr, ...)                                           \
-  TILE_INTERNAL_LOG_IF(TILE_ERROR, (expr))                                     \
-      << ::tile::internal::logging::FormatLog(__FILE__, __LINE__,              \
-                                              ##__VA_ARGS__)
-#define TILE_LOG_FATAL_IF(expr, ...)                                           \
-  TILE_INTERNAL_LOG_IF(TILE_FATAL, (expr))                                     \
-      << ::tile::internal::logging::FormatLog(__FILE__, __LINE__,              \
-                                              ##__VA_ARGS__)
+#define TILE_LOG_INFO_IF(expr, ...)                                                                                    \
+    TILE_INTERNAL_LOG_IF(TILE_INFO, (expr)) << ::tile::internal::logging::FormatLog(__FILE__, __LINE__, ##__VA_ARGS__)
+#define TILE_LOG_WARNING_IF(expr, ...)                                                                                 \
+    TILE_INTERNAL_LOG_IF(TILE_WARNING, (expr))                                                                         \
+        << ::tile::internal::logging::FormatLog(__FILE__, __LINE__, ##__VA_ARGS__)
+#define TILE_LOG_ERROR_IF(expr, ...)                                                                                   \
+    TILE_INTERNAL_LOG_IF(TILE_ERROR, (expr)) << ::tile::internal::logging::FormatLog(__FILE__, __LINE__, ##__VA_ARGS__)
+#define TILE_LOG_FATAL_IF(expr, ...)                                                                                   \
+    TILE_INTERNAL_LOG_IF(TILE_FATAL, (expr)) << ::tile::internal::logging::FormatLog(__FILE__, __LINE__, ##__VA_ARGS__)
 
 #define TILE_LOG_EVERY_N_VARNAME(base, line) TILE_INTERNAL_PP_CAT(base, line)
-#define TILE_LOG_OCCURRENCES()                                                 \
-  TILE_LOG_EVERY_N_VARNAME(tile_log_occurrences_, __LINE__)
-#define TILE_LOG_OCCURRENCES_MOD_N()                                           \
-  TILE_LOG_EVERY_N_VARNAME(tile_log_occurrences_mod_n_, __LINE__)
+#define TILE_LOG_OCCURRENCES() TILE_LOG_EVERY_N_VARNAME(tile_log_occurrences_, __LINE__)
+#define TILE_LOG_OCCURRENCES_MOD_N() TILE_LOG_EVERY_N_VARNAME(tile_log_occurrences_mod_n_, __LINE__)
 
-#define TILE_LOG_EVERY_N_IMPL(severity, N, ...)                                \
-  do {                                                                         \
-    static std::atomic<int> TILE_LOG_OCCURRENCES_MOD_N{};                      \
-    if ((TILE_LOG_OCCURRENCES_MOD_N = (TILE_LOG_OCCURRENCES_MOD_N + 1) % N) == \
-        (1 % N)) {                                                             \
-      TILE_LOG(severity) << ::tile::internal::logging::FormatLog(              \
-          __FILE__, __LINE__, ##__VA_ARGS__);                                  \
-    }                                                                          \
-  } while (0)
+#define TILE_LOG_EVERY_N_IMPL(severity, N, ...)                                                                        \
+    do {                                                                                                               \
+        static std::atomic<int> TILE_LOG_OCCURRENCES_MOD_N{};                                                          \
+        if ((TILE_LOG_OCCURRENCES_MOD_N = (TILE_LOG_OCCURRENCES_MOD_N + 1) % N) == (1 % N)) {                          \
+            TILE_LOG(severity) << ::tile::internal::logging::FormatLog(__FILE__, __LINE__, ##__VA_ARGS__);             \
+        }                                                                                                              \
+    } while (0)
 
-#define TILE_LOG_INFO_EVERY_N(N, ...)                                          \
-  TILE_LOG_EVERY_N_IMPL(TILE_INFO, N, ##__VA_ARGS__)
-#define TILE_LOG_WARNING_EVERY_N(N, ...)                                       \
-  TILE_LOG_EVERY_N_IMPL(TILE_WARNING, N, ##__VA_ARGS__)
-#define TILE_LOG_ERROR_EVERY_N(N, ...)                                         \
-  TILE_LOG_EVERY_N_IMPL(TILE_WARNING, N, ##__VA_ARGS__)
-#define TILE_LOG_FATAL_EVERY_N(N, ...)                                         \
-  TILE_LOG_EVERY_N_IMPL(TILE_FATAL, N, ##__VA_ARGS__)
+#define TILE_LOG_INFO_EVERY_N(N, ...) TILE_LOG_EVERY_N_IMPL(TILE_INFO, N, ##__VA_ARGS__)
+#define TILE_LOG_WARNING_EVERY_N(N, ...) TILE_LOG_EVERY_N_IMPL(TILE_WARNING, N, ##__VA_ARGS__)
+#define TILE_LOG_ERROR_EVERY_N(N, ...) TILE_LOG_EVERY_N_IMPL(TILE_WARNING, N, ##__VA_ARGS__)
+#define TILE_LOG_FATAL_EVERY_N(N, ...) TILE_LOG_EVERY_N_IMPL(TILE_FATAL, N, ##__VA_ARGS__)
 
-#define TILE_LOG_IF_EVERY_N_IMPL(severity, expr, N, ...)                       \
-  do {                                                                         \
-    if (expr) {                                                                \
-      TILE_LOG_EVERY_N_IMPL(severity, N, ##__VA_ARGS__)                        \
-    }                                                                          \
-  } while (0)
+#define TILE_LOG_IF_EVERY_N_IMPL(severity, expr, N, ...)                                                               \
+    do {                                                                                                               \
+        if (expr) { TILE_LOG_EVERY_N_IMPL(severity, N, ##__VA_ARGS__) }                                                \
+    } while (0)
 
-#define TILE_LOG_INFO_IF_EVERY_N(expr, N, ...)                                 \
-  TILE_LOG_IF_EVERY_N_IMPL(TILE_INFO, N, ##__VA_ARGS__)
-#define TILE_LOG_WARNING_IF_EVERY_N(expr, N, ...)                              \
-  TILE_LOG_IF_EVERY_N_IMPL(TILE_WARNING, N, ##__VA_ARGS__)
-#define TILE_LOG_ERROR_IF_EVERY_N(expr, N, ...)                                \
-  TILE_LOG_IF_EVERY_N_IMPL(TILE_WARNING, N, ##__VA_ARGS__)
-#define TILE_LOG_FATAL_IF_EVERY_N(expr, N, ...)                                \
-  TILE_LOG_IF_EVERY_N_IMPL(TILE_FATAL, N, ##__VA_ARGS__)
+#define TILE_LOG_INFO_IF_EVERY_N(expr, N, ...) TILE_LOG_IF_EVERY_N_IMPL(TILE_INFO, N, ##__VA_ARGS__)
+#define TILE_LOG_WARNING_IF_EVERY_N(expr, N, ...) TILE_LOG_IF_EVERY_N_IMPL(TILE_WARNING, N, ##__VA_ARGS__)
+#define TILE_LOG_ERROR_IF_EVERY_N(expr, N, ...) TILE_LOG_IF_EVERY_N_IMPL(TILE_WARNING, N, ##__VA_ARGS__)
+#define TILE_LOG_FATAL_IF_EVERY_N(expr, N, ...) TILE_LOG_IF_EVERY_N_IMPL(TILE_FATAL, N, ##__VA_ARGS__)
 
 #define TILE_LOG_ONCE_VARNAME(base, line) TILE_INTERNAL_PP_CAT(base, line)
 #define TILE_LOG_ONCE_FLAG TILE_LOG_ONCE_VARNAME(tile_log_once_flag_, __LINE__)
-#define TILE_LOG_ONCE_FLAG_EXPECTED                                            \
-  TILE_LOG_ONCE_VARNAME(tile_log_once_flag_expected_, __LINE__)
+#define TILE_LOG_ONCE_FLAG_EXPECTED TILE_LOG_ONCE_VARNAME(tile_log_once_flag_expected_, __LINE__)
 
-#define TILE_LOG_ONCE_IMPL(severity, ...)                                      \
-  do {                                                                         \
-    static std::atomic<bool> TILE_LOG_ONCE_FLAG(false);                        \
-    bool TILE_LOG_ONCE_FLAG_EXPECTED(false);                                   \
-    if (!TILE_LOG_ONCE_FLAG.load() &&                                          \
-        TILE_LOG_ONCE_FLAG.compare_exchange_strong(                            \
-            TILE_LOG_ONCE_FLAG_EXPECTED, true)) {                              \
-      TILE_LOG(severity) << ::tile::internal::logging::FormatLog(              \
-          __FILE__, __LINE__, ##__VA_ARGS__);                                  \
-    }                                                                          \
-  } while (0)
+#define TILE_LOG_ONCE_IMPL(severity, ...)                                                                              \
+    do {                                                                                                               \
+        static std::atomic<bool> TILE_LOG_ONCE_FLAG(false);                                                            \
+        bool TILE_LOG_ONCE_FLAG_EXPECTED(false);                                                                       \
+        if (!TILE_LOG_ONCE_FLAG.load()                                                                                 \
+            && TILE_LOG_ONCE_FLAG.compare_exchange_strong(TILE_LOG_ONCE_FLAG_EXPECTED, true)) {                        \
+            TILE_LOG(severity) << ::tile::internal::logging::FormatLog(__FILE__, __LINE__, ##__VA_ARGS__);             \
+        }                                                                                                              \
+    } while (0)
 
 #define TILE_LOG_INFO_ONCE(...) TILE_LOG_ONCE_IMPL(TILE_INFO, ##__VA_ARGS__)
-#define TILE_LOG_WARNING_ONCE(...)                                             \
-  TILE_LOG_ONCE_IMPL(TILE_WARNING, ##__VA_ARGS__)
+#define TILE_LOG_WARNING_ONCE(...) TILE_LOG_ONCE_IMPL(TILE_WARNING, ##__VA_ARGS__)
 #define TILE_LOG_ERROR_ONCE(...) TILE_LOG_ONCE_IMPL(TILE_WARNING, ##__VA_ARGS__)
 #define TILE_LOG_FATAL_ONCE(...) TILE_LOG_ONCE_IMPL(TILE_FATAL, ##__VA_ARGS__)
 
-#define TILE_LOG_IF_ONCE_IMPL(severity, expr, ...)                             \
-  do {                                                                         \
-    if (expr) {                                                                \
-      TILE_LOG_ONCE_IMPL(severity, ##__VA_ARGS__);                             \
-    }                                                                          \
-  } while (0)
+#define TILE_LOG_IF_ONCE_IMPL(severity, expr, ...)                                                                     \
+    do {                                                                                                               \
+        if (expr) { TILE_LOG_ONCE_IMPL(severity, ##__VA_ARGS__); }                                                     \
+    } while (0)
 
-#define TILE_LOG_INFO_IF_ONCE(expr, ...)                                       \
-  TILE_LOG_IF_ONCE_IMPL(TILE_INFO, expr, ##__VA_ARGS__)
-#define TILE_LOG_WARNING_IF_ONCE(expr, ...)                                    \
-  TILE_LOG_IF_ONCE_IMPL(TILE_WARNING, expr, ##__VA_ARGS__)
-#define TILE_LOG_ERROR_IF_ONCE(expr, ...)                                      \
-  TILE_LOG_IF_ONCE_IMPL(TILE_WARNING, expr, ##__VA_ARGS__)
-#define TILE_LOG_FATAL_IF_ONCE(expr, ...)                                      \
-  TILE_LOG_IF_ONCE_IMPL(TILE_FATAL, expr, ##__VA_ARGS__)
+#define TILE_LOG_INFO_IF_ONCE(expr, ...) TILE_LOG_IF_ONCE_IMPL(TILE_INFO, expr, ##__VA_ARGS__)
+#define TILE_LOG_WARNING_IF_ONCE(expr, ...) TILE_LOG_IF_ONCE_IMPL(TILE_WARNING, expr, ##__VA_ARGS__)
+#define TILE_LOG_ERROR_IF_ONCE(expr, ...) TILE_LOG_IF_ONCE_IMPL(TILE_WARNING, expr, ##__VA_ARGS__)
+#define TILE_LOG_FATAL_IF_ONCE(expr, ...) TILE_LOG_IF_ONCE_IMPL(TILE_FATAL, expr, ##__VA_ARGS__)
 
 #if defined(NDEBUG) && !defined(DCHECK_ALWAYS_ON)
 #define TILE_ENABLE_DEBUG 0
@@ -306,8 +255,7 @@ DEFINE_CHECK_OP_IMPL(Check_GT, >)
 #define TILE_DCHECK_LE(a, b, ...) TILE_CHECK_LE(a, b, ##__VA_ARGS__)
 #define TILE_DCHECK_GT(a, b, ...) TILE_CHECK_GT(a, b, ##__VA_ARGS__)
 #define TILE_DCHECK_GE(a, b, ...) TILE_CHECK_GE(a, b, ##__VA_ARGS__)
-#define TILE_DCHECK_NEAR(a, b, margin, ...)                                    \
-  TILE_CHECK_NEAR(a, b, margin, ##__VA_ARGS__)
+#define TILE_DCHECK_NEAR(a, b, margin, ...) TILE_CHECK_NEAR(a, b, margin, ##__VA_ARGS__)
 
 #define TILE_DLOG_INFO(...) TILE_LOG_INFO(__VA_ARGS__)
 #define TILE_DLOG_WARNING(...) TILE_LOG_WARNING(__VA_ARGS__)
@@ -320,326 +268,284 @@ DEFINE_CHECK_OP_IMPL(Check_GT, >)
 #define TILE_DLOG_FATAL_IF(expr, ...) TILE_LOG_FATAL_IF(expr, ##__VA_ARGS__)
 
 #define TILE_DLOG_INFO_EVERY_N(N, ...) TILE_LOG_INFO_EVERY_N(N, ##__VA_ARGS__)
-#define TILE_DLOG_WARNING_EVERY_N(N, ...)                                      \
-  TILE_LOG_WARNING_EVERY_N(N, __VA_ARGS__)
+#define TILE_DLOG_WARNING_EVERY_N(N, ...) TILE_LOG_WARNING_EVERY_N(N, __VA_ARGS__)
 #define TILE_DLOG_ERROR_EVERY_N(N, ...) TILE_LOG_ERROR_EVERY_N(N, ##__VA_ARGS__)
 #define TILE_DLOG_FATAL_EVERY_N(N, ...) TILE_LOG_FATAL_EVERY_N(N, ##__VA_ARGS__)
 
-#define TILE_DLOG_INFO_IF_EVERY_N(expr, N, ...)                                \
-  TILE_LOG_INFO_IF_EVERY_N(expr, N, ##__VA_ARGS__)
-#define TILE_DLOG_WARNING_IF_EVERY_N(expr, N, ...)                             \
-  TILE_LOG_WARNING_IF_EVERY_N(expr, N, ##__VA_ARGS__)
-#define TILE_DLOG_ERROR_IF_EVERY_N(expr, N, ...)                               \
-  TILE_LOG_ERROR_IF_EVERY_N(expr, N, ##__VA_ARGS__)
-#define TILE_DLOG_FATAL_IF_EVERY_N(expr, N, ...)                               \
-  TILE_LOG_FATAL_IF_EVERY_N(expr, N, ##__VA_ARGS__)
+#define TILE_DLOG_INFO_IF_EVERY_N(expr, N, ...) TILE_LOG_INFO_IF_EVERY_N(expr, N, ##__VA_ARGS__)
+#define TILE_DLOG_WARNING_IF_EVERY_N(expr, N, ...) TILE_LOG_WARNING_IF_EVERY_N(expr, N, ##__VA_ARGS__)
+#define TILE_DLOG_ERROR_IF_EVERY_N(expr, N, ...) TILE_LOG_ERROR_IF_EVERY_N(expr, N, ##__VA_ARGS__)
+#define TILE_DLOG_FATAL_IF_EVERY_N(expr, N, ...) TILE_LOG_FATAL_IF_EVERY_N(expr, N, ##__VA_ARGS__)
 
 #define TILE_DLOG_ONCE(...) TILE_LOG_ONCE_IMPL(TILE_INFO, ##__VA_ARGS__)
-#define TILE_DLOG_WARNING_ONCE(...)                                            \
-  TILE_LOG_ONCE_IMPL(TILE_WARNING, ##__VA_ARGS__)
-#define TILE_DLOG_ERROR_ONCE(...)                                              \
-  TILE_LOG_ONCE_IMPL(TILE_WARNING, ##__VA_ARGS__)
+#define TILE_DLOG_WARNING_ONCE(...) TILE_LOG_ONCE_IMPL(TILE_WARNING, ##__VA_ARGS__)
+#define TILE_DLOG_ERROR_ONCE(...) TILE_LOG_ONCE_IMPL(TILE_WARNING, ##__VA_ARGS__)
 #define TILE_DLOG_FATAL_ONCE(...) TILE_LOG_ONCE_IMPL(TILE_FATAL, ##__VA_ARGS__)
 
-#define TILE_DLOG_INFO_IF_ONCE(expr, ...)                                      \
-  TILE_LOG_IF_ONCE_IMPL(TILE_INFO, expr, ##__VA_ARGS__)
-#define TILE_DLOG_WARNING_IF_ONCE(expr, ...)                                   \
-  TILE_LOG_IF_ONCE_IMPL(TILE_WARNING, expr, ##__VA_ARGS__)
-#define TILE_DLOG_ERROR_IF_ONCE(expr, ...)                                     \
-  TILE_LOG_IF_ONCE_IMPL(TILE_WARNING, expr, ##__VA_ARGS__)
-#define TILE_DLOG_FATAL_IF_ONCE(expr, ...)                                     \
-  TILE_LOG_IF_ONCE_IMPL(TILE_FATAL, expr, ##__VA_ARGS__)
+#define TILE_DLOG_INFO_IF_ONCE(expr, ...) TILE_LOG_IF_ONCE_IMPL(TILE_INFO, expr, ##__VA_ARGS__)
+#define TILE_DLOG_WARNING_IF_ONCE(expr, ...) TILE_LOG_IF_ONCE_IMPL(TILE_WARNING, expr, ##__VA_ARGS__)
+#define TILE_DLOG_ERROR_IF_ONCE(expr, ...) TILE_LOG_IF_ONCE_IMPL(TILE_WARNING, expr, ##__VA_ARGS__)
+#define TILE_DLOG_FATAL_IF_ONCE(expr, ...) TILE_LOG_IF_ONCE_IMPL(TILE_FATAL, expr, ##__VA_ARGS__)
 
 #else
-#define TILE_DCHECK(expr, ...)                                                 \
-  while (0)                                                                    \
-  TILE_CHECK(expr)
-#define TILE_DCHECK_EQ(a, b, ...)                                              \
-  while (0)                                                                    \
-  TILE_CHECK_EQ(a, b)
-#define TILE_DCHECK_NE(a, b, ...)                                              \
-  while (0)                                                                    \
-  TILE_CHECK_NE(a, b)
-#define TILE_DCHECK_LT(a, b, ...)                                              \
-  while (0)                                                                    \
-  TILE_CHECK_LT(a, b)
-#define TILE_DCHECK_LE(a, b, ...)                                              \
-  while (0)                                                                    \
-  TILE_CHECK_LE(a, b)
-#define TILE_DCHECK_GT(a, b, ...)                                              \
-  while (0)                                                                    \
-  TILE_CHECK_GT(a, b)
-#define TILE_DCHECK_GE(a, b, ...)                                              \
-  while (0)                                                                    \
-  TILE_CHECK_GE(a, b)
-#define TILE_DCHECK_NEAR(a, b, margin, ...)                                    \
-  while (0)                                                                    \
-  TILE_CHECK_NEAR(a, b, margin)
+#define TILE_DCHECK(expr, ...)                                                                                         \
+    while (0) TILE_CHECK(expr)
+#define TILE_DCHECK_EQ(a, b, ...)                                                                                      \
+    while (0) TILE_CHECK_EQ(a, b)
+#define TILE_DCHECK_NE(a, b, ...)                                                                                      \
+    while (0) TILE_CHECK_NE(a, b)
+#define TILE_DCHECK_LT(a, b, ...)                                                                                      \
+    while (0) TILE_CHECK_LT(a, b)
+#define TILE_DCHECK_LE(a, b, ...)                                                                                      \
+    while (0) TILE_CHECK_LE(a, b)
+#define TILE_DCHECK_GT(a, b, ...)                                                                                      \
+    while (0) TILE_CHECK_GT(a, b)
+#define TILE_DCHECK_GE(a, b, ...)                                                                                      \
+    while (0) TILE_CHECK_GE(a, b)
+#define TILE_DCHECK_NEAR(a, b, margin, ...)                                                                            \
+    while (0) TILE_CHECK_NEAR(a, b, margin)
 
-#define TILE_DLOG_INFO(...)                                                    \
-  while (0)                                                                    \
-  TILE_LOG_INFO(__VA_ARGS__)
-#define TILE_DLOG_WARNING(...)                                                 \
-  while (0)                                                                    \
-  TILE_LOG_WARNING(__VA_ARGS__)
-#define TILE_DLOG_ERROR(...)                                                   \
-  while (0)                                                                    \
-  TILE_LOG_ERROR(__VA_ARGS__)
-#define TILE_DLOG_FATAL(...)                                                   \
-  while (0)                                                                    \
-  TILE_LOG_FATAL(__VA_ARGS__)
+#define TILE_DLOG_INFO(...)                                                                                            \
+    while (0) TILE_LOG_INFO(__VA_ARGS__)
+#define TILE_DLOG_WARNING(...)                                                                                         \
+    while (0) TILE_LOG_WARNING(__VA_ARGS__)
+#define TILE_DLOG_ERROR(...)                                                                                           \
+    while (0) TILE_LOG_ERROR(__VA_ARGS__)
+#define TILE_DLOG_FATAL(...)                                                                                           \
+    while (0) TILE_LOG_FATAL(__VA_ARGS__)
 
-#define TILE_DLOG_INFO_IF(expr, ...)                                           \
-  while (0)                                                                    \
-  TILE_LOG_INFO_IF(expr, ##__VA_ARGS__)
-#define TILE_DLOG_WARNING_IF(expr, ...)                                        \
-  while (0)                                                                    \
-  TILE_LOG_WARNING_IF(expr, ##__VA_ARGS__)
-#define TILE_DLOG_ERROR_IF(expr, ...)                                          \
-  while (0)                                                                    \
-  TILE_LOG_ERROR_IF(expr, ##__VA_ARGS__)
-#define TILE_DLOG_FATAL_IF(expr, ...)                                          \
-  while (0)                                                                    \
-  TILE_LOG_FATAL_IF(expr, ##__VA_ARGS__)
+#define TILE_DLOG_INFO_IF(expr, ...)                                                                                   \
+    while (0) TILE_LOG_INFO_IF(expr, ##__VA_ARGS__)
+#define TILE_DLOG_WARNING_IF(expr, ...)                                                                                \
+    while (0) TILE_LOG_WARNING_IF(expr, ##__VA_ARGS__)
+#define TILE_DLOG_ERROR_IF(expr, ...)                                                                                  \
+    while (0) TILE_LOG_ERROR_IF(expr, ##__VA_ARGS__)
+#define TILE_DLOG_FATAL_IF(expr, ...)                                                                                  \
+    while (0) TILE_LOG_FATAL_IF(expr, ##__VA_ARGS__)
 
-#define TILE_DLOG_INFO_EVERY_N(N, ...)                                         \
-  while (0)                                                                    \
-  TILE_LOG_INFO_EVERY_N(N, ##__VA_ARGS__)
-#define TILE_DLOG_WARNING_EVERY_N(N, ...)                                      \
-  while (0)                                                                    \
-  TILE_LOG_WARNING_EVERY_N(N, ##__VA_ARGS__)
-#define TILE_DLOG_ERROR_EVERY_N(N, ...)                                        \
-  while (0)                                                                    \
-  TILE_LOG_ERROR_EVERY_N(N, ##__VA_ARGS__)
-#define TILE_DLOG_FATAL_EVERY_N(N, ...)                                        \
-  while (0)                                                                    \
-  TILE_LOG_FATAL_EVERY_N(N, ##__VA_ARGS__)
+#define TILE_DLOG_INFO_EVERY_N(N, ...)                                                                                 \
+    while (0) TILE_LOG_INFO_EVERY_N(N, ##__VA_ARGS__)
+#define TILE_DLOG_WARNING_EVERY_N(N, ...)                                                                              \
+    while (0) TILE_LOG_WARNING_EVERY_N(N, ##__VA_ARGS__)
+#define TILE_DLOG_ERROR_EVERY_N(N, ...)                                                                                \
+    while (0) TILE_LOG_ERROR_EVERY_N(N, ##__VA_ARGS__)
+#define TILE_DLOG_FATAL_EVERY_N(N, ...)                                                                                \
+    while (0) TILE_LOG_FATAL_EVERY_N(N, ##__VA_ARGS__)
 
-#define TILE_DLOG_INFO_IF_EVERY_N(expr, N, ...)                                \
-  while (0)                                                                    \
-  TILE_LOG_INFO_IF_EVERY_N(expr, N, ##__VA_ARGS__)
-#define TILE_DLOG_WARNING_IF_EVERY_N(expr, N, ...)                             \
-  while (0)                                                                    \
-  TILE_LOG_WARNING_IF_EVERY_N(expr, N, ##__VA_ARGS__)
-#define TILE_DLOG_ERROR_IF_EVERY_N(expr, N, ...)                               \
-  while (0)                                                                    \
-  TILE_LOG_ERROR_IF_EVERY_N(expr, N, ##__VA_ARGS__)
-#define TILE_DLOG_FATAL_IF_EVERY_N(expr, N, ...)                               \
-  while (0)                                                                    \
-  TILE_LOG_FATAL_IF_EVERY_N(expr, N, ##__VA_ARGS__)
+#define TILE_DLOG_INFO_IF_EVERY_N(expr, N, ...)                                                                        \
+    while (0) TILE_LOG_INFO_IF_EVERY_N(expr, N, ##__VA_ARGS__)
+#define TILE_DLOG_WARNING_IF_EVERY_N(expr, N, ...)                                                                     \
+    while (0) TILE_LOG_WARNING_IF_EVERY_N(expr, N, ##__VA_ARGS__)
+#define TILE_DLOG_ERROR_IF_EVERY_N(expr, N, ...)                                                                       \
+    while (0) TILE_LOG_ERROR_IF_EVERY_N(expr, N, ##__VA_ARGS__)
+#define TILE_DLOG_FATAL_IF_EVERY_N(expr, N, ...)                                                                       \
+    while (0) TILE_LOG_FATAL_IF_EVERY_N(expr, N, ##__VA_ARGS__)
 
-#define TILE_DLOG_ONCE(...)                                                    \
-  while (0)                                                                    \
-  TILE_LOG_ONCE_IMPL(TILE_INFO, ##__VA_ARGS__)
-#define TILE_DLOG_WARNING_ONCE(...)                                            \
-  while (0)                                                                    \
-  TILE_LOG_ONCE_IMPL(TILE_WARNING, ##__VA_ARGS__)
-#define TILE_DLOG_ERROR_ONCE(...)                                              \
-  while (0)                                                                    \
-  TILE_LOG_ONCE_IMPL(TILE_WARNING, ##__VA_ARGS__)
-#define TILE_DLOG_FATAL_ONCE(...)                                              \
-  while (0)                                                                    \
-  TILE_LOG_ONCE_IMPL(TILE_FATAL, ##__VA_ARGS__)
+#define TILE_DLOG_ONCE(...)                                                                                            \
+    while (0) TILE_LOG_ONCE_IMPL(TILE_INFO, ##__VA_ARGS__)
+#define TILE_DLOG_WARNING_ONCE(...)                                                                                    \
+    while (0) TILE_LOG_ONCE_IMPL(TILE_WARNING, ##__VA_ARGS__)
+#define TILE_DLOG_ERROR_ONCE(...)                                                                                      \
+    while (0) TILE_LOG_ONCE_IMPL(TILE_WARNING, ##__VA_ARGS__)
+#define TILE_DLOG_FATAL_ONCE(...)                                                                                      \
+    while (0) TILE_LOG_ONCE_IMPL(TILE_FATAL, ##__VA_ARGS__)
 
-#define TILE_DLOG_INFO_IF_ONCE(expr, ...)                                      \
-  while (0)                                                                    \
-  TILE_LOG_IF_ONCE_IMPL(TILE_INFO, expr, ##__VA_ARGS__)
-#define TILE_DLOG_WARNING_IF_ONCE(expr, ...)                                   \
-  while (0)                                                                    \
-  TILE_LOG_IF_ONCE_IMPL(TILE_WARNING, expr, ##__VA_ARGS__)
-#define TILE_DLOG_ERROR_IF_ONCE(expr, ...)                                     \
-  while (0)                                                                    \
-  TILE_LOG_IF_ONCE_IMPL(TILE_WARNING, expr, ##__VA_ARGS__)
-#define TILE_DLOG_FATAL_IF_ONCE(expr, ...)                                     \
-  while (0)                                                                    \
-  TILE_LOG_IF_ONCE_IMPL(TILE_FATAL, expr, ##__VA_ARGS__)
+#define TILE_DLOG_INFO_IF_ONCE(expr, ...)                                                                              \
+    while (0) TILE_LOG_IF_ONCE_IMPL(TILE_INFO, expr, ##__VA_ARGS__)
+#define TILE_DLOG_WARNING_IF_ONCE(expr, ...)                                                                           \
+    while (0) TILE_LOG_IF_ONCE_IMPL(TILE_WARNING, expr, ##__VA_ARGS__)
+#define TILE_DLOG_ERROR_IF_ONCE(expr, ...)                                                                             \
+    while (0) TILE_LOG_IF_ONCE_IMPL(TILE_WARNING, expr, ##__VA_ARGS__)
+#define TILE_DLOG_FATAL_IF_ONCE(expr, ...)                                                                             \
+    while (0) TILE_LOG_IF_ONCE_IMPL(TILE_FATAL, expr, ##__VA_ARGS__)
 #endif
 
-#define TILE_INTERNAL_PLOG(severity)                                           \
-  ::tile::LogMessageFatal(__FILE__, __LINE__).stream()
+#define TILE_INTERNAL_PLOG(severity) ::tile::LogMessageFatal(__FILE__, __LINE__).stream()
 
-#define TILE_INTERNAL_PLOG_IF(severity, expr, ...)                             \
-  static_cast<void>(0),                                                        \
-      !(expr) ? (void)0                                                        \
-              : tile::LogMessageVoidify() & TILE_INTERNAL_PLOG(severity)
+#define TILE_INTERNAL_PLOG_IF(severity, expr, ...)                                                                     \
+    static_cast<void>(0), !(expr) ? (void) 0 : tile::LogMessageVoidify() & TILE_INTERNAL_PLOG(severity)
 
-#define TILE_PCHECK(expr, ...)                                                 \
-  TILE_INTERNAL_PLOG_IF(::tile::TILE_FATAL, (!(expr)))                         \
-      << "Check failed: " #expr " "                                            \
-      << ::tile::internal::logging::FormatLog(__FILE__, __LINE__,              \
-                                              ##__VA_ARGS__)
+#define TILE_PCHECK(expr, ...)                                                                                         \
+    TILE_INTERNAL_PLOG_IF(::tile::TILE_FATAL, (!(expr)))                                                               \
+        << "Check failed: " #expr " " << ::tile::internal::logging::FormatLog(__FILE__, __LINE__, ##__VA_ARGS__)
 
 #define TILE_PLOG_INFO(...) TILE_INTERNAL_PLOG(TILE_INFO, ##__VA_ARGS__)
 #define TILE_PLOG_WARNING(...) TILE_INTERNAL_PLOG(TILE_WARNING, ##__VA_ARGS__)
 #define TILE_PLOG_ERROR(...) TILE_INTERNAL_PLOG(TILE_WARNING, ##__VA_ARGS__)
 #define TILE_PLOG_FATAL(...) TILE_INTERNAL_PLOG(TILE_FATAL, ##__VA_ARGS__)
 
-#define TILE_PLOG_INFO_IF(expr, ...)                                           \
-  TILE_INTERNAL_PLOG_IF(TILE_INFO, expr, ##__VA_ARGS__)
-#define TILE_PLOG_WARNING_IF(expr, ...)                                        \
-  TILE_INTERNAL_PLOG_IF(TILE_WARNING, expr, ##__VA_ARGS__)
-#define TILE_PLOG_ERROR_IF(expr, ...)                                          \
-  TILE_INTERNAL_PLOG_IF(TILE_WARNING, expr, ##__VA_ARGS__)
-#define TILE_PLOG_FATAL_IF(expr, ...)                                          \
-  TILE_INTERNAL_PLOG_IF(TILE_FATAL, expr, ##__VA_ARGS__)
+#define TILE_PLOG_INFO_IF(expr, ...) TILE_INTERNAL_PLOG_IF(TILE_INFO, expr, ##__VA_ARGS__)
+#define TILE_PLOG_WARNING_IF(expr, ...) TILE_INTERNAL_PLOG_IF(TILE_WARNING, expr, ##__VA_ARGS__)
+#define TILE_PLOG_ERROR_IF(expr, ...) TILE_INTERNAL_PLOG_IF(TILE_WARNING, expr, ##__VA_ARGS__)
+#define TILE_PLOG_FATAL_IF(expr, ...) TILE_INTERNAL_PLOG_IF(TILE_FATAL, expr, ##__VA_ARGS__)
 
-#define TILE_UNREACHABLE(...)                                                  \
-  do {                                                                         \
-    TILE_INTERNAL_LOG_TILE_FATAL() << "Unreachable code reached. "             \
-                                   << ::tile::internal::logging::FormatLog(    \
-                                          __FILE__, __LINE__, ##__VA_ARGS__);  \
-  } while (1)
-#define TILE_NOT_IMPLEMENTED(...)                                              \
-  do {                                                                         \
-    TILE_INTERNAL_LOG_TILE_FATAL() << "Not implemented. "                      \
-                                   << ::tile::internal::logging::FormatLog(    \
-                                          __FILE__, __LINE__, ##__VA_ARGS__);  \
-  } while (1)
-#define TILE_UNEXPECTED(...)                                                   \
-  do {                                                                         \
-    TILE_INTERNAL_LOG_TILE_FATAL() << "Unexpected condition. "                 \
-                                   << ::tile::internal::logging::FormatLog(    \
-                                          __FILE__, __LINE__, ##__VA_ARGS__);  \
-  } while (1)
+#define TILE_UNREACHABLE(...)                                                                                          \
+    do {                                                                                                               \
+        TILE_INTERNAL_LOG_TILE_FATAL() << "Unreachable code reached. "                                                 \
+                                       << ::tile::internal::logging::FormatLog(__FILE__, __LINE__, ##__VA_ARGS__);     \
+    } while (1)
+#define TILE_NOT_IMPLEMENTED(...)                                                                                      \
+    do {                                                                                                               \
+        TILE_INTERNAL_LOG_TILE_FATAL() << "Not implemented. "                                                          \
+                                       << ::tile::internal::logging::FormatLog(__FILE__, __LINE__, ##__VA_ARGS__);     \
+    } while (1)
+#define TILE_UNEXPECTED(...)                                                                                           \
+    do {                                                                                                               \
+        TILE_INTERNAL_LOG_TILE_FATAL() << "Unexpected condition. "                                                     \
+                                       << ::tile::internal::logging::FormatLog(__FILE__, __LINE__, ##__VA_ARGS__);     \
+    } while (1)
 
-#define TILE_LOG_EVERY_SECOND_IMPL(severity, N, ...)                           \
-  do {                                                                         \
-    static ::std::chrono::nanoseconds tile_anonmous_log_last_occurs{};         \
-    if (::tile::ReadCoarseSteadyClock().time_since_epoch() >                   \
-        std::chrono::seconds(N) + tile_anonmous_log_last_occurs) {             \
-      static ::std::atomic<bool> tile_anonymous_logging{false};                \
-      if (::tile::internal::TestAndSet(tile_anonymous_logging, false, true)) { \
-        TILE_LOG(severity) << ::tile::internal::logging::FormatLog(            \
-            __FILE__, __LINE__, ##__VA_ARGS__);                                \
-        tile_anonmous_log_last_occurs =                                        \
-            ::tile::ReadCoarseSteadyClock().time_since_epoch();                \
-        tile_anonymous_logging.store(false);                                   \
-      }                                                                        \
-    }                                                                          \
-  } while (0)
+#define TILE_LOG_EVERY_SECOND_IMPL(severity, N, ...)                                                                   \
+    do {                                                                                                               \
+        static ::std::chrono::nanoseconds tile_anonmous_log_last_occurs{};                                             \
+        if (::tile::ReadCoarseSteadyClock().time_since_epoch()                                                         \
+            > std::chrono::seconds(N) + tile_anonmous_log_last_occurs) {                                               \
+            static ::std::atomic<bool> tile_anonymous_logging{false};                                                  \
+            if (::tile::internal::TestAndSet(tile_anonymous_logging, false, true)) {                                   \
+                TILE_LOG(severity) << ::tile::internal::logging::FormatLog(__FILE__, __LINE__, ##__VA_ARGS__);         \
+                tile_anonmous_log_last_occurs = ::tile::ReadCoarseSteadyClock().time_since_epoch();                    \
+                tile_anonymous_logging.store(false);                                                                   \
+            }                                                                                                          \
+        }                                                                                                              \
+    } while (0)
 
-#define TILE_LOG_INFO_EVERY_SECOND(...)                                        \
-  TILE_LOG_EVERY_SECOND_IMPL(TILE_INFO, 1, ##__VA_ARGS__)
-#define TILE_LOG_WARNING_EVERY_SECOND(...)                                     \
-  TILE_LOG_EVERY_SECOND_IMPL(TILE_WARNING, 1, ##__VA_ARGS__)
-#define TILE_LOG_ERROR_EVERY_SECOND(...)                                       \
-  TILE_LOG_EVERY_SECOND_IMPL(TILE_WARNING, 1, ##__VA_ARGS__)
-#define TILE_LOG_FATAL_EVERY_SECOND(...)                                       \
-  TILE_LOG_EVERY_SECOND_IMPL(TILE_FATAL, 1, ##__VA_ARGS__)
+#define TILE_LOG_INFO_EVERY_SECOND(...) TILE_LOG_EVERY_SECOND_IMPL(TILE_INFO, 1, ##__VA_ARGS__)
+#define TILE_LOG_WARNING_EVERY_SECOND(...) TILE_LOG_EVERY_SECOND_IMPL(TILE_WARNING, 1, ##__VA_ARGS__)
+#define TILE_LOG_ERROR_EVERY_SECOND(...) TILE_LOG_EVERY_SECOND_IMPL(TILE_WARNING, 1, ##__VA_ARGS__)
+#define TILE_LOG_FATAL_EVERY_SECOND(...) TILE_LOG_EVERY_SECOND_IMPL(TILE_FATAL, 1, ##__VA_ARGS__)
 
-#define TILE_LOG_IF_EVERY_SECOND_IMPL(severity, expr, N, ...)                  \
-  do {                                                                         \
-    if (expr) {                                                                \
-      TILE_LOG_EVERY_SECOND_IMPL(severity, N, ##__VA_ARGS__);                  \
-    }                                                                          \
-  } while (0)
+#define TILE_LOG_IF_EVERY_SECOND_IMPL(severity, expr, N, ...)                                                          \
+    do {                                                                                                               \
+        if (expr) { TILE_LOG_EVERY_SECOND_IMPL(severity, N, ##__VA_ARGS__); }                                          \
+    } while (0)
 
-#define TILE_LOG_INFO_IF_EVERY_SECOND(expr, ...)                               \
-  TILE_LOG_IF_EVERY_SECOND_IMPL(TILE_INFO, expr, 1, ##__VA_ARGS__)
-#define TILE_LOG_WARNING_IF_EVERY_SECOND(expr, ...)                            \
-  TILE_LOG_IF_EVERY_SECOND_IMPL(TILE_WARNING, expr, 1, ##__VA_ARGS__)
-#define TILE_LOG_ERROR_IF_EVERY_SECOND(expr, ...)                              \
-  TILE_LOG_IF_EVERY_SECOND_IMPL(TILE_WARNING, expr, 1, ##__VA_ARGS__)
-#define TILE_LOG_FATAL_IF_EVERY_SECOND(expr, ...)                              \
-  TILE_LOG_IF_EVERY_SECOND_IMPL(TILE_FATAL, expr, 1, ##__VA_ARGS__)
+#define TILE_LOG_INFO_IF_EVERY_SECOND(expr, ...) TILE_LOG_IF_EVERY_SECOND_IMPL(TILE_INFO, expr, 1, ##__VA_ARGS__)
+#define TILE_LOG_WARNING_IF_EVERY_SECOND(expr, ...) TILE_LOG_IF_EVERY_SECOND_IMPL(TILE_WARNING, expr, 1, ##__VA_ARGS__)
+#define TILE_LOG_ERROR_IF_EVERY_SECOND(expr, ...) TILE_LOG_IF_EVERY_SECOND_IMPL(TILE_WARNING, expr, 1, ##__VA_ARGS__)
+#define TILE_LOG_FATAL_IF_EVERY_SECOND(expr, ...) TILE_LOG_IF_EVERY_SECOND_IMPL(TILE_FATAL, expr, 1, ##__VA_ARGS__)
 
 namespace tile {
 namespace internal {
 namespace logging {
 namespace details {
-template <typename T> std::string ToString(const T &value) {
-  return fmt::format("{}", value);
+template<typename T>
+std::string
+ToString(const T &value)
+{
+    return fmt::format("{}", value);
 }
 
 std::string DescribeFormatArguments(const std::vector<std::string> &args);
 
-} // namespace details
+}// namespace details
 
 using PrefixAppender = void(std::string *to);
 
 void InstallPrefixProvider(PrefixAppender *writer);
 void WritePrefixTo(std::string *to);
 
-#define TILE_INTERNAL_LOGGING_REGISTER_PREFIX_PROVIDER(priority, cb)           \
-  __attribute__((constructor(priority + 101))) static void                     \
-  TILE_INTERNAL_PP_CAT(tile_reserved_logging_prefix_installer_,                \
-                       __COUNTER__)() {                                        \
-    ::tile::internal::logging::InstallPrefixProvider(cb);                      \
-  }
+#define TILE_INTERNAL_LOGGING_REGISTER_PREFIX_PROVIDER(priority, cb)                                                   \
+    __attribute__((constructor(priority + 101))) static void TILE_INTERNAL_PP_CAT(                                     \
+        tile_reserved_logging_prefix_installer_, __COUNTER__)()                                                        \
+    {                                                                                                                  \
+        ::tile::internal::logging::InstallPrefixProvider(cb);                                                          \
+    }
 
-template <typename... Args>
-void FormatLogImpl(std::string *str, const char *file, int line,
-                   Args &&...args) {
-  try {
-    *str += fmt::format(std::forward<Args>(args)...);
-  } catch (const std::exception &xcpt) {
-    *str = fmt::format(
-        "FAILED TO FORMAT LOG AT [{}:{}] WITH ARGUMENTS ({}): {}", file, line,
-        details::DescribeFormatArguments({details::ToString(args)...}),
-        xcpt.what());
-  }
+template<typename... Args>
+void
+FormatLogImpl(std::string *str, const char *file, int line, Args &&...args)
+{
+    try {
+        *str += fmt::format(std::forward<Args>(args)...);
+    } catch (const std::exception &xcpt) {
+        *str = fmt::format("FAILED TO FORMAT LOG AT [{}:{}] WITH ARGUMENTS ({}): {}", file, line,
+                           details::DescribeFormatArguments({details::ToString(args)...}), xcpt.what());
+    }
 }
 
-inline void FormatLogImpl(std::string *str, const char *file, int line) {}
+inline void
+FormatLogImpl(std::string *str, const char *file, int line)
+{}
 
-template <typename... Ts>
-std::string FormatLog(const char *file, int line, Ts &&...args) noexcept {
-  std::string result;
-  WritePrefixTo(&result);
-  FormatLogImpl(&result, file, line, std::forward<Ts>(args)...);
-  return result;
+template<typename... Ts>
+std::string
+FormatLog(const char *file, int line, Ts &&...args) noexcept
+{
+    std::string result;
+    WritePrefixTo(&result);
+    FormatLogImpl(&result, file, line, std::forward<Ts>(args)...);
+    return result;
 }
-} // namespace logging
-} // namespace internal
-} // namespace tile
+}// namespace logging
+}// namespace internal
+}// namespace tile
 
 namespace tile {
 typedef double WallTime;
-struct LogMessageTime {
-  LogMessageTime();
-  LogMessageTime(std::tm t);
-  LogMessageTime(std::time_t timestamp, WallTime now);
 
-  const time_t &timestamp() const { return timestamp_; }
-  const int &sec() const { return time_struct_.tm_sec; }
-  const int32_t &usec() const { return usecs_; }
-  const int &(min)() const { return time_struct_.tm_min; }
-  const int &hour() const { return time_struct_.tm_hour; }
-  const int &day() const { return time_struct_.tm_mday; }
-  const int &month() const { return time_struct_.tm_mon; }
-  const int &year() const { return time_struct_.tm_year; }
-  const int &dayOfWeek() const { return time_struct_.tm_wday; }
-  const int &dayInYear() const { return time_struct_.tm_yday; }
-  const int &dst() const { return time_struct_.tm_isdst; }
-  const long int &gmtoff() const { return gmtoffset_; }
-  const std::tm &tm() const { return time_struct_; }
+struct LogMessageTime {
+    LogMessageTime();
+    LogMessageTime(std::tm t);
+    LogMessageTime(std::time_t timestamp, WallTime now);
+
+    const time_t &timestamp() const { return timestamp_; }
+
+    const int &sec() const { return time_struct_.tm_sec; }
+
+    const int32_t &usec() const { return usecs_; }
+
+    const int &(min) () const { return time_struct_.tm_min; }
+
+    const int &hour() const { return time_struct_.tm_hour; }
+
+    const int &day() const { return time_struct_.tm_mday; }
+
+    const int &month() const { return time_struct_.tm_mon; }
+
+    const int &year() const { return time_struct_.tm_year; }
+
+    const int &dayOfWeek() const { return time_struct_.tm_wday; }
+
+    const int &dayInYear() const { return time_struct_.tm_yday; }
+
+    const int &dst() const { return time_struct_.tm_isdst; }
+
+    const long int &gmtoff() const { return gmtoffset_; }
+
+    const std::tm &tm() const { return time_struct_; }
 
 private:
-  void init(const std::tm &t, std::time_t timestamp, WallTime now);
-  std::tm time_struct_; // Time of creation of LogMessage
-  time_t timestamp_;    // Time of creation of LogMessage in seconds
-  int32_t usecs_;       // Time of creation of LogMessage - microseconds part
-  long int gmtoffset_;
+    void init(const std::tm &t, std::time_t timestamp, WallTime now);
+    std::tm time_struct_;// Time of creation of LogMessage
+    time_t timestamp_;   // Time of creation of LogMessage in seconds
+    int32_t usecs_;      // Time of creation of LogMessage - microseconds part
+    long int gmtoffset_;
 
-  void CalcGmtOffset();
+    void CalcGmtOffset();
 };
 
 class LogSink {
 public:
-  virtual ~LogSink();
-  virtual void send(LogSeverity severity, const char *full_filename,
-                    const char *base_filename, int line,
-                    const LogMessageTime &logmsgtime, const char *message,
-                    size_t message_len);
-  virtual void WaitTillSent();
-  std::string ToString(LogSeverity severity, const char *file, int line,
-                       const LogMessageTime &logmsgtime, const char *message,
-                       size_t message_len);
+    virtual ~LogSink();
+    virtual void send(LogSeverity severity,
+                      const char *full_filename,
+                      const char *base_filename,
+                      int line,
+                      const LogMessageTime &logmsgtime,
+                      const char *message,
+                      size_t message_len);
+    virtual void WaitTillSent();
+    std::string ToString(LogSeverity severity,
+                         const char *file,
+                         int line,
+                         const LogMessageTime &logmsgtime,
+                         const char *message,
+                         size_t message_len);
 };
 
 class FileLogSink : public LogSink {
 public:
-  FileLogSink(const std::string &file_path_template);
+    FileLogSink(const std::string &file_path_template);
 };
 
 void AddLogSink(LogSink *dest);
@@ -648,5 +554,5 @@ void SetStderrLogging(LogSeverity min_severity);
 void LogToStderr();
 const char *GetLogSeverityName(LogSeverity severity);
 
-} // namespace tile
-#endif // _TILE_BASE_INTERNAL_LOG_H
+}// namespace tile
+#endif// _TILE_BASE_INTERNAL_LOG_H
diff --git a/tile/base/internal/logging_test.cc b/tile/base/internal/logging_test.cc
index 6f0d585..d356075 100644
--- a/tile/base/internal/logging_test.cc
+++ b/tile/base/internal/logging_test.cc
@@ -9,86 +9,105 @@
 #include <thread>
 
 struct AwesomeLogSink : public tile::LogSink {
-  virtual void send(tile::LogSeverity severity, const char *full_filename,
-                    const char *base_filename, int line,
-                    const tile::LogMessageTime &logmsgtime, const char *message,
-                    size_t message_len) override {
-    msgs.emplace_back(message, message_len);
-  }
-  std::vector<std::string> msgs;
+    virtual void send(tile::LogSeverity severity,
+                      const char *full_filename,
+                      const char *base_filename,
+                      int line,
+                      const tile::LogMessageTime &logmsgtime,
+                      const char *message,
+                      size_t message_len) override
+    {
+        msgs.emplace_back(message, message_len);
+    }
+
+    std::vector<std::string> msgs;
 };
 
 std::string my_prefix, my_prefix2;
 
-void WriteLoggingPrefix(std::string *s) { *s += my_prefix; }
-void WriteLoggingPrefix2(std::string *s) { *s += my_prefix2; }
-
-void ResetLogPrefix() {
-  my_prefix = "";
-  my_prefix2 = "";
+void
+WriteLoggingPrefix(std::string *s)
+{
+    *s += my_prefix;
 }
 
-TEST(Logging, CHECK) {
-  ASSERT_DEATH(([] { TILE_CHECK(false, "CHECK"); }()), "CHECK");
-  ASSERT_DEATH(([] { TILE_CHECK_LE(2, 1, "CHECK_LE"); }()), "CHECK_LE");
-  ASSERT_DEATH(([] { TILE_CHECK_LT(2, 1, "CHECK_LT"); }()), "CHECK_LT");
-  ASSERT_DEATH(([] { TILE_CHECK_GE(1, 2, "CHECK_GE"); }()), "CHECK_GE");
-  ASSERT_DEATH(([] { TILE_CHECK_GT(1, 2, "CHECK_GT"); }()), "CHECK_GT");
-  ASSERT_DEATH(([] { TILE_CHECK_EQ(1, 2, "CHECK_EQ"); }()), "CHECK_EQ");
-  ASSERT_DEATH(([] { TILE_CHECK_NE(1, 1, "CHECK_NE"); }()), "CHECK_NE");
+void
+WriteLoggingPrefix2(std::string *s)
+{
+    *s += my_prefix2;
 }
 
-TEST(Logging, Prefix) {
-  AwesomeLogSink sink;
-  tile::AddLogSink(&sink);
-  tile::ScopedDeferred defered([&] { tile::RemoveLogSink(&sink); });
-
-  TILE_LOG_INFO("something");
-
-  my_prefix = "[prefix]";
-  TILE_LOG_INFO("something");
-
-  my_prefix = "[prefix1]";
-  TILE_LOG_INFO("something");
-
-  my_prefix2 = "[prefix2]";
-  TILE_LOG_INFO("something");
-
-  ASSERT_THAT(sink.msgs,
-              ::testing::ElementsAre("something", "[prefix] something",
-                                     "[prefix1] something",
-                                     "[prefix1] [prefix2] something"));
+void
+ResetLogPrefix()
+{
+    my_prefix  = "";
+    my_prefix2 = "";
 }
 
-TEST(Logging, DontPanicOnFormatFailure) {
-  TILE_LOG_INFO("Don't panic!{}{}", 1);
+TEST(Logging, CHECK)
+{
+    ASSERT_DEATH(([] { TILE_CHECK(false, "CHECK"); }()), "CHECK");
+    ASSERT_DEATH(([] { TILE_CHECK_LE(2, 1, "CHECK_LE"); }()), "CHECK_LE");
+    ASSERT_DEATH(([] { TILE_CHECK_LT(2, 1, "CHECK_LT"); }()), "CHECK_LT");
+    ASSERT_DEATH(([] { TILE_CHECK_GE(1, 2, "CHECK_GE"); }()), "CHECK_GE");
+    ASSERT_DEATH(([] { TILE_CHECK_GT(1, 2, "CHECK_GT"); }()), "CHECK_GT");
+    ASSERT_DEATH(([] { TILE_CHECK_EQ(1, 2, "CHECK_EQ"); }()), "CHECK_EQ");
+    ASSERT_DEATH(([] { TILE_CHECK_NE(1, 1, "CHECK_NE"); }()), "CHECK_NE");
 }
 
-TEST(Logging, EverySecond) {
-  ResetLogPrefix();
+TEST(Logging, Prefix)
+{
+    AwesomeLogSink sink;
+    tile::AddLogSink(&sink);
+    tile::ScopedDeferred defered([&] { tile::RemoveLogSink(&sink); });
 
-  AwesomeLogSink sink;
-  tile::AddLogSink(&sink);
-  tile::ScopedDeferred defered([&] { tile::RemoveLogSink(&sink); });
-  for (int i = 0; i < 30; i++) {
-    TILE_LOG_INFO_EVERY_SECOND("something");
-    std::this_thread::sleep_for(std::chrono::milliseconds(100));
-  }
+    TILE_LOG_INFO("something");
 
-  ASSERT_THAT(sink.msgs,
-              ::testing::ElementsAre("something", "something", "something"));
+    my_prefix = "[prefix]";
+    TILE_LOG_INFO("something");
+
+    my_prefix = "[prefix1]";
+    TILE_LOG_INFO("something");
+
+    my_prefix2 = "[prefix2]";
+    TILE_LOG_INFO("something");
+
+    ASSERT_THAT(sink.msgs,
+                ::testing::ElementsAre(
+                    "something", "[prefix] something", "[prefix1] something", "[prefix1] [prefix2] something"));
 }
 
-TEST(Logging, Enum) {
-  enum MyEnum { A, B, C };
-  MyEnum e = MyEnum::A;
-  TILE_LOG_INFO("{}", e);
+TEST(Logging, DontPanicOnFormatFailure) { TILE_LOG_INFO("Don't panic!{}{}", 1); }
+
+TEST(Logging, EverySecond)
+{
+    ResetLogPrefix();
+
+    AwesomeLogSink sink;
+    tile::AddLogSink(&sink);
+    tile::ScopedDeferred defered([&] { tile::RemoveLogSink(&sink); });
+    for (int i = 0; i < 30; i++) {
+        TILE_LOG_INFO_EVERY_SECOND("something");
+        std::this_thread::sleep_for(std::chrono::milliseconds(100));
+    }
+
+    ASSERT_THAT(sink.msgs, ::testing::ElementsAre("something", "something", "something"));
 }
 
-TEST(Logging, EnumClass) {
-  enum MyEnumClass { A, B, C };
-  MyEnumClass e = MyEnumClass::A;
-  TILE_LOG_INFO("{}", e);
+TEST(Logging, Enum)
+{
+    enum MyEnum { A, B, C };
+
+    MyEnum e = MyEnum::A;
+    TILE_LOG_INFO("{}", e);
+}
+
+TEST(Logging, EnumClass)
+{
+    enum MyEnumClass { A, B, C };
+
+    MyEnumClass e = MyEnumClass::A;
+    TILE_LOG_INFO("{}", e);
 }
 
 TILE_INTERNAL_LOGGING_REGISTER_PREFIX_PROVIDER(0, WriteLoggingPrefix)
diff --git a/tile/base/internal/macro.h b/tile/base/internal/macro.h
index 05206a5..f5ad9de 100644
--- a/tile/base/internal/macro.h
+++ b/tile/base/internal/macro.h
@@ -13,36 +13,30 @@
 
 #define TILE_INTERNAL_PP_STRINGIZE(X) TILE_INTERNAL_PP_STRINGIZE_IMPL(X)
 
-#define TILE_INTERNAL_PP_COUNT(...)                                            \
-  TILE_INTERNAL_PP_COUNT_IMPL(                                                 \
-      __VA_ARGS__, 64, 63, 62, 61, 60, 59, 58, 57, 56, 55, 54, 53, 52, 51, 50, \
-      49, 48, 47, 46, 45, 44, 43, 42, 41, 40, 39, 38, 37, 36, 35, 34, 33, 32,  \
-      31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14,  \
-      13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1)
+#define TILE_INTERNAL_PP_COUNT(...)                                                                                    \
+    TILE_INTERNAL_PP_COUNT_IMPL(                                                                                       \
+        __VA_ARGS__, 64, 63, 62, 61, 60, 59, 58, 57, 56, 55, 54, 53, 52, 51, 50, 49, 48, 47, 46, 45, 44, 43, 42, 41,   \
+        40, 39, 38, 37, 36, 35, 34, 33, 32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14,    \
+        13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1)
 
 // TILE_INTERNAL_PP_SEQ_AT(0, (a, b, c)) => a
 // TILE_INTERNAL_PP_SEQ_AT(1, (a, b, c)) => b
-#define TILE_INTERNAL_PP_SEQ_AT(Index, Sequence)                               \
-  TILE_INTERNAL_PP_SEQ_AT_##Index##_IMPL Sequence
+#define TILE_INTERNAL_PP_SEQ_AT(Index, Sequence) TILE_INTERNAL_PP_SEQ_AT_##Index##_IMPL Sequence
 
 // TILE_INTERNAL_PP_FOR_EACH(Callback, Context, a, b, c) =>
 // Callback(a, Context) Callback(b, Context) Callback(c, Context)
-#define TILE_INTERNAL_PP_FOR_EACH(Callback, Context, ...)                      \
-  TILE_INTERNAL_PP_CAT(TILE_INTERNAL_PP_FOR_EACH_,                             \
-                       TILE_INTERNAL_PP_COUNT(__VA_ARGS__))                    \
-  (Callback, Context, __VA_ARGS__)
+#define TILE_INTERNAL_PP_FOR_EACH(Callback, Context, ...)                                                              \
+    TILE_INTERNAL_PP_CAT(TILE_INTERNAL_PP_FOR_EACH_, TILE_INTERNAL_PP_COUNT(__VA_ARGS__))                              \
+    (Callback, Context, __VA_ARGS__)
 
 #define TILE_INTERNAL_DETAIL_PP_CAT_IMPL_2(X, Y) X##Y
-#define TILE_INTERNAL_DETAIL_PP_CAT_IMPL(X, Y)                                 \
-  TILE_INTERNAL_DETAIL_PP_CAT_IMPL_2(X, Y)
+#define TILE_INTERNAL_DETAIL_PP_CAT_IMPL(X, Y) TILE_INTERNAL_DETAIL_PP_CAT_IMPL_2(X, Y)
 
 #define TILE_INTERNAL_PP_STRINGIZE_IMPL(X) #X
-#define TILE_INTERNAL_PP_COUNT_IMPL(                                           \
-    _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, Count, ...)                                                      \
-  Count
+#define TILE_INTERNAL_PP_COUNT_IMPL(                                                                                   \
+    _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, Count, ...)                        \
+    Count
 
-#endif // _TILE_BASE_INTERNAL_MACRO_H
+#endif// _TILE_BASE_INTERNAL_MACRO_H
diff --git a/tile/base/internal/macro_inl.h b/tile/base/internal/macro_inl.h
index e549a35..ce9d8fc 100644
--- a/tile/base/internal/macro_inl.h
+++ b/tile/base/internal/macro_inl.h
@@ -134,4 +134,4 @@
   // NOLINT
 // clang-format on
 
-#endif // _TILE_BASE_INTERNAL_MACRO_INL_H
+#endif// _TILE_BASE_INTERNAL_MACRO_INL_H
diff --git a/tile/base/internal/meta.h b/tile/base/internal/meta.h
index 2554bec..78ce699 100644
--- a/tile/base/internal/meta.h
+++ b/tile/base/internal/meta.h
@@ -15,43 +15,47 @@ namespace tile {
 namespace internal {
 namespace detail {
 
-template <typename F>
+template<typename F>
 struct return_traits : return_traits<decltype(&F::operator())> {};
-template <typename T> struct return_traits<T *> : return_traits<T> {};
 
-template <typename R, typename... Args> struct return_traits<R (*)(Args...)> {
-  using type = R;
+template<typename T>
+struct return_traits<T *> : return_traits<T> {};
+
+template<typename R, typename... Args>
+struct return_traits<R (*)(Args...)> {
+    using type = R;
 };
 
-#define TILE_INTERNAL_DETAIL_RETURN_TRAITS_FOR_MEM_FUN(...)                    \
-  template <typename R, typename C, typename... Args>                          \
-  struct return_traits<R (C::*)(Args...) __VA_ARGS__> {                        \
-    using type = R;                                                            \
-  }
+#define TILE_INTERNAL_DETAIL_RETURN_TRAITS_FOR_MEM_FUN(...)                                                            \
+    template<typename R, typename C, typename... Args>                                                                 \
+    struct return_traits<R (C::*)(Args...) __VA_ARGS__> {                                                              \
+        using type = R;                                                                                                \
+    }
 TILE_INTERNAL_DETAIL_RETURN_TRAITS_FOR_MEM_FUN();
 TILE_INTERNAL_DETAIL_RETURN_TRAITS_FOR_MEM_FUN(const);
 TILE_INTERNAL_DETAIL_RETURN_TRAITS_FOR_MEM_FUN(volatile);
 TILE_INTERNAL_DETAIL_RETURN_TRAITS_FOR_MEM_FUN(const volatile);
 #undef TILE_INTERNAL_DETAIL_RETURN_TRAITS_FOR_MEM_FUN
 
-} // namespace detail
-} // namespace internal
-} // namespace tile
+}// namespace detail
+}// namespace internal
+}// namespace tile
 
 namespace tile {
 
 // underlying_type
 // underlying_type_t
-template <typename T, typename = void> struct underlying_type {
-  using type = void;
+template<typename T, typename = void>
+struct underlying_type {
+    using type = void;
 };
 
-template <typename T>
+template<typename T>
 struct underlying_type<T, enable_if_t<std::is_enum<T>::value>> {
-  using type = typename std::underlying_type<T>::type;
+    using type = typename std::underlying_type<T>::type;
 };
 
-template <typename T>
+template<typename T>
 using underlying_type_t = typename underlying_type<T>::type;
 
 // template <typename F, typename... Args>
@@ -69,90 +73,104 @@ using underlying_type_t = typename underlying_type<T>::type;
 
 namespace internal {
 
-template <typename F, typename... Args> struct is_valid {
-  constexpr static bool value = tile::is_invocable<F, Args...>::value;
+template<typename F, typename... Args>
+struct is_valid {
+    constexpr static bool value = tile::is_invocable<F, Args...>::value;
 };
 
-template <typename S, typename T> struct is_streamable {
-  template <typename SS, typename TT,
-            typename = decltype(std::declval<SS &>() << std::declval<TT>())>
-  static int Test(int);
-  template <typename, typename> static char Test(...);
-  static constexpr bool value =
-      std::is_same<decltype(Test<S, T>(0)), int>::value;
+template<typename S, typename T>
+struct is_streamable {
+    template<typename SS, typename TT, typename = decltype(std::declval<SS &>() << std::declval<TT>())>
+    static int Test(int);
+    template<typename, typename>
+    static char Test(...);
+    static constexpr bool value = std::is_same<decltype(Test<S, T>(0)), int>::value;
 };
 
-template <typename T, typename... Args> struct first_element {
-  using type = T;
+template<typename T, typename... Args>
+struct first_element {
+    using type = T;
 };
-template <typename T, typename... Args>
+
+template<typename T, typename... Args>
 using first_element_t = typename first_element<T, Args...>::type;
 
-template <typename T>
-typename std::remove_const<T>::type *RemoveConstPtr(T *p) {
-  return const_cast<typename std::remove_const<T>::type *>(p);
+template<typename T>
+typename std::remove_const<T>::type *
+RemoveConstPtr(T *p)
+{
+    return const_cast<typename std::remove_const<T>::type *>(p);
 }
 
-template <typename Op, typename A1, typename A2>
-auto InvokeOp(Op &&op, A1 &&a1, A2 &&a2) -> decltype(op(std::forward<A1>(a1),
-                                                        std::forward<A2>(a2))) {
-  return op(std::forward<A1>(a1), std::forward<A2>(a2));
+template<typename Op, typename A1, typename A2>
+auto
+InvokeOp(Op &&op, A1 &&a1, A2 &&a2) -> decltype(op(std::forward<A1>(a1), std::forward<A2>(a2)))
+{
+    return op(std::forward<A1>(a1), std::forward<A2>(a2));
 }
 
-template <typename Op, typename A1, typename... Ts>
-auto InvokeOp(Op &&op, A1 &&a1,
-              Ts &&...ts) -> decltype(op(a1, InvokeOp(op, ts...))) {
-  return op(op, a1, InvokeOp(op, ts...));
+template<typename Op, typename A1, typename... Ts>
+auto
+InvokeOp(Op &&op, A1 &&a1, Ts &&...ts) -> decltype(op(a1, InvokeOp(op, ts...)))
+{
+    return op(op, a1, InvokeOp(op, ts...));
 }
 
-template <typename T> using remove_cv_t = typename std::remove_cv<T>::type;
+template<typename T>
+using remove_cv_t = typename std::remove_cv<T>::type;
 
-template <typename T> struct remove_cvref {
-  using type =
-      typename std::remove_cv<typename std::remove_reference<T>::type>::type;
+template<typename T>
+struct remove_cvref {
+    using type = typename std::remove_cv<typename std::remove_reference<T>::type>::type;
 };
 
-template <typename T> using remove_cvref_t = typename remove_cvref<T>::type;
+template<typename T>
+using remove_cvref_t = typename remove_cvref<T>::type;
 
-template <typename T>
+template<typename T>
 using remove_reference_t = typename std::remove_reference<T>::type;
 
-template <typename...> using void_t = void;
+template<typename...>
+using void_t = void;
 
-template <bool value, typename TrueType, typename FalseType>
-using conditional_t =
-    typename std::conditional<value, TrueType, FalseType>::type;
+template<bool value, typename TrueType, typename FalseType>
+using conditional_t = typename std::conditional<value, TrueType, FalseType>::type;
 
-template <typename...> struct conjunction : std::true_type {};
-template <typename T> struct conjunction<T> : T {};
-template <typename T, typename... Ts>
-struct conjunction<T, Ts...>
-    : conditional_t<bool(T::value), conjunction<Ts...>, T> {};
+template<typename...>
+struct conjunction : std::true_type {};
 
-template <typename T>
+template<typename T>
+struct conjunction<T> : T {};
+
+template<typename T, typename... Ts>
+struct conjunction<T, Ts...> : conditional_t<bool(T::value), conjunction<Ts...>, T> {};
+
+template<typename T>
 using add_lvalue_reference_t = typename std::add_lvalue_reference<T>::type;
-template <typename T>
+template<typename T>
 using add_rvalue_reference_t = typename std::add_rvalue_reference<T>::type;
 
-template <typename T> using decay_t = typename std::decay<T>::type;
+template<typename T>
+using decay_t = typename std::decay<T>::type;
 
-template <typename T>
+template<typename T>
 struct is_pointer_noref : std::is_pointer<remove_reference_t<T>> {};
-template <typename T>
-struct is_memfunc_noref
-    : std::is_member_function_pointer<remove_reference_t<T>> {};
+
+template<typename T>
+struct is_memfunc_noref : std::is_member_function_pointer<remove_reference_t<T>> {};
 
 // Check is std::reference_wrapper
-template <typename T> struct is_wrapper : std::false_type {};
+template<typename T>
+struct is_wrapper : std::false_type {};
 
-template <typename T>
+template<typename T>
 struct is_wrapper<std::reference_wrapper<T>> : std::true_type {};
 
-template <typename T>
+template<typename T>
 struct is_wrapper_noref : is_wrapper<remove_reference_t<remove_cv_t<T>>> {};
 
-} // namespace internal
+}// namespace internal
 
-} // namespace tile
+}// namespace tile
 
-#endif // _TILE_BASE_META_META_H
+#endif// _TILE_BASE_META_META_H
diff --git a/tile/base/internal/meta/apply.h b/tile/base/internal/meta/apply.h
index 82340fe..cd750f5 100644
--- a/tile/base/internal/meta/apply.h
+++ b/tile/base/internal/meta/apply.h
@@ -7,91 +7,94 @@
 namespace tile {
 namespace detail {
 namespace apply {
-template <typename T> struct is_tuple_impl : std::false_type {};
-template <typename... Args>
+template<typename T>
+struct is_tuple_impl : std::false_type {};
+
+template<typename... Args>
 struct is_tuple_impl<std::tuple<Args...>> : std::true_type {};
-template <typename T>
+
+template<typename T>
 struct is_tuple : is_tuple_impl<remove_reference_t<remove_cvref_t<T>>> {};
 
-template <typename F, typename Tuple> struct is_tuple_callable {
+template<typename F, typename Tuple>
+struct is_tuple_callable {
 private:
-  struct unsupport_type_tag_t {
-    explicit unsupport_type_tag_t() = default;
-  };
+    struct unsupport_type_tag_t {
+        explicit unsupport_type_tag_t() = default;
+    };
 
-  using RawTuple = remove_reference_t<remove_cvref_t<Tuple>>;
+    using RawTuple = remove_reference_t<remove_cvref_t<Tuple>>;
 
-  template <typename FF, typename... Ts,
-            typename = enable_if_t<is_invocable<FF, Ts...>::value>>
-  static int Test(FF &&, std::tuple<Ts...> &&);
-  template <typename...> static unsupport_type_tag_t Test(...);
+    template<typename FF, typename... Ts, typename = enable_if_t<is_invocable<FF, Ts...>::value>>
+    static int Test(FF &&, std::tuple<Ts...> &&);
+    template<typename...>
+    static unsupport_type_tag_t Test(...);
 
 public:
-  static constexpr bool value =
-      is_tuple<RawTuple>::value &&
-      !std::is_same<decltype(Test(std::declval<F>(), std::declval<RawTuple>())),
-                    unsupport_type_tag_t>::value;
+    static constexpr bool value = is_tuple<RawTuple>::value
+        && !std::is_same<decltype(Test(std::declval<F>(), std::declval<RawTuple>())), unsupport_type_tag_t>::value;
 };
-template <typename F, typename Tuple> struct tuple_invoke_result {
-  using RawTuple = remove_reference_t<remove_cvref_t<Tuple>>;
-  template <typename FF, typename... Ts>
-  static auto Test(FF &&, std::tuple<Ts...> &&) -> invoke_result_t<FF, Ts...>;
 
-  using type = decltype(Test(std::declval<F>(), std::declval<RawTuple>()));
+template<typename F, typename Tuple>
+struct tuple_invoke_result {
+    using RawTuple = remove_reference_t<remove_cvref_t<Tuple>>;
+    template<typename FF, typename... Ts>
+    static auto Test(FF &&, std::tuple<Ts...> &&) -> invoke_result_t<FF, Ts...>;
+
+    using type = decltype(Test(std::declval<F>(), std::declval<RawTuple>()));
 };
-template <typename F, typename Tuple>
+
+template<typename F, typename Tuple>
 using tuple_invoke_result_t = typename tuple_invoke_result<F, Tuple>::type;
 
-static_assert(is_tuple_callable<std::function<void()>, std::tuple<>>::value,
-              "");
+static_assert(is_tuple_callable<std::function<void()>, std::tuple<>>::value, "");
 
-static_assert(is_tuple_callable<std::function<char()>, std::tuple<>>::value,
-              "");
+static_assert(is_tuple_callable<std::function<char()>, std::tuple<>>::value, "");
 
-static_assert(
-    is_tuple_callable<std::function<void(int)>, std::tuple<int>>::value, "");
+static_assert(is_tuple_callable<std::function<void(int)>, std::tuple<int>>::value, "");
 
-static_assert(
-    is_tuple_callable<std::function<int(int)>, std::tuple<int>>::value, "");
+static_assert(is_tuple_callable<std::function<int(int)>, std::tuple<int>>::value, "");
 
-static_assert(is_tuple_callable<std::function<int(int, int)>,
-                                std::tuple<int, char>>::value,
-              "");
+static_assert(is_tuple_callable<std::function<int(int, int)>, std::tuple<int, char>>::value, "");
 
-template <typename F, typename... Args, int... Idxs>
-auto tuple_invoke_impl(F &&f, const std::tuple<Args...> &tp,
-                       index_sequence<Idxs...>) -> invoke_result_t<F, Args...> {
-  return invoke(std::forward<F>(f), std::forward<Args>(std::get<Idxs>(tp))...);
+template<typename F, typename... Args, int... Idxs>
+auto
+tuple_invoke_impl(F &&f, const std::tuple<Args...> &tp, index_sequence<Idxs...>) -> invoke_result_t<F, Args...>
+{
+    return invoke(std::forward<F>(f), std::forward<Args>(std::get<Idxs>(tp))...);
 }
 
-template <typename F, typename... Args, int... Idxs>
-auto tuple_invoke_impl(F &&f, std::tuple<Args...> &tp,
-                       index_sequence<Idxs...>) -> invoke_result_t<F, Args...> {
-  return invoke(std::forward<F>(f), std::forward<Args>(std::get<Idxs>(tp))...);
+template<typename F, typename... Args, int... Idxs>
+auto
+tuple_invoke_impl(F &&f, std::tuple<Args...> &tp, index_sequence<Idxs...>) -> invoke_result_t<F, Args...>
+{
+    return invoke(std::forward<F>(f), std::forward<Args>(std::get<Idxs>(tp))...);
 }
 
-template <typename F, typename... Args, int... Idxs>
-auto tuple_invoke_impl(F &&f, std::tuple<Args...> &&tp,
-                       index_sequence<Idxs...>) -> invoke_result_t<F, Args...> {
-  return invoke(std::forward<F>(f), std::forward<Args>(std::get<Idxs>(tp))...);
+template<typename F, typename... Args, int... Idxs>
+auto
+tuple_invoke_impl(F &&f, std::tuple<Args...> &&tp, index_sequence<Idxs...>) -> invoke_result_t<F, Args...>
+{
+    return invoke(std::forward<F>(f), std::forward<Args>(std::get<Idxs>(tp))...);
 }
 
-template <typename F, typename Tuple>
-auto tuple_invoke(F &&f, Tuple &&tp) -> tuple_invoke_result_t<F, Tuple> {
-  using RawTuple = remove_reference_t<remove_cvref_t<Tuple>>;
-  return tuple_invoke_impl(
-      std::forward<F>(f), std::forward<Tuple>(tp),
-      make_index_sequence_t<std::tuple_size<RawTuple>::value>{});
+template<typename F, typename Tuple>
+auto
+tuple_invoke(F &&f, Tuple &&tp) -> tuple_invoke_result_t<F, Tuple>
+{
+    using RawTuple = remove_reference_t<remove_cvref_t<Tuple>>;
+    return tuple_invoke_impl(
+        std::forward<F>(f), std::forward<Tuple>(tp), make_index_sequence_t<std::tuple_size<RawTuple>::value>{});
 }
 
-} // namespace apply
-} // namespace detail
+}// namespace apply
+}// namespace detail
 
-template <typename F, typename Tuple>
-auto apply(F &&f,
-           Tuple &&tp) -> detail::apply::tuple_invoke_result_t<F, Tuple> {
-  return detail::apply::tuple_invoke(std::forward<F>(f),
-                                     std::forward<Tuple>(tp));
+template<typename F, typename Tuple>
+auto
+apply(F &&f, Tuple &&tp) -> detail::apply::tuple_invoke_result_t<F, Tuple>
+{
+    return detail::apply::tuple_invoke(std::forward<F>(f), std::forward<Tuple>(tp));
 }
 
-} // namespace tile
+}// namespace tile
diff --git a/tile/base/internal/meta/base.h b/tile/base/internal/meta/base.h
index bc8772b..3fb4459 100644
--- a/tile/base/internal/meta/base.h
+++ b/tile/base/internal/meta/base.h
@@ -1,20 +1,22 @@
 #include <type_traits>
 
 namespace tile {
-template <typename T> struct remove_cvref {
-  using type =
-      typename std::remove_cv<typename std::remove_reference<T>::type>::type;
+template<typename T>
+struct remove_cvref {
+    using type = typename std::remove_cv<typename std::remove_reference<T>::type>::type;
 };
 
-template <typename T> using remove_cvref_t = typename remove_cvref<T>::type;
+template<typename T>
+using remove_cvref_t = typename remove_cvref<T>::type;
 
-template <typename T>
+template<typename T>
 using remove_reference_t = typename std::remove_reference<T>::type;
 
 // enable_if_t
-template <bool Enable, typename T = void>
+template<bool Enable, typename T = void>
 using enable_if_t = typename std::enable_if<Enable, T>::type;
 
-template <typename T> using decay_t = typename std::decay<T>::type;
+template<typename T>
+using decay_t = typename std::decay<T>::type;
 
-} // namespace tile
+}// namespace tile
diff --git a/tile/base/internal/meta/index_sequence.h b/tile/base/internal/meta/index_sequence.h
index ca0bc48..cc2e417 100644
--- a/tile/base/internal/meta/index_sequence.h
+++ b/tile/base/internal/meta/index_sequence.h
@@ -1,41 +1,37 @@
 #include <type_traits>
 
 namespace tile {
-template <int...> struct index_sequence {};
-template <int N, int... Us>
-struct make_index_sequence_helper
-    : public make_index_sequence_helper<N - 1, N - 1, Us...> {};
+template<int...>
+struct index_sequence {};
 
-template <> struct make_index_sequence_helper<0> {
-  using type = index_sequence<>;
+template<int N, int... Us>
+struct make_index_sequence_helper : public make_index_sequence_helper<N - 1, N - 1, Us...> {};
+
+template<>
+struct make_index_sequence_helper<0> {
+    using type = index_sequence<>;
 };
 
-template <int... Us> struct make_index_sequence_helper<0, Us...> {
-  using type = index_sequence<Us...>;
+template<int... Us>
+struct make_index_sequence_helper<0, Us...> {
+    using type = index_sequence<Us...>;
 };
 
-template <int N>
+template<int N>
 using make_index_sequence_t = typename make_index_sequence_helper<N>::type;
 
-template <typename... Ts, typename IS = make_index_sequence_t<sizeof...(Ts)>>
-IS index_sequence_for() {
-  return IS();
+template<typename... Ts, typename IS = make_index_sequence_t<sizeof...(Ts)>>
+IS
+index_sequence_for()
+{
+    return IS();
 }
 
-static_assert(std::is_same<make_index_sequence_t<0>, index_sequence<>>::value,
-              "");
-static_assert(std::is_same<make_index_sequence_t<1>, index_sequence<0>>::value,
-              "");
-static_assert(
-    std::is_same<make_index_sequence_t<2>, index_sequence<0, 1>>::value, "");
+static_assert(std::is_same<make_index_sequence_t<0>, index_sequence<>>::value, "");
+static_assert(std::is_same<make_index_sequence_t<1>, index_sequence<0>>::value, "");
+static_assert(std::is_same<make_index_sequence_t<2>, index_sequence<0, 1>>::value, "");
 
-static_assert(
-    std::is_same<decltype(index_sequence_for<>()), index_sequence<>>::value,
-    "");
-static_assert(
-    std::is_same<decltype(index_sequence_for<int>()), index_sequence<0>>::value,
-    "");
-static_assert(std::is_same<decltype(index_sequence_for<int, char>()),
-                           index_sequence<0, 1>>::value,
-              "");
-} // namespace tile
+static_assert(std::is_same<decltype(index_sequence_for<>()), index_sequence<>>::value, "");
+static_assert(std::is_same<decltype(index_sequence_for<int>()), index_sequence<0>>::value, "");
+static_assert(std::is_same<decltype(index_sequence_for<int, char>()), index_sequence<0, 1>>::value, "");
+}// namespace tile
diff --git a/tile/base/internal/meta/invoke.h b/tile/base/internal/meta/invoke.h
index bede55d..8daa87a 100644
--- a/tile/base/internal/meta/invoke.h
+++ b/tile/base/internal/meta/invoke.h
@@ -18,172 +18,187 @@ namespace detail {
 #define EGGS_FWD(...) static_cast<decltype(__VA_ARGS__) &&>(__VA_ARGS__)
 
 ///////////////////////////////////////////////////////////////////////////
-template <typename C, typename T, bool Ref, bool RefWrapper,
-          bool IsFunction = std::is_function<T>::value>
+template<typename C, typename T, bool Ref, bool RefWrapper, bool IsFunction = std::is_function<T>::value>
 struct invoke_mem_ptr;
 
 // when `pm` is a pointer to member of a class `C` and
 // `is_base_of_v<C, remove_reference_t<T>>` is `true`;
-template <typename C, typename T>
-struct invoke_mem_ptr<C, T, /*Ref=*/true, /*RefWrapper=*/false,
+template<typename C, typename T>
+struct invoke_mem_ptr<C,
+                      T,
+                      /*Ref=*/true,
+                      /*RefWrapper=*/false,
                       /*IsFunction=*/false> {
-  T C::*pm;
+    T C::*pm;
 
 #if !__cpp_aggregate_paren_init
-  constexpr invoke_mem_ptr(T C::*pm) noexcept : pm(pm) {}
+    constexpr invoke_mem_ptr(T C::*pm) noexcept : pm(pm) {}
 #endif
 
-  template <typename T1>
-  constexpr auto operator()(T1 &&t1) const
-      noexcept(noexcept(EGGS_FWD(t1).*pm)) -> decltype(EGGS_FWD(t1).*pm) {
-    return EGGS_FWD(t1).*pm;
-  }
+    template<typename T1>
+    constexpr auto operator()(T1 &&t1) const noexcept(noexcept(EGGS_FWD(t1).*pm)) -> decltype(EGGS_FWD(t1).*pm)
+    {
+        return EGGS_FWD(t1).*pm;
+    }
 };
 
-template <typename C, typename T>
-struct invoke_mem_ptr<C, T, /*Ref=*/true, /*RefWrapper=*/false,
+template<typename C, typename T>
+struct invoke_mem_ptr<C,
+                      T,
+                      /*Ref=*/true,
+                      /*RefWrapper=*/false,
                       /*IsFunction=*/true> {
-  T C::*pm;
+    T C::*pm;
 
 #if !__cpp_aggregate_paren_init
-  constexpr invoke_mem_ptr(T C::*pm) noexcept : pm(pm) {}
+    constexpr invoke_mem_ptr(T C::*pm) noexcept : pm(pm) {}
 #endif
 
-  template <typename T1, typename... Tn>
-  constexpr auto operator()(T1 &&t1, Tn &&...tn) const
-      noexcept(noexcept((EGGS_FWD(t1).*pm)(EGGS_FWD(tn)...)))
-          -> decltype((EGGS_FWD(t1).*pm)(EGGS_FWD(tn)...)) {
-    return (EGGS_FWD(t1).*pm)(EGGS_FWD(tn)...);
-  }
+    template<typename T1, typename... Tn>
+    constexpr auto operator()(T1 &&t1, Tn &&...tn) const
+        noexcept(noexcept((EGGS_FWD(t1).*pm)(EGGS_FWD(tn)...))) -> decltype((EGGS_FWD(t1).*pm)(EGGS_FWD(tn)...))
+    {
+        return (EGGS_FWD(t1).*pm)(EGGS_FWD(tn)...);
+    }
 };
 
 // when `pm` is a pointer to member of a class `C` and
 // `remove_cvref_t<T>` is a specialization of `reference_wrapper`;
-template <typename C, typename T>
-struct invoke_mem_ptr<C, T, /*Ref=*/false, /*RefWrapper=*/true,
+template<typename C, typename T>
+struct invoke_mem_ptr<C,
+                      T,
+                      /*Ref=*/false,
+                      /*RefWrapper=*/true,
                       /*IsFunction=*/false> {
-  T C::*pm;
+    T C::*pm;
 
 #if !__cpp_aggregate_paren_init
-  constexpr invoke_mem_ptr(T C::*pm) noexcept : pm(pm) {}
+    constexpr invoke_mem_ptr(T C::*pm) noexcept : pm(pm) {}
 #endif
 
-  template <typename T1>
-  constexpr auto operator()(T1 &&t1) const
-      noexcept(noexcept(t1.get().*pm)) -> decltype(t1.get().*pm) {
-    return t1.get().*pm;
-  }
+    template<typename T1>
+    constexpr auto operator()(T1 &&t1) const noexcept(noexcept(t1.get().*pm)) -> decltype(t1.get().*pm)
+    {
+        return t1.get().*pm;
+    }
 };
 
-template <typename C, typename T>
-struct invoke_mem_ptr<C, T, /*Ref=*/false, /*RefWrapper=*/true,
+template<typename C, typename T>
+struct invoke_mem_ptr<C,
+                      T,
+                      /*Ref=*/false,
+                      /*RefWrapper=*/true,
                       /*IsFunction=*/true> {
-  T C::*pm;
+    T C::*pm;
 
 #if !__cpp_aggregate_paren_init
-  constexpr invoke_mem_ptr(T C::*pm) noexcept : pm(pm) {}
+    constexpr invoke_mem_ptr(T C::*pm) noexcept : pm(pm) {}
 #endif
 
-  template <typename T1, typename... Tn>
-  constexpr auto operator()(T1 &&t1, Tn &&...tn) const
-      noexcept(noexcept((t1.get().*pm)(EGGS_FWD(tn)...)))
-          -> decltype((t1.get().*pm)(EGGS_FWD(tn)...)) {
-    return (t1.get().*pm)(EGGS_FWD(tn)...);
-  }
+    template<typename T1, typename... Tn>
+    constexpr auto operator()(T1 &&t1, Tn &&...tn) const
+        noexcept(noexcept((t1.get().*pm)(EGGS_FWD(tn)...))) -> decltype((t1.get().*pm)(EGGS_FWD(tn)...))
+    {
+        return (t1.get().*pm)(EGGS_FWD(tn)...);
+    }
 };
 
 // when `pm` is a pointer to member of a class `C` and `T` does not
 // satisfy the previous two items;
-template <typename C, typename T>
-struct invoke_mem_ptr<C, T, /*Ref=*/false, /*RefWrapper=*/false,
+template<typename C, typename T>
+struct invoke_mem_ptr<C,
+                      T,
+                      /*Ref=*/false,
+                      /*RefWrapper=*/false,
                       /*IsFunction=*/false> {
-  T C::*pm;
+    T C::*pm;
 
 #if !__cpp_aggregate_paren_init
-  constexpr invoke_mem_ptr(T C::*pm) noexcept : pm(pm) {}
+    constexpr invoke_mem_ptr(T C::*pm) noexcept : pm(pm) {}
 #endif
 
-  template <typename T1>
-  constexpr auto operator()(T1 &&t1) const
-      noexcept(noexcept((*EGGS_FWD(t1)).*pm)) -> decltype((*EGGS_FWD(t1)).*pm) {
-    return (*EGGS_FWD(t1)).*pm;
-  }
+    template<typename T1>
+    constexpr auto operator()(T1 &&t1) const noexcept(noexcept((*EGGS_FWD(t1)).*pm)) -> decltype((*EGGS_FWD(t1)).*pm)
+    {
+        return (*EGGS_FWD(t1)).*pm;
+    }
 };
 
-template <typename C, typename T>
-struct invoke_mem_ptr<C, T, /*Ref=*/false, /*RefWrapper=*/false,
+template<typename C, typename T>
+struct invoke_mem_ptr<C,
+                      T,
+                      /*Ref=*/false,
+                      /*RefWrapper=*/false,
                       /*IsFunction=*/true> {
-  T C::*pm;
+    T C::*pm;
 
 #if !__cpp_aggregate_paren_init
-  constexpr invoke_mem_ptr(T C::*pm) noexcept : pm(pm) {}
+    constexpr invoke_mem_ptr(T C::*pm) noexcept : pm(pm) {}
 #endif
 
-  template <typename T1, typename... Tn>
-  constexpr auto operator()(T1 &&t1, Tn &&...tn) const
-      noexcept(noexcept(((*EGGS_FWD(t1)).*pm)(EGGS_FWD(tn)...)))
-          -> decltype(((*EGGS_FWD(t1)).*pm)(EGGS_FWD(tn)...)) {
-    return ((*EGGS_FWD(t1)).*pm)(EGGS_FWD(tn)...);
-  }
+    template<typename T1, typename... Tn>
+    constexpr auto operator()(T1 &&t1, Tn &&...tn) const
+        noexcept(noexcept(((*EGGS_FWD(t1)).*pm)(EGGS_FWD(tn)...))) -> decltype(((*EGGS_FWD(t1)).*pm)(EGGS_FWD(tn)...))
+    {
+        return ((*EGGS_FWD(t1)).*pm)(EGGS_FWD(tn)...);
+    }
 };
 
 ///////////////////////////////////////////////////////////////////////////
-template <typename F> auto invoke(F &&, ...) -> F &&;
+template<typename F>
+auto invoke(F &&, ...) -> F &&;
 
-template <typename T, typename C, typename T1>
-auto invoke(T C::*, T1 const &,
-            ...) -> invoke_mem_ptr<C, T,
-                                   /*Ref=*/std::is_base_of<C, T1>::value,
-                                   /*RefWrapper=*/false>;
+template<typename T, typename C, typename T1>
+auto invoke(T C::*, T1 const &, ...) -> invoke_mem_ptr<C,
+                                                       T,
+                                                       /*Ref=*/std::is_base_of<C, T1>::value,
+                                                       /*RefWrapper=*/false>;
 
-template <typename T, typename C, typename X>
-auto invoke(T C::*, std::reference_wrapper<X>,
-            ...) -> invoke_mem_ptr<C, T,
-                                   /*Ref=*/false,
-                                   /*RefWrapper=*/true>;
+template<typename T, typename C, typename X>
+auto invoke(T C::*, std::reference_wrapper<X>, ...)
+    -> invoke_mem_ptr<C,
+                      T,
+                      /*Ref=*/false,
+                      /*RefWrapper=*/true>;
 
 //! EGGS_INVOKE(F, ...)
 //!
 //! - _Returns_: `INVOKE(F __VA_OPT__(,) __VA_ARGS__)`.
-#if __cplusplus > 201703L // C++20: P0306
-#define EGGS_INVOKE(F, ...)                                                    \
-  (static_cast<decltype(::eggs::detail::invoke(                                \
-       F __VA_OPT__(, ) __VA_ARGS__))>(F)(__VA_ARGS__))
+#if __cplusplus > 201703L// C++20: P0306
+#define EGGS_INVOKE(F, ...)                                                                                            \
+    (static_cast<decltype(::eggs::detail::invoke(F __VA_OPT__(, ) __VA_ARGS__))>(F)(__VA_ARGS__))
 #elif _MSVC_TRADITIONAL
-#define EGGS_INVOKE(F, ...)                                                    \
-  (static_cast<decltype(::eggs::detail::invoke(F, __VA_ARGS__))>(F)(           \
-      __VA_ARGS__))
+#define EGGS_INVOKE(F, ...) (static_cast<decltype(::eggs::detail::invoke(F, __VA_ARGS__))>(F)(__VA_ARGS__))
 #else
-#define EGGS_INVOKE(F, ...)                                                    \
-  (static_cast<decltype(::eggs::detail::invoke(F, ##__VA_ARGS__))>(F)(         \
-      __VA_ARGS__))
+#define EGGS_INVOKE(F, ...) (static_cast<decltype(::eggs::detail::invoke(F, ##__VA_ARGS__))>(F)(__VA_ARGS__))
 #endif
 
 ///////////////////////////////////////////////////////////////////////////
 // `INVOKE(f, t1, t2, ..., tN)` implicitly converted to `R`.
-template <typename R, typename RD = typename std::remove_cv<R>::type>
+template<typename R, typename RD = typename std::remove_cv<R>::type>
 struct invoke_r {
 private:
-  static R conversion(R) noexcept;
+    static R conversion(R) noexcept;
 
 public:
-  template <typename F, typename... Args>
-  static constexpr auto call(F &&f, Args &&...args) noexcept(
-      noexcept(conversion(EGGS_INVOKE(EGGS_FWD(f), EGGS_FWD(args)...))))
-      -> decltype(conversion(EGGS_INVOKE(EGGS_FWD(f), EGGS_FWD(args)...))) {
-    return EGGS_INVOKE(EGGS_FWD(f), EGGS_FWD(args)...);
-  }
+    template<typename F, typename... Args>
+    static constexpr auto
+    call(F &&f, Args &&...args) noexcept(noexcept(conversion(EGGS_INVOKE(EGGS_FWD(f), EGGS_FWD(args)...))))
+        -> decltype(conversion(EGGS_INVOKE(EGGS_FWD(f), EGGS_FWD(args)...)))
+    {
+        return EGGS_INVOKE(EGGS_FWD(f), EGGS_FWD(args)...);
+    }
 };
 
 // `static_cast<void>(INVOKE(f, t1, t2, ..., tN))` if `R` is _cv_ `void`.
-template <typename R> struct invoke_r<R, void> {
-  template <typename F, typename... Args>
-  static constexpr auto call(F &&f, Args &&...args) noexcept(
-      noexcept(EGGS_INVOKE(EGGS_FWD(f), EGGS_FWD(args)...)))
-      -> decltype(static_cast<void>(EGGS_INVOKE(EGGS_FWD(f),
-                                                EGGS_FWD(args)...))) {
-    return static_cast<void>(EGGS_INVOKE(EGGS_FWD(f), EGGS_FWD(args)...));
-  }
+template<typename R>
+struct invoke_r<R, void> {
+    template<typename F, typename... Args>
+    static constexpr auto call(F &&f, Args &&...args) noexcept(noexcept(EGGS_INVOKE(EGGS_FWD(f), EGGS_FWD(args)...)))
+        -> decltype(static_cast<void>(EGGS_INVOKE(EGGS_FWD(f), EGGS_FWD(args)...)))
+    {
+        return static_cast<void>(EGGS_INVOKE(EGGS_FWD(f), EGGS_FWD(args)...));
+    }
 };
 
 //! EGGS_INVOKE(R, F, ...)
@@ -191,21 +206,20 @@ template <typename R> struct invoke_r<R, void> {
 //! - _Returns_: `INVOKE<R>(F __VA_OPT__(,) __VA_ARGS__)`.
 #define EGGS_INVOKE_R(R, ...) (::eggs::detail::invoke_r<R>::call(__VA_ARGS__))
 
-} // namespace detail
-} // namespace eggs
+}// namespace detail
+}// namespace eggs
 
 namespace eggs {
 ///////////////////////////////////////////////////////////////////////////
 namespace detail {
-template <typename T, typename Enable = void> struct invoke_result_impl {};
+template<typename T, typename Enable = void>
+struct invoke_result_impl {};
 
-template <typename F, typename... Ts>
-struct invoke_result_impl<F(Ts...),
-                          decltype((void)EGGS_INVOKE(std::declval<F>(),
-                                                     std::declval<Ts>()...))> {
-  using type = decltype(EGGS_INVOKE(std::declval<F>(), std::declval<Ts>()...));
+template<typename F, typename... Ts>
+struct invoke_result_impl<F(Ts...), decltype((void) EGGS_INVOKE(std::declval<F>(), std::declval<Ts>()...))> {
+    using type = decltype(EGGS_INVOKE(std::declval<F>(), std::declval<Ts>()...));
 };
-} // namespace detail
+}// namespace detail
 
 //! template <class Fn, class... ArgTypes> struct invoke_result;
 //!
@@ -220,25 +234,23 @@ struct invoke_result_impl<F(Ts...),
 //! - _Preconditions_: `Fn` and all types in the template parameter pack
 //!   `ArgTypes` are complete types, _cv_ `void`, or arrays of unknown
 //!   bound.
-template <typename Fn, typename... ArgTypes>
+template<typename Fn, typename... ArgTypes>
 struct invoke_result : detail::invoke_result_impl<Fn && (ArgTypes && ...)> {};
 
 //! template <class Fn, class... ArgTypes>
 //! using invoke_result_t = typename invoke_result<Fn, ArgTypes...>::type;
-template <typename Fn, typename... ArgTypes>
+template<typename Fn, typename... ArgTypes>
 using invoke_result_t = typename invoke_result<Fn, ArgTypes...>::type;
 
 ///////////////////////////////////////////////////////////////////////////
 namespace detail {
-template <typename T, typename Enable = void>
+template<typename T, typename Enable = void>
 struct is_invocable_impl : std::false_type {};
 
-template <typename F, typename... Ts>
-struct is_invocable_impl<F(Ts...),
-                         decltype((void)EGGS_INVOKE(std::declval<F>(),
-                                                    std::declval<Ts>()...))>
+template<typename F, typename... Ts>
+struct is_invocable_impl<F(Ts...), decltype((void) EGGS_INVOKE(std::declval<F>(), std::declval<Ts>()...))>
     : std::true_type {};
-} // namespace detail
+}// namespace detail
 
 //! template <class Fn, class... ArgTypes> struct is_invocable;
 //!
@@ -249,15 +261,14 @@ struct is_invocable_impl<F(Ts...),
 //! - _Comments_: `Fn` and all types in the template parameter pack
 //!   `ArgTypes` shall be complete types, _cv_ `void`, or arrays of
 //!   unknown bound.
-template <typename Fn, typename... ArgTypes>
-struct is_invocable : detail::is_invocable_impl<Fn && (ArgTypes && ...)>::type {
-};
+template<typename Fn, typename... ArgTypes>
+struct is_invocable : detail::is_invocable_impl<Fn && (ArgTypes && ...)>::type {};
 
 #if __cpp_variable_templates
 //! template <class Fn, class... ArgTypes> // (C++14)
 //! inline constexpr bool is_invocable_v =
 //!     eggs::is_invocable<Fn, ArgTypes...>::value;
-template <typename Fn, typename... ArgTypes>
+template<typename Fn, typename... ArgTypes>
 #if __cpp_inline_variables
 inline
 #endif
@@ -266,15 +277,13 @@ inline
 
 ///////////////////////////////////////////////////////////////////////////
 namespace detail {
-template <typename T, typename R, typename Enable = void>
+template<typename T, typename R, typename Enable = void>
 struct is_invocable_r_impl : std::false_type {};
 
-template <typename F, typename... Ts, typename R>
-struct is_invocable_r_impl<F(Ts...), R,
-                           decltype((void)EGGS_INVOKE_R(R, std::declval<F>(),
-                                                        std::declval<Ts>()...))>
+template<typename F, typename... Ts, typename R>
+struct is_invocable_r_impl<F(Ts...), R, decltype((void) EGGS_INVOKE_R(R, std::declval<F>(), std::declval<Ts>()...))>
     : std::true_type {};
-} // namespace detail
+}// namespace detail
 
 //! template <class R, class Fn, class... ArgTypes> struct is_invocable_r;
 //!
@@ -285,15 +294,14 @@ struct is_invocable_r_impl<F(Ts...), R,
 //! - _Comments_: `Fn`, `R`, and all types in the template parameter pack
 //!   `ArgTypes` shall be complete types, _cv_ `void`, or arrays of
 //!   unknown bound.
-template <typename R, typename Fn, typename... ArgTypes>
-struct is_invocable_r
-    : detail::is_invocable_r_impl<Fn && (ArgTypes && ...), R>::type {};
+template<typename R, typename Fn, typename... ArgTypes>
+struct is_invocable_r : detail::is_invocable_r_impl<Fn && (ArgTypes && ...), R>::type {};
 
 #if __cpp_variable_templates
 //! template <class R, class Fn, class... ArgTypes> // (C++14)
 //! inline constexpr bool is_invocable_r_v =
 //!     eggs::is_invocable_r<R, Fn, ArgTypes...>::value;
-template <typename R, typename Fn, typename... ArgTypes>
+template<typename R, typename Fn, typename... ArgTypes>
 #if __cpp_inline_variables
 inline
 #endif
@@ -302,17 +310,13 @@ inline
 
 ///////////////////////////////////////////////////////////////////////////
 namespace detail {
-template <typename T, typename Enable = void>
+template<typename T, typename Enable = void>
 struct is_nothrow_invocable_impl : std::false_type {};
 
-template <typename F, typename... Ts>
-struct is_nothrow_invocable_impl<F(Ts...),
-                                 decltype((void)EGGS_INVOKE(
-                                     std::declval<F>(), std::declval<Ts>()...))>
-    : std::integral_constant<bool,
-                             noexcept(EGGS_INVOKE(std::declval<F>(),
-                                                  std::declval<Ts>()...))> {};
-} // namespace detail
+template<typename F, typename... Ts>
+struct is_nothrow_invocable_impl<F(Ts...), decltype((void) EGGS_INVOKE(std::declval<F>(), std::declval<Ts>()...))>
+    : std::integral_constant<bool, noexcept(EGGS_INVOKE(std::declval<F>(), std::declval<Ts>()...))> {};
+}// namespace detail
 
 //! template <class Fn, class... ArgTypes> struct is_nothrow_invocable;
 //!
@@ -323,35 +327,31 @@ struct is_nothrow_invocable_impl<F(Ts...),
 //! - _Comments_: `Fn` and all types in the template parameter pack
 //!   `ArgTypes` shall be complete types, _cv_ `void`, or arrays of
 //!   unknown bound.
-template <typename Fn, typename... ArgTypes>
-struct is_nothrow_invocable
-    : detail::is_nothrow_invocable_impl<Fn && (ArgTypes && ...)>::type {};
+template<typename Fn, typename... ArgTypes>
+struct is_nothrow_invocable : detail::is_nothrow_invocable_impl<Fn && (ArgTypes && ...)>::type {};
 
 #if __cpp_variable_templates
 //! template <class Fn, class... ArgTypes> // (C++14)
 //! inline constexpr bool is_nothrow_invocable_v =
 //!     eggs::is_nothrow_invocable<Fn, ArgTypes...>::value;
-template <typename Fn, typename... ArgTypes>
+template<typename Fn, typename... ArgTypes>
 #if __cpp_inline_variables
 inline
 #endif
-    constexpr bool is_nothrow_invocable_v =
-        is_nothrow_invocable<Fn, ArgTypes...>::value;
+    constexpr bool is_nothrow_invocable_v = is_nothrow_invocable<Fn, ArgTypes...>::value;
 #endif
 
 ///////////////////////////////////////////////////////////////////////////
 namespace detail {
-template <typename T, typename R, typename Enable = void>
+template<typename T, typename R, typename Enable = void>
 struct is_nothrow_invocable_r_impl : std::false_type {};
 
-template <typename F, typename... Ts, typename R>
-struct is_nothrow_invocable_r_impl<
-    F(Ts...), R,
-    decltype((void)EGGS_INVOKE_R(R, std::declval<F>(), std::declval<Ts>()...))>
-    : std::integral_constant<bool,
-                             noexcept(EGGS_INVOKE_R(R, std::declval<F>(),
-                                                    std::declval<Ts>()...))> {};
-} // namespace detail
+template<typename F, typename... Ts, typename R>
+struct is_nothrow_invocable_r_impl<F(Ts...),
+                                   R,
+                                   decltype((void) EGGS_INVOKE_R(R, std::declval<F>(), std::declval<Ts>()...))>
+    : std::integral_constant<bool, noexcept(EGGS_INVOKE_R(R, std::declval<F>(), std::declval<Ts>()...))> {};
+}// namespace detail
 
 //! template <class R, class Fn, class... ArgTypes> struct
 //! is_nothrow_invocable_r;
@@ -363,20 +363,18 @@ struct is_nothrow_invocable_r_impl<
 //! - _Comments_: `Fn`, `R`, and all types in the template parameter pack
 //!   `ArgTypes` shall be complete types, _cv_ `void`, or arrays of
 //!   unknown bound.
-template <typename R, typename Fn, typename... ArgTypes>
-struct is_nothrow_invocable_r
-    : detail::is_nothrow_invocable_r_impl<Fn && (ArgTypes && ...), R>::type {};
+template<typename R, typename Fn, typename... ArgTypes>
+struct is_nothrow_invocable_r : detail::is_nothrow_invocable_r_impl<Fn && (ArgTypes && ...), R>::type {};
 
 #if __cpp_variable_templates
 //! template <class R, class Fn, class... ArgTypes> // (C++14)
 //! inline constexpr bool is_nothrow_invocable_r_v =
 //!     eggs::is_nothrow_invocable_r<R, Fn, ArgTypes...>::value;
-template <typename R, typename Fn, typename... ArgTypes>
+template<typename R, typename Fn, typename... ArgTypes>
 #if __cpp_inline_variables
 inline
 #endif
-    constexpr bool is_nothrow_invocable_r_v =
-        is_nothrow_invocable_r<R, Fn, ArgTypes...>::value;
+    constexpr bool is_nothrow_invocable_r_v = is_nothrow_invocable_r<R, Fn, ArgTypes...>::value;
 #endif
 
 ///////////////////////////////////////////////////////////////////////////
@@ -388,11 +386,12 @@ inline
 //!
 //! - _Remarks_: This function shall not participate in overload resolution
 //!   unless `eggs::is_invocable_v<F, Args...>` is `true`.
-template <typename Fn, typename... ArgTypes>
-constexpr auto invoke(Fn &&f, ArgTypes &&...args) noexcept(
-    noexcept(EGGS_INVOKE(EGGS_FWD(f), EGGS_FWD(args)...)))
-    -> decltype(EGGS_INVOKE(EGGS_FWD(f), EGGS_FWD(args)...)) {
-  return EGGS_INVOKE(EGGS_FWD(f), EGGS_FWD(args)...);
+template<typename Fn, typename... ArgTypes>
+constexpr auto
+invoke(Fn &&f, ArgTypes &&...args) noexcept(noexcept(EGGS_INVOKE(EGGS_FWD(f), EGGS_FWD(args)...)))
+    -> decltype(EGGS_INVOKE(EGGS_FWD(f), EGGS_FWD(args)...))
+{
+    return EGGS_INVOKE(EGGS_FWD(f), EGGS_FWD(args)...);
 }
 
 ///////////////////////////////////////////////////////////////////////////
@@ -404,15 +403,16 @@ constexpr auto invoke(Fn &&f, ArgTypes &&...args) noexcept(
 //!
 //! - _Remarks_: This function shall not participate in overload resolution
 //!   unless `eggs::is_invocable_r_v<R, F, Args...>` is `true`.
-template <typename R, typename Fn, typename... ArgTypes>
-constexpr auto invoke_r(Fn &&f, ArgTypes &&...args) noexcept(
-    noexcept(EGGS_INVOKE_R(R, EGGS_FWD(f), EGGS_FWD(args)...)))
-    -> decltype(EGGS_INVOKE_R(R, EGGS_FWD(f), EGGS_FWD(args)...)) {
-  return EGGS_INVOKE_R(R, EGGS_FWD(f), EGGS_FWD(args)...);
+template<typename R, typename Fn, typename... ArgTypes>
+constexpr auto
+invoke_r(Fn &&f, ArgTypes &&...args) noexcept(noexcept(EGGS_INVOKE_R(R, EGGS_FWD(f), EGGS_FWD(args)...)))
+    -> decltype(EGGS_INVOKE_R(R, EGGS_FWD(f), EGGS_FWD(args)...))
+{
+    return EGGS_INVOKE_R(R, EGGS_FWD(f), EGGS_FWD(args)...);
 }
 
 #undef EGGS_FWD
-} // namespace eggs
+}// namespace eggs
 
 namespace tile {
 using namespace eggs;
diff --git a/tile/base/internal/meta_test.cc b/tile/base/internal/meta_test.cc
index e2767a1..b9400ce 100644
--- a/tile/base/internal/meta_test.cc
+++ b/tile/base/internal/meta_test.cc
@@ -6,60 +6,80 @@ namespace tile {
 namespace internal {
 
 // no ret function
-void F0() {}
-void F1(int) {}
-void F2(int, char) {}
-int F3(int, char) { return 0; }
+void
+F0()
+{}
+
+void
+F1(int)
+{}
+
+void
+F2(int, char)
+{}
+
+int
+F3(int, char)
+{
+    return 0;
+}
+
 static auto LF0 = []() {};
 static auto LF1 = [](int) {};
 static auto LF2 = [](int, char) {};
 
 class A {
 public:
-  void F0() {}
-  int F1(int v) { return v; }
-  std::pair<int, char> F2(int v, char c) { return {v, c}; }
+    void F0() {}
+
+    int F1(int v) { return v; }
+
+    std::pair<int, char> F2(int v, char c) { return {v, c}; }
 };
 
 struct VoidFunctor {
-  void operator()() {}
+    void operator()() {}
 };
+
 struct IntFunctor {
-  int operator()(int a) { return a; }
+    int operator()(int a) { return a; }
 };
 
-TEST(apply, Function) {
+TEST(apply, Function)
+{
 
-  auto p0 = std::make_tuple();
-  auto p1 = std::make_tuple(1);
-  auto p2 = std::make_tuple(1, 'a');
-  apply(F0, std::make_tuple());
-  apply(F1, std::make_tuple(1));
-  apply(F2, std::make_tuple(1, 'a'));
-  apply(LF0, std::make_tuple());
-  apply(LF1, std::make_tuple(1));
-  apply(LF2, std::make_tuple(1, 'a'));
+    auto p0 = std::make_tuple();
+    auto p1 = std::make_tuple(1);
+    auto p2 = std::make_tuple(1, 'a');
+    apply(F0, std::make_tuple());
+    apply(F1, std::make_tuple(1));
+    apply(F2, std::make_tuple(1, 'a'));
+    apply(LF0, std::make_tuple());
+    apply(LF1, std::make_tuple(1));
+    apply(LF2, std::make_tuple(1, 'a'));
 }
 
-TEST(apply, MemFunction) {
-  A a;
-  auto p0 = std::make_tuple();
-  auto p1 = std::make_tuple(1);
-  auto p2 = std::make_tuple(1, 'a');
-  apply(&A::F0, std::make_tuple(a));
-  auto r1 = apply(&A::F1, std::make_tuple(a, 1));
-  auto r2 = apply(&A::F2, std::make_tuple(&a, 1, 'a'));
-  ASSERT_EQ(1, r1);
-  ASSERT_EQ(1, r2.first);
-  ASSERT_EQ('a', r2.second);
+TEST(apply, MemFunction)
+{
+    A a;
+    auto p0 = std::make_tuple();
+    auto p1 = std::make_tuple(1);
+    auto p2 = std::make_tuple(1, 'a');
+    apply(&A::F0, std::make_tuple(a));
+    auto r1 = apply(&A::F1, std::make_tuple(a, 1));
+    auto r2 = apply(&A::F2, std::make_tuple(&a, 1, 'a'));
+    ASSERT_EQ(1, r1);
+    ASSERT_EQ(1, r2.first);
+    ASSERT_EQ('a', r2.second);
 }
 
-TEST(apply, IntFunctor) {
-  IntFunctor f;
-  auto p1 = std::make_tuple(1);
-  auto r1 = apply(f, p1);
-  ASSERT_EQ(1, r1);
+TEST(apply, IntFunctor)
+{
+    IntFunctor f;
+    auto p1 = std::make_tuple(1);
+    auto r1 = apply(f, p1);
+    ASSERT_EQ(1, r1);
 }
 
-} // namespace internal
-} // namespace tile
+}// namespace internal
+}// namespace tile
diff --git a/tile/base/internal/move_on_copy.h b/tile/base/internal/move_on_copy.h
index e7ee176..f22166f 100644
--- a/tile/base/internal/move_on_copy.h
+++ b/tile/base/internal/move_on_copy.h
@@ -8,59 +8,64 @@
 #include <memory>
 
 namespace tile {
-template <typename T> class MoveOnCopy {
+template<typename T>
+class MoveOnCopy {
 public:
-  MoveOnCopy() = delete;
-  MoveOnCopy(T &&x) : value_(make_unique<T>(std::move(x))) {}
-  MoveOnCopy(T &other) : value_{std::move(other)} { other.value_ = nullptr; }
+    MoveOnCopy() = delete;
 
-  MoveOnCopy(const MoveOnCopy &other) : value_(std::move(other.value_)) {
-    other.value_ = nullptr;
-  }
-  // MoveOnCopy &operator=(const MoveOnCopy &other) = delete;
-  MoveOnCopy(MoveOnCopy &other) : value_{std::move(other.value_)} {
-    other.value_ = nullptr;
-  }
-  MoveOnCopy(MoveOnCopy &&other) : value_{std::move(other.value_)} {
-    other.value_ = nullptr;
-  }
+    MoveOnCopy(T &&x) : value_(make_unique<T>(std::move(x))) {}
 
-  MoveOnCopy &operator=(MoveOnCopy &other) {
-    if (this != &other) {
-      value_ = std::move(other.value_);
-      other.value_ = nullptr;
+    MoveOnCopy(T &other) : value_{std::move(other)} { other.value_ = nullptr; }
+
+    MoveOnCopy(const MoveOnCopy &other) : value_(std::move(other.value_)) { other.value_ = nullptr; }
+
+    // MoveOnCopy &operator=(const MoveOnCopy &other) = delete;
+    MoveOnCopy(MoveOnCopy &other) : value_{std::move(other.value_)} { other.value_ = nullptr; }
+
+    MoveOnCopy(MoveOnCopy &&other) : value_{std::move(other.value_)} { other.value_ = nullptr; }
+
+    MoveOnCopy &operator=(MoveOnCopy &other)
+    {
+        if (this != &other) {
+            value_       = std::move(other.value_);
+            other.value_ = nullptr;
+        }
+        return *this;
     }
-    return *this;
-  }
-  MoveOnCopy &operator=(MoveOnCopy &&other) {
-    if (this != &other) {
-      value_ = std::move(other.value_);
-      other.value_ = nullptr;
+
+    MoveOnCopy &operator=(MoveOnCopy &&other)
+    {
+        if (this != &other) {
+            value_       = std::move(other.value_);
+            other.value_ = nullptr;
+        }
+        return *this;
     }
-    return *this;
-  }
 
-  T &Ref() const {
-    TILE_CHECK(value_ != nullptr);
-    return *value_;
-  }
+    T &Ref() const
+    {
+        TILE_CHECK(value_ != nullptr);
+        return *value_;
+    }
 
-  T &&Move() const { return std::move(Ref()); }
+    T &&Move() const { return std::move(Ref()); }
 
-  T *operator->() { return &Ref(); }
+    T *operator->() { return &Ref(); }
 
-  operator bool() const noexcept { return value_ != nullptr; }
-  bool operator!() const noexcept { return !value_; }
+    operator bool() const noexcept { return value_ != nullptr; }
+
+    bool operator!() const noexcept { return !value_; }
 
 private:
-  mutable std::unique_ptr<T> value_;
+    mutable std::unique_ptr<T> value_;
 };
 
-template <typename T>
-auto MakeMoveOnCopy(T &&value)
-    -> MoveOnCopy<remove_reference_t<remove_cvref_t<T>>> {
-  return MoveOnCopy<remove_reference_t<remove_cvref_t<T>>>{std::move(value)};
+template<typename T>
+auto
+MakeMoveOnCopy(T &&value) -> MoveOnCopy<remove_reference_t<remove_cvref_t<T>>>
+{
+    return MoveOnCopy<remove_reference_t<remove_cvref_t<T>>>{std::move(value)};
 }
-} // namespace tile
+}// namespace tile
 
-#endif // TILE_BASE_INTERNAL_MOVE_ON_COPY_H
+#endif// TILE_BASE_INTERNAL_MOVE_ON_COPY_H
diff --git a/tile/base/internal/move_on_copy_test.cc b/tile/base/internal/move_on_copy_test.cc
index 54e5d37..0aab3d3 100644
--- a/tile/base/internal/move_on_copy_test.cc
+++ b/tile/base/internal/move_on_copy_test.cc
@@ -12,52 +12,57 @@
 #include <thread>
 
 using MoveOnlyType = std::unique_ptr<int>;
+
 namespace tile {
 
-TEST(MoveOnCopy, Construct) {
-  // from lvalue
-  MoveOnlyType x = make_unique<int>(1);
-  auto moved_x = MakeMoveOnCopy(x);
-  EXPECT_EQ(*moved_x.Ref(), 1);
+TEST(MoveOnCopy, Construct)
+{
+    // from lvalue
+    MoveOnlyType x = make_unique<int>(1);
+    auto moved_x   = MakeMoveOnCopy(x);
+    EXPECT_EQ(*moved_x.Ref(), 1);
 }
 
-TEST(MoveOnCopy, Copy) {
-  // from rvalue
-  MoveOnlyType x = make_unique<int>(1);
-  auto moved_x = MakeMoveOnCopy(std::move(x));
-  auto moved_x2 = moved_x;
-  EXPECT_EQ(*moved_x2.Ref(), 1);
+TEST(MoveOnCopy, Copy)
+{
+    // from rvalue
+    MoveOnlyType x = make_unique<int>(1);
+    auto moved_x   = MakeMoveOnCopy(std::move(x));
+    auto moved_x2  = moved_x;
+    EXPECT_EQ(*moved_x2.Ref(), 1);
 }
 
-TEST(MoveOnCopy, Lambda) {
-  MoveOnlyType x = make_unique<int>(1);
-  auto moved_x = MakeMoveOnCopy(x);
-  auto l1 = [moved_x]() mutable { return *moved_x.Ref(); };
-  auto l2 = l1;
-  auto l3 = std::move(l2);
-  ASSERT_DEATH(l1(), ".*");
-  ASSERT_DEATH(l2(), ".*");
-  ASSERT_EQ(l3(), 1);
+TEST(MoveOnCopy, Lambda)
+{
+    MoveOnlyType x = make_unique<int>(1);
+    auto moved_x   = MakeMoveOnCopy(x);
+    auto l1        = [moved_x]() mutable { return *moved_x.Ref(); };
+    auto l2        = l1;
+    auto l3        = std::move(l2);
+    ASSERT_DEATH(l1(), ".*");
+    ASSERT_DEATH(l2(), ".*");
+    ASSERT_EQ(l3(), 1);
 }
 
-TEST(MoveOnCopy, LambdaWithRef) {
-  auto x = make_unique<int>(1);
-  auto moved_x = MakeMoveOnCopy(x);
-  int v = 0;
+TEST(MoveOnCopy, LambdaWithRef)
+{
+    auto x       = make_unique<int>(1);
+    auto moved_x = MakeMoveOnCopy(x);
+    int v        = 0;
 
-  Mutex m;
-  CondVar cv;
+    Mutex m;
+    CondVar cv;
 
-  auto l1 = [&]() {
+    auto l1 = [&]() {
+        ScopedLock l(m);
+        v = *moved_x.Ref();
+        cv.NotifyOne();
+    };
+
+    std::thread(l1).detach();
     ScopedLock l(m);
-    v = *moved_x.Ref();
-    cv.NotifyOne();
-  };
-
-  std::thread(l1).detach();
-  ScopedLock l(m);
-  cv.Wait(l, [&] { return v != 0; });
-  ASSERT_EQ(v, 1);
+    cv.Wait(l, [&] { return v != 0; });
+    ASSERT_EQ(v, 1);
 }
 
-} // namespace tile
+}// namespace tile
diff --git a/tile/base/internal/mutex.h b/tile/base/internal/mutex.h
index 37775db..48e20fb 100644
--- a/tile/base/internal/mutex.h
+++ b/tile/base/internal/mutex.h
@@ -8,25 +8,25 @@
 #include <vector>
 
 namespace tile {
-template <typename T, typename = void> struct MutexTraits {
-  static_assert(sizeof(T) == 0, "T is not lockable");
+template<typename T, typename = void>
+struct MutexTraits {
+    static_assert(sizeof(T) == 0, "T is not lockable");
 };
 
 namespace detail {
 namespace thread {
-#define TILE_DETAIL_DEFINE_HAS_FUNCTOIN_TRAITS(FuncName, Ret)                  \
-  template <typename C> class has_##FuncName##_fn {                            \
-    template <typename U,                                                      \
-              typename = enable_if_t<std::is_same<                             \
-                  decltype(std::declval<U>().FuncName()), Ret>::value>>        \
-    static int Test(int);                                                      \
-                                                                               \
-    template <typename> static char Test(...);                                 \
-                                                                               \
-  public:                                                                      \
-    static constexpr bool value =                                              \
-        std::is_same<int, decltype(Test<C>(0))>::value;                        \
-  };
+#define TILE_DETAIL_DEFINE_HAS_FUNCTOIN_TRAITS(FuncName, Ret)                                                          \
+    template<typename C>                                                                                               \
+    class has_##FuncName##_fn {                                                                                        \
+        template<typename U, typename = enable_if_t<std::is_same<decltype(std::declval<U>().FuncName()), Ret>::value>> \
+        static int Test(int);                                                                                          \
+                                                                                                                       \
+        template<typename>                                                                                             \
+        static char Test(...);                                                                                         \
+                                                                                                                       \
+    public:                                                                                                            \
+        static constexpr bool value = std::is_same<int, decltype(Test<C>(0))>::value;                                  \
+    };
 
 #define TILE_DETAIL_HAS_FUNCTON_VALUE(FuncName, T) has_##FuncName##_fn<T>::value
 
@@ -38,172 +38,230 @@ TILE_DETAIL_DEFINE_HAS_FUNCTOIN_TRAITS(lock, void);
 TILE_DETAIL_DEFINE_HAS_FUNCTOIN_TRAITS(unlock, void);
 TILE_DETAIL_DEFINE_HAS_FUNCTOIN_TRAITS(try_lock, bool);
 
-template <typename T> struct Lockable {
-  static constexpr bool value = TILE_DETAIL_HAS_FUNCTON_VALUE(Lock, T);
+template<typename T>
+struct Lockable {
+    static constexpr bool value = TILE_DETAIL_HAS_FUNCTON_VALUE(Lock, T);
 };
 
-template <typename T> struct lockable {
-  static constexpr bool value = TILE_DETAIL_HAS_FUNCTON_VALUE(lock, T);
+template<typename T>
+struct lockable {
+    static constexpr bool value = TILE_DETAIL_HAS_FUNCTON_VALUE(lock, T);
 };
 
-template <typename T> struct Unlockable {
-  static constexpr bool value = TILE_DETAIL_HAS_FUNCTON_VALUE(Unlock, T);
-};
-template <typename T> struct unlockable {
-  static constexpr bool value = TILE_DETAIL_HAS_FUNCTON_VALUE(unlock, T);
+template<typename T>
+struct Unlockable {
+    static constexpr bool value = TILE_DETAIL_HAS_FUNCTON_VALUE(Unlock, T);
 };
 
-template <typename T> struct TryLockable {
-  static constexpr bool value = TILE_DETAIL_HAS_FUNCTON_VALUE(TryLock, T);
+template<typename T>
+struct unlockable {
+    static constexpr bool value = TILE_DETAIL_HAS_FUNCTON_VALUE(unlock, T);
 };
 
-template <typename T> struct try_lockable {
-  static constexpr bool value = TILE_DETAIL_HAS_FUNCTON_VALUE(try_lock, T);
+template<typename T>
+struct TryLockable {
+    static constexpr bool value = TILE_DETAIL_HAS_FUNCTON_VALUE(TryLock, T);
+};
+
+template<typename T>
+struct try_lockable {
+    static constexpr bool value = TILE_DETAIL_HAS_FUNCTON_VALUE(try_lock, T);
 };
 
 #undef TILE_DETAIL_DEFINE_HAS_FUNCTOIN_TRAITS
 #undef TILE_DETAIL_HAS_FUNCTON_VALUE
 
-template <typename T> constexpr bool Lockable<T>::value;
-template <typename T> constexpr bool lockable<T>::value;
-template <typename T> constexpr bool Unlockable<T>::value;
-template <typename T> constexpr bool unlockable<T>::value;
-template <typename T> constexpr bool TryLockable<T>::value;
-template <typename T> constexpr bool try_lockable<T>::value;
+template<typename T>
+constexpr bool Lockable<T>::value;
+template<typename T>
+constexpr bool lockable<T>::value;
+template<typename T>
+constexpr bool Unlockable<T>::value;
+template<typename T>
+constexpr bool unlockable<T>::value;
+template<typename T>
+constexpr bool TryLockable<T>::value;
+template<typename T>
+constexpr bool try_lockable<T>::value;
 
-template <typename M> enable_if_t<Lockable<M>::value> Lock(M *m) { m->Lock(); }
-template <typename M>
-enable_if_t<!Lockable<M>::value && lockable<M>::value> Lock(M *m) {
-  m->lock();
+template<typename M>
+enable_if_t<Lockable<M>::value>
+Lock(M *m)
+{
+    m->Lock();
 }
 
-template <typename M> enable_if_t<Unlockable<M>::value> Unlock(M *m) {
-  m->Unlock();
+template<typename M>
+enable_if_t<!Lockable<M>::value && lockable<M>::value>
+Lock(M *m)
+{
+    m->lock();
 }
 
-template <typename M>
-enable_if_t<!Unlockable<M>::value && unlockable<M>::value> Unlock(M *m) {
-  m->unlock();
+template<typename M>
+enable_if_t<Unlockable<M>::value>
+Unlock(M *m)
+{
+    m->Unlock();
 }
 
-template <typename M> enable_if_t<TryLockable<M>::value, bool> TryLock(M *m) {
-  return m->TryLock();
+template<typename M>
+enable_if_t<!Unlockable<M>::value && unlockable<M>::value>
+Unlock(M *m)
+{
+    m->unlock();
 }
 
-template <typename M>
+template<typename M>
+enable_if_t<TryLockable<M>::value, bool>
+TryLock(M *m)
+{
+    return m->TryLock();
+}
+
+template<typename M>
 enable_if_t<!TryLockable<M>::value && try_lockable<M>::value, bool>
-TryLock(M *m) {
-  return m->try_lock();
+TryLock(M *m)
+{
+    return m->try_lock();
 }
 
-} // namespace thread
-} // namespace detail
+}// namespace thread
+}// namespace detail
 
-template <typename T> struct MutexTraits<T> {
-  static_assert((detail::thread::lockable<T>::value ||
-                 detail::thread::Lockable<T>::value),
-                "T is not lockable");
-  static_assert((detail::thread::unlockable<T>::value ||
-                 detail::thread::Unlockable<T>::value),
-                "T is not unlockable");
+template<typename T>
+struct MutexTraits<T> {
+    static_assert((detail::thread::lockable<T>::value || detail::thread::Lockable<T>::value), "T is not lockable");
+    static_assert((detail::thread::unlockable<T>::value || detail::thread::Unlockable<T>::value),
+                  "T is not unlockable");
 
-  static void Lock(T *m) { detail::thread::Lock(m); }
-  static void Unlock(T *m) { detail::thread::Unlock(m); }
-  static bool TryLock(T *m) { return detail::thread::TryLock(m); }
+    static void Lock(T *m) { detail::thread::Lock(m); }
+
+    static void Unlock(T *m) { detail::thread::Unlock(m); }
+
+    static bool TryLock(T *m) { return detail::thread::TryLock(m); }
 };
 
 // 1. Lock + lock, use Lock
 // 2. lock       , use lock
 // 3. Lock       , use Lock
 // * TryLock, Unlock the same *
-template <typename T> struct MutexOperator {
-  static void Lock(T *m) { MutexTraits<T>::Lock(m); }
-  static void Unlock(T *m) { MutexTraits<T>::Unlock(m); }
-  static bool TryLock(T *m) { return MutexTraits<T>::TryLock(m); }
+template<typename T>
+struct MutexOperator {
+    static void Lock(T *m) { MutexTraits<T>::Lock(m); }
+
+    static void Unlock(T *m) { MutexTraits<T>::Unlock(m); }
+
+    static bool TryLock(T *m) { return MutexTraits<T>::TryLock(m); }
 };
 
 namespace detail {
 namespace thread {
 
-template <typename M> std::vector<std::function<void()>> GetLockers(M &m) {
-  return {[&]() { tile::MutexOperator<M>::Lock(&m); }};
+template<typename M>
+std::vector<std::function<void()>>
+GetLockers(M &m)
+{
+    return {[&]() { tile::MutexOperator<M>::Lock(&m); }};
 }
 
-template <typename M, typename... MutexType>
-std::vector<std::function<void()>> GetLockers(M &m, MutexType &...ms) {
-  std::vector<std::function<void()>> lockers = GetLockers(ms...);
-  lockers.push_back([&m]() { tile::MutexOperator<M>::Lock(&m); });
-  return lockers;
+template<typename M, typename... MutexType>
+std::vector<std::function<void()>>
+GetLockers(M &m, MutexType &...ms)
+{
+    std::vector<std::function<void()>> lockers = GetLockers(ms...);
+    lockers.push_back([&m]() { tile::MutexOperator<M>::Lock(&m); });
+    return lockers;
 }
 
-template <typename Vec, typename M>
-enable_if_t<!detail::thread::TryLockable<M>::value &&
-            !detail::thread::try_lockable<M>::value>
-GetTryLockersAppendTryLockOp(Vec &vec, M &m) { /* do nothing */ }
+template<typename Vec, typename M>
+enable_if_t<!detail::thread::TryLockable<M>::value && !detail::thread::try_lockable<M>::value>
+GetTryLockersAppendTryLockOp(Vec &vec, M &m)
+{ /* do nothing */
+}
 
 // `TryLockable` or `try_lockable`
-template <typename Vec, typename M>
-enable_if_t<detail::thread::TryLockable<M>::value ||
-            detail::thread::try_lockable<M>::value>
-GetTryLockersAppendTryLockOp(Vec &vec, M &m) {
-  vec.push_back([&] { return tile::MutexOperator<M>::TryLock(&m); });
+template<typename Vec, typename M>
+enable_if_t<detail::thread::TryLockable<M>::value || detail::thread::try_lockable<M>::value>
+GetTryLockersAppendTryLockOp(Vec &vec, M &m)
+{
+    vec.push_back([&] { return tile::MutexOperator<M>::TryLock(&m); });
 }
 
-template <typename M> std::vector<std::function<bool()>> GetTryLockers(M &m) {
-  std::vector<std::function<bool()>> try_lockers;
-  GetTryLockersAppendTryLockOp(try_lockers, m);
-  return try_lockers;
+template<typename M>
+std::vector<std::function<bool()>>
+GetTryLockers(M &m)
+{
+    std::vector<std::function<bool()>> try_lockers;
+    GetTryLockersAppendTryLockOp(try_lockers, m);
+    return try_lockers;
 }
 
-template <typename M, typename... MutexType>
-std::vector<std::function<bool()>> GetTryLockers(M &m, MutexType &...ms) {
-  std::vector<std::function<bool()>> try_lockers = GetTryLockers(ms...);
-  GetTryLockersAppendTryLockOp(try_lockers, m);
-  // lockers.push_back([&m]() { return tile::MutexOperator<M>::TryLock(&m); });
-  return try_lockers;
+template<typename M, typename... MutexType>
+std::vector<std::function<bool()>>
+GetTryLockers(M &m, MutexType &...ms)
+{
+    std::vector<std::function<bool()>> try_lockers = GetTryLockers(ms...);
+    GetTryLockersAppendTryLockOp(try_lockers, m);
+    // lockers.push_back([&m]() { return tile::MutexOperator<M>::TryLock(&m); });
+    return try_lockers;
 }
 
-template <typename M> std::vector<std::function<void()>> GetUnlockers(M &m) {
-  return {[&m]() { tile::MutexOperator<M>::Unlock(&m); }};
-}
-template <typename M, typename... MutexType>
-std::vector<std::function<void()>> GetUnlockers(M &m, MutexType &...ms) {
-  std::vector<std::function<void()>> unlockers = GetUnlockers(ms...);
-  unlockers.push_back([&m]() { tile::MutexOperator<M>::Unlock(&m); });
-  return unlockers;
+template<typename M>
+std::vector<std::function<void()>>
+GetUnlockers(M &m)
+{
+    return {[&m]() { tile::MutexOperator<M>::Unlock(&m); }};
 }
 
-template <typename M, typename... MutexType> struct mutex_count_impl;
+template<typename M, typename... MutexType>
+std::vector<std::function<void()>>
+GetUnlockers(M &m, MutexType &...ms)
+{
+    std::vector<std::function<void()>> unlockers = GetUnlockers(ms...);
+    unlockers.push_back([&m]() { tile::MutexOperator<M>::Unlock(&m); });
+    return unlockers;
+}
 
-template <typename M> struct mutex_count_impl<M> {
-  static constexpr std::size_t value = 1;
+template<typename M, typename... MutexType>
+struct mutex_count_impl;
+
+template<typename M>
+struct mutex_count_impl<M> {
+    static constexpr std::size_t value = 1;
 };
 
-template <typename M, typename... MutexType> struct mutex_count_impl {
-  static constexpr std::size_t value =
-      1 + mutex_count_impl<MutexType...>::value;
+template<typename M, typename... MutexType>
+struct mutex_count_impl {
+    static constexpr std::size_t value = 1 + mutex_count_impl<MutexType...>::value;
 };
 
-template <typename... MutexType> struct mutex_count {
-  static constexpr std::size_t value = mutex_count_impl<MutexType...>::value;
+template<typename... MutexType>
+struct mutex_count {
+    static constexpr std::size_t value = mutex_count_impl<MutexType...>::value;
 };
 
-template <typename M>
-std::vector<std::pair<void *, int>> GetMutexPtrs(int idx, M &m) {
-  return {{static_cast<void *>(&m), idx}};
+template<typename M>
+std::vector<std::pair<void *, int>>
+GetMutexPtrs(int idx, M &m)
+{
+    return {
+        {static_cast<void *>(&m), idx}
+    };
 }
 
-template <typename M, typename... MutexType>
-std::vector<std::pair<void *, int>> GetMutexPtrs(int idx, M &m,
-                                                 MutexType &...ms) {
-  auto ptrs = GetMutexPtrs(idx + 1, ms...);
-  ptrs.push_back({static_cast<void *>(&m), idx});
-  return ptrs;
+template<typename M, typename... MutexType>
+std::vector<std::pair<void *, int>>
+GetMutexPtrs(int idx, M &m, MutexType &...ms)
+{
+    auto ptrs = GetMutexPtrs(idx + 1, ms...);
+    ptrs.push_back({static_cast<void *>(&m), idx});
+    return ptrs;
 }
 
-} // namespace thread
-} // namespace detail
+}// namespace thread
+}// namespace detail
 
-} // namespace tile
+}// namespace tile
 
-#endif // TILE_BASE_INTERNAL_MUTEX_H
+#endif// TILE_BASE_INTERNAL_MUTEX_H
diff --git a/tile/base/internal/optional.h b/tile/base/internal/optional.h
index 16ffe44..b87873c 100644
--- a/tile/base/internal/optional.h
+++ b/tile/base/internal/optional.h
@@ -31,68 +31,54 @@
 #define TL_OPTIONAL_MSVC2015
 #endif
 
-#if (defined(__GNUC__) && __GNUC__ == 4 && __GNUC_MINOR__ <= 9 &&              \
-     !defined(__clang__))
+#if (defined(__GNUC__) && __GNUC__ == 4 && __GNUC_MINOR__ <= 9 && !defined(__clang__))
 #define TL_OPTIONAL_GCC49
 #endif
 
-#if (defined(__GNUC__) && __GNUC__ == 5 && __GNUC_MINOR__ <= 4 &&              \
-     !defined(__clang__))
+#if (defined(__GNUC__) && __GNUC__ == 5 && __GNUC_MINOR__ <= 4 && !defined(__clang__))
 #define TL_OPTIONAL_GCC54
 #endif
 
-#if (defined(__GNUC__) && __GNUC__ == 5 && __GNUC_MINOR__ <= 5 &&              \
-     !defined(__clang__))
+#if (defined(__GNUC__) && __GNUC__ == 5 && __GNUC_MINOR__ <= 5 && !defined(__clang__))
 #define TL_OPTIONAL_GCC55
 #endif
 
-#if (defined(__GNUC__) && __GNUC__ == 4 && __GNUC_MINOR__ <= 9 &&              \
-     !defined(__clang__))
+#if (defined(__GNUC__) && __GNUC__ == 4 && __GNUC_MINOR__ <= 9 && !defined(__clang__))
 // GCC < 5 doesn't support overloading on const&& for member functions
 #define TL_OPTIONAL_NO_CONSTRR
 
 // GCC < 5 doesn't support some standard C++11 type traits
-#define TL_OPTIONAL_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T)                         \
-  std::has_trivial_copy_constructor<T>::value
-#define TL_OPTIONAL_IS_TRIVIALLY_COPY_ASSIGNABLE(T)                            \
-  std::has_trivial_copy_assign<T>::value
+#define TL_OPTIONAL_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T) std::has_trivial_copy_constructor<T>::value
+#define TL_OPTIONAL_IS_TRIVIALLY_COPY_ASSIGNABLE(T) std::has_trivial_copy_assign<T>::value
 
 // This one will be different for GCC 5.7 if it's ever supported
-#define TL_OPTIONAL_IS_TRIVIALLY_DESTRUCTIBLE(T)                               \
-  std::is_trivially_destructible<T>::value
+#define TL_OPTIONAL_IS_TRIVIALLY_DESTRUCTIBLE(T) std::is_trivially_destructible<T>::value
 
 // GCC 5 < v < 8 has a bug in is_trivially_copy_constructible which breaks
 // std::vector for non-copyable types
 #elif (defined(__GNUC__) && __GNUC__ < 8 && !defined(__clang__))
 #ifndef TL_GCC_LESS_8_TRIVIALLY_COPY_CONSTRUCTIBLE_MUTEX
 #define TL_GCC_LESS_8_TRIVIALLY_COPY_CONSTRUCTIBLE_MUTEX
+
 namespace tl {
 namespace detail {
-template <class T>
-struct is_trivially_copy_constructible
-    : std::is_trivially_copy_constructible<T> {};
+template<class T>
+struct is_trivially_copy_constructible : std::is_trivially_copy_constructible<T> {};
 #ifdef _GLIBCXX_VECTOR
-template <class T, class A>
-struct is_trivially_copy_constructible<std::vector<T, A>>
-    : std::is_trivially_copy_constructible<T> {};
+template<class T, class A>
+struct is_trivially_copy_constructible<std::vector<T, A>> : std::is_trivially_copy_constructible<T> {};
 #endif
-} // namespace detail
-} // namespace tl
+}// namespace detail
+}// namespace tl
 #endif
 
-#define TL_OPTIONAL_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T)                         \
-  tl::detail::is_trivially_copy_constructible<T>::value
-#define TL_OPTIONAL_IS_TRIVIALLY_COPY_ASSIGNABLE(T)                            \
-  std::is_trivially_copy_assignable<T>::value
-#define TL_OPTIONAL_IS_TRIVIALLY_DESTRUCTIBLE(T)                               \
-  std::is_trivially_destructible<T>::value
+#define TL_OPTIONAL_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T) tl::detail::is_trivially_copy_constructible<T>::value
+#define TL_OPTIONAL_IS_TRIVIALLY_COPY_ASSIGNABLE(T) std::is_trivially_copy_assignable<T>::value
+#define TL_OPTIONAL_IS_TRIVIALLY_DESTRUCTIBLE(T) std::is_trivially_destructible<T>::value
 #else
-#define TL_OPTIONAL_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T)                         \
-  std::is_trivially_copy_constructible<T>::value
-#define TL_OPTIONAL_IS_TRIVIALLY_COPY_ASSIGNABLE(T)                            \
-  std::is_trivially_copy_assignable<T>::value
-#define TL_OPTIONAL_IS_TRIVIALLY_DESTRUCTIBLE(T)                               \
-  std::is_trivially_destructible<T>::value
+#define TL_OPTIONAL_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T) std::is_trivially_copy_constructible<T>::value
+#define TL_OPTIONAL_IS_TRIVIALLY_COPY_ASSIGNABLE(T) std::is_trivially_copy_assignable<T>::value
+#define TL_OPTIONAL_IS_TRIVIALLY_DESTRUCTIBLE(T) std::is_trivially_destructible<T>::value
 #endif
 
 #if __cplusplus > 201103L
@@ -100,8 +86,7 @@ struct is_trivially_copy_constructible<std::vector<T, A>>
 #endif
 
 // constexpr implies const in C++11, not C++14
-#if (__cplusplus == 201103L || defined(TL_OPTIONAL_MSVC2015) ||                \
-     defined(TL_OPTIONAL_GCC49))
+#if (__cplusplus == 201103L || defined(TL_OPTIONAL_MSVC2015) || defined(TL_OPTIONAL_GCC49))
 #define TL_OPTIONAL_11_CONSTEXPR
 #else
 #define TL_OPTIONAL_11_CONSTEXPR constexpr
@@ -110,38 +95,46 @@ struct is_trivially_copy_constructible<std::vector<T, A>>
 namespace tl {
 #ifndef TL_MONOSTATE_INPLACE_MUTEX
 #define TL_MONOSTATE_INPLACE_MUTEX
+
 /// Used to represent an optional with no data; essentially a bool
 class monostate {};
 
 ///  A tag type to tell optional to construct its value in-place
 struct in_place_t {
-  explicit in_place_t() = default;
+    explicit in_place_t() = default;
 };
+
 /// A tag to tell optional to construct its value in-place
 static constexpr in_place_t in_place{};
 #endif
 
-template <class T> class optional;
+template<class T>
+class optional;
 
 namespace detail {
 #ifndef TL_TRAITS_MUTEX
 #define TL_TRAITS_MUTEX
 // C++14-style aliases for brevity
-template <class T> using remove_const_t = typename std::remove_const<T>::type;
-template <class T>
+template<class T>
+using remove_const_t = typename std::remove_const<T>::type;
+template<class T>
 using remove_reference_t = typename std::remove_reference<T>::type;
-template <class T> using decay_t = typename std::decay<T>::type;
-template <bool E, class T = void>
+template<class T>
+using decay_t = typename std::decay<T>::type;
+template<bool E, class T = void>
 using enable_if_t = typename std::enable_if<E, T>::type;
-template <bool B, class T, class F>
+template<bool B, class T, class F>
 using conditional_t = typename std::conditional<B, T, F>::type;
 
 // std::conjunction from C++17
-template <class...> struct conjunction : std::true_type {};
-template <class B> struct conjunction<B> : B {};
-template <class B, class... Bs>
-struct conjunction<B, Bs...>
-    : std::conditional<bool(B::value), conjunction<Bs...>, B>::type {};
+template<class...>
+struct conjunction : std::true_type {};
+
+template<class B>
+struct conjunction<B> : B {};
+
+template<class B, class... Bs>
+struct conjunction<B, Bs...> : std::conditional<bool(B::value), conjunction<Bs...>, B>::type {};
 
 #if defined(_LIBCPP_VERSION) && __cplusplus == 201103L
 #define TL_TRAITS_LIBCXX_MEM_FN_WORKAROUND
@@ -151,78 +144,84 @@ struct conjunction<B, Bs...>
 // which results in a hard-error when using it in a noexcept expression
 // in some cases. This is a check to workaround the common failing case.
 #ifdef TL_TRAITS_LIBCXX_MEM_FN_WORKAROUND
-template <class T>
+template<class T>
 struct is_pointer_to_non_const_member_func : std::false_type {};
-template <class T, class Ret, class... Args>
-struct is_pointer_to_non_const_member_func<Ret (T::*)(Args...)>
-    : std::true_type {};
-template <class T, class Ret, class... Args>
-struct is_pointer_to_non_const_member_func<Ret (T::*)(Args...) &>
-    : std::true_type {};
-template <class T, class Ret, class... Args>
-struct is_pointer_to_non_const_member_func<Ret (T::*)(Args...) &&>
-    : std::true_type {};
-template <class T, class Ret, class... Args>
-struct is_pointer_to_non_const_member_func<Ret (T::*)(Args...) volatile>
-    : std::true_type {};
-template <class T, class Ret, class... Args>
-struct is_pointer_to_non_const_member_func<Ret (T::*)(Args...) volatile &>
-    : std::true_type {};
-template <class T, class Ret, class... Args>
-struct is_pointer_to_non_const_member_func<Ret (T::*)(Args...) volatile &&>
-    : std::true_type {};
 
-template <class T> struct is_const_or_const_ref : std::false_type {};
-template <class T> struct is_const_or_const_ref<T const &> : std::true_type {};
-template <class T> struct is_const_or_const_ref<T const> : std::true_type {};
+template<class T, class Ret, class... Args>
+struct is_pointer_to_non_const_member_func<Ret (T::*)(Args...)> : std::true_type {};
+
+template<class T, class Ret, class... Args>
+struct is_pointer_to_non_const_member_func<Ret (T::*)(Args...) &> : std::true_type {};
+
+template<class T, class Ret, class... Args>
+struct is_pointer_to_non_const_member_func<Ret (T::*)(Args...) &&> : std::true_type {};
+
+template<class T, class Ret, class... Args>
+struct is_pointer_to_non_const_member_func<Ret (T::*)(Args...) volatile> : std::true_type {};
+
+template<class T, class Ret, class... Args>
+struct is_pointer_to_non_const_member_func<Ret (T::*)(Args...) volatile &> : std::true_type {};
+
+template<class T, class Ret, class... Args>
+struct is_pointer_to_non_const_member_func<Ret (T::*)(Args...) volatile &&> : std::true_type {};
+
+template<class T>
+struct is_const_or_const_ref : std::false_type {};
+
+template<class T>
+struct is_const_or_const_ref<T const &> : std::true_type {};
+
+template<class T>
+struct is_const_or_const_ref<T const> : std::true_type {};
 #endif
 
 // std::invoke from C++17
 // https://stackoverflow.com/questions/38288042/c11-14-invoke-workaround
-template <
-    typename Fn, typename... Args,
+template<
+    typename Fn,
+    typename... Args,
 #ifdef TL_TRAITS_LIBCXX_MEM_FN_WORKAROUND
-    typename = enable_if_t<!(is_pointer_to_non_const_member_func<Fn>::value &&
-                             is_const_or_const_ref<Args...>::value)>,
+    typename = enable_if_t<!(is_pointer_to_non_const_member_func<Fn>::value && is_const_or_const_ref<Args...>::value)>,
 #endif
-    typename = enable_if_t<std::is_member_pointer<decay_t<Fn>>::value>, int = 0>
-constexpr auto invoke(Fn &&f, Args &&...args) noexcept(
-    noexcept(std::mem_fn(f)(std::forward<Args>(args)...)))
-    -> decltype(std::mem_fn(f)(std::forward<Args>(args)...)) {
-  return std::mem_fn(f)(std::forward<Args>(args)...);
+    typename = enable_if_t<std::is_member_pointer<decay_t<Fn>>::value>,
+    int      = 0>
+constexpr auto
+invoke(Fn &&f, Args &&...args) noexcept(noexcept(std::mem_fn(f)(std::forward<Args>(args)...)))
+    -> decltype(std::mem_fn(f)(std::forward<Args>(args)...))
+{
+    return std::mem_fn(f)(std::forward<Args>(args)...);
 }
 
-template <typename Fn, typename... Args,
-          typename = enable_if_t<!std::is_member_pointer<decay_t<Fn>>::value>>
-constexpr auto invoke(Fn &&f, Args &&...args) noexcept(
-    noexcept(std::forward<Fn>(f)(std::forward<Args>(args)...)))
-    -> decltype(std::forward<Fn>(f)(std::forward<Args>(args)...)) {
-  return std::forward<Fn>(f)(std::forward<Args>(args)...);
+template<typename Fn, typename... Args, typename = enable_if_t<!std::is_member_pointer<decay_t<Fn>>::value>>
+constexpr auto
+invoke(Fn &&f, Args &&...args) noexcept(noexcept(std::forward<Fn>(f)(std::forward<Args>(args)...)))
+    -> decltype(std::forward<Fn>(f)(std::forward<Args>(args)...))
+{
+    return std::forward<Fn>(f)(std::forward<Args>(args)...);
 }
 
 // std::invoke_result from C++17
-template <class F, class, class... Us> struct invoke_result_impl;
+template<class F, class, class... Us>
+struct invoke_result_impl;
 
-template <class F, class... Us>
-struct invoke_result_impl<
-    F,
-    decltype(detail::invoke(std::declval<F>(), std::declval<Us>()...), void()),
-    Us...> {
-  using type =
-      decltype(detail::invoke(std::declval<F>(), std::declval<Us>()...));
+template<class F, class... Us>
+struct invoke_result_impl<F, decltype(detail::invoke(std::declval<F>(), std::declval<Us>()...), void()), Us...> {
+    using type = decltype(detail::invoke(std::declval<F>(), std::declval<Us>()...));
 };
 
-template <class F, class... Us>
+template<class F, class... Us>
 using invoke_result = invoke_result_impl<F, void, Us...>;
 
-template <class F, class... Us>
+template<class F, class... Us>
 using invoke_result_t = typename invoke_result<F, Us...>::type;
 
 #if defined(_MSC_VER) && _MSC_VER <= 1900
 // TODO make a version which works with MSVC 2015
-template <class T, class U = T> struct is_swappable : std::true_type {};
+template<class T, class U = T>
+struct is_swappable : std::true_type {};
 
-template <class T, class U = T> struct is_nothrow_swappable : std::true_type {};
+template<class T, class U = T>
+struct is_nothrow_swappable : std::true_type {};
 #else
 // https://stackoverflow.com/questions/26744589/what-is-a-proper-way-to-implement-is-swappable-to-test-for-the-swappable-concept
 namespace swap_adl_tests {
@@ -230,253 +229,258 @@ namespace swap_adl_tests {
 // signature)
 struct tag {};
 
-template <class T> tag swap(T &, T &);
-template <class T, std::size_t N> tag swap(T (&a)[N], T (&b)[N]);
+template<class T>
+tag swap(T &, T &);
+template<class T, std::size_t N>
+tag swap(T (&a)[N], T (&b)[N]);
 
 // helper functions to test if an unqualified swap is possible, and if it
 // becomes std::swap
-template <class, class> std::false_type can_swap(...) noexcept(false);
-template <class T, class U,
-          class = decltype(swap(std::declval<T &>(), std::declval<U &>()))>
-std::true_type can_swap(int) noexcept(noexcept(swap(std::declval<T &>(),
-                                                    std::declval<U &>())));
+template<class, class>
+std::false_type can_swap(...) noexcept(false);
+template<class T, class U, class = decltype(swap(std::declval<T &>(), std::declval<U &>()))>
+std::true_type can_swap(int) noexcept(noexcept(swap(std::declval<T &>(), std::declval<U &>())));
 
-template <class, class> std::false_type uses_std(...);
-template <class T, class U>
-std::is_same<decltype(swap(std::declval<T &>(), std::declval<U &>())), tag>
-uses_std(int);
+template<class, class>
+std::false_type uses_std(...);
+template<class T, class U>
+std::is_same<decltype(swap(std::declval<T &>(), std::declval<U &>())), tag> uses_std(int);
 
-template <class T>
+template<class T>
 struct is_std_swap_noexcept
     : std::integral_constant<bool,
-                             std::is_nothrow_move_constructible<T>::value &&
-                                 std::is_nothrow_move_assignable<T>::value> {};
+                             std::is_nothrow_move_constructible<T>::value
+                                 && std::is_nothrow_move_assignable<T>::value> {};
 
-template <class T, std::size_t N>
+template<class T, std::size_t N>
 struct is_std_swap_noexcept<T[N]> : is_std_swap_noexcept<T> {};
 
-template <class T, class U>
-struct is_adl_swap_noexcept
-    : std::integral_constant<bool, noexcept(can_swap<T, U>(0))> {};
-} // namespace swap_adl_tests
+template<class T, class U>
+struct is_adl_swap_noexcept : std::integral_constant<bool, noexcept(can_swap<T, U>(0))> {};
+}// namespace swap_adl_tests
 
-template <class T, class U = T>
+template<class T, class U = T>
 struct is_swappable
-    : std::integral_constant<
-          bool,
-          decltype(detail::swap_adl_tests::can_swap<T, U>(0))::value &&
-              (!decltype(detail::swap_adl_tests::uses_std<T, U>(0))::value ||
-               (std::is_move_assignable<T>::value &&
-                std::is_move_constructible<T>::value))> {};
+    : std::integral_constant<bool,
+                             decltype(detail::swap_adl_tests::can_swap<T, U>(0))::value
+                                 && (!decltype(detail::swap_adl_tests::uses_std<T, U>(0))::value
+                                     || (std::is_move_assignable<T>::value && std::is_move_constructible<T>::value))> {
+};
 
-template <class T, std::size_t N>
+template<class T, std::size_t N>
 struct is_swappable<T[N], T[N]>
-    : std::integral_constant<
-          bool,
-          decltype(detail::swap_adl_tests::can_swap<T[N], T[N]>(0))::value &&
-              (!decltype(detail::swap_adl_tests::uses_std<T[N], T[N]>(
-                   0))::value ||
-               is_swappable<T, T>::value)> {};
+    : std::integral_constant<bool,
+                             decltype(detail::swap_adl_tests::can_swap<T[N], T[N]>(0))::value
+                                 && (!decltype(detail::swap_adl_tests::uses_std<T[N], T[N]>(0))::value
+                                     || is_swappable<T, T>::value)> {};
 
-template <class T, class U = T>
+template<class T, class U = T>
 struct is_nothrow_swappable
-    : std::integral_constant<
-          bool,
-          is_swappable<T, U>::value &&
-              ((decltype(detail::swap_adl_tests::uses_std<T, U>(0))::value &&
-                detail::swap_adl_tests::is_std_swap_noexcept<T>::value) ||
-               (!decltype(detail::swap_adl_tests::uses_std<T, U>(0))::value &&
-                detail::swap_adl_tests::is_adl_swap_noexcept<T, U>::value))> {};
+    : std::integral_constant<bool,
+                             is_swappable<T, U>::value
+                                 && ((decltype(detail::swap_adl_tests::uses_std<T, U>(0))::value
+                                      && detail::swap_adl_tests::is_std_swap_noexcept<T>::value)
+                                     || (!decltype(detail::swap_adl_tests::uses_std<T, U>(0))::value
+                                         && detail::swap_adl_tests::is_adl_swap_noexcept<T, U>::value))> {};
 #endif
 #endif
 
 // std::void_t from C++17
-template <class...> struct voider {
-  using type = void;
+template<class...>
+struct voider {
+    using type = void;
 };
-template <class... Ts> using void_t = typename voider<Ts...>::type;
+template<class... Ts>
+using void_t = typename voider<Ts...>::type;
 
 // Trait for checking if a type is a tl::optional
-template <class T> struct is_optional_impl : std::false_type {};
-template <class T> struct is_optional_impl<optional<T>> : std::true_type {};
-template <class T> using is_optional = is_optional_impl<decay_t<T>>;
+template<class T>
+struct is_optional_impl : std::false_type {};
+
+template<class T>
+struct is_optional_impl<optional<T>> : std::true_type {};
+template<class T>
+using is_optional = is_optional_impl<decay_t<T>>;
 
 // Change void to tl::monostate
-template <class U>
+template<class U>
 using fixup_void = conditional_t<std::is_void<U>::value, monostate, U>;
 
-template <class F, class U, class = invoke_result_t<F, U>>
+template<class F, class U, class = invoke_result_t<F, U>>
 using get_map_return = optional<fixup_void<invoke_result_t<F, U>>>;
 
 // Check if invoking F for some Us returns void
-template <class F, class = void, class... U> struct returns_void_impl;
-template <class F, class... U>
-struct returns_void_impl<F, void_t<invoke_result_t<F, U...>>, U...>
-    : std::is_void<invoke_result_t<F, U...>> {};
-template <class F, class... U>
+template<class F, class = void, class... U>
+struct returns_void_impl;
+
+template<class F, class... U>
+struct returns_void_impl<F, void_t<invoke_result_t<F, U...>>, U...> : std::is_void<invoke_result_t<F, U...>> {};
+template<class F, class... U>
 using returns_void = returns_void_impl<F, void, U...>;
 
-template <class T, class... U>
+template<class T, class... U>
 using enable_if_ret_void = enable_if_t<returns_void<T &&, U...>::value>;
 
-template <class T, class... U>
+template<class T, class... U>
 using disable_if_ret_void = enable_if_t<!returns_void<T &&, U...>::value>;
 
-template <class T, class U>
+template<class T, class U>
 using enable_forward_value =
-    detail::enable_if_t<std::is_constructible<T, U &&>::value &&
-                        !std::is_same<detail::decay_t<U>, in_place_t>::value &&
-                        !std::is_same<optional<T>, detail::decay_t<U>>::value>;
+    detail::enable_if_t<std::is_constructible<T, U &&>::value && !std::is_same<detail::decay_t<U>, in_place_t>::value
+                        && !std::is_same<optional<T>, detail::decay_t<U>>::value>;
 
-template <class T, class U, class Other>
+template<class T, class U, class Other>
 using enable_from_other = detail::enable_if_t<
-    std::is_constructible<T, Other>::value &&
-    !std::is_constructible<T, optional<U> &>::value &&
-    !std::is_constructible<T, optional<U> &&>::value &&
-    !std::is_constructible<T, const optional<U> &>::value &&
-    !std::is_constructible<T, const optional<U> &&>::value &&
-    !std::is_convertible<optional<U> &, T>::value &&
-    !std::is_convertible<optional<U> &&, T>::value &&
-    !std::is_convertible<const optional<U> &, T>::value &&
-    !std::is_convertible<const optional<U> &&, T>::value>;
+    std::is_constructible<T, Other>::value && !std::is_constructible<T, optional<U> &>::value
+    && !std::is_constructible<T, optional<U> &&>::value && !std::is_constructible<T, const optional<U> &>::value
+    && !std::is_constructible<T, const optional<U> &&>::value && !std::is_convertible<optional<U> &, T>::value
+    && !std::is_convertible<optional<U> &&, T>::value && !std::is_convertible<const optional<U> &, T>::value
+    && !std::is_convertible<const optional<U> &&, T>::value>;
 
-template <class T, class U>
-using enable_assign_forward = detail::enable_if_t<
-    !std::is_same<optional<T>, detail::decay_t<U>>::value &&
-    !detail::conjunction<std::is_scalar<T>,
-                         std::is_same<T, detail::decay_t<U>>>::value &&
-    std::is_constructible<T, U>::value && std::is_assignable<T &, U>::value>;
+template<class T, class U>
+using enable_assign_forward =
+    detail::enable_if_t<!std::is_same<optional<T>, detail::decay_t<U>>::value
+                        && !detail::conjunction<std::is_scalar<T>, std::is_same<T, detail::decay_t<U>>>::value
+                        && std::is_constructible<T, U>::value && std::is_assignable<T &, U>::value>;
 
-template <class T, class U, class Other>
+template<class T, class U, class Other>
 using enable_assign_from_other = detail::enable_if_t<
-    std::is_constructible<T, Other>::value &&
-    std::is_assignable<T &, Other>::value &&
-    !std::is_constructible<T, optional<U> &>::value &&
-    !std::is_constructible<T, optional<U> &&>::value &&
-    !std::is_constructible<T, const optional<U> &>::value &&
-    !std::is_constructible<T, const optional<U> &&>::value &&
-    !std::is_convertible<optional<U> &, T>::value &&
-    !std::is_convertible<optional<U> &&, T>::value &&
-    !std::is_convertible<const optional<U> &, T>::value &&
-    !std::is_convertible<const optional<U> &&, T>::value &&
-    !std::is_assignable<T &, optional<U> &>::value &&
-    !std::is_assignable<T &, optional<U> &&>::value &&
-    !std::is_assignable<T &, const optional<U> &>::value &&
-    !std::is_assignable<T &, const optional<U> &&>::value>;
+    std::is_constructible<T, Other>::value && std::is_assignable<T &, Other>::value
+    && !std::is_constructible<T, optional<U> &>::value && !std::is_constructible<T, optional<U> &&>::value
+    && !std::is_constructible<T, const optional<U> &>::value && !std::is_constructible<T, const optional<U> &&>::value
+    && !std::is_convertible<optional<U> &, T>::value && !std::is_convertible<optional<U> &&, T>::value
+    && !std::is_convertible<const optional<U> &, T>::value && !std::is_convertible<const optional<U> &&, T>::value
+    && !std::is_assignable<T &, optional<U> &>::value && !std::is_assignable<T &, optional<U> &&>::value
+    && !std::is_assignable<T &, const optional<U> &>::value && !std::is_assignable<T &, const optional<U> &&>::value>;
 
 // The storage base manages the actual storage, and correctly propagates
 // trivial destruction from T. This case is for when T is not trivially
 // destructible.
-template <class T, bool = ::std::is_trivially_destructible<T>::value>
+template<class T, bool = ::std::is_trivially_destructible<T>::value>
 struct optional_storage_base {
-  TL_OPTIONAL_11_CONSTEXPR optional_storage_base() noexcept
-      : m_dummy(), m_has_value(false) {}
+    TL_OPTIONAL_11_CONSTEXPR optional_storage_base() noexcept : m_dummy(), m_has_value(false) {}
 
-  template <class... U>
-  TL_OPTIONAL_11_CONSTEXPR optional_storage_base(in_place_t, U &&...u)
-      : m_value(std::forward<U>(u)...), m_has_value(true) {}
+    template<class... U>
+    TL_OPTIONAL_11_CONSTEXPR optional_storage_base(in_place_t, U &&...u)
+        : m_value(std::forward<U>(u)...),
+          m_has_value(true)
+    {}
 
-  ~optional_storage_base() {
-    if (m_has_value) {
-      m_value.~T();
-      m_has_value = false;
+    ~optional_storage_base()
+    {
+        if (m_has_value) {
+            m_value.~T();
+            m_has_value = false;
+        }
     }
-  }
 
-  struct dummy {};
-  union {
-    dummy m_dummy;
-    T m_value;
-  };
+    struct dummy {};
 
-  bool m_has_value;
+    union {
+        dummy m_dummy;
+        T m_value;
+    };
+
+    bool m_has_value;
 };
 
 // This case is for when T is trivially destructible.
-template <class T> struct optional_storage_base<T, true> {
-  TL_OPTIONAL_11_CONSTEXPR optional_storage_base() noexcept
-      : m_dummy(), m_has_value(false) {}
+template<class T>
+struct optional_storage_base<T, true> {
+    TL_OPTIONAL_11_CONSTEXPR optional_storage_base() noexcept : m_dummy(), m_has_value(false) {}
 
-  template <class... U>
-  TL_OPTIONAL_11_CONSTEXPR optional_storage_base(in_place_t, U &&...u)
-      : m_value(std::forward<U>(u)...), m_has_value(true) {}
+    template<class... U>
+    TL_OPTIONAL_11_CONSTEXPR optional_storage_base(in_place_t, U &&...u)
+        : m_value(std::forward<U>(u)...),
+          m_has_value(true)
+    {}
 
-  // No destructor, so this class is trivially destructible
+    // No destructor, so this class is trivially destructible
 
-  struct dummy {};
-  union {
-    dummy m_dummy;
-    T m_value;
-  };
+    struct dummy {};
 
-  bool m_has_value = false;
+    union {
+        dummy m_dummy;
+        T m_value;
+    };
+
+    bool m_has_value = false;
 };
 
 // This base class provides some handy member functions which can be used in
 // further derived classes
-template <class T> struct optional_operations_base : optional_storage_base<T> {
-  using optional_storage_base<T>::optional_storage_base;
+template<class T>
+struct optional_operations_base : optional_storage_base<T> {
+    using optional_storage_base<T>::optional_storage_base;
 
-  void hard_reset() noexcept {
-    get().~T();
-    this->m_has_value = false;
-  }
-
-  template <class... Args> void construct(Args &&...args) {
-    new (std::addressof(this->m_value)) T(std::forward<Args>(args)...);
-    this->m_has_value = true;
-  }
-
-  template <class Opt> void assign(Opt &&rhs) {
-    if (this->has_value()) {
-      if (rhs.has_value()) {
-        this->m_value = std::forward<Opt>(rhs).get();
-      } else {
-        this->m_value.~T();
+    void hard_reset() noexcept
+    {
+        get().~T();
         this->m_has_value = false;
-      }
     }
 
-    else if (rhs.has_value()) {
-      construct(std::forward<Opt>(rhs).get());
+    template<class... Args>
+    void construct(Args &&...args)
+    {
+        new (std::addressof(this->m_value)) T(std::forward<Args>(args)...);
+        this->m_has_value = true;
     }
-  }
 
-  bool has_value() const { return this->m_has_value; }
+    template<class Opt>
+    void assign(Opt &&rhs)
+    {
+        if (this->has_value()) {
+            if (rhs.has_value()) {
+                this->m_value = std::forward<Opt>(rhs).get();
+            } else {
+                this->m_value.~T();
+                this->m_has_value = false;
+            }
+        }
 
-  TL_OPTIONAL_11_CONSTEXPR T &get() & { return this->m_value; }
-  TL_OPTIONAL_11_CONSTEXPR const T &get() const & { return this->m_value; }
-  TL_OPTIONAL_11_CONSTEXPR T &&get() && { return std::move(this->m_value); }
+        else if (rhs.has_value()) {
+            construct(std::forward<Opt>(rhs).get());
+        }
+    }
+
+    bool has_value() const { return this->m_has_value; }
+
+    TL_OPTIONAL_11_CONSTEXPR T &get() & { return this->m_value; }
+
+    TL_OPTIONAL_11_CONSTEXPR const T &get() const & { return this->m_value; }
+
+    TL_OPTIONAL_11_CONSTEXPR T &&get() && { return std::move(this->m_value); }
 #ifndef TL_OPTIONAL_NO_CONSTRR
-  constexpr const T &&get() const && { return std::move(this->m_value); }
+    constexpr const T &&get() const && { return std::move(this->m_value); }
 #endif
 };
 
 // This class manages conditionally having a trivial copy constructor
 // This specialization is for when T is trivially copy constructible
-template <class T, bool = TL_OPTIONAL_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T)>
+template<class T, bool = TL_OPTIONAL_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T)>
 struct optional_copy_base : optional_operations_base<T> {
-  using optional_operations_base<T>::optional_operations_base;
+    using optional_operations_base<T>::optional_operations_base;
 };
 
 // This specialization is for when T is not trivially copy constructible
-template <class T>
+template<class T>
 struct optional_copy_base<T, false> : optional_operations_base<T> {
-  using optional_operations_base<T>::optional_operations_base;
+    using optional_operations_base<T>::optional_operations_base;
 
-  optional_copy_base() = default;
-  optional_copy_base(const optional_copy_base &rhs)
-      : optional_operations_base<T>() {
-    if (rhs.has_value()) {
-      this->construct(rhs.get());
-    } else {
-      this->m_has_value = false;
+    optional_copy_base() = default;
+
+    optional_copy_base(const optional_copy_base &rhs) : optional_operations_base<T>()
+    {
+        if (rhs.has_value()) {
+            this->construct(rhs.get());
+        } else {
+            this->m_has_value = false;
+        }
     }
-  }
 
-  optional_copy_base(optional_copy_base &&rhs) = default;
-  optional_copy_base &operator=(const optional_copy_base &rhs) = default;
-  optional_copy_base &operator=(optional_copy_base &&rhs) = default;
+    optional_copy_base(optional_copy_base &&rhs)                 = default;
+    optional_copy_base &operator=(const optional_copy_base &rhs) = default;
+    optional_copy_base &operator=(optional_copy_base &&rhs)      = default;
 };
 
 // This class manages conditionally having a trivial move constructor
@@ -485,53 +489,58 @@ struct optional_copy_base<T, false> : optional_operations_base<T> {
 // have to make do with a non-trivial move constructor even if T is trivially
 // move constructible
 #ifndef TL_OPTIONAL_GCC49
-template <class T, bool = std::is_trivially_move_constructible<T>::value>
+template<class T, bool = std::is_trivially_move_constructible<T>::value>
 struct optional_move_base : optional_copy_base<T> {
-  using optional_copy_base<T>::optional_copy_base;
+    using optional_copy_base<T>::optional_copy_base;
 };
 #else
-template <class T, bool = false> struct optional_move_base;
+template<class T, bool = false>
+struct optional_move_base;
 #endif
-template <class T> struct optional_move_base<T, false> : optional_copy_base<T> {
-  using optional_copy_base<T>::optional_copy_base;
+template<class T>
+struct optional_move_base<T, false> : optional_copy_base<T> {
+    using optional_copy_base<T>::optional_copy_base;
 
-  optional_move_base() = default;
-  optional_move_base(const optional_move_base &rhs) = default;
+    optional_move_base()                              = default;
+    optional_move_base(const optional_move_base &rhs) = default;
 
-  optional_move_base(optional_move_base &&rhs) noexcept(
-      std::is_nothrow_move_constructible<T>::value) {
-    if (rhs.has_value()) {
-      this->construct(std::move(rhs.get()));
-    } else {
-      this->m_has_value = false;
+    optional_move_base(optional_move_base &&rhs) noexcept(std::is_nothrow_move_constructible<T>::value)
+    {
+        if (rhs.has_value()) {
+            this->construct(std::move(rhs.get()));
+        } else {
+            this->m_has_value = false;
+        }
     }
-  }
-  optional_move_base &operator=(const optional_move_base &rhs) = default;
-  optional_move_base &operator=(optional_move_base &&rhs) = default;
+
+    optional_move_base &operator=(const optional_move_base &rhs) = default;
+    optional_move_base &operator=(optional_move_base &&rhs)      = default;
 };
 
 // This class manages conditionally having a trivial copy assignment operator
-template <class T, bool = TL_OPTIONAL_IS_TRIVIALLY_COPY_ASSIGNABLE(T) &&
-                          TL_OPTIONAL_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T) &&
-                          TL_OPTIONAL_IS_TRIVIALLY_DESTRUCTIBLE(T)>
+template<class T,
+         bool = TL_OPTIONAL_IS_TRIVIALLY_COPY_ASSIGNABLE(T) && TL_OPTIONAL_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T)
+             && TL_OPTIONAL_IS_TRIVIALLY_DESTRUCTIBLE(T)>
 struct optional_copy_assign_base : optional_move_base<T> {
-  using optional_move_base<T>::optional_move_base;
+    using optional_move_base<T>::optional_move_base;
 };
 
-template <class T>
+template<class T>
 struct optional_copy_assign_base<T, false> : optional_move_base<T> {
-  using optional_move_base<T>::optional_move_base;
+    using optional_move_base<T>::optional_move_base;
 
-  optional_copy_assign_base() = default;
-  optional_copy_assign_base(const optional_copy_assign_base &rhs) = default;
+    optional_copy_assign_base()                                     = default;
+    optional_copy_assign_base(const optional_copy_assign_base &rhs) = default;
 
-  optional_copy_assign_base(optional_copy_assign_base &&rhs) = default;
-  optional_copy_assign_base &operator=(const optional_copy_assign_base &rhs) {
-    this->assign(rhs);
-    return *this;
-  }
-  optional_copy_assign_base &
-  operator=(optional_copy_assign_base &&rhs) = default;
+    optional_copy_assign_base(optional_copy_assign_base &&rhs)      = default;
+
+    optional_copy_assign_base &operator=(const optional_copy_assign_base &rhs)
+    {
+        this->assign(rhs);
+        return *this;
+    }
+
+    optional_copy_assign_base &operator=(optional_copy_assign_base &&rhs) = default;
 };
 
 // This class manages conditionally having a trivial move assignment operator
@@ -540,147 +549,133 @@ struct optional_copy_assign_base<T, false> : optional_move_base<T> {
 // to make do with a non-trivial move assignment operator even if T is trivially
 // move assignable
 #ifndef TL_OPTIONAL_GCC49
-template <class T, bool = std::is_trivially_destructible<T>::value &&
-                          std::is_trivially_move_constructible<T>::value &&
-                          std::is_trivially_move_assignable<T>::value>
+template<class T,
+         bool = std::is_trivially_destructible<T>::value && std::is_trivially_move_constructible<T>::value
+             && std::is_trivially_move_assignable<T>::value>
 struct optional_move_assign_base : optional_copy_assign_base<T> {
-  using optional_copy_assign_base<T>::optional_copy_assign_base;
+    using optional_copy_assign_base<T>::optional_copy_assign_base;
 };
 #else
-template <class T, bool = false> struct optional_move_assign_base;
+template<class T, bool = false>
+struct optional_move_assign_base;
 #endif
 
-template <class T>
+template<class T>
 struct optional_move_assign_base<T, false> : optional_copy_assign_base<T> {
-  using optional_copy_assign_base<T>::optional_copy_assign_base;
+    using optional_copy_assign_base<T>::optional_copy_assign_base;
 
-  optional_move_assign_base() = default;
-  optional_move_assign_base(const optional_move_assign_base &rhs) = default;
+    optional_move_assign_base()                                                = default;
+    optional_move_assign_base(const optional_move_assign_base &rhs)            = default;
 
-  optional_move_assign_base(optional_move_assign_base &&rhs) = default;
+    optional_move_assign_base(optional_move_assign_base &&rhs)                 = default;
 
-  optional_move_assign_base &
-  operator=(const optional_move_assign_base &rhs) = default;
+    optional_move_assign_base &operator=(const optional_move_assign_base &rhs) = default;
 
-  optional_move_assign_base &
-  operator=(optional_move_assign_base &&rhs) noexcept(
-      std::is_nothrow_move_constructible<T>::value &&
-      std::is_nothrow_move_assignable<T>::value) {
-    this->assign(std::move(rhs));
-    return *this;
-  }
+    optional_move_assign_base &operator=(optional_move_assign_base &&rhs) noexcept(
+        std::is_nothrow_move_constructible<T>::value && std::is_nothrow_move_assignable<T>::value)
+    {
+        this->assign(std::move(rhs));
+        return *this;
+    }
 };
 
 // optional_delete_ctor_base will conditionally delete copy and move
 // constructors depending on whether T is copy/move constructible
-template <class T, bool EnableCopy = std::is_copy_constructible<T>::value,
-          bool EnableMove = std::is_move_constructible<T>::value>
+template<class T,
+         bool EnableCopy = std::is_copy_constructible<T>::value,
+         bool EnableMove = std::is_move_constructible<T>::value>
 struct optional_delete_ctor_base {
-  optional_delete_ctor_base() = default;
-  optional_delete_ctor_base(const optional_delete_ctor_base &) = default;
-  optional_delete_ctor_base(optional_delete_ctor_base &&) noexcept = default;
-  optional_delete_ctor_base &
-  operator=(const optional_delete_ctor_base &) = default;
-  optional_delete_ctor_base &
-  operator=(optional_delete_ctor_base &&) noexcept = default;
+    optional_delete_ctor_base()                                                 = default;
+    optional_delete_ctor_base(const optional_delete_ctor_base &)                = default;
+    optional_delete_ctor_base(optional_delete_ctor_base &&) noexcept            = default;
+    optional_delete_ctor_base &operator=(const optional_delete_ctor_base &)     = default;
+    optional_delete_ctor_base &operator=(optional_delete_ctor_base &&) noexcept = default;
 };
 
-template <class T> struct optional_delete_ctor_base<T, true, false> {
-  optional_delete_ctor_base() = default;
-  optional_delete_ctor_base(const optional_delete_ctor_base &) = default;
-  optional_delete_ctor_base(optional_delete_ctor_base &&) noexcept = delete;
-  optional_delete_ctor_base &
-  operator=(const optional_delete_ctor_base &) = default;
-  optional_delete_ctor_base &
-  operator=(optional_delete_ctor_base &&) noexcept = default;
+template<class T>
+struct optional_delete_ctor_base<T, true, false> {
+    optional_delete_ctor_base()                                                 = default;
+    optional_delete_ctor_base(const optional_delete_ctor_base &)                = default;
+    optional_delete_ctor_base(optional_delete_ctor_base &&) noexcept            = delete;
+    optional_delete_ctor_base &operator=(const optional_delete_ctor_base &)     = default;
+    optional_delete_ctor_base &operator=(optional_delete_ctor_base &&) noexcept = default;
 };
 
-template <class T> struct optional_delete_ctor_base<T, false, true> {
-  optional_delete_ctor_base() = default;
-  optional_delete_ctor_base(const optional_delete_ctor_base &) = delete;
-  optional_delete_ctor_base(optional_delete_ctor_base &&) noexcept = default;
-  optional_delete_ctor_base &
-  operator=(const optional_delete_ctor_base &) = default;
-  optional_delete_ctor_base &
-  operator=(optional_delete_ctor_base &&) noexcept = default;
+template<class T>
+struct optional_delete_ctor_base<T, false, true> {
+    optional_delete_ctor_base()                                                 = default;
+    optional_delete_ctor_base(const optional_delete_ctor_base &)                = delete;
+    optional_delete_ctor_base(optional_delete_ctor_base &&) noexcept            = default;
+    optional_delete_ctor_base &operator=(const optional_delete_ctor_base &)     = default;
+    optional_delete_ctor_base &operator=(optional_delete_ctor_base &&) noexcept = default;
 };
 
-template <class T> struct optional_delete_ctor_base<T, false, false> {
-  optional_delete_ctor_base() = default;
-  optional_delete_ctor_base(const optional_delete_ctor_base &) = delete;
-  optional_delete_ctor_base(optional_delete_ctor_base &&) noexcept = delete;
-  optional_delete_ctor_base &
-  operator=(const optional_delete_ctor_base &) = default;
-  optional_delete_ctor_base &
-  operator=(optional_delete_ctor_base &&) noexcept = default;
+template<class T>
+struct optional_delete_ctor_base<T, false, false> {
+    optional_delete_ctor_base()                                                 = default;
+    optional_delete_ctor_base(const optional_delete_ctor_base &)                = delete;
+    optional_delete_ctor_base(optional_delete_ctor_base &&) noexcept            = delete;
+    optional_delete_ctor_base &operator=(const optional_delete_ctor_base &)     = default;
+    optional_delete_ctor_base &operator=(optional_delete_ctor_base &&) noexcept = default;
 };
 
 // optional_delete_assign_base will conditionally delete copy and move
 // constructors depending on whether T is copy/move constructible + assignable
-template <class T,
-          bool EnableCopy = (std::is_copy_constructible<T>::value &&
-                             std::is_copy_assignable<T>::value),
-          bool EnableMove = (std::is_move_constructible<T>::value &&
-                             std::is_move_assignable<T>::value)>
+template<class T,
+         bool EnableCopy = (std::is_copy_constructible<T>::value && std::is_copy_assignable<T>::value),
+         bool EnableMove = (std::is_move_constructible<T>::value && std::is_move_assignable<T>::value)>
 struct optional_delete_assign_base {
-  optional_delete_assign_base() = default;
-  optional_delete_assign_base(const optional_delete_assign_base &) = default;
-  optional_delete_assign_base(optional_delete_assign_base &&) noexcept =
-      default;
-  optional_delete_assign_base &
-  operator=(const optional_delete_assign_base &) = default;
-  optional_delete_assign_base &
-  operator=(optional_delete_assign_base &&) noexcept = default;
+    optional_delete_assign_base()                                                   = default;
+    optional_delete_assign_base(const optional_delete_assign_base &)                = default;
+    optional_delete_assign_base(optional_delete_assign_base &&) noexcept            = default;
+    optional_delete_assign_base &operator=(const optional_delete_assign_base &)     = default;
+    optional_delete_assign_base &operator=(optional_delete_assign_base &&) noexcept = default;
 };
 
-template <class T> struct optional_delete_assign_base<T, true, false> {
-  optional_delete_assign_base() = default;
-  optional_delete_assign_base(const optional_delete_assign_base &) = default;
-  optional_delete_assign_base(optional_delete_assign_base &&) noexcept =
-      default;
-  optional_delete_assign_base &
-  operator=(const optional_delete_assign_base &) = default;
-  optional_delete_assign_base &
-  operator=(optional_delete_assign_base &&) noexcept = delete;
+template<class T>
+struct optional_delete_assign_base<T, true, false> {
+    optional_delete_assign_base()                                                   = default;
+    optional_delete_assign_base(const optional_delete_assign_base &)                = default;
+    optional_delete_assign_base(optional_delete_assign_base &&) noexcept            = default;
+    optional_delete_assign_base &operator=(const optional_delete_assign_base &)     = default;
+    optional_delete_assign_base &operator=(optional_delete_assign_base &&) noexcept = delete;
 };
 
-template <class T> struct optional_delete_assign_base<T, false, true> {
-  optional_delete_assign_base() = default;
-  optional_delete_assign_base(const optional_delete_assign_base &) = default;
-  optional_delete_assign_base(optional_delete_assign_base &&) noexcept =
-      default;
-  optional_delete_assign_base &
-  operator=(const optional_delete_assign_base &) = delete;
-  optional_delete_assign_base &
-  operator=(optional_delete_assign_base &&) noexcept = default;
+template<class T>
+struct optional_delete_assign_base<T, false, true> {
+    optional_delete_assign_base()                                                   = default;
+    optional_delete_assign_base(const optional_delete_assign_base &)                = default;
+    optional_delete_assign_base(optional_delete_assign_base &&) noexcept            = default;
+    optional_delete_assign_base &operator=(const optional_delete_assign_base &)     = delete;
+    optional_delete_assign_base &operator=(optional_delete_assign_base &&) noexcept = default;
 };
 
-template <class T> struct optional_delete_assign_base<T, false, false> {
-  optional_delete_assign_base() = default;
-  optional_delete_assign_base(const optional_delete_assign_base &) = default;
-  optional_delete_assign_base(optional_delete_assign_base &&) noexcept =
-      default;
-  optional_delete_assign_base &
-  operator=(const optional_delete_assign_base &) = delete;
-  optional_delete_assign_base &
-  operator=(optional_delete_assign_base &&) noexcept = delete;
+template<class T>
+struct optional_delete_assign_base<T, false, false> {
+    optional_delete_assign_base()                                                   = default;
+    optional_delete_assign_base(const optional_delete_assign_base &)                = default;
+    optional_delete_assign_base(optional_delete_assign_base &&) noexcept            = default;
+    optional_delete_assign_base &operator=(const optional_delete_assign_base &)     = delete;
+    optional_delete_assign_base &operator=(optional_delete_assign_base &&) noexcept = delete;
 };
 
-} // namespace detail
+}// namespace detail
 
 /// A tag type to represent an empty optional
 struct nullopt_t {
-  struct do_not_use {};
-  constexpr explicit nullopt_t(do_not_use, do_not_use) noexcept {}
+    struct do_not_use {};
+
+    constexpr explicit nullopt_t(do_not_use, do_not_use) noexcept {}
 };
+
 /// Represents an empty optional
-static constexpr nullopt_t nullopt{nullopt_t::do_not_use{},
-                                   nullopt_t::do_not_use{}};
+static constexpr nullopt_t nullopt{nullopt_t::do_not_use{}, nullopt_t::do_not_use{}};
 
 class bad_optional_access : public std::exception {
 public:
-  bad_optional_access() = default;
-  const char *what() const noexcept { return "Optional has no value"; }
+    bad_optional_access() = default;
+
+    const char *what() const noexcept { return "Optional has no value"; }
 };
 
 /// An optional object is an object that contains the storage for another
@@ -689,1389 +684,1498 @@ public:
 /// initialized, and may be destroyed before the optional object has been
 /// destroyed. The initialization state of the contained object is tracked by
 /// the optional object.
-template <class T>
+template<class T>
 class optional : private detail::optional_move_assign_base<T>,
                  private detail::optional_delete_ctor_base<T>,
                  private detail::optional_delete_assign_base<T> {
-  using base = detail::optional_move_assign_base<T>;
+    using base = detail::optional_move_assign_base<T>;
 
-  static_assert(!std::is_same<T, in_place_t>::value,
-                "instantiation of optional with in_place_t is ill-formed");
-  static_assert(!std::is_same<detail::decay_t<T>, nullopt_t>::value,
-                "instantiation of optional with nullopt_t is ill-formed");
+    static_assert(!std::is_same<T, in_place_t>::value, "instantiation of optional with in_place_t is ill-formed");
+    static_assert(!std::is_same<detail::decay_t<T>, nullopt_t>::value,
+                  "instantiation of optional with nullopt_t is ill-formed");
 
 public:
 // The different versions for C++14 and 11 are needed because deduced return
 // types are not SFINAE-safe. This provides better support for things like
 // generic lambdas. C.f.
 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2017/p0826r0.html
-#if defined(TL_OPTIONAL_CXX14) && !defined(TL_OPTIONAL_GCC49) &&               \
-    !defined(TL_OPTIONAL_GCC54) && !defined(TL_OPTIONAL_GCC55)
-  /// Carries out some operation which returns an optional on the stored
-  /// object if there is one.
-  template <class F> TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) & {
-    using result = detail::invoke_result_t<F, T &>;
-    static_assert(detail::is_optional<result>::value,
-                  "F must return an optional");
+#if defined(TL_OPTIONAL_CXX14) && !defined(TL_OPTIONAL_GCC49) && !defined(TL_OPTIONAL_GCC54)                           \
+    && !defined(TL_OPTIONAL_GCC55)
+    /// Carries out some operation which returns an optional on the stored
+    /// object if there is one.
+    template<class F>
+    TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) &
+    {
+        using result = detail::invoke_result_t<F, T &>;
+        static_assert(detail::is_optional<result>::value, "F must return an optional");
 
-    return has_value() ? detail::invoke(std::forward<F>(f), **this)
-                       : result(nullopt);
-  }
+        return has_value() ? detail::invoke(std::forward<F>(f), **this) : result(nullopt);
+    }
 
-  template <class F> TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) && {
-    using result = detail::invoke_result_t<F, T &&>;
-    static_assert(detail::is_optional<result>::value,
-                  "F must return an optional");
+    template<class F>
+    TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) &&
+    {
+        using result = detail::invoke_result_t<F, T &&>;
+        static_assert(detail::is_optional<result>::value, "F must return an optional");
 
-    return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this))
-                       : result(nullopt);
-  }
+        return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this)) : result(nullopt);
+    }
 
-  template <class F> constexpr auto and_then(F &&f) const & {
-    using result = detail::invoke_result_t<F, const T &>;
-    static_assert(detail::is_optional<result>::value,
-                  "F must return an optional");
+    template<class F>
+    constexpr auto and_then(F &&f) const &
+    {
+        using result = detail::invoke_result_t<F, const T &>;
+        static_assert(detail::is_optional<result>::value, "F must return an optional");
 
-    return has_value() ? detail::invoke(std::forward<F>(f), **this)
-                       : result(nullopt);
-  }
+        return has_value() ? detail::invoke(std::forward<F>(f), **this) : result(nullopt);
+    }
 
 #ifndef TL_OPTIONAL_NO_CONSTRR
-  template <class F> constexpr auto and_then(F &&f) const && {
-    using result = detail::invoke_result_t<F, const T &&>;
-    static_assert(detail::is_optional<result>::value,
-                  "F must return an optional");
+    template<class F>
+    constexpr auto and_then(F &&f) const &&
+    {
+        using result = detail::invoke_result_t<F, const T &&>;
+        static_assert(detail::is_optional<result>::value, "F must return an optional");
 
-    return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this))
-                       : result(nullopt);
-  }
+        return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this)) : result(nullopt);
+    }
 #endif
 #else
-  /// Carries out some operation which returns an optional on the stored
-  /// object if there is one.
-  template <class F>
-  TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T &> and_then(F &&f) & {
-    using result = detail::invoke_result_t<F, T &>;
-    static_assert(detail::is_optional<result>::value,
-                  "F must return an optional");
+    /// Carries out some operation which returns an optional on the stored
+    /// object if there is one.
+    template<class F>
+    TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T &> and_then(F &&f) &
+    {
+        using result = detail::invoke_result_t<F, T &>;
+        static_assert(detail::is_optional<result>::value, "F must return an optional");
 
-    return has_value() ? detail::invoke(std::forward<F>(f), **this)
-                       : result(nullopt);
-  }
+        return has_value() ? detail::invoke(std::forward<F>(f), **this) : result(nullopt);
+    }
 
-  template <class F>
-  TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T &&> and_then(F &&f) && {
-    using result = detail::invoke_result_t<F, T &&>;
-    static_assert(detail::is_optional<result>::value,
-                  "F must return an optional");
+    template<class F>
+    TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T &&> and_then(F &&f) &&
+    {
+        using result = detail::invoke_result_t<F, T &&>;
+        static_assert(detail::is_optional<result>::value, "F must return an optional");
 
-    return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this))
-                       : result(nullopt);
-  }
+        return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this)) : result(nullopt);
+    }
 
-  template <class F>
-  constexpr detail::invoke_result_t<F, const T &> and_then(F &&f) const & {
-    using result = detail::invoke_result_t<F, const T &>;
-    static_assert(detail::is_optional<result>::value,
-                  "F must return an optional");
+    template<class F>
+    constexpr detail::invoke_result_t<F, const T &> and_then(F &&f) const &
+    {
+        using result = detail::invoke_result_t<F, const T &>;
+        static_assert(detail::is_optional<result>::value, "F must return an optional");
 
-    return has_value() ? detail::invoke(std::forward<F>(f), **this)
-                       : result(nullopt);
-  }
+        return has_value() ? detail::invoke(std::forward<F>(f), **this) : result(nullopt);
+    }
 
 #ifndef TL_OPTIONAL_NO_CONSTRR
-  template <class F>
-  constexpr detail::invoke_result_t<F, const T &&> and_then(F &&f) const && {
-    using result = detail::invoke_result_t<F, const T &&>;
-    static_assert(detail::is_optional<result>::value,
-                  "F must return an optional");
+    template<class F>
+    constexpr detail::invoke_result_t<F, const T &&> and_then(F &&f) const &&
+    {
+        using result = detail::invoke_result_t<F, const T &&>;
+        static_assert(detail::is_optional<result>::value, "F must return an optional");
 
-    return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this))
-                       : result(nullopt);
-  }
+        return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this)) : result(nullopt);
+    }
 #endif
 #endif
 
-#if defined(TL_OPTIONAL_CXX14) && !defined(TL_OPTIONAL_GCC49) &&               \
-    !defined(TL_OPTIONAL_GCC54) && !defined(TL_OPTIONAL_GCC55)
-  /// Carries out some operation on the stored object if there is one.
-  template <class F> TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) & {
-    return optional_map_impl(*this, std::forward<F>(f));
-  }
+#if defined(TL_OPTIONAL_CXX14) && !defined(TL_OPTIONAL_GCC49) && !defined(TL_OPTIONAL_GCC54)                           \
+    && !defined(TL_OPTIONAL_GCC55)
+    /// Carries out some operation on the stored object if there is one.
+    template<class F>
+    TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) &
+    {
+        return optional_map_impl(*this, std::forward<F>(f));
+    }
 
-  template <class F> TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) && {
-    return optional_map_impl(std::move(*this), std::forward<F>(f));
-  }
+    template<class F>
+    TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) &&
+    {
+        return optional_map_impl(std::move(*this), std::forward<F>(f));
+    }
 
-  template <class F> constexpr auto map(F &&f) const & {
-    return optional_map_impl(*this, std::forward<F>(f));
-  }
+    template<class F>
+    constexpr auto map(F &&f) const &
+    {
+        return optional_map_impl(*this, std::forward<F>(f));
+    }
 
-  template <class F> constexpr auto map(F &&f) const && {
-    return optional_map_impl(std::move(*this), std::forward<F>(f));
-  }
+    template<class F>
+    constexpr auto map(F &&f) const &&
+    {
+        return optional_map_impl(std::move(*this), std::forward<F>(f));
+    }
 #else
-  /// Carries out some operation on the stored object if there is one.
-  template <class F>
-  TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(
-      std::declval<optional &>(), std::declval<F &&>()))
-  map(F &&f) & {
-    return optional_map_impl(*this, std::forward<F>(f));
-  }
+    /// Carries out some operation on the stored object if there is one.
+    template<class F>
+    TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<optional &>(), std::declval<F &&>())) map(F &&f) &
+    {
+        return optional_map_impl(*this, std::forward<F>(f));
+    }
 
-  template <class F>
-  TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(
-      std::declval<optional &&>(), std::declval<F &&>()))
-  map(F &&f) && {
-    return optional_map_impl(std::move(*this), std::forward<F>(f));
-  }
+    template<class F>
+    TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<optional &&>(), std::declval<F &&>()))
+    map(F &&f) &&
+    {
+        return optional_map_impl(std::move(*this), std::forward<F>(f));
+    }
 
-  template <class F>
-  constexpr decltype(optional_map_impl(std::declval<const optional &>(),
-                                       std::declval<F &&>()))
-  map(F &&f) const & {
-    return optional_map_impl(*this, std::forward<F>(f));
-  }
+    template<class F>
+    constexpr decltype(optional_map_impl(std::declval<const optional &>(), std::declval<F &&>())) map(F &&f) const &
+    {
+        return optional_map_impl(*this, std::forward<F>(f));
+    }
 
 #ifndef TL_OPTIONAL_NO_CONSTRR
-  template <class F>
-  constexpr decltype(optional_map_impl(std::declval<const optional &&>(),
-                                       std::declval<F &&>()))
-  map(F &&f) const && {
-    return optional_map_impl(std::move(*this), std::forward<F>(f));
-  }
+    template<class F>
+    constexpr decltype(optional_map_impl(std::declval<const optional &&>(), std::declval<F &&>())) map(F &&f) const &&
+    {
+        return optional_map_impl(std::move(*this), std::forward<F>(f));
+    }
 #endif
 #endif
 
-#if defined(TL_OPTIONAL_CXX14) && !defined(TL_OPTIONAL_GCC49) &&               \
-    !defined(TL_OPTIONAL_GCC54) && !defined(TL_OPTIONAL_GCC55)
-  /// Carries out some operation on the stored object if there is one.
-  template <class F> TL_OPTIONAL_11_CONSTEXPR auto transform(F &&f) & {
-    return optional_map_impl(*this, std::forward<F>(f));
-  }
+#if defined(TL_OPTIONAL_CXX14) && !defined(TL_OPTIONAL_GCC49) && !defined(TL_OPTIONAL_GCC54)                           \
+    && !defined(TL_OPTIONAL_GCC55)
+    /// Carries out some operation on the stored object if there is one.
+    template<class F>
+    TL_OPTIONAL_11_CONSTEXPR auto transform(F &&f) &
+    {
+        return optional_map_impl(*this, std::forward<F>(f));
+    }
 
-  template <class F> TL_OPTIONAL_11_CONSTEXPR auto transform(F &&f) && {
-    return optional_map_impl(std::move(*this), std::forward<F>(f));
-  }
+    template<class F>
+    TL_OPTIONAL_11_CONSTEXPR auto transform(F &&f) &&
+    {
+        return optional_map_impl(std::move(*this), std::forward<F>(f));
+    }
 
-  template <class F> constexpr auto transform(F &&f) const & {
-    return optional_map_impl(*this, std::forward<F>(f));
-  }
+    template<class F>
+    constexpr auto transform(F &&f) const &
+    {
+        return optional_map_impl(*this, std::forward<F>(f));
+    }
 
-  template <class F> constexpr auto transform(F &&f) const && {
-    return optional_map_impl(std::move(*this), std::forward<F>(f));
-  }
+    template<class F>
+    constexpr auto transform(F &&f) const &&
+    {
+        return optional_map_impl(std::move(*this), std::forward<F>(f));
+    }
 #else
-  /// Carries out some operation on the stored object if there is one.
-  template <class F>
-  TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(
-      std::declval<optional &>(), std::declval<F &&>()))
-  transform(F &&f) & {
-    return optional_map_impl(*this, std::forward<F>(f));
-  }
+    /// Carries out some operation on the stored object if there is one.
+    template<class F>
+    TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<optional &>(), std::declval<F &&>()))
+    transform(F &&f) &
+    {
+        return optional_map_impl(*this, std::forward<F>(f));
+    }
 
-  template <class F>
-  TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(
-      std::declval<optional &&>(), std::declval<F &&>()))
-  transform(F &&f) && {
-    return optional_map_impl(std::move(*this), std::forward<F>(f));
-  }
+    template<class F>
+    TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<optional &&>(), std::declval<F &&>()))
+    transform(F &&f) &&
+    {
+        return optional_map_impl(std::move(*this), std::forward<F>(f));
+    }
 
-  template <class F>
-  constexpr decltype(optional_map_impl(std::declval<const optional &>(),
-                                       std::declval<F &&>()))
-  transform(F &&f) const & {
-    return optional_map_impl(*this, std::forward<F>(f));
-  }
+    template<class F>
+    constexpr decltype(optional_map_impl(std::declval<const optional &>(), std::declval<F &&>()))
+    transform(F &&f) const &
+    {
+        return optional_map_impl(*this, std::forward<F>(f));
+    }
 
 #ifndef TL_OPTIONAL_NO_CONSTRR
-  template <class F>
-  constexpr decltype(optional_map_impl(std::declval<const optional &&>(),
-                                       std::declval<F &&>()))
-  transform(F &&f) const && {
-    return optional_map_impl(std::move(*this), std::forward<F>(f));
-  }
+    template<class F>
+    constexpr decltype(optional_map_impl(std::declval<const optional &&>(), std::declval<F &&>()))
+    transform(F &&f) const &&
+    {
+        return optional_map_impl(std::move(*this), std::forward<F>(f));
+    }
 #endif
 #endif
 
-  /// Calls `f` if the optional is empty
-  template <class F, detail::enable_if_ret_void<F> * = nullptr>
-  optional<T> TL_OPTIONAL_11_CONSTEXPR or_else(F &&f) & {
-    if (has_value())
-      return *this;
+    /// Calls `f` if the optional is empty
+    template<class F, detail::enable_if_ret_void<F> * = nullptr>
+    optional<T> TL_OPTIONAL_11_CONSTEXPR or_else(F &&f) &
+    {
+        if (has_value()) return *this;
 
-    std::forward<F>(f)();
-    return nullopt;
-  }
+        std::forward<F>(f)();
+        return nullopt;
+    }
 
-  template <class F, detail::disable_if_ret_void<F> * = nullptr>
-  optional<T> TL_OPTIONAL_11_CONSTEXPR or_else(F &&f) & {
-    return has_value() ? *this : std::forward<F>(f)();
-  }
+    template<class F, detail::disable_if_ret_void<F> * = nullptr>
+    optional<T> TL_OPTIONAL_11_CONSTEXPR or_else(F &&f) &
+    {
+        return has_value() ? *this : std::forward<F>(f)();
+    }
 
-  template <class F, detail::enable_if_ret_void<F> * = nullptr>
-  optional<T> or_else(F &&f) && {
-    if (has_value())
-      return std::move(*this);
+    template<class F, detail::enable_if_ret_void<F> * = nullptr>
+    optional<T> or_else(F &&f) &&
+    {
+        if (has_value()) return std::move(*this);
 
-    std::forward<F>(f)();
-    return nullopt;
-  }
+        std::forward<F>(f)();
+        return nullopt;
+    }
 
-  template <class F, detail::disable_if_ret_void<F> * = nullptr>
-  optional<T> TL_OPTIONAL_11_CONSTEXPR or_else(F &&f) && {
-    return has_value() ? std::move(*this) : std::forward<F>(f)();
-  }
+    template<class F, detail::disable_if_ret_void<F> * = nullptr>
+    optional<T> TL_OPTIONAL_11_CONSTEXPR or_else(F &&f) &&
+    {
+        return has_value() ? std::move(*this) : std::forward<F>(f)();
+    }
 
-  template <class F, detail::enable_if_ret_void<F> * = nullptr>
-  optional<T> or_else(F &&f) const & {
-    if (has_value())
-      return *this;
+    template<class F, detail::enable_if_ret_void<F> * = nullptr>
+    optional<T> or_else(F &&f) const &
+    {
+        if (has_value()) return *this;
 
-    std::forward<F>(f)();
-    return nullopt;
-  }
+        std::forward<F>(f)();
+        return nullopt;
+    }
 
-  template <class F, detail::disable_if_ret_void<F> * = nullptr>
-  optional<T> TL_OPTIONAL_11_CONSTEXPR or_else(F &&f) const & {
-    return has_value() ? *this : std::forward<F>(f)();
-  }
+    template<class F, detail::disable_if_ret_void<F> * = nullptr>
+    optional<T> TL_OPTIONAL_11_CONSTEXPR or_else(F &&f) const &
+    {
+        return has_value() ? *this : std::forward<F>(f)();
+    }
 
 #ifndef TL_OPTIONAL_NO_CONSTRR
-  template <class F, detail::enable_if_ret_void<F> * = nullptr>
-  optional<T> or_else(F &&f) const && {
-    if (has_value())
-      return std::move(*this);
+    template<class F, detail::enable_if_ret_void<F> * = nullptr>
+    optional<T> or_else(F &&f) const &&
+    {
+        if (has_value()) return std::move(*this);
 
-    std::forward<F>(f)();
-    return nullopt;
-  }
+        std::forward<F>(f)();
+        return nullopt;
+    }
 
-  template <class F, detail::disable_if_ret_void<F> * = nullptr>
-  optional<T> or_else(F &&f) const && {
-    return has_value() ? std::move(*this) : std::forward<F>(f)();
-  }
+    template<class F, detail::disable_if_ret_void<F> * = nullptr>
+    optional<T> or_else(F &&f) const &&
+    {
+        return has_value() ? std::move(*this) : std::forward<F>(f)();
+    }
 #endif
 
-  /// Maps the stored value with `f` if there is one, otherwise returns `u`.
-  template <class F, class U> U map_or(F &&f, U &&u) & {
-    return has_value() ? detail::invoke(std::forward<F>(f), **this)
-                       : std::forward<U>(u);
-  }
+    /// Maps the stored value with `f` if there is one, otherwise returns `u`.
+    template<class F, class U>
+    U map_or(F &&f, U &&u) &
+    {
+        return has_value() ? detail::invoke(std::forward<F>(f), **this) : std::forward<U>(u);
+    }
 
-  template <class F, class U> U map_or(F &&f, U &&u) && {
-    return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this))
-                       : std::forward<U>(u);
-  }
+    template<class F, class U>
+    U map_or(F &&f, U &&u) &&
+    {
+        return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this)) : std::forward<U>(u);
+    }
 
-  template <class F, class U> U map_or(F &&f, U &&u) const & {
-    return has_value() ? detail::invoke(std::forward<F>(f), **this)
-                       : std::forward<U>(u);
-  }
+    template<class F, class U>
+    U map_or(F &&f, U &&u) const &
+    {
+        return has_value() ? detail::invoke(std::forward<F>(f), **this) : std::forward<U>(u);
+    }
 
 #ifndef TL_OPTIONAL_NO_CONSTRR
-  template <class F, class U> U map_or(F &&f, U &&u) const && {
-    return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this))
-                       : std::forward<U>(u);
-  }
+    template<class F, class U>
+    U map_or(F &&f, U &&u) const &&
+    {
+        return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this)) : std::forward<U>(u);
+    }
 #endif
 
-  /// Maps the stored value with `f` if there is one, otherwise calls
-  /// `u` and returns the result.
-  template <class F, class U>
-  detail::invoke_result_t<U> map_or_else(F &&f, U &&u) & {
-    return has_value() ? detail::invoke(std::forward<F>(f), **this)
-                       : std::forward<U>(u)();
-  }
+    /// Maps the stored value with `f` if there is one, otherwise calls
+    /// `u` and returns the result.
+    template<class F, class U>
+    detail::invoke_result_t<U> map_or_else(F &&f, U &&u) &
+    {
+        return has_value() ? detail::invoke(std::forward<F>(f), **this) : std::forward<U>(u)();
+    }
 
-  template <class F, class U>
-  detail::invoke_result_t<U> map_or_else(F &&f, U &&u) && {
-    return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this))
-                       : std::forward<U>(u)();
-  }
+    template<class F, class U>
+    detail::invoke_result_t<U> map_or_else(F &&f, U &&u) &&
+    {
+        return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this)) : std::forward<U>(u)();
+    }
 
-  template <class F, class U>
-  detail::invoke_result_t<U> map_or_else(F &&f, U &&u) const & {
-    return has_value() ? detail::invoke(std::forward<F>(f), **this)
-                       : std::forward<U>(u)();
-  }
+    template<class F, class U>
+    detail::invoke_result_t<U> map_or_else(F &&f, U &&u) const &
+    {
+        return has_value() ? detail::invoke(std::forward<F>(f), **this) : std::forward<U>(u)();
+    }
 
 #ifndef TL_OPTIONAL_NO_CONSTRR
-  template <class F, class U>
-  detail::invoke_result_t<U> map_or_else(F &&f, U &&u) const && {
-    return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this))
-                       : std::forward<U>(u)();
-  }
+    template<class F, class U>
+    detail::invoke_result_t<U> map_or_else(F &&f, U &&u) const &&
+    {
+        return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this)) : std::forward<U>(u)();
+    }
 #endif
 
-  /// Returns `u` if `*this` has a value, otherwise an empty optional.
-  template <class U>
-  constexpr optional<typename std::decay<U>::type> conjunction(U &&u) const {
-    using result = optional<detail::decay_t<U>>;
-    return has_value() ? result{u} : result{nullopt};
-  }
+    /// Returns `u` if `*this` has a value, otherwise an empty optional.
+    template<class U>
+    constexpr optional<typename std::decay<U>::type> conjunction(U &&u) const
+    {
+        using result = optional<detail::decay_t<U>>;
+        return has_value() ? result{u} : result{nullopt};
+    }
 
-  /// Returns `rhs` if `*this` is empty, otherwise the current value.
-  TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional &rhs) & {
-    return has_value() ? *this : rhs;
-  }
+    /// Returns `rhs` if `*this` is empty, otherwise the current value.
+    TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional &rhs) & { return has_value() ? *this : rhs; }
 
-  constexpr optional disjunction(const optional &rhs) const & {
-    return has_value() ? *this : rhs;
-  }
+    constexpr optional disjunction(const optional &rhs) const & { return has_value() ? *this : rhs; }
 
-  TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional &rhs) && {
-    return has_value() ? std::move(*this) : rhs;
-  }
+    TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional &rhs) &&
+    {
+        return has_value() ? std::move(*this) : rhs;
+    }
 
 #ifndef TL_OPTIONAL_NO_CONSTRR
-  constexpr optional disjunction(const optional &rhs) const && {
-    return has_value() ? std::move(*this) : rhs;
-  }
+    constexpr optional disjunction(const optional &rhs) const && { return has_value() ? std::move(*this) : rhs; }
 #endif
 
-  TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional &&rhs) & {
-    return has_value() ? *this : std::move(rhs);
-  }
+    TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional &&rhs) & { return has_value() ? *this : std::move(rhs); }
 
-  constexpr optional disjunction(optional &&rhs) const & {
-    return has_value() ? *this : std::move(rhs);
-  }
+    constexpr optional disjunction(optional &&rhs) const & { return has_value() ? *this : std::move(rhs); }
 
-  TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional &&rhs) && {
-    return has_value() ? std::move(*this) : std::move(rhs);
-  }
+    TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional &&rhs) &&
+    {
+        return has_value() ? std::move(*this) : std::move(rhs);
+    }
 
 #ifndef TL_OPTIONAL_NO_CONSTRR
-  constexpr optional disjunction(optional &&rhs) const && {
-    return has_value() ? std::move(*this) : std::move(rhs);
-  }
+    constexpr optional disjunction(optional &&rhs) const && { return has_value() ? std::move(*this) : std::move(rhs); }
 #endif
 
-  /// Takes the value out of the optional, leaving it empty
-  optional take() {
-    optional ret = std::move(*this);
-    reset();
-    return ret;
-  }
-
-  using value_type = T;
-
-  /// Constructs an optional that does not contain a value.
-  constexpr optional() noexcept = default;
-
-  constexpr optional(nullopt_t) noexcept {}
-
-  /// Copy constructor
-  ///
-  /// If `rhs` contains a value, the stored value is direct-initialized with
-  /// it. Otherwise, the constructed optional is empty.
-  TL_OPTIONAL_11_CONSTEXPR optional(const optional &rhs) = default;
-
-  /// Move constructor
-  ///
-  /// If `rhs` contains a value, the stored value is direct-initialized with
-  /// it. Otherwise, the constructed optional is empty.
-  TL_OPTIONAL_11_CONSTEXPR optional(optional &&rhs) = default;
-
-  /// Constructs the stored value in-place using the given arguments.
-  template <class... Args>
-  constexpr explicit optional(
-      detail::enable_if_t<std::is_constructible<T, Args...>::value, in_place_t>,
-      Args &&...args)
-      : base(in_place, std::forward<Args>(args)...) {}
-
-  template <class U, class... Args>
-  TL_OPTIONAL_11_CONSTEXPR explicit optional(
-      detail::enable_if_t<std::is_constructible<T, std::initializer_list<U> &,
-                                                Args &&...>::value,
-                          in_place_t>,
-      std::initializer_list<U> il, Args &&...args) {
-    this->construct(il, std::forward<Args>(args)...);
-  }
-
-  /// Constructs the stored value with `u`.
-  template <
-      class U = T,
-      detail::enable_if_t<std::is_convertible<U &&, T>::value> * = nullptr,
-      detail::enable_forward_value<T, U> * = nullptr>
-  constexpr optional(U &&u) : base(in_place, std::forward<U>(u)) {}
-
-  template <
-      class U = T,
-      detail::enable_if_t<!std::is_convertible<U &&, T>::value> * = nullptr,
-      detail::enable_forward_value<T, U> * = nullptr>
-  constexpr explicit optional(U &&u) : base(in_place, std::forward<U>(u)) {}
-
-  /// Converting copy constructor.
-  template <
-      class U, detail::enable_from_other<T, U, const U &> * = nullptr,
-      detail::enable_if_t<std::is_convertible<const U &, T>::value> * = nullptr>
-  optional(const optional<U> &rhs) {
-    if (rhs.has_value()) {
-      this->construct(*rhs);
-    }
-  }
-
-  template <class U, detail::enable_from_other<T, U, const U &> * = nullptr,
-            detail::enable_if_t<!std::is_convertible<const U &, T>::value> * =
-                nullptr>
-  explicit optional(const optional<U> &rhs) {
-    if (rhs.has_value()) {
-      this->construct(*rhs);
-    }
-  }
-
-  /// Converting move constructor.
-  template <
-      class U, detail::enable_from_other<T, U, U &&> * = nullptr,
-      detail::enable_if_t<std::is_convertible<U &&, T>::value> * = nullptr>
-  optional(optional<U> &&rhs) {
-    if (rhs.has_value()) {
-      this->construct(std::move(*rhs));
-    }
-  }
-
-  template <
-      class U, detail::enable_from_other<T, U, U &&> * = nullptr,
-      detail::enable_if_t<!std::is_convertible<U &&, T>::value> * = nullptr>
-  explicit optional(optional<U> &&rhs) {
-    if (rhs.has_value()) {
-      this->construct(std::move(*rhs));
-    }
-  }
-
-  /// Destroys the stored value if there is one.
-  ~optional() = default;
-
-  /// Assignment to empty.
-  ///
-  /// Destroys the current value if there is one.
-  optional &operator=(nullopt_t) noexcept {
-    if (has_value()) {
-      this->m_value.~T();
-      this->m_has_value = false;
+    /// Takes the value out of the optional, leaving it empty
+    optional take()
+    {
+        optional ret = std::move(*this);
+        reset();
+        return ret;
     }
 
-    return *this;
-  }
+    using value_type = T;
 
-  /// Copy assignment.
-  ///
-  /// Copies the value from `rhs` if there is one. Otherwise resets the stored
-  /// value in `*this`.
-  optional &operator=(const optional &rhs) = default;
+    /// Constructs an optional that does not contain a value.
+    constexpr optional() noexcept = default;
 
-  /// Move assignment.
-  ///
-  /// Moves the value from `rhs` if there is one. Otherwise resets the stored
-  /// value in `*this`.
-  optional &operator=(optional &&rhs) = default;
+    constexpr optional(nullopt_t) noexcept {}
 
-  /// Assigns the stored value from `u`, destroying the old value if there was
-  /// one.
-  template <class U = T, detail::enable_assign_forward<T, U> * = nullptr>
-  optional &operator=(U &&u) {
-    if (has_value()) {
-      this->m_value = std::forward<U>(u);
-    } else {
-      this->construct(std::forward<U>(u));
+    /// Copy constructor
+    ///
+    /// If `rhs` contains a value, the stored value is direct-initialized with
+    /// it. Otherwise, the constructed optional is empty.
+    TL_OPTIONAL_11_CONSTEXPR optional(const optional &rhs) = default;
+
+    /// Move constructor
+    ///
+    /// If `rhs` contains a value, the stored value is direct-initialized with
+    /// it. Otherwise, the constructed optional is empty.
+    TL_OPTIONAL_11_CONSTEXPR optional(optional &&rhs) = default;
+
+    /// Constructs the stored value in-place using the given arguments.
+    template<class... Args>
+    constexpr explicit optional(detail::enable_if_t<std::is_constructible<T, Args...>::value, in_place_t>,
+                                Args &&...args)
+        : base(in_place, std::forward<Args>(args)...)
+    {}
+
+    template<class U, class... Args>
+    TL_OPTIONAL_11_CONSTEXPR explicit optional(
+        detail::enable_if_t<std::is_constructible<T, std::initializer_list<U> &, Args &&...>::value, in_place_t>,
+        std::initializer_list<U> il,
+        Args &&...args)
+    {
+        this->construct(il, std::forward<Args>(args)...);
     }
 
-    return *this;
-  }
+    /// Constructs the stored value with `u`.
+    template<class U                                                    = T,
+             detail::enable_if_t<std::is_convertible<U &&, T>::value> * = nullptr,
+             detail::enable_forward_value<T, U>                       * = nullptr>
+    constexpr optional(U &&u) : base(in_place, std::forward<U>(u))
+    {}
 
-  /// Converting copy assignment operator.
-  ///
-  /// Copies the value from `rhs` if there is one. Otherwise resets the stored
-  /// value in `*this`.
-  template <class U,
-            detail::enable_assign_from_other<T, U, const U &> * = nullptr>
-  optional &operator=(const optional<U> &rhs) {
-    if (has_value()) {
-      if (rhs.has_value()) {
-        this->m_value = *rhs;
-      } else {
-        this->hard_reset();
-      }
+    template<class U                                                     = T,
+             detail::enable_if_t<!std::is_convertible<U &&, T>::value> * = nullptr,
+             detail::enable_forward_value<T, U>                        * = nullptr>
+    constexpr explicit optional(U &&u) : base(in_place, std::forward<U>(u))
+    {}
+
+    /// Converting copy constructor.
+    template<class U,
+             detail::enable_from_other<T, U, const U &>                    * = nullptr,
+             detail::enable_if_t<std::is_convertible<const U &, T>::value> * = nullptr>
+    optional(const optional<U> &rhs)
+    {
+        if (rhs.has_value()) { this->construct(*rhs); }
     }
 
-    else if (rhs.has_value()) {
-      this->construct(*rhs);
+    template<class U,
+             detail::enable_from_other<T, U, const U &>                     * = nullptr,
+             detail::enable_if_t<!std::is_convertible<const U &, T>::value> * = nullptr>
+    explicit optional(const optional<U> &rhs)
+    {
+        if (rhs.has_value()) { this->construct(*rhs); }
     }
 
-    return *this;
-  }
-
-  // TODO check exception guarantee
-  /// Converting move assignment operator.
-  ///
-  /// Moves the value from `rhs` if there is one. Otherwise resets the stored
-  /// value in `*this`.
-  template <class U, detail::enable_assign_from_other<T, U, U> * = nullptr>
-  optional &operator=(optional<U> &&rhs) {
-    if (has_value()) {
-      if (rhs.has_value()) {
-        this->m_value = std::move(*rhs);
-      } else {
-        this->hard_reset();
-      }
+    /// Converting move constructor.
+    template<class U,
+             detail::enable_from_other<T, U, U &&>                    * = nullptr,
+             detail::enable_if_t<std::is_convertible<U &&, T>::value> * = nullptr>
+    optional(optional<U> &&rhs)
+    {
+        if (rhs.has_value()) { this->construct(std::move(*rhs)); }
     }
 
-    else if (rhs.has_value()) {
-      this->construct(std::move(*rhs));
+    template<class U,
+             detail::enable_from_other<T, U, U &&>                     * = nullptr,
+             detail::enable_if_t<!std::is_convertible<U &&, T>::value> * = nullptr>
+    explicit optional(optional<U> &&rhs)
+    {
+        if (rhs.has_value()) { this->construct(std::move(*rhs)); }
     }
 
-    return *this;
-  }
+    /// Destroys the stored value if there is one.
+    ~optional() = default;
 
-  /// Constructs the value in-place, destroying the current one if there is
-  /// one.
-  template <class... Args> T &emplace(Args &&...args) {
-    static_assert(std::is_constructible<T, Args &&...>::value,
-                  "T must be constructible with Args");
+    /// Assignment to empty.
+    ///
+    /// Destroys the current value if there is one.
+    optional &operator=(nullopt_t) noexcept
+    {
+        if (has_value()) {
+            this->m_value.~T();
+            this->m_has_value = false;
+        }
 
-    *this = nullopt;
-    this->construct(std::forward<Args>(args)...);
-    return value();
-  }
-
-  template <class U, class... Args>
-  detail::enable_if_t<
-      std::is_constructible<T, std::initializer_list<U> &, Args &&...>::value,
-      T &>
-  emplace(std::initializer_list<U> il, Args &&...args) {
-    *this = nullopt;
-    this->construct(il, std::forward<Args>(args)...);
-    return value();
-  }
-
-  /// Swaps this optional with the other.
-  ///
-  /// If neither optionals have a value, nothing happens.
-  /// If both have a value, the values are swapped.
-  /// If one has a value, it is moved to the other and the movee is left
-  /// valueless.
-  void
-  swap(optional &rhs) noexcept(std::is_nothrow_move_constructible<T>::value &&
-                               detail::is_nothrow_swappable<T>::value) {
-    using std::swap;
-    if (has_value()) {
-      if (rhs.has_value()) {
-        swap(**this, *rhs);
-      } else {
-        new (std::addressof(rhs.m_value)) T(std::move(this->m_value));
-        this->m_value.T::~T();
-      }
-    } else if (rhs.has_value()) {
-      new (std::addressof(this->m_value)) T(std::move(rhs.m_value));
-      rhs.m_value.T::~T();
+        return *this;
     }
-    swap(this->m_has_value, rhs.m_has_value);
-  }
 
-  /// Returns a pointer to the stored value
-  constexpr const T *operator->() const {
-    return std::addressof(this->m_value);
-  }
+    /// Copy assignment.
+    ///
+    /// Copies the value from `rhs` if there is one. Otherwise resets the stored
+    /// value in `*this`.
+    optional &operator=(const optional &rhs) = default;
 
-  TL_OPTIONAL_11_CONSTEXPR T *operator->() {
-    return std::addressof(this->m_value);
-  }
+    /// Move assignment.
+    ///
+    /// Moves the value from `rhs` if there is one. Otherwise resets the stored
+    /// value in `*this`.
+    optional &operator=(optional &&rhs) = default;
 
-  /// Returns the stored value
-  TL_OPTIONAL_11_CONSTEXPR T &operator*() & { return this->m_value; }
+    /// Assigns the stored value from `u`, destroying the old value if there was
+    /// one.
+    template<class U = T, detail::enable_assign_forward<T, U> * = nullptr>
+    optional &operator=(U &&u)
+    {
+        if (has_value()) {
+            this->m_value = std::forward<U>(u);
+        } else {
+            this->construct(std::forward<U>(u));
+        }
 
-  constexpr const T &operator*() const & { return this->m_value; }
+        return *this;
+    }
 
-  TL_OPTIONAL_11_CONSTEXPR T &&operator*() && {
-    return std::move(this->m_value);
-  }
+    /// Converting copy assignment operator.
+    ///
+    /// Copies the value from `rhs` if there is one. Otherwise resets the stored
+    /// value in `*this`.
+    template<class U, detail::enable_assign_from_other<T, U, const U &> * = nullptr>
+    optional &operator=(const optional<U> &rhs)
+    {
+        if (has_value()) {
+            if (rhs.has_value()) {
+                this->m_value = *rhs;
+            } else {
+                this->hard_reset();
+            }
+        }
+
+        else if (rhs.has_value()) {
+            this->construct(*rhs);
+        }
+
+        return *this;
+    }
+
+    // TODO check exception guarantee
+    /// Converting move assignment operator.
+    ///
+    /// Moves the value from `rhs` if there is one. Otherwise resets the stored
+    /// value in `*this`.
+    template<class U, detail::enable_assign_from_other<T, U, U> * = nullptr>
+    optional &operator=(optional<U> &&rhs)
+    {
+        if (has_value()) {
+            if (rhs.has_value()) {
+                this->m_value = std::move(*rhs);
+            } else {
+                this->hard_reset();
+            }
+        }
+
+        else if (rhs.has_value()) {
+            this->construct(std::move(*rhs));
+        }
+
+        return *this;
+    }
+
+    /// Constructs the value in-place, destroying the current one if there is
+    /// one.
+    template<class... Args>
+    T &emplace(Args &&...args)
+    {
+        static_assert(std::is_constructible<T, Args &&...>::value, "T must be constructible with Args");
+
+        *this = nullopt;
+        this->construct(std::forward<Args>(args)...);
+        return value();
+    }
+
+    template<class U, class... Args>
+    detail::enable_if_t<std::is_constructible<T, std::initializer_list<U> &, Args &&...>::value, T &>
+    emplace(std::initializer_list<U> il, Args &&...args)
+    {
+        *this = nullopt;
+        this->construct(il, std::forward<Args>(args)...);
+        return value();
+    }
+
+    /// Swaps this optional with the other.
+    ///
+    /// If neither optionals have a value, nothing happens.
+    /// If both have a value, the values are swapped.
+    /// If one has a value, it is moved to the other and the movee is left
+    /// valueless.
+    void swap(optional &rhs) noexcept(std::is_nothrow_move_constructible<T>::value
+                                      && detail::is_nothrow_swappable<T>::value)
+    {
+        using std::swap;
+        if (has_value()) {
+            if (rhs.has_value()) {
+                swap(**this, *rhs);
+            } else {
+                new (std::addressof(rhs.m_value)) T(std::move(this->m_value));
+                this->m_value.T::~T();
+            }
+        } else if (rhs.has_value()) {
+            new (std::addressof(this->m_value)) T(std::move(rhs.m_value));
+            rhs.m_value.T::~T();
+        }
+        swap(this->m_has_value, rhs.m_has_value);
+    }
+
+    /// Returns a pointer to the stored value
+    constexpr const T *operator->() const { return std::addressof(this->m_value); }
+
+    TL_OPTIONAL_11_CONSTEXPR T *operator->() { return std::addressof(this->m_value); }
+
+    /// Returns the stored value
+    TL_OPTIONAL_11_CONSTEXPR T &operator*() & { return this->m_value; }
+
+    constexpr const T &operator*() const & { return this->m_value; }
+
+    TL_OPTIONAL_11_CONSTEXPR T &&operator*() && { return std::move(this->m_value); }
 
 #ifndef TL_OPTIONAL_NO_CONSTRR
-  constexpr const T &&operator*() const && { return std::move(this->m_value); }
+    constexpr const T &&operator*() const && { return std::move(this->m_value); }
 #endif
 
-  /// Returns whether or not the optional has a value
-  constexpr bool has_value() const noexcept { return this->m_has_value; }
+    /// Returns whether or not the optional has a value
+    constexpr bool has_value() const noexcept { return this->m_has_value; }
 
-  constexpr explicit operator bool() const noexcept {
-    return this->m_has_value;
-  }
+    constexpr explicit operator bool() const noexcept { return this->m_has_value; }
 
-  /// Returns the contained value if there is one, otherwise throws
-  /// bad_optional_access
-  TL_OPTIONAL_11_CONSTEXPR T &value() & {
-    if (has_value())
-      return this->m_value;
-    throw bad_optional_access();
-  }
-  TL_OPTIONAL_11_CONSTEXPR const T &value() const & {
-    if (has_value())
-      return this->m_value;
-    throw bad_optional_access();
-  }
-  TL_OPTIONAL_11_CONSTEXPR T &&value() && {
-    if (has_value())
-      return std::move(this->m_value);
-    throw bad_optional_access();
-  }
+    /// Returns the contained value if there is one, otherwise throws
+    /// bad_optional_access
+    TL_OPTIONAL_11_CONSTEXPR T &value() &
+    {
+        if (has_value()) return this->m_value;
+        throw bad_optional_access();
+    }
+
+    TL_OPTIONAL_11_CONSTEXPR const T &value() const &
+    {
+        if (has_value()) return this->m_value;
+        throw bad_optional_access();
+    }
+
+    TL_OPTIONAL_11_CONSTEXPR T &&value() &&
+    {
+        if (has_value()) return std::move(this->m_value);
+        throw bad_optional_access();
+    }
 
 #ifndef TL_OPTIONAL_NO_CONSTRR
-  TL_OPTIONAL_11_CONSTEXPR const T &&value() const && {
-    if (has_value())
-      return std::move(this->m_value);
-    throw bad_optional_access();
-  }
+    TL_OPTIONAL_11_CONSTEXPR const T &&value() const &&
+    {
+        if (has_value()) return std::move(this->m_value);
+        throw bad_optional_access();
+    }
 #endif
 
-  /// Returns the stored value if there is one, otherwise returns `u`
-  template <class U> constexpr T value_or(U &&u) const & {
-    static_assert(std::is_copy_constructible<T>::value &&
-                      std::is_convertible<U &&, T>::value,
-                  "T must be copy constructible and convertible from U");
-    return has_value() ? **this : static_cast<T>(std::forward<U>(u));
-  }
-
-  template <class U> TL_OPTIONAL_11_CONSTEXPR T value_or(U &&u) && {
-    static_assert(std::is_move_constructible<T>::value &&
-                      std::is_convertible<U &&, T>::value,
-                  "T must be move constructible and convertible from U");
-    return has_value() ? std::move(**this) : static_cast<T>(std::forward<U>(u));
-  }
-
-  /// Destroys the stored value if one exists, making the optional empty
-  void reset() noexcept {
-    if (has_value()) {
-      this->m_value.~T();
-      this->m_has_value = false;
+    /// Returns the stored value if there is one, otherwise returns `u`
+    template<class U>
+    constexpr T value_or(U &&u) const &
+    {
+        static_assert(std::is_copy_constructible<T>::value && std::is_convertible<U &&, T>::value,
+                      "T must be copy constructible and convertible from U");
+        return has_value() ? **this : static_cast<T>(std::forward<U>(u));
     }
-  }
-}; // namespace tl
+
+    template<class U>
+    TL_OPTIONAL_11_CONSTEXPR T value_or(U &&u) &&
+    {
+        static_assert(std::is_move_constructible<T>::value && std::is_convertible<U &&, T>::value,
+                      "T must be move constructible and convertible from U");
+        return has_value() ? std::move(**this) : static_cast<T>(std::forward<U>(u));
+    }
+
+    /// Destroys the stored value if one exists, making the optional empty
+    void reset() noexcept
+    {
+        if (has_value()) {
+            this->m_value.~T();
+            this->m_has_value = false;
+        }
+    }
+};// namespace tl
 
 /// Compares two optional objects
-template <class T, class U>
-inline constexpr bool operator==(const optional<T> &lhs,
-                                 const optional<U> &rhs) {
-  return lhs.has_value() == rhs.has_value() &&
-         (!lhs.has_value() || *lhs == *rhs);
+template<class T, class U>
+inline constexpr bool
+operator==(const optional<T> &lhs, const optional<U> &rhs)
+{
+    return lhs.has_value() == rhs.has_value() && (!lhs.has_value() || *lhs == *rhs);
 }
-template <class T, class U>
-inline constexpr bool operator!=(const optional<T> &lhs,
-                                 const optional<U> &rhs) {
-  return lhs.has_value() != rhs.has_value() ||
-         (lhs.has_value() && *lhs != *rhs);
+
+template<class T, class U>
+inline constexpr bool
+operator!=(const optional<T> &lhs, const optional<U> &rhs)
+{
+    return lhs.has_value() != rhs.has_value() || (lhs.has_value() && *lhs != *rhs);
 }
-template <class T, class U>
-inline constexpr bool operator<(const optional<T> &lhs,
-                                const optional<U> &rhs) {
-  return rhs.has_value() && (!lhs.has_value() || *lhs < *rhs);
+
+template<class T, class U>
+inline constexpr bool
+operator<(const optional<T> &lhs, const optional<U> &rhs)
+{
+    return rhs.has_value() && (!lhs.has_value() || *lhs < *rhs);
 }
-template <class T, class U>
-inline constexpr bool operator>(const optional<T> &lhs,
-                                const optional<U> &rhs) {
-  return lhs.has_value() && (!rhs.has_value() || *lhs > *rhs);
+
+template<class T, class U>
+inline constexpr bool
+operator>(const optional<T> &lhs, const optional<U> &rhs)
+{
+    return lhs.has_value() && (!rhs.has_value() || *lhs > *rhs);
 }
-template <class T, class U>
-inline constexpr bool operator<=(const optional<T> &lhs,
-                                 const optional<U> &rhs) {
-  return !lhs.has_value() || (rhs.has_value() && *lhs <= *rhs);
+
+template<class T, class U>
+inline constexpr bool
+operator<=(const optional<T> &lhs, const optional<U> &rhs)
+{
+    return !lhs.has_value() || (rhs.has_value() && *lhs <= *rhs);
 }
-template <class T, class U>
-inline constexpr bool operator>=(const optional<T> &lhs,
-                                 const optional<U> &rhs) {
-  return !rhs.has_value() || (lhs.has_value() && *lhs >= *rhs);
+
+template<class T, class U>
+inline constexpr bool
+operator>=(const optional<T> &lhs, const optional<U> &rhs)
+{
+    return !rhs.has_value() || (lhs.has_value() && *lhs >= *rhs);
 }
 
 /// Compares an optional to a `nullopt`
-template <class T>
-inline constexpr bool operator==(const optional<T> &lhs, nullopt_t) noexcept {
-  return !lhs.has_value();
+template<class T>
+inline constexpr bool
+operator==(const optional<T> &lhs, nullopt_t) noexcept
+{
+    return !lhs.has_value();
 }
-template <class T>
-inline constexpr bool operator==(nullopt_t, const optional<T> &rhs) noexcept {
-  return !rhs.has_value();
+
+template<class T>
+inline constexpr bool
+operator==(nullopt_t, const optional<T> &rhs) noexcept
+{
+    return !rhs.has_value();
 }
-template <class T>
-inline constexpr bool operator!=(const optional<T> &lhs, nullopt_t) noexcept {
-  return lhs.has_value();
+
+template<class T>
+inline constexpr bool
+operator!=(const optional<T> &lhs, nullopt_t) noexcept
+{
+    return lhs.has_value();
 }
-template <class T>
-inline constexpr bool operator!=(nullopt_t, const optional<T> &rhs) noexcept {
-  return rhs.has_value();
+
+template<class T>
+inline constexpr bool
+operator!=(nullopt_t, const optional<T> &rhs) noexcept
+{
+    return rhs.has_value();
 }
-template <class T>
-inline constexpr bool operator<(const optional<T> &, nullopt_t) noexcept {
-  return false;
+
+template<class T>
+inline constexpr bool
+operator<(const optional<T> &, nullopt_t) noexcept
+{
+    return false;
 }
-template <class T>
-inline constexpr bool operator<(nullopt_t, const optional<T> &rhs) noexcept {
-  return rhs.has_value();
+
+template<class T>
+inline constexpr bool
+operator<(nullopt_t, const optional<T> &rhs) noexcept
+{
+    return rhs.has_value();
 }
-template <class T>
-inline constexpr bool operator<=(const optional<T> &lhs, nullopt_t) noexcept {
-  return !lhs.has_value();
+
+template<class T>
+inline constexpr bool
+operator<=(const optional<T> &lhs, nullopt_t) noexcept
+{
+    return !lhs.has_value();
 }
-template <class T>
-inline constexpr bool operator<=(nullopt_t, const optional<T> &) noexcept {
-  return true;
+
+template<class T>
+inline constexpr bool
+operator<=(nullopt_t, const optional<T> &) noexcept
+{
+    return true;
 }
-template <class T>
-inline constexpr bool operator>(const optional<T> &lhs, nullopt_t) noexcept {
-  return lhs.has_value();
+
+template<class T>
+inline constexpr bool
+operator>(const optional<T> &lhs, nullopt_t) noexcept
+{
+    return lhs.has_value();
 }
-template <class T>
-inline constexpr bool operator>(nullopt_t, const optional<T> &) noexcept {
-  return false;
+
+template<class T>
+inline constexpr bool
+operator>(nullopt_t, const optional<T> &) noexcept
+{
+    return false;
 }
-template <class T>
-inline constexpr bool operator>=(const optional<T> &, nullopt_t) noexcept {
-  return true;
+
+template<class T>
+inline constexpr bool
+operator>=(const optional<T> &, nullopt_t) noexcept
+{
+    return true;
 }
-template <class T>
-inline constexpr bool operator>=(nullopt_t, const optional<T> &rhs) noexcept {
-  return !rhs.has_value();
+
+template<class T>
+inline constexpr bool
+operator>=(nullopt_t, const optional<T> &rhs) noexcept
+{
+    return !rhs.has_value();
 }
 
 /// Compares the optional with a value.
-template <class T, class U>
-inline constexpr bool operator==(const optional<T> &lhs, const U &rhs) {
-  return lhs.has_value() ? *lhs == rhs : false;
-}
-template <class T, class U>
-inline constexpr bool operator==(const U &lhs, const optional<T> &rhs) {
-  return rhs.has_value() ? lhs == *rhs : false;
-}
-template <class T, class U>
-inline constexpr bool operator!=(const optional<T> &lhs, const U &rhs) {
-  return lhs.has_value() ? *lhs != rhs : true;
-}
-template <class T, class U>
-inline constexpr bool operator!=(const U &lhs, const optional<T> &rhs) {
-  return rhs.has_value() ? lhs != *rhs : true;
-}
-template <class T, class U>
-inline constexpr bool operator<(const optional<T> &lhs, const U &rhs) {
-  return lhs.has_value() ? *lhs < rhs : true;
-}
-template <class T, class U>
-inline constexpr bool operator<(const U &lhs, const optional<T> &rhs) {
-  return rhs.has_value() ? lhs < *rhs : false;
-}
-template <class T, class U>
-inline constexpr bool operator<=(const optional<T> &lhs, const U &rhs) {
-  return lhs.has_value() ? *lhs <= rhs : true;
-}
-template <class T, class U>
-inline constexpr bool operator<=(const U &lhs, const optional<T> &rhs) {
-  return rhs.has_value() ? lhs <= *rhs : false;
-}
-template <class T, class U>
-inline constexpr bool operator>(const optional<T> &lhs, const U &rhs) {
-  return lhs.has_value() ? *lhs > rhs : false;
-}
-template <class T, class U>
-inline constexpr bool operator>(const U &lhs, const optional<T> &rhs) {
-  return rhs.has_value() ? lhs > *rhs : true;
-}
-template <class T, class U>
-inline constexpr bool operator>=(const optional<T> &lhs, const U &rhs) {
-  return lhs.has_value() ? *lhs >= rhs : false;
-}
-template <class T, class U>
-inline constexpr bool operator>=(const U &lhs, const optional<T> &rhs) {
-  return rhs.has_value() ? lhs >= *rhs : true;
+template<class T, class U>
+inline constexpr bool
+operator==(const optional<T> &lhs, const U &rhs)
+{
+    return lhs.has_value() ? *lhs == rhs : false;
 }
 
-template <class T,
-          detail::enable_if_t<std::is_move_constructible<T>::value> * = nullptr,
-          detail::enable_if_t<detail::is_swappable<T>::value> * = nullptr>
-void swap(optional<T> &lhs,
-          optional<T> &rhs) noexcept(noexcept(lhs.swap(rhs))) {
-  return lhs.swap(rhs);
+template<class T, class U>
+inline constexpr bool
+operator==(const U &lhs, const optional<T> &rhs)
+{
+    return rhs.has_value() ? lhs == *rhs : false;
+}
+
+template<class T, class U>
+inline constexpr bool
+operator!=(const optional<T> &lhs, const U &rhs)
+{
+    return lhs.has_value() ? *lhs != rhs : true;
+}
+
+template<class T, class U>
+inline constexpr bool
+operator!=(const U &lhs, const optional<T> &rhs)
+{
+    return rhs.has_value() ? lhs != *rhs : true;
+}
+
+template<class T, class U>
+inline constexpr bool
+operator<(const optional<T> &lhs, const U &rhs)
+{
+    return lhs.has_value() ? *lhs < rhs : true;
+}
+
+template<class T, class U>
+inline constexpr bool
+operator<(const U &lhs, const optional<T> &rhs)
+{
+    return rhs.has_value() ? lhs < *rhs : false;
+}
+
+template<class T, class U>
+inline constexpr bool
+operator<=(const optional<T> &lhs, const U &rhs)
+{
+    return lhs.has_value() ? *lhs <= rhs : true;
+}
+
+template<class T, class U>
+inline constexpr bool
+operator<=(const U &lhs, const optional<T> &rhs)
+{
+    return rhs.has_value() ? lhs <= *rhs : false;
+}
+
+template<class T, class U>
+inline constexpr bool
+operator>(const optional<T> &lhs, const U &rhs)
+{
+    return lhs.has_value() ? *lhs > rhs : false;
+}
+
+template<class T, class U>
+inline constexpr bool
+operator>(const U &lhs, const optional<T> &rhs)
+{
+    return rhs.has_value() ? lhs > *rhs : true;
+}
+
+template<class T, class U>
+inline constexpr bool
+operator>=(const optional<T> &lhs, const U &rhs)
+{
+    return lhs.has_value() ? *lhs >= rhs : false;
+}
+
+template<class T, class U>
+inline constexpr bool
+operator>=(const U &lhs, const optional<T> &rhs)
+{
+    return rhs.has_value() ? lhs >= *rhs : true;
+}
+
+template<class T,
+         detail::enable_if_t<std::is_move_constructible<T>::value> * = nullptr,
+         detail::enable_if_t<detail::is_swappable<T>::value>       * = nullptr>
+void
+swap(optional<T> &lhs, optional<T> &rhs) noexcept(noexcept(lhs.swap(rhs)))
+{
+    return lhs.swap(rhs);
 }
 
 namespace detail {
 struct i_am_secret {};
-} // namespace detail
+}// namespace detail
 
-template <class T = detail::i_am_secret, class U,
-          class Ret =
-              detail::conditional_t<std::is_same<T, detail::i_am_secret>::value,
-                                    detail::decay_t<U>, T>>
-inline constexpr optional<Ret> make_optional(U &&v) {
-  return optional<Ret>(std::forward<U>(v));
+template<class T = detail::i_am_secret,
+         class U,
+         class Ret = detail::conditional_t<std::is_same<T, detail::i_am_secret>::value, detail::decay_t<U>, T>>
+inline constexpr optional<Ret>
+make_optional(U &&v)
+{
+    return optional<Ret>(std::forward<U>(v));
 }
 
-template <class T, class... Args>
-inline constexpr optional<T> make_optional(Args &&...args) {
-  return optional<T>(in_place, std::forward<Args>(args)...);
+template<class T, class... Args>
+inline constexpr optional<T>
+make_optional(Args &&...args)
+{
+    return optional<T>(in_place, std::forward<Args>(args)...);
 }
-template <class T, class U, class... Args>
-inline constexpr optional<T> make_optional(std::initializer_list<U> il,
-                                           Args &&...args) {
-  return optional<T>(in_place, il, std::forward<Args>(args)...);
+
+template<class T, class U, class... Args>
+inline constexpr optional<T>
+make_optional(std::initializer_list<U> il, Args &&...args)
+{
+    return optional<T>(in_place, il, std::forward<Args>(args)...);
 }
 
 #if __cplusplus >= 201703L
-template <class T> optional(T) -> optional<T>;
+template<class T>
+optional(T) -> optional<T>;
 #endif
 
 /// \exclude
 namespace detail {
 #ifdef TL_OPTIONAL_CXX14
-template <class Opt, class F,
-          class Ret = decltype(detail::invoke(std::declval<F>(),
-                                              *std::declval<Opt>())),
-          detail::enable_if_t<!std::is_void<Ret>::value> * = nullptr>
-constexpr auto optional_map_impl(Opt &&opt, F &&f) {
-  return opt.has_value()
-             ? detail::invoke(std::forward<F>(f), *std::forward<Opt>(opt))
-             : optional<Ret>(nullopt);
+template<class Opt,
+         class F,
+         class Ret = decltype(detail::invoke(std::declval<F>(), *std::declval<Opt>())),
+         detail::enable_if_t<!std::is_void<Ret>::value> * = nullptr>
+constexpr auto
+optional_map_impl(Opt &&opt, F &&f)
+{
+    return opt.has_value() ? detail::invoke(std::forward<F>(f), *std::forward<Opt>(opt)) : optional<Ret>(nullopt);
 }
 
-template <class Opt, class F,
-          class Ret = decltype(detail::invoke(std::declval<F>(),
-                                              *std::declval<Opt>())),
-          detail::enable_if_t<std::is_void<Ret>::value> * = nullptr>
-auto optional_map_impl(Opt &&opt, F &&f) {
-  if (opt.has_value()) {
-    detail::invoke(std::forward<F>(f), *std::forward<Opt>(opt));
-    return make_optional(monostate{});
-  }
+template<class Opt,
+         class F,
+         class Ret = decltype(detail::invoke(std::declval<F>(), *std::declval<Opt>())),
+         detail::enable_if_t<std::is_void<Ret>::value> * = nullptr>
+auto
+optional_map_impl(Opt &&opt, F &&f)
+{
+    if (opt.has_value()) {
+        detail::invoke(std::forward<F>(f), *std::forward<Opt>(opt));
+        return make_optional(monostate{});
+    }
 
-  return optional<monostate>(nullopt);
+    return optional<monostate>(nullopt);
 }
 #else
-template <class Opt, class F,
-          class Ret = decltype(detail::invoke(std::declval<F>(),
-                                              *std::declval<Opt>())),
-          detail::enable_if_t<!std::is_void<Ret>::value> * = nullptr>
+template<class Opt,
+         class F,
+         class Ret = decltype(detail::invoke(std::declval<F>(), *std::declval<Opt>())),
+         detail::enable_if_t<!std::is_void<Ret>::value> * = nullptr>
 
-constexpr auto optional_map_impl(Opt &&opt, F &&f) -> optional<Ret> {
-  return opt.has_value()
-             ? detail::invoke(std::forward<F>(f), *std::forward<Opt>(opt))
-             : optional<Ret>(nullopt);
+constexpr auto
+optional_map_impl(Opt &&opt, F &&f) -> optional<Ret>
+{
+    return opt.has_value() ? detail::invoke(std::forward<F>(f), *std::forward<Opt>(opt)) : optional<Ret>(nullopt);
 }
 
-template <class Opt, class F,
-          class Ret = decltype(detail::invoke(std::declval<F>(),
-                                              *std::declval<Opt>())),
-          detail::enable_if_t<std::is_void<Ret>::value> * = nullptr>
+template<class Opt,
+         class F,
+         class Ret = decltype(detail::invoke(std::declval<F>(), *std::declval<Opt>())),
+         detail::enable_if_t<std::is_void<Ret>::value> * = nullptr>
 
-auto optional_map_impl(Opt &&opt, F &&f) -> optional<monostate> {
-  if (opt.has_value()) {
-    detail::invoke(std::forward<F>(f), *std::forward<Opt>(opt));
-    return monostate{};
-  }
+auto
+optional_map_impl(Opt &&opt, F &&f) -> optional<monostate>
+{
+    if (opt.has_value()) {
+        detail::invoke(std::forward<F>(f), *std::forward<Opt>(opt));
+        return monostate{};
+    }
 
-  return nullopt;
+    return nullopt;
 }
 #endif
-} // namespace detail
+}// namespace detail
 
 /// Specialization for when `T` is a reference. `optional<T&>` acts similarly
 /// to a `T*`, but provides more operations and shows intent more clearly.
-template <class T> class optional<T &> {
+template<class T>
+class optional<T &> {
 public:
 // The different versions for C++14 and 11 are needed because deduced return
 // types are not SFINAE-safe. This provides better support for things like
 // generic lambdas. C.f.
 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2017/p0826r0.html
-#if defined(TL_OPTIONAL_CXX14) && !defined(TL_OPTIONAL_GCC49) &&               \
-    !defined(TL_OPTIONAL_GCC54) && !defined(TL_OPTIONAL_GCC55)
+#if defined(TL_OPTIONAL_CXX14) && !defined(TL_OPTIONAL_GCC49) && !defined(TL_OPTIONAL_GCC54)                           \
+    && !defined(TL_OPTIONAL_GCC55)
 
-  /// Carries out some operation which returns an optional on the stored
-  /// object if there is one.
-  template <class F> TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) & {
-    using result = detail::invoke_result_t<F, T &>;
-    static_assert(detail::is_optional<result>::value,
-                  "F must return an optional");
+    /// Carries out some operation which returns an optional on the stored
+    /// object if there is one.
+    template<class F>
+    TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) &
+    {
+        using result = detail::invoke_result_t<F, T &>;
+        static_assert(detail::is_optional<result>::value, "F must return an optional");
 
-    return has_value() ? detail::invoke(std::forward<F>(f), **this)
-                       : result(nullopt);
-  }
+        return has_value() ? detail::invoke(std::forward<F>(f), **this) : result(nullopt);
+    }
 
-  template <class F> TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) && {
-    using result = detail::invoke_result_t<F, T &>;
-    static_assert(detail::is_optional<result>::value,
-                  "F must return an optional");
+    template<class F>
+    TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) &&
+    {
+        using result = detail::invoke_result_t<F, T &>;
+        static_assert(detail::is_optional<result>::value, "F must return an optional");
 
-    return has_value() ? detail::invoke(std::forward<F>(f), **this)
-                       : result(nullopt);
-  }
+        return has_value() ? detail::invoke(std::forward<F>(f), **this) : result(nullopt);
+    }
 
-  template <class F> constexpr auto and_then(F &&f) const & {
-    using result = detail::invoke_result_t<F, const T &>;
-    static_assert(detail::is_optional<result>::value,
-                  "F must return an optional");
+    template<class F>
+    constexpr auto and_then(F &&f) const &
+    {
+        using result = detail::invoke_result_t<F, const T &>;
+        static_assert(detail::is_optional<result>::value, "F must return an optional");
 
-    return has_value() ? detail::invoke(std::forward<F>(f), **this)
-                       : result(nullopt);
-  }
+        return has_value() ? detail::invoke(std::forward<F>(f), **this) : result(nullopt);
+    }
 
 #ifndef TL_OPTIONAL_NO_CONSTRR
-  template <class F> constexpr auto and_then(F &&f) const && {
-    using result = detail::invoke_result_t<F, const T &>;
-    static_assert(detail::is_optional<result>::value,
-                  "F must return an optional");
+    template<class F>
+    constexpr auto and_then(F &&f) const &&
+    {
+        using result = detail::invoke_result_t<F, const T &>;
+        static_assert(detail::is_optional<result>::value, "F must return an optional");
 
-    return has_value() ? detail::invoke(std::forward<F>(f), **this)
-                       : result(nullopt);
-  }
+        return has_value() ? detail::invoke(std::forward<F>(f), **this) : result(nullopt);
+    }
 #endif
 #else
-  /// Carries out some operation which returns an optional on the stored
-  /// object if there is one.
-  template <class F>
-  TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T &> and_then(F &&f) & {
-    using result = detail::invoke_result_t<F, T &>;
-    static_assert(detail::is_optional<result>::value,
-                  "F must return an optional");
+    /// Carries out some operation which returns an optional on the stored
+    /// object if there is one.
+    template<class F>
+    TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T &> and_then(F &&f) &
+    {
+        using result = detail::invoke_result_t<F, T &>;
+        static_assert(detail::is_optional<result>::value, "F must return an optional");
 
-    return has_value() ? detail::invoke(std::forward<F>(f), **this)
-                       : result(nullopt);
-  }
+        return has_value() ? detail::invoke(std::forward<F>(f), **this) : result(nullopt);
+    }
 
-  template <class F>
-  TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T &> and_then(F &&f) && {
-    using result = detail::invoke_result_t<F, T &>;
-    static_assert(detail::is_optional<result>::value,
-                  "F must return an optional");
+    template<class F>
+    TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T &> and_then(F &&f) &&
+    {
+        using result = detail::invoke_result_t<F, T &>;
+        static_assert(detail::is_optional<result>::value, "F must return an optional");
 
-    return has_value() ? detail::invoke(std::forward<F>(f), **this)
-                       : result(nullopt);
-  }
+        return has_value() ? detail::invoke(std::forward<F>(f), **this) : result(nullopt);
+    }
 
-  template <class F>
-  constexpr detail::invoke_result_t<F, const T &> and_then(F &&f) const & {
-    using result = detail::invoke_result_t<F, const T &>;
-    static_assert(detail::is_optional<result>::value,
-                  "F must return an optional");
+    template<class F>
+    constexpr detail::invoke_result_t<F, const T &> and_then(F &&f) const &
+    {
+        using result = detail::invoke_result_t<F, const T &>;
+        static_assert(detail::is_optional<result>::value, "F must return an optional");
 
-    return has_value() ? detail::invoke(std::forward<F>(f), **this)
-                       : result(nullopt);
-  }
+        return has_value() ? detail::invoke(std::forward<F>(f), **this) : result(nullopt);
+    }
 
 #ifndef TL_OPTIONAL_NO_CONSTRR
-  template <class F>
-  constexpr detail::invoke_result_t<F, const T &> and_then(F &&f) const && {
-    using result = detail::invoke_result_t<F, const T &>;
-    static_assert(detail::is_optional<result>::value,
-                  "F must return an optional");
+    template<class F>
+    constexpr detail::invoke_result_t<F, const T &> and_then(F &&f) const &&
+    {
+        using result = detail::invoke_result_t<F, const T &>;
+        static_assert(detail::is_optional<result>::value, "F must return an optional");
 
-    return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this))
-                       : result(nullopt);
-  }
+        return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this)) : result(nullopt);
+    }
 #endif
 #endif
 
-#if defined(TL_OPTIONAL_CXX14) && !defined(TL_OPTIONAL_GCC49) &&               \
-    !defined(TL_OPTIONAL_GCC54) && !defined(TL_OPTIONAL_GCC55)
-  /// Carries out some operation on the stored object if there is one.
-  template <class F> TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) & {
-    return detail::optional_map_impl(*this, std::forward<F>(f));
-  }
+#if defined(TL_OPTIONAL_CXX14) && !defined(TL_OPTIONAL_GCC49) && !defined(TL_OPTIONAL_GCC54)                           \
+    && !defined(TL_OPTIONAL_GCC55)
+    /// Carries out some operation on the stored object if there is one.
+    template<class F>
+    TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) &
+    {
+        return detail::optional_map_impl(*this, std::forward<F>(f));
+    }
 
-  template <class F> TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) && {
-    return detail::optional_map_impl(std::move(*this), std::forward<F>(f));
-  }
+    template<class F>
+    TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) &&
+    {
+        return detail::optional_map_impl(std::move(*this), std::forward<F>(f));
+    }
 
-  template <class F> constexpr auto map(F &&f) const & {
-    return detail::optional_map_impl(*this, std::forward<F>(f));
-  }
+    template<class F>
+    constexpr auto map(F &&f) const &
+    {
+        return detail::optional_map_impl(*this, std::forward<F>(f));
+    }
 
-  template <class F> constexpr auto map(F &&f) const && {
-    return detail::optional_map_impl(std::move(*this), std::forward<F>(f));
-  }
+    template<class F>
+    constexpr auto map(F &&f) const &&
+    {
+        return detail::optional_map_impl(std::move(*this), std::forward<F>(f));
+    }
 #else
-  /// Carries out some operation on the stored object if there is one.
-  template <class F>
-  TL_OPTIONAL_11_CONSTEXPR decltype(detail::optional_map_impl(
-      std::declval<optional &>(), std::declval<F &&>()))
-  map(F &&f) & {
-    return detail::optional_map_impl(*this, std::forward<F>(f));
-  }
+    /// Carries out some operation on the stored object if there is one.
+    template<class F>
+    TL_OPTIONAL_11_CONSTEXPR decltype(detail::optional_map_impl(std::declval<optional &>(), std::declval<F &&>()))
+    map(F &&f) &
+    {
+        return detail::optional_map_impl(*this, std::forward<F>(f));
+    }
 
-  template <class F>
-  TL_OPTIONAL_11_CONSTEXPR decltype(detail::optional_map_impl(
-      std::declval<optional &&>(), std::declval<F &&>()))
-  map(F &&f) && {
-    return detail::optional_map_impl(std::move(*this), std::forward<F>(f));
-  }
+    template<class F>
+    TL_OPTIONAL_11_CONSTEXPR decltype(detail::optional_map_impl(std::declval<optional &&>(), std::declval<F &&>()))
+    map(F &&f) &&
+    {
+        return detail::optional_map_impl(std::move(*this), std::forward<F>(f));
+    }
 
-  template <class F>
-  constexpr decltype(detail::optional_map_impl(std::declval<const optional &>(),
-                                               std::declval<F &&>()))
-  map(F &&f) const & {
-    return detail::optional_map_impl(*this, std::forward<F>(f));
-  }
+    template<class F>
+    constexpr decltype(detail::optional_map_impl(std::declval<const optional &>(), std::declval<F &&>()))
+    map(F &&f) const &
+    {
+        return detail::optional_map_impl(*this, std::forward<F>(f));
+    }
 
 #ifndef TL_OPTIONAL_NO_CONSTRR
-  template <class F>
-  constexpr decltype(detail::optional_map_impl(
-      std::declval<const optional &&>(), std::declval<F &&>()))
-  map(F &&f) const && {
-    return detail::optional_map_impl(std::move(*this), std::forward<F>(f));
-  }
+    template<class F>
+    constexpr decltype(detail::optional_map_impl(std::declval<const optional &&>(), std::declval<F &&>()))
+    map(F &&f) const &&
+    {
+        return detail::optional_map_impl(std::move(*this), std::forward<F>(f));
+    }
 #endif
 #endif
 
-#if defined(TL_OPTIONAL_CXX14) && !defined(TL_OPTIONAL_GCC49) &&               \
-    !defined(TL_OPTIONAL_GCC54) && !defined(TL_OPTIONAL_GCC55)
-  /// Carries out some operation on the stored object if there is one.
-  template <class F> TL_OPTIONAL_11_CONSTEXPR auto transform(F &&f) & {
-    return detail::optional_map_impl(*this, std::forward<F>(f));
-  }
+#if defined(TL_OPTIONAL_CXX14) && !defined(TL_OPTIONAL_GCC49) && !defined(TL_OPTIONAL_GCC54)                           \
+    && !defined(TL_OPTIONAL_GCC55)
+    /// Carries out some operation on the stored object if there is one.
+    template<class F>
+    TL_OPTIONAL_11_CONSTEXPR auto transform(F &&f) &
+    {
+        return detail::optional_map_impl(*this, std::forward<F>(f));
+    }
 
-  template <class F> TL_OPTIONAL_11_CONSTEXPR auto transform(F &&f) && {
-    return detail::optional_map_impl(std::move(*this), std::forward<F>(f));
-  }
+    template<class F>
+    TL_OPTIONAL_11_CONSTEXPR auto transform(F &&f) &&
+    {
+        return detail::optional_map_impl(std::move(*this), std::forward<F>(f));
+    }
 
-  template <class F> constexpr auto transform(F &&f) const & {
-    return detail::optional_map_impl(*this, std::forward<F>(f));
-  }
+    template<class F>
+    constexpr auto transform(F &&f) const &
+    {
+        return detail::optional_map_impl(*this, std::forward<F>(f));
+    }
 
-  template <class F> constexpr auto transform(F &&f) const && {
-    return detail::optional_map_impl(std::move(*this), std::forward<F>(f));
-  }
+    template<class F>
+    constexpr auto transform(F &&f) const &&
+    {
+        return detail::optional_map_impl(std::move(*this), std::forward<F>(f));
+    }
 #else
-  /// Carries out some operation on the stored object if there is one.
-  template <class F>
-  TL_OPTIONAL_11_CONSTEXPR decltype(detail::optional_map_impl(
-      std::declval<optional &>(), std::declval<F &&>()))
-  transform(F &&f) & {
-    return detail::optional_map_impl(*this, std::forward<F>(f));
-  }
+    /// Carries out some operation on the stored object if there is one.
+    template<class F>
+    TL_OPTIONAL_11_CONSTEXPR decltype(detail::optional_map_impl(std::declval<optional &>(), std::declval<F &&>()))
+    transform(F &&f) &
+    {
+        return detail::optional_map_impl(*this, std::forward<F>(f));
+    }
 
-  /// \group map
-  /// \synopsis template <class F> auto transform(F &&f) &&;
-  template <class F>
-  TL_OPTIONAL_11_CONSTEXPR decltype(detail::optional_map_impl(
-      std::declval<optional &&>(), std::declval<F &&>()))
-  transform(F &&f) && {
-    return detail::optional_map_impl(std::move(*this), std::forward<F>(f));
-  }
+    /// \group map
+    /// \synopsis template <class F> auto transform(F &&f) &&;
+    template<class F>
+    TL_OPTIONAL_11_CONSTEXPR decltype(detail::optional_map_impl(std::declval<optional &&>(), std::declval<F &&>()))
+    transform(F &&f) &&
+    {
+        return detail::optional_map_impl(std::move(*this), std::forward<F>(f));
+    }
 
-  template <class F>
-  constexpr decltype(detail::optional_map_impl(std::declval<const optional &>(),
-                                               std::declval<F &&>()))
-  transform(F &&f) const & {
-    return detail::optional_map_impl(*this, std::forward<F>(f));
-  }
+    template<class F>
+    constexpr decltype(detail::optional_map_impl(std::declval<const optional &>(), std::declval<F &&>()))
+    transform(F &&f) const &
+    {
+        return detail::optional_map_impl(*this, std::forward<F>(f));
+    }
 
 #ifndef TL_OPTIONAL_NO_CONSTRR
-  template <class F>
-  constexpr decltype(detail::optional_map_impl(
-      std::declval<const optional &&>(), std::declval<F &&>()))
-  transform(F &&f) const && {
-    return detail::optional_map_impl(std::move(*this), std::forward<F>(f));
-  }
+    template<class F>
+    constexpr decltype(detail::optional_map_impl(std::declval<const optional &&>(), std::declval<F &&>()))
+    transform(F &&f) const &&
+    {
+        return detail::optional_map_impl(std::move(*this), std::forward<F>(f));
+    }
 #endif
 #endif
 
-  /// Calls `f` if the optional is empty
-  template <class F, detail::enable_if_ret_void<F> * = nullptr>
-  optional<T> TL_OPTIONAL_11_CONSTEXPR or_else(F &&f) & {
-    if (has_value())
-      return *this;
+    /// Calls `f` if the optional is empty
+    template<class F, detail::enable_if_ret_void<F> * = nullptr>
+    optional<T> TL_OPTIONAL_11_CONSTEXPR or_else(F &&f) &
+    {
+        if (has_value()) return *this;
 
-    std::forward<F>(f)();
-    return nullopt;
-  }
+        std::forward<F>(f)();
+        return nullopt;
+    }
 
-  template <class F, detail::disable_if_ret_void<F> * = nullptr>
-  optional<T> TL_OPTIONAL_11_CONSTEXPR or_else(F &&f) & {
-    return has_value() ? *this : std::forward<F>(f)();
-  }
+    template<class F, detail::disable_if_ret_void<F> * = nullptr>
+    optional<T> TL_OPTIONAL_11_CONSTEXPR or_else(F &&f) &
+    {
+        return has_value() ? *this : std::forward<F>(f)();
+    }
 
-  template <class F, detail::enable_if_ret_void<F> * = nullptr>
-  optional<T> or_else(F &&f) && {
-    if (has_value())
-      return std::move(*this);
+    template<class F, detail::enable_if_ret_void<F> * = nullptr>
+    optional<T> or_else(F &&f) &&
+    {
+        if (has_value()) return std::move(*this);
 
-    std::forward<F>(f)();
-    return nullopt;
-  }
+        std::forward<F>(f)();
+        return nullopt;
+    }
 
-  template <class F, detail::disable_if_ret_void<F> * = nullptr>
-  optional<T> TL_OPTIONAL_11_CONSTEXPR or_else(F &&f) && {
-    return has_value() ? std::move(*this) : std::forward<F>(f)();
-  }
+    template<class F, detail::disable_if_ret_void<F> * = nullptr>
+    optional<T> TL_OPTIONAL_11_CONSTEXPR or_else(F &&f) &&
+    {
+        return has_value() ? std::move(*this) : std::forward<F>(f)();
+    }
 
-  template <class F, detail::enable_if_ret_void<F> * = nullptr>
-  optional<T> or_else(F &&f) const & {
-    if (has_value())
-      return *this;
+    template<class F, detail::enable_if_ret_void<F> * = nullptr>
+    optional<T> or_else(F &&f) const &
+    {
+        if (has_value()) return *this;
 
-    std::forward<F>(f)();
-    return nullopt;
-  }
+        std::forward<F>(f)();
+        return nullopt;
+    }
 
-  template <class F, detail::disable_if_ret_void<F> * = nullptr>
-  optional<T> TL_OPTIONAL_11_CONSTEXPR or_else(F &&f) const & {
-    return has_value() ? *this : std::forward<F>(f)();
-  }
+    template<class F, detail::disable_if_ret_void<F> * = nullptr>
+    optional<T> TL_OPTIONAL_11_CONSTEXPR or_else(F &&f) const &
+    {
+        return has_value() ? *this : std::forward<F>(f)();
+    }
 
 #ifndef TL_OPTIONAL_NO_CONSTRR
-  template <class F, detail::enable_if_ret_void<F> * = nullptr>
-  optional<T> or_else(F &&f) const && {
-    if (has_value())
-      return std::move(*this);
+    template<class F, detail::enable_if_ret_void<F> * = nullptr>
+    optional<T> or_else(F &&f) const &&
+    {
+        if (has_value()) return std::move(*this);
 
-    std::forward<F>(f)();
-    return nullopt;
-  }
+        std::forward<F>(f)();
+        return nullopt;
+    }
 
-  template <class F, detail::disable_if_ret_void<F> * = nullptr>
-  optional<T> or_else(F &&f) const && {
-    return has_value() ? std::move(*this) : std::forward<F>(f)();
-  }
+    template<class F, detail::disable_if_ret_void<F> * = nullptr>
+    optional<T> or_else(F &&f) const &&
+    {
+        return has_value() ? std::move(*this) : std::forward<F>(f)();
+    }
 #endif
 
-  /// Maps the stored value with `f` if there is one, otherwise returns `u`
-  template <class F, class U> U map_or(F &&f, U &&u) & {
-    return has_value() ? detail::invoke(std::forward<F>(f), **this)
-                       : std::forward<U>(u);
-  }
+    /// Maps the stored value with `f` if there is one, otherwise returns `u`
+    template<class F, class U>
+    U map_or(F &&f, U &&u) &
+    {
+        return has_value() ? detail::invoke(std::forward<F>(f), **this) : std::forward<U>(u);
+    }
 
-  template <class F, class U> U map_or(F &&f, U &&u) && {
-    return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this))
-                       : std::forward<U>(u);
-  }
+    template<class F, class U>
+    U map_or(F &&f, U &&u) &&
+    {
+        return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this)) : std::forward<U>(u);
+    }
 
-  template <class F, class U> U map_or(F &&f, U &&u) const & {
-    return has_value() ? detail::invoke(std::forward<F>(f), **this)
-                       : std::forward<U>(u);
-  }
+    template<class F, class U>
+    U map_or(F &&f, U &&u) const &
+    {
+        return has_value() ? detail::invoke(std::forward<F>(f), **this) : std::forward<U>(u);
+    }
 
 #ifndef TL_OPTIONAL_NO_CONSTRR
-  template <class F, class U> U map_or(F &&f, U &&u) const && {
-    return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this))
-                       : std::forward<U>(u);
-  }
+    template<class F, class U>
+    U map_or(F &&f, U &&u) const &&
+    {
+        return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this)) : std::forward<U>(u);
+    }
 #endif
 
-  /// Maps the stored value with `f` if there is one, otherwise calls
-  /// `u` and returns the result.
-  template <class F, class U>
-  detail::invoke_result_t<U> map_or_else(F &&f, U &&u) & {
-    return has_value() ? detail::invoke(std::forward<F>(f), **this)
-                       : std::forward<U>(u)();
-  }
+    /// Maps the stored value with `f` if there is one, otherwise calls
+    /// `u` and returns the result.
+    template<class F, class U>
+    detail::invoke_result_t<U> map_or_else(F &&f, U &&u) &
+    {
+        return has_value() ? detail::invoke(std::forward<F>(f), **this) : std::forward<U>(u)();
+    }
 
-  template <class F, class U>
-  detail::invoke_result_t<U> map_or_else(F &&f, U &&u) && {
-    return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this))
-                       : std::forward<U>(u)();
-  }
+    template<class F, class U>
+    detail::invoke_result_t<U> map_or_else(F &&f, U &&u) &&
+    {
+        return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this)) : std::forward<U>(u)();
+    }
 
-  template <class F, class U>
-  detail::invoke_result_t<U> map_or_else(F &&f, U &&u) const & {
-    return has_value() ? detail::invoke(std::forward<F>(f), **this)
-                       : std::forward<U>(u)();
-  }
+    template<class F, class U>
+    detail::invoke_result_t<U> map_or_else(F &&f, U &&u) const &
+    {
+        return has_value() ? detail::invoke(std::forward<F>(f), **this) : std::forward<U>(u)();
+    }
 
 #ifndef TL_OPTIONAL_NO_CONSTRR
-  template <class F, class U>
-  detail::invoke_result_t<U> map_or_else(F &&f, U &&u) const && {
-    return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this))
-                       : std::forward<U>(u)();
-  }
+    template<class F, class U>
+    detail::invoke_result_t<U> map_or_else(F &&f, U &&u) const &&
+    {
+        return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this)) : std::forward<U>(u)();
+    }
 #endif
 
-  /// Returns `u` if `*this` has a value, otherwise an empty optional.
-  template <class U>
-  constexpr optional<typename std::decay<U>::type> conjunction(U &&u) const {
-    using result = optional<detail::decay_t<U>>;
-    return has_value() ? result{u} : result{nullopt};
-  }
+    /// Returns `u` if `*this` has a value, otherwise an empty optional.
+    template<class U>
+    constexpr optional<typename std::decay<U>::type> conjunction(U &&u) const
+    {
+        using result = optional<detail::decay_t<U>>;
+        return has_value() ? result{u} : result{nullopt};
+    }
 
-  /// Returns `rhs` if `*this` is empty, otherwise the current value.
-  TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional &rhs) & {
-    return has_value() ? *this : rhs;
-  }
+    /// Returns `rhs` if `*this` is empty, otherwise the current value.
+    TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional &rhs) & { return has_value() ? *this : rhs; }
 
-  constexpr optional disjunction(const optional &rhs) const & {
-    return has_value() ? *this : rhs;
-  }
+    constexpr optional disjunction(const optional &rhs) const & { return has_value() ? *this : rhs; }
 
-  TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional &rhs) && {
-    return has_value() ? std::move(*this) : rhs;
-  }
+    TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional &rhs) &&
+    {
+        return has_value() ? std::move(*this) : rhs;
+    }
 
 #ifndef TL_OPTIONAL_NO_CONSTRR
-  constexpr optional disjunction(const optional &rhs) const && {
-    return has_value() ? std::move(*this) : rhs;
-  }
+    constexpr optional disjunction(const optional &rhs) const && { return has_value() ? std::move(*this) : rhs; }
 #endif
 
-  TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional &&rhs) & {
-    return has_value() ? *this : std::move(rhs);
-  }
+    TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional &&rhs) & { return has_value() ? *this : std::move(rhs); }
 
-  constexpr optional disjunction(optional &&rhs) const & {
-    return has_value() ? *this : std::move(rhs);
-  }
+    constexpr optional disjunction(optional &&rhs) const & { return has_value() ? *this : std::move(rhs); }
 
-  TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional &&rhs) && {
-    return has_value() ? std::move(*this) : std::move(rhs);
-  }
+    TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional &&rhs) &&
+    {
+        return has_value() ? std::move(*this) : std::move(rhs);
+    }
 
 #ifndef TL_OPTIONAL_NO_CONSTRR
-  constexpr optional disjunction(optional &&rhs) const && {
-    return has_value() ? std::move(*this) : std::move(rhs);
-  }
+    constexpr optional disjunction(optional &&rhs) const && { return has_value() ? std::move(*this) : std::move(rhs); }
 #endif
 
-  /// Takes the value out of the optional, leaving it empty
-  optional take() {
-    optional ret = std::move(*this);
-    reset();
-    return ret;
-  }
+    /// Takes the value out of the optional, leaving it empty
+    optional take()
+    {
+        optional ret = std::move(*this);
+        reset();
+        return ret;
+    }
 
-  using value_type = T &;
+    using value_type = T &;
 
-  /// Constructs an optional that does not contain a value.
-  constexpr optional() noexcept : m_value(nullptr) {}
+    /// Constructs an optional that does not contain a value.
+    constexpr optional() noexcept : m_value(nullptr) {}
 
-  constexpr optional(nullopt_t) noexcept : m_value(nullptr) {}
+    constexpr optional(nullopt_t) noexcept : m_value(nullptr) {}
 
-  /// Copy constructor
-  ///
-  /// If `rhs` contains a value, the stored value is direct-initialized with
-  /// it. Otherwise, the constructed optional is empty.
-  TL_OPTIONAL_11_CONSTEXPR optional(const optional &rhs) noexcept = default;
+    /// Copy constructor
+    ///
+    /// If `rhs` contains a value, the stored value is direct-initialized with
+    /// it. Otherwise, the constructed optional is empty.
+    TL_OPTIONAL_11_CONSTEXPR optional(const optional &rhs) noexcept = default;
 
-  /// Move constructor
-  ///
-  /// If `rhs` contains a value, the stored value is direct-initialized with
-  /// it. Otherwise, the constructed optional is empty.
-  TL_OPTIONAL_11_CONSTEXPR optional(optional &&rhs) = default;
+    /// Move constructor
+    ///
+    /// If `rhs` contains a value, the stored value is direct-initialized with
+    /// it. Otherwise, the constructed optional is empty.
+    TL_OPTIONAL_11_CONSTEXPR optional(optional &&rhs) = default;
 
-  /// Constructs the stored value with `u`.
-  template <class U = T,
-            detail::enable_if_t<!detail::is_optional<detail::decay_t<U>>::value>
-                * = nullptr>
-  constexpr optional(U &&u) noexcept : m_value(std::addressof(u)) {
-    static_assert(std::is_lvalue_reference<U>::value, "U must be an lvalue");
-  }
+    /// Constructs the stored value with `u`.
+    template<class U = T, detail::enable_if_t<!detail::is_optional<detail::decay_t<U>>::value> * = nullptr>
+    constexpr optional(U &&u) noexcept : m_value(std::addressof(u))
+    {
+        static_assert(std::is_lvalue_reference<U>::value, "U must be an lvalue");
+    }
 
-  template <class U>
-  constexpr explicit optional(const optional<U> &rhs) noexcept
-      : optional(*rhs) {}
+    template<class U>
+    constexpr explicit optional(const optional<U> &rhs) noexcept : optional(*rhs)
+    {}
 
-  /// No-op
-  ~optional() = default;
+    /// No-op
+    ~optional() = default;
 
-  /// Assignment to empty.
-  ///
-  /// Destroys the current value if there is one.
-  optional &operator=(nullopt_t) noexcept {
-    m_value = nullptr;
-    return *this;
-  }
+    /// Assignment to empty.
+    ///
+    /// Destroys the current value if there is one.
+    optional &operator=(nullopt_t) noexcept
+    {
+        m_value = nullptr;
+        return *this;
+    }
 
-  /// Copy assignment.
-  ///
-  /// Rebinds this optional to the referee of `rhs` if there is one. Otherwise
-  /// resets the stored value in `*this`.
-  optional &operator=(const optional &rhs) = default;
+    /// Copy assignment.
+    ///
+    /// Rebinds this optional to the referee of `rhs` if there is one. Otherwise
+    /// resets the stored value in `*this`.
+    optional &operator=(const optional &rhs) = default;
 
-  /// Rebinds this optional to `u`.
-  template <class U = T,
-            detail::enable_if_t<!detail::is_optional<detail::decay_t<U>>::value>
-                * = nullptr>
-  optional &operator=(U &&u) {
-    static_assert(std::is_lvalue_reference<U>::value, "U must be an lvalue");
-    m_value = std::addressof(u);
-    return *this;
-  }
+    /// Rebinds this optional to `u`.
+    template<class U = T, detail::enable_if_t<!detail::is_optional<detail::decay_t<U>>::value> * = nullptr>
+    optional &operator=(U &&u)
+    {
+        static_assert(std::is_lvalue_reference<U>::value, "U must be an lvalue");
+        m_value = std::addressof(u);
+        return *this;
+    }
 
-  /// Converting copy assignment operator.
-  ///
-  /// Rebinds this optional to the referee of `rhs` if there is one. Otherwise
-  /// resets the stored value in `*this`.
-  template <class U> optional &operator=(const optional<U> &rhs) noexcept {
-    m_value = std::addressof(rhs.value());
-    return *this;
-  }
+    /// Converting copy assignment operator.
+    ///
+    /// Rebinds this optional to the referee of `rhs` if there is one. Otherwise
+    /// resets the stored value in `*this`.
+    template<class U>
+    optional &operator=(const optional<U> &rhs) noexcept
+    {
+        m_value = std::addressof(rhs.value());
+        return *this;
+    }
 
-  /// Rebinds this optional to `u`.
-  template <class U = T,
-            detail::enable_if_t<!detail::is_optional<detail::decay_t<U>>::value>
-                * = nullptr>
-  optional &emplace(U &&u) noexcept {
-    return *this = std::forward<U>(u);
-  }
+    /// Rebinds this optional to `u`.
+    template<class U = T, detail::enable_if_t<!detail::is_optional<detail::decay_t<U>>::value> * = nullptr>
+    optional &emplace(U &&u) noexcept
+    {
+        return *this = std::forward<U>(u);
+    }
 
-  void swap(optional &rhs) noexcept { std::swap(m_value, rhs.m_value); }
+    void swap(optional &rhs) noexcept { std::swap(m_value, rhs.m_value); }
 
-  /// Returns a pointer to the stored value
-  constexpr const T *operator->() const noexcept { return m_value; }
+    /// Returns a pointer to the stored value
+    constexpr const T *operator->() const noexcept { return m_value; }
 
-  TL_OPTIONAL_11_CONSTEXPR T *operator->() noexcept { return m_value; }
+    TL_OPTIONAL_11_CONSTEXPR T *operator->() noexcept { return m_value; }
 
-  /// Returns the stored value
-  TL_OPTIONAL_11_CONSTEXPR T &operator*() noexcept { return *m_value; }
+    /// Returns the stored value
+    TL_OPTIONAL_11_CONSTEXPR T &operator*() noexcept { return *m_value; }
 
-  constexpr const T &operator*() const noexcept { return *m_value; }
+    constexpr const T &operator*() const noexcept { return *m_value; }
 
-  constexpr bool has_value() const noexcept { return m_value != nullptr; }
+    constexpr bool has_value() const noexcept { return m_value != nullptr; }
 
-  constexpr explicit operator bool() const noexcept {
-    return m_value != nullptr;
-  }
+    constexpr explicit operator bool() const noexcept { return m_value != nullptr; }
 
-  /// Returns the contained value if there is one, otherwise throws
-  /// bad_optional_access
-  TL_OPTIONAL_11_CONSTEXPR T &value() {
-    if (has_value())
-      return *m_value;
-    throw bad_optional_access();
-  }
-  TL_OPTIONAL_11_CONSTEXPR const T &value() const {
-    if (has_value())
-      return *m_value;
-    throw bad_optional_access();
-  }
+    /// Returns the contained value if there is one, otherwise throws
+    /// bad_optional_access
+    TL_OPTIONAL_11_CONSTEXPR T &value()
+    {
+        if (has_value()) return *m_value;
+        throw bad_optional_access();
+    }
 
-  /// Returns the stored value if there is one, otherwise returns `u`
-  template <class U> constexpr T value_or(U &&u) const & noexcept {
-    static_assert(std::is_copy_constructible<T>::value &&
-                      std::is_convertible<U &&, T>::value,
-                  "T must be copy constructible and convertible from U");
-    return has_value() ? **this : static_cast<T>(std::forward<U>(u));
-  }
+    TL_OPTIONAL_11_CONSTEXPR const T &value() const
+    {
+        if (has_value()) return *m_value;
+        throw bad_optional_access();
+    }
 
-  /// \group value_or
-  template <class U> TL_OPTIONAL_11_CONSTEXPR T value_or(U &&u) && noexcept {
-    static_assert(std::is_move_constructible<T>::value &&
-                      std::is_convertible<U &&, T>::value,
-                  "T must be move constructible and convertible from U");
-    return has_value() ? **this : static_cast<T>(std::forward<U>(u));
-  }
+    /// Returns the stored value if there is one, otherwise returns `u`
+    template<class U>
+    constexpr T value_or(U &&u) const & noexcept
+    {
+        static_assert(std::is_copy_constructible<T>::value && std::is_convertible<U &&, T>::value,
+                      "T must be copy constructible and convertible from U");
+        return has_value() ? **this : static_cast<T>(std::forward<U>(u));
+    }
 
-  /// Destroys the stored value if one exists, making the optional empty
-  void reset() noexcept { m_value = nullptr; }
+    /// \group value_or
+    template<class U>
+    TL_OPTIONAL_11_CONSTEXPR T value_or(U &&u) && noexcept
+    {
+        static_assert(std::is_move_constructible<T>::value && std::is_convertible<U &&, T>::value,
+                      "T must be move constructible and convertible from U");
+        return has_value() ? **this : static_cast<T>(std::forward<U>(u));
+    }
+
+    /// Destroys the stored value if one exists, making the optional empty
+    void reset() noexcept { m_value = nullptr; }
 
 private:
-  T *m_value;
-}; // namespace tl
+    T *m_value;
+};// namespace tl
 
-} // namespace tl
+}// namespace tl
 
 namespace std {
 // TODO SFINAE
-template <class T> struct hash<tl::optional<T>> {
-  ::std::size_t operator()(const tl::optional<T> &o) const {
-    if (!o.has_value())
-      return 0;
+template<class T>
+struct hash<tl::optional<T>> {
+    ::std::size_t operator()(const tl::optional<T> &o) const
+    {
+        if (!o.has_value()) return 0;
 
-    return std::hash<tl::detail::remove_const_t<T>>()(*o);
-  }
+        return std::hash<tl::detail::remove_const_t<T>>()(*o);
+    }
 };
-} // namespace std
+}// namespace std
 
 #endif
diff --git a/tile/base/internal/singly_linked_list.h b/tile/base/internal/singly_linked_list.h
index aa500c2..ccfb131 100644
--- a/tile/base/internal/singly_linked_list.h
+++ b/tile/base/internal/singly_linked_list.h
@@ -11,287 +11,319 @@
 namespace tile {
 namespace internal {
 struct SinglyLinkedListEntry {
-  SinglyLinkedListEntry *next = this;
+    SinglyLinkedListEntry *next = this;
 };
 
-template <typename T, SinglyLinkedListEntry T::*kEntry> class SinglyLinkedList {
+template<typename T, SinglyLinkedListEntry T::*kEntry>
+class SinglyLinkedList {
 public:
-  class iterator;
-  class const_iterator;
+    class iterator;
+    class const_iterator;
 
-  constexpr SinglyLinkedList();
-  T &front() noexcept;
-  T &back() noexcept;
+    constexpr SinglyLinkedList();
+    T &front() noexcept;
+    T &back() noexcept;
 
-  constexpr const T &front() const noexcept;
-  constexpr const T &back() const noexcept;
+    constexpr const T &front() const noexcept;
+    constexpr const T &back() const noexcept;
 
-  T *pop_front() noexcept;
-  void push_front(T *entry) noexcept;
-  void push_back(T *entry) noexcept;
+    T *pop_front() noexcept;
+    void push_front(T *entry) noexcept;
+    void push_back(T *entry) noexcept;
 
-  void splice(SinglyLinkedList &&other) noexcept;
-  void swap(SinglyLinkedList &other) noexcept;
+    void splice(SinglyLinkedList &&other) noexcept;
+    void swap(SinglyLinkedList &other) noexcept;
 
-  constexpr std::size_t size() const noexcept;
+    constexpr std::size_t size() const noexcept;
 
-  constexpr bool empty() const noexcept;
+    constexpr bool empty() const noexcept;
 
-  iterator begin() noexcept;
-  iterator end() noexcept;
-  constexpr const_iterator begin() const noexcept;
-  constexpr const_iterator end() const noexcept;
+    iterator begin() noexcept;
+    iterator end() noexcept;
+    constexpr const_iterator begin() const noexcept;
+    constexpr const_iterator end() const noexcept;
 
-  SinglyLinkedList(SinglyLinkedList &&other) noexcept;
-  SinglyLinkedList &operator=(SinglyLinkedList &&otehr) noexcept;
+    SinglyLinkedList(SinglyLinkedList &&other) noexcept;
+    SinglyLinkedList &operator=(SinglyLinkedList &&otehr) noexcept;
 
-  SinglyLinkedList(const SinglyLinkedList &) = delete;
-  SinglyLinkedList &operator=(const SinglyLinkedList &) = delete;
+    SinglyLinkedList(const SinglyLinkedList &)            = delete;
+    SinglyLinkedList &operator=(const SinglyLinkedList &) = delete;
 
 private:
-  static const std::uintptr_t kSinglyLinkedListEntryOffset =
-      reinterpret_cast<std::uintptr_t>(&(reinterpret_cast<T *>(0)->*kEntry));
-  static constexpr SinglyLinkedListEntry *node_cast(T *ptr) noexcept;
-  static constexpr const SinglyLinkedListEntry *
-  node_cast(const T *ptr) noexcept;
+    static const std::uintptr_t kSinglyLinkedListEntryOffset =
+        reinterpret_cast<std::uintptr_t>(&(reinterpret_cast<T *>(0)->*kEntry));
+    static constexpr SinglyLinkedListEntry *node_cast(T *ptr) noexcept;
+    static constexpr const SinglyLinkedListEntry *node_cast(const T *ptr) noexcept;
 
-  static constexpr T *object_cast(SinglyLinkedListEntry *entry) noexcept;
-  static constexpr const T *
-  object_cast(const SinglyLinkedListEntry *entry) noexcept;
+    static constexpr T *object_cast(SinglyLinkedListEntry *entry) noexcept;
+    static constexpr const T *object_cast(const SinglyLinkedListEntry *entry) noexcept;
 
 private:
-  std::size_t size_{};
-  SinglyLinkedListEntry *next_{};
-  SinglyLinkedListEntry *tail_{};
+    std::size_t size_{};
+    SinglyLinkedListEntry *next_{};
+    SinglyLinkedListEntry *tail_{};
 };
 
-template <typename T, SinglyLinkedListEntry T::*kEntry>
+template<typename T, SinglyLinkedListEntry T::*kEntry>
 class SinglyLinkedList<T, kEntry>::iterator {
 public:
-  constexpr iterator() : current_(nullptr) {}
-  iterator &operator++() noexcept {
-    current_ = current_->next;
-    return *this;
-  }
+    constexpr iterator() : current_(nullptr) {}
 
-  iterator operator++(int) noexcept {
-    iterator copy = *this;
-    current_ = current_->next;
-    return copy;
-  }
+    iterator &operator++() noexcept
+    {
+        current_ = current_->next;
+        return *this;
+    }
 
-  constexpr T *operator->() const noexcept { return object_cast(current_); }
-  constexpr T &operator*() const noexcept { return *object_cast(current_); }
-  constexpr bool operator!=(const iterator &other) const noexcept {
-    return current_ != other.current_;
-  }
+    iterator operator++(int) noexcept
+    {
+        iterator copy = *this;
+        current_      = current_->next;
+        return copy;
+    }
 
-  constexpr bool operator==(const iterator &other) const noexcept {
-    return current_ == other.current_;
-  }
+    constexpr T *operator->() const noexcept { return object_cast(current_); }
+
+    constexpr T &operator*() const noexcept { return *object_cast(current_); }
+
+    constexpr bool operator!=(const iterator &other) const noexcept { return current_ != other.current_; }
+
+    constexpr bool operator==(const iterator &other) const noexcept { return current_ == other.current_; }
 
 private:
-  friend class SinglyLinkedList<T, kEntry>;
-  constexpr iterator(SinglyLinkedListEntry *start) : current_(start) {}
+    friend class SinglyLinkedList<T, kEntry>;
+
+    constexpr iterator(SinglyLinkedListEntry *start) : current_(start) {}
 
 private:
-  SinglyLinkedListEntry *current_;
+    SinglyLinkedListEntry *current_;
 };
 
-template <typename T, SinglyLinkedListEntry T::*kEntry>
+template<typename T, SinglyLinkedListEntry T::*kEntry>
 class SinglyLinkedList<T, kEntry>::const_iterator {
 public:
-  constexpr const_iterator() : current_(nullptr) {}
-  constexpr const_iterator(const iterator &from) : current_(from.current_) {}
-  const_iterator &operator++() noexcept {
-    current_ = current_->next;
-    return *this;
-  }
-  const_iterator operator++(int) noexcept {
-    const_iterator copy = *this;
-    current_ = current_->next;
-    return copy;
-  }
-  constexpr T *operator->() const noexcept { return object_cast(current_); }
-  constexpr T &operator*() const noexcept { return *object_cast(current_); }
-  constexpr bool operator!=(const const_iterator &other) const noexcept {
-    return current_ != other.current_;
-  }
-  constexpr bool operator==(const const_iterator &other) const noexcept {
-    return current_ == other.current_;
-  }
+    constexpr const_iterator() : current_(nullptr) {}
+
+    constexpr const_iterator(const iterator &from) : current_(from.current_) {}
+
+    const_iterator &operator++() noexcept
+    {
+        current_ = current_->next;
+        return *this;
+    }
+
+    const_iterator operator++(int) noexcept
+    {
+        const_iterator copy = *this;
+        current_            = current_->next;
+        return copy;
+    }
+
+    constexpr T *operator->() const noexcept { return object_cast(current_); }
+
+    constexpr T &operator*() const noexcept { return *object_cast(current_); }
+
+    constexpr bool operator!=(const const_iterator &other) const noexcept { return current_ != other.current_; }
+
+    constexpr bool operator==(const const_iterator &other) const noexcept { return current_ == other.current_; }
 
 private:
-  SinglyLinkedListEntry *current_;
+    SinglyLinkedListEntry *current_;
 };
 
-template <typename T, SinglyLinkedListEntry T::*kEntry>
+template<typename T, SinglyLinkedListEntry T::*kEntry>
 const std::uintptr_t SinglyLinkedList<T, kEntry>::kSinglyLinkedListEntryOffset;
 
-template <class T, SinglyLinkedListEntry T::*kEntry>
+template<class T, SinglyLinkedListEntry T::*kEntry>
 constexpr inline SinglyLinkedList<T, kEntry>::SinglyLinkedList() = default;
 
-template <class T, SinglyLinkedListEntry T::*kEntry>
-T &SinglyLinkedList<T, kEntry>::front() noexcept {
-  TILE_DCHECK(!empty(), "Calling `front()` on empty list is undefined.");
-  return *object_cast(next_);
+template<class T, SinglyLinkedListEntry T::*kEntry>
+T &
+SinglyLinkedList<T, kEntry>::front() noexcept
+{
+    TILE_DCHECK(!empty(), "Calling `front()` on empty list is undefined.");
+    return *object_cast(next_);
 }
 
-template <class T, SinglyLinkedListEntry T::*kEntry>
-constexpr const T &SinglyLinkedList<T, kEntry>::front() const noexcept {
-  return const_cast<SinglyLinkedList *>(this)->front();
+template<class T, SinglyLinkedListEntry T::*kEntry>
+constexpr const T &
+SinglyLinkedList<T, kEntry>::front() const noexcept
+{
+    return const_cast<SinglyLinkedList *>(this)->front();
 }
 
-template <class T, SinglyLinkedListEntry T::*kEntry>
-T &SinglyLinkedList<T, kEntry>::back() noexcept {
-  TILE_DCHECK(!empty(), "Calling `back()` on empty list is undefined.");
-  return *object_cast(tail_);
+template<class T, SinglyLinkedListEntry T::*kEntry>
+T &
+SinglyLinkedList<T, kEntry>::back() noexcept
+{
+    TILE_DCHECK(!empty(), "Calling `back()` on empty list is undefined.");
+    return *object_cast(tail_);
 }
 
-template <class T, SinglyLinkedListEntry T::*kEntry>
-constexpr const T &SinglyLinkedList<T, kEntry>::back() const noexcept {
-  return const_cast<SinglyLinkedList *>(this)->back();
+template<class T, SinglyLinkedListEntry T::*kEntry>
+constexpr const T &
+SinglyLinkedList<T, kEntry>::back() const noexcept
+{
+    return const_cast<SinglyLinkedList *>(this)->back();
 }
 
-template <class T, SinglyLinkedListEntry T::*kEntry>
-T *SinglyLinkedList<T, kEntry>::pop_front() noexcept {
-  TILE_DCHECK(!empty(), "Calling `pop_front()` on empty list is undefined.");
-  auto rc = next_;
-  next_ = next_->next;
-  if (!--size_) {
-    tail_ = nullptr;
-    TILE_DCHECK(!next_);
-  }
-  return object_cast(rc);
+template<class T, SinglyLinkedListEntry T::*kEntry>
+T *
+SinglyLinkedList<T, kEntry>::pop_front() noexcept
+{
+    TILE_DCHECK(!empty(), "Calling `pop_front()` on empty list is undefined.");
+    auto rc = next_;
+    next_   = next_->next;
+    if (!--size_) {
+        tail_ = nullptr;
+        TILE_DCHECK(!next_);
+    }
+    return object_cast(rc);
 }
 
-template <class T, SinglyLinkedListEntry T::*kEntry>
-void SinglyLinkedList<T, kEntry>::push_front(T *entry) noexcept {
-  auto ptr = node_cast(entry);
-  ptr->next = next_;
-  next_ = ptr;
-  if (!size_++) {
-    tail_ = next_;
-  }
+template<class T, SinglyLinkedListEntry T::*kEntry>
+void
+SinglyLinkedList<T, kEntry>::push_front(T *entry) noexcept
+{
+    auto ptr  = node_cast(entry);
+    ptr->next = next_;
+    next_     = ptr;
+    if (!size_++) { tail_ = next_; }
 }
 
-template <class T, SinglyLinkedListEntry T::*kEntry>
-void SinglyLinkedList<T, kEntry>::push_back(T *entry) noexcept {
-  auto ptr = node_cast(entry);
-  ptr->next = nullptr;
-  if (!empty()) {
-    tail_ = tail_->next = ptr;
-  } else {
-    next_ = tail_ = ptr;
-  }
-  ++size_;
+template<class T, SinglyLinkedListEntry T::*kEntry>
+void
+SinglyLinkedList<T, kEntry>::push_back(T *entry) noexcept
+{
+    auto ptr  = node_cast(entry);
+    ptr->next = nullptr;
+    if (!empty()) {
+        tail_ = tail_->next = ptr;
+    } else {
+        next_ = tail_ = ptr;
+    }
+    ++size_;
 }
 
-template <class T, SinglyLinkedListEntry T::*kEntry>
-void SinglyLinkedList<T, kEntry>::splice(SinglyLinkedList &&from) noexcept {
-  if (empty()) {
-    swap(from);
-    return;
-  }
-  if (from.empty()) {
-    return;
-  }
-  tail_->next = from.next_;
-  tail_ = from.tail_;
-  size_ += from.size_;
-  from.next_ = from.tail_ = nullptr;
-  from.size_ = 0;
+template<class T, SinglyLinkedListEntry T::*kEntry>
+void
+SinglyLinkedList<T, kEntry>::splice(SinglyLinkedList &&from) noexcept
+{
+    if (empty()) {
+        swap(from);
+        return;
+    }
+    if (from.empty()) { return; }
+    tail_->next = from.next_;
+    tail_       = from.tail_;
+    size_ += from.size_;
+    from.next_ = from.tail_ = nullptr;
+    from.size_              = 0;
 }
 
-template <class T, SinglyLinkedListEntry T::*kEntry>
-void SinglyLinkedList<T, kEntry>::swap(SinglyLinkedList &other) noexcept {
-  std::swap(next_, other.next_);
-  std::swap(tail_, other.tail_);
-  std::swap(size_, other.size_);
+template<class T, SinglyLinkedListEntry T::*kEntry>
+void
+SinglyLinkedList<T, kEntry>::swap(SinglyLinkedList &other) noexcept
+{
+    std::swap(next_, other.next_);
+    std::swap(tail_, other.tail_);
+    std::swap(size_, other.size_);
 }
 
-template <class T, SinglyLinkedListEntry T::*kEntry>
-constexpr std::size_t SinglyLinkedList<T, kEntry>::size() const noexcept {
-  return size_;
+template<class T, SinglyLinkedListEntry T::*kEntry>
+constexpr std::size_t
+SinglyLinkedList<T, kEntry>::size() const noexcept
+{
+    return size_;
 }
 
-template <class T, SinglyLinkedListEntry T::*kEntry>
-constexpr bool SinglyLinkedList<T, kEntry>::empty() const noexcept {
-  // TILE_DCHECK(!size_ == !next_);
-  return !size_;
+template<class T, SinglyLinkedListEntry T::*kEntry>
+constexpr bool
+SinglyLinkedList<T, kEntry>::empty() const noexcept
+{
+    // TILE_DCHECK(!size_ == !next_);
+    return !size_;
 }
 
-template <class T, SinglyLinkedListEntry T::*kEntry>
+template<class T, SinglyLinkedListEntry T::*kEntry>
 typename SinglyLinkedList<T, kEntry>::iterator
-SinglyLinkedList<T, kEntry>::begin() noexcept {
-  return iterator(next_);
+SinglyLinkedList<T, kEntry>::begin() noexcept
+{
+    return iterator(next_);
 }
 
-template <class T, SinglyLinkedListEntry T::*kEntry>
+template<class T, SinglyLinkedListEntry T::*kEntry>
 typename SinglyLinkedList<T, kEntry>::iterator
-SinglyLinkedList<T, kEntry>::end() noexcept {
-  return iterator(nullptr);
+SinglyLinkedList<T, kEntry>::end() noexcept
+{
+    return iterator(nullptr);
 }
 
-template <class T, SinglyLinkedListEntry T::*kEntry>
+template<class T, SinglyLinkedListEntry T::*kEntry>
 constexpr typename SinglyLinkedList<T, kEntry>::const_iterator
-SinglyLinkedList<T, kEntry>::begin() const noexcept {
-  return const_iterator(next_);
+SinglyLinkedList<T, kEntry>::begin() const noexcept
+{
+    return const_iterator(next_);
 }
 
-template <class T, SinglyLinkedListEntry T::*kEntry>
+template<class T, SinglyLinkedListEntry T::*kEntry>
 constexpr typename SinglyLinkedList<T, kEntry>::const_iterator
-SinglyLinkedList<T, kEntry>::end() const noexcept {
-  return const_iterator(nullptr);
+SinglyLinkedList<T, kEntry>::end() const noexcept
+{
+    return const_iterator(nullptr);
 }
 
-template <class T, SinglyLinkedListEntry T::*kEntry>
-SinglyLinkedList<T, kEntry>::SinglyLinkedList(
-    SinglyLinkedList &&other) noexcept {
-  swap(other);
+template<class T, SinglyLinkedListEntry T::*kEntry>
+SinglyLinkedList<T, kEntry>::SinglyLinkedList(SinglyLinkedList &&other) noexcept
+{
+    swap(other);
 }
 
-template <class T, SinglyLinkedListEntry T::*kEntry>
+template<class T, SinglyLinkedListEntry T::*kEntry>
 SinglyLinkedList<T, kEntry> &
-SinglyLinkedList<T, kEntry>::operator=(SinglyLinkedList &&other) noexcept {
-  TILE_CHECK(empty(), "Moving into non-empty list will likely leak.");
-  swap(other);
-  return *this;
+SinglyLinkedList<T, kEntry>::operator=(SinglyLinkedList &&other) noexcept
+{
+    TILE_CHECK(empty(), "Moving into non-empty list will likely leak.");
+    swap(other);
+    return *this;
 }
 
-template <class T, SinglyLinkedListEntry T::*kEntry>
+template<class T, SinglyLinkedListEntry T::*kEntry>
 constexpr SinglyLinkedListEntry *
-SinglyLinkedList<T, kEntry>::node_cast(T *ptr) noexcept {
-  return &(ptr->*kEntry);
+SinglyLinkedList<T, kEntry>::node_cast(T *ptr) noexcept
+{
+    return &(ptr->*kEntry);
 }
 
-template <class T, SinglyLinkedListEntry T::*kEntry>
+template<class T, SinglyLinkedListEntry T::*kEntry>
 constexpr const SinglyLinkedListEntry *
-SinglyLinkedList<T, kEntry>::node_cast(const T *ptr) noexcept {
-  return &(ptr->*kEntry);
+SinglyLinkedList<T, kEntry>::node_cast(const T *ptr) noexcept
+{
+    return &(ptr->*kEntry);
 }
 
-template <class T, SinglyLinkedListEntry T::*kEntry>
-constexpr T *SinglyLinkedList<T, kEntry>::object_cast(
-    SinglyLinkedListEntry *entry) noexcept {
-  return reinterpret_cast<T *>(reinterpret_cast<std::uintptr_t>(entry) -
-                               kSinglyLinkedListEntryOffset);
+template<class T, SinglyLinkedListEntry T::*kEntry>
+constexpr T *
+SinglyLinkedList<T, kEntry>::object_cast(SinglyLinkedListEntry *entry) noexcept
+{
+    return reinterpret_cast<T *>(reinterpret_cast<std::uintptr_t>(entry) - kSinglyLinkedListEntryOffset);
 }
 
-template <class T, SinglyLinkedListEntry T::*kEntry>
-constexpr const T *SinglyLinkedList<T, kEntry>::object_cast(
-    const SinglyLinkedListEntry *entry) noexcept {
-  return reinterpret_cast<const T *>(reinterpret_cast<std::uintptr_t>(entry) -
-                                     kSinglyLinkedListEntryOffset);
+template<class T, SinglyLinkedListEntry T::*kEntry>
+constexpr const T *
+SinglyLinkedList<T, kEntry>::object_cast(const SinglyLinkedListEntry *entry) noexcept
+{
+    return reinterpret_cast<const T *>(reinterpret_cast<std::uintptr_t>(entry) - kSinglyLinkedListEntryOffset);
 }
 
-template <class T, SinglyLinkedListEntry T::*kEntry>
-void swap(SinglyLinkedList<T, kEntry> &left,
-          SinglyLinkedList<T, kEntry> &right) noexcept {
-  left.swap(right);
+template<class T, SinglyLinkedListEntry T::*kEntry>
+void
+swap(SinglyLinkedList<T, kEntry> &left, SinglyLinkedList<T, kEntry> &right) noexcept
+{
+    left.swap(right);
 }
 
-} // namespace internal
-} // namespace tile
+}// namespace internal
+}// namespace tile
 
-#endif // TILE_BASE_INTERNAL_SINGLY_LINKED_LIST_H
+#endif// TILE_BASE_INTERNAL_SINGLY_LINKED_LIST_H
diff --git a/tile/base/internal/singly_linked_list_test.cc b/tile/base/internal/singly_linked_list_test.cc
index 66a0b55..8e5f516 100644
--- a/tile/base/internal/singly_linked_list_test.cc
+++ b/tile/base/internal/singly_linked_list_test.cc
@@ -6,153 +6,150 @@ namespace tile {
 namespace internal {
 
 struct C {
-  SinglyLinkedListEntry chain;
-  int x;
+    SinglyLinkedListEntry chain;
+    int x;
 };
 
-TEST(SinglyLinkedList, All) {
-  SinglyLinkedList<C, &C::chain> list;
-  list.push_back(new C{.x = 10});
-  list.push_back(new C{.x = 11});
-  list.push_front(new C{.x = 9});
-  list.push_front(new C{.x = 8});
-  ASSERT_FALSE(list.empty());
-  ASSERT_EQ(4, list.size());
-  ASSERT_EQ(8, list.front().x);
-  ASSERT_EQ(11, list.back().x);
+TEST(SinglyLinkedList, All)
+{
+    SinglyLinkedList<C, &C::chain> list;
+    list.push_back(new C{.x = 10});
+    list.push_back(new C{.x = 11});
+    list.push_front(new C{.x = 9});
+    list.push_front(new C{.x = 8});
+    ASSERT_FALSE(list.empty());
+    ASSERT_EQ(4, list.size());
+    ASSERT_EQ(8, list.front().x);
+    ASSERT_EQ(11, list.back().x);
 
-  C tmp{.x = 7};
-  list.push_front(&tmp);
-  list.push_front(new C{.x = 6});
-  ASSERT_EQ(6, list.front().x);
-  delete list.pop_front();
-  ASSERT_EQ(7, list.front().x);
-  list.pop_front();
-
-  for (int i = 8; i <= 11; ++i) {
-    ASSERT_EQ(i, list.front().x);
+    C tmp{.x = 7};
+    list.push_front(&tmp);
+    list.push_front(new C{.x = 6});
+    ASSERT_EQ(6, list.front().x);
     delete list.pop_front();
-  }
+    ASSERT_EQ(7, list.front().x);
+    list.pop_front();
+
+    for (int i = 8; i <= 11; ++i) {
+        ASSERT_EQ(i, list.front().x);
+        delete list.pop_front();
+    }
 }
 
-TEST(SinglyLinkedList, Splice) {
-  SinglyLinkedList<C, &C::chain> list;
-  list.push_back(new C{.x = 1});
-  SinglyLinkedList<C, &C::chain> list2;
-  ASSERT_EQ(1, list.front().x);
-  ASSERT_EQ(1, list.back().x);
-  list.splice(std::move(list2));
-  ASSERT_EQ(1, list.front().x);
-  ASSERT_EQ(1, list.back().x);
-  list.push_back(new C{.x = 2});
-  ASSERT_EQ(1, list.front().x);
-  ASSERT_EQ(2, list.back().x);
-  list.splice(std::move(list2));
-  ASSERT_EQ(1, list.front().x);
-  ASSERT_EQ(2, list.back().x);
-  list2.push_back(new C{.x = 3});
-  list.splice(std::move(list2));
-  ASSERT_TRUE(list2.empty());
-  ASSERT_EQ(1, list.front().x);
-  ASSERT_EQ(3, list.back().x);
-  list2.push_back(new C{.x = 4});
-  list2.push_back(new C{.x = 5});
-  list.splice(std::move(list2));
-  ASSERT_TRUE(list2.empty());
-  ASSERT_EQ(1, list.front().x);
-  ASSERT_EQ(5, list.back().x);
+TEST(SinglyLinkedList, Splice)
+{
+    SinglyLinkedList<C, &C::chain> list;
+    list.push_back(new C{.x = 1});
+    SinglyLinkedList<C, &C::chain> list2;
+    ASSERT_EQ(1, list.front().x);
+    ASSERT_EQ(1, list.back().x);
+    list.splice(std::move(list2));
+    ASSERT_EQ(1, list.front().x);
+    ASSERT_EQ(1, list.back().x);
+    list.push_back(new C{.x = 2});
+    ASSERT_EQ(1, list.front().x);
+    ASSERT_EQ(2, list.back().x);
+    list.splice(std::move(list2));
+    ASSERT_EQ(1, list.front().x);
+    ASSERT_EQ(2, list.back().x);
+    list2.push_back(new C{.x = 3});
+    list.splice(std::move(list2));
+    ASSERT_TRUE(list2.empty());
+    ASSERT_EQ(1, list.front().x);
+    ASSERT_EQ(3, list.back().x);
+    list2.push_back(new C{.x = 4});
+    list2.push_back(new C{.x = 5});
+    list.splice(std::move(list2));
+    ASSERT_TRUE(list2.empty());
+    ASSERT_EQ(1, list.front().x);
+    ASSERT_EQ(5, list.back().x);
 
-  for (int i = 1; i <= 5; ++i) {
-    ASSERT_EQ(i, list.front().x);
-    delete list.pop_front();
-  }
+    for (int i = 1; i <= 5; ++i) {
+        ASSERT_EQ(i, list.front().x);
+        delete list.pop_front();
+    }
 }
 
-TEST(SinglyLinkedList, Swap) {
-  SinglyLinkedList<C, &C::chain> list;
-  list.push_back(new C{.x = 1});
-  list.push_back(new C{.x = 2});
-  list.push_back(new C{.x = 3});
-  list.push_back(new C{.x = 4});
-  ASSERT_EQ(4, list.size());
-  ASSERT_EQ(1, list.front().x);
-  ASSERT_EQ(4, list.back().x);
+TEST(SinglyLinkedList, Swap)
+{
+    SinglyLinkedList<C, &C::chain> list;
+    list.push_back(new C{.x = 1});
+    list.push_back(new C{.x = 2});
+    list.push_back(new C{.x = 3});
+    list.push_back(new C{.x = 4});
+    ASSERT_EQ(4, list.size());
+    ASSERT_EQ(1, list.front().x);
+    ASSERT_EQ(4, list.back().x);
 
-  SinglyLinkedList<C, &C::chain> list2;
-  list.swap(list2);
-  ASSERT_TRUE(list.empty());
-  ASSERT_EQ(4, list2.size());
-  ASSERT_EQ(1, list2.front().x);
-  ASSERT_EQ(4, list2.back().x);
+    SinglyLinkedList<C, &C::chain> list2;
+    list.swap(list2);
+    ASSERT_TRUE(list.empty());
+    ASSERT_EQ(4, list2.size());
+    ASSERT_EQ(1, list2.front().x);
+    ASSERT_EQ(4, list2.back().x);
 
-  list.swap(list2);
-  ASSERT_TRUE(list2.empty());
-  ASSERT_EQ(4, list.size());
-  ASSERT_EQ(1, list.front().x);
-  ASSERT_EQ(4, list.back().x);
+    list.swap(list2);
+    ASSERT_TRUE(list2.empty());
+    ASSERT_EQ(4, list.size());
+    ASSERT_EQ(1, list.front().x);
+    ASSERT_EQ(4, list.back().x);
 
-  list2.push_back(new C{.x = 5});
-  list2.push_back(new C{.x = 6});
-  list2.push_back(new C{.x = 7});
-  list2.push_back(new C{.x = 8});
+    list2.push_back(new C{.x = 5});
+    list2.push_back(new C{.x = 6});
+    list2.push_back(new C{.x = 7});
+    list2.push_back(new C{.x = 8});
 
-  list.swap(list2);
-  ASSERT_EQ(4, list2.size());
-  ASSERT_EQ(1, list2.front().x);
-  ASSERT_EQ(4, list2.back().x);
-  ASSERT_EQ(4, list.size());
-  ASSERT_EQ(5, list.front().x);
-  ASSERT_EQ(8, list.back().x);
+    list.swap(list2);
+    ASSERT_EQ(4, list2.size());
+    ASSERT_EQ(1, list2.front().x);
+    ASSERT_EQ(4, list2.back().x);
+    ASSERT_EQ(4, list.size());
+    ASSERT_EQ(5, list.front().x);
+    ASSERT_EQ(8, list.back().x);
 
-  for (int i = 1; i <= 4; ++i) {
-    ASSERT_EQ(i, list2.front().x);
-    delete list2.pop_front();
-  }
-  for (int i = 5; i <= 8; ++i) {
-    ASSERT_EQ(i, list.front().x);
-    delete list.pop_front();
-  }
+    for (int i = 1; i <= 4; ++i) {
+        ASSERT_EQ(i, list2.front().x);
+        delete list2.pop_front();
+    }
+    for (int i = 5; i <= 8; ++i) {
+        ASSERT_EQ(i, list.front().x);
+        delete list.pop_front();
+    }
 
-  ASSERT_TRUE(list.empty());
-  ASSERT_TRUE(list2.empty());
+    ASSERT_TRUE(list.empty());
+    ASSERT_TRUE(list2.empty());
 }
 
-TEST(SinglyLinkedList, Iterator) {
-  SinglyLinkedList<C, &C::chain> list;
-  list.push_back(new C{.x = 4});
-  list.push_back(new C{.x = 5});
-  list.push_back(new C{.x = 6});
-  list.push_front(new C{.x = 3});
-  list.push_front(new C{.x = 2});
-  list.push_front(new C{.x = 1});
+TEST(SinglyLinkedList, Iterator)
+{
+    SinglyLinkedList<C, &C::chain> list;
+    list.push_back(new C{.x = 4});
+    list.push_back(new C{.x = 5});
+    list.push_back(new C{.x = 6});
+    list.push_front(new C{.x = 3});
+    list.push_front(new C{.x = 2});
+    list.push_front(new C{.x = 1});
 
-  int i = 1;
-  for (auto v : list) {
-    ASSERT_EQ(i++, v.x);
-  }
-  while (!list.empty()) {
-    delete list.pop_front();
-  }
+    int i = 1;
+    for (auto v : list) { ASSERT_EQ(i++, v.x); }
+    while (!list.empty()) { delete list.pop_front(); }
 }
 
-TEST(SinglyLinkedList, ConstIterator) {
-  SinglyLinkedList<C, &C::chain> list;
-  list.push_back(new C{.x = 4});
-  list.push_back(new C{.x = 5});
-  list.push_back(new C{.x = 6});
-  list.push_front(new C{.x = 3});
-  list.push_front(new C{.x = 2});
-  list.push_front(new C{.x = 1});
-  const auto &const_list = list;
+TEST(SinglyLinkedList, ConstIterator)
+{
+    SinglyLinkedList<C, &C::chain> list;
+    list.push_back(new C{.x = 4});
+    list.push_back(new C{.x = 5});
+    list.push_back(new C{.x = 6});
+    list.push_front(new C{.x = 3});
+    list.push_front(new C{.x = 2});
+    list.push_front(new C{.x = 1});
+    const auto &const_list = list;
 
-  int i = 1;
-  for (auto v : const_list) {
-    ASSERT_EQ(i++, v.x);
-  }
-  while (!list.empty()) {
-    delete list.pop_front();
-  }
+    int i                  = 1;
+    for (auto v : const_list) { ASSERT_EQ(i++, v.x); }
+    while (!list.empty()) { delete list.pop_front(); }
 }
 
-} // namespace internal
-} // namespace tile
+}// namespace internal
+}// namespace tile
diff --git a/tile/base/internal/test_prod.h b/tile/base/internal/test_prod.h
index 1e3acf4..5ac51da 100644
--- a/tile/base/internal/test_prod.h
+++ b/tile/base/internal/test_prod.h
@@ -4,8 +4,7 @@
 #pragma once
 
 #ifndef TILE_FRIEND_TEST
-#define TILE_FRIEND_TEST(test_cast_name, test_case_name)                       \
-  friend class test_cast_name##_##test_case_name##_Test
-#endif // !TILE_FRIEND_TEST
+#define TILE_FRIEND_TEST(test_cast_name, test_case_name) friend class test_cast_name##_##test_case_name##_Test
+#endif// !TILE_FRIEND_TEST
 
-#endif // TILE_BASE_INTERNAL_TEST_PROD_H
+#endif// TILE_BASE_INTERNAL_TEST_PROD_H
diff --git a/tile/base/internal/thread_pool.cc b/tile/base/internal/thread_pool.cc
index 3a333f9..6a76a4f 100644
--- a/tile/base/internal/thread_pool.cc
+++ b/tile/base/internal/thread_pool.cc
@@ -5,63 +5,66 @@
 
 namespace tile {
 namespace internal {
-ThreadPool::ThreadPool(std::size_t workers, const std::vector<int> &affinity,
-                       int nice_value) {
-  TILE_CHECK_GE(workers, 1);
-  workers_.resize(workers);
-  for (auto &&t : workers_) {
-    t = std::thread([=] {
-      if (nice_value) {
-        // set nice
-      }
+ThreadPool::ThreadPool(std::size_t workers, const std::vector<int> &affinity, int nice_value)
+{
+    TILE_CHECK_GE(workers, 1);
+    workers_.resize(workers);
+    for (auto &&t : workers_) {
+        t = std::thread([=] {
+            if (nice_value) {
+                // set nice
+            }
 
-      if (!affinity.empty()) {
-        // SetCurrentThreadAffinity
-      }
+            if (!affinity.empty()) {
+                // SetCurrentThreadAffinity
+            }
 
-      WorkerProc();
-    });
-  }
-}
-
-void ThreadPool::QueueJob(JobType &&job) {
-  TILE_CHECK(job != nullptr);
-  ScopedLock _(lock_);
-  jobs_.push(std::move(job));
-  cv_.NotifyOne();
-}
-
-void ThreadPool::Stop() {
-  ScopedLock _(lock_);
-  exiting_.store(true, std::memory_order_relaxed);
-  cv_.NotifyAll();
-}
-void ThreadPool::Join() {
-  for (auto &&t : workers_) {
-    t.join();
-  }
-}
-
-void ThreadPool::WorkerProc() {
-  while (true) {
-    UniqueLock<Mutex> lk(lock_);
-    cv_.Wait(lk, [&] {
-      return exiting_.load(std::memory_order_relaxed) || !jobs_.empty();
-    });
-
-    if (exiting_.load(std::memory_order_relaxed)) {
-      break;
+            WorkerProc();
+        });
     }
-
-    TILE_CHECK(!jobs_.empty());
-    JobType job = jobs_.front();
-    jobs_.pop();
-
-    lk.Unlock();
-    TILE_CHECK(job != nullptr);
-    job();
-  }
 }
 
-} // namespace internal
-} // namespace tile
+void
+ThreadPool::QueueJob(JobType &&job)
+{
+    TILE_CHECK(job != nullptr);
+    ScopedLock _(lock_);
+    jobs_.push(std::move(job));
+    cv_.NotifyOne();
+}
+
+void
+ThreadPool::Stop()
+{
+    ScopedLock _(lock_);
+    exiting_.store(true, std::memory_order_relaxed);
+    cv_.NotifyAll();
+}
+
+void
+ThreadPool::Join()
+{
+    for (auto &&t : workers_) { t.join(); }
+}
+
+void
+ThreadPool::WorkerProc()
+{
+    while (true) {
+        UniqueLock<Mutex> lk(lock_);
+        cv_.Wait(lk, [&] { return exiting_.load(std::memory_order_relaxed) || !jobs_.empty(); });
+
+        if (exiting_.load(std::memory_order_relaxed)) { break; }
+
+        TILE_CHECK(!jobs_.empty());
+        JobType job = jobs_.front();
+        jobs_.pop();
+
+        lk.Unlock();
+        TILE_CHECK(job != nullptr);
+        job();
+    }
+}
+
+}// namespace internal
+}// namespace tile
diff --git a/tile/base/internal/thread_pool.h b/tile/base/internal/thread_pool.h
index ff68c25..f8c43e6 100644
--- a/tile/base/internal/thread_pool.h
+++ b/tile/base/internal/thread_pool.h
@@ -14,25 +14,24 @@ namespace tile {
 namespace internal {
 class ThreadPool {
 public:
-  using JobType = std::function<void()>;
-  explicit ThreadPool(std::size_t workers, const std::vector<int> &afinity,
-                      int nice_value);
-  void QueueJob(JobType &&job);
-  void Stop();
-  void Join();
+    using JobType = std::function<void()>;
+    explicit ThreadPool(std::size_t workers, const std::vector<int> &afinity, int nice_value);
+    void QueueJob(JobType &&job);
+    void Stop();
+    void Join();
 
 private:
-  void WorkerProc();
+    void WorkerProc();
 
 private:
-  std::atomic<bool> exiting_{false};
-  std::vector<std::thread> workers_;
+    std::atomic<bool> exiting_{false};
+    std::vector<std::thread> workers_;
 
-  Mutex lock_;
-  CondVar cv_;
-  std::queue<JobType> jobs_;
+    Mutex lock_;
+    CondVar cv_;
+    std::queue<JobType> jobs_;
 };
-} // namespace internal
-} // namespace tile
+}// namespace internal
+}// namespace tile
 
-#endif // TILE_BASE_INTERNAL_THREAD_POOL_H
+#endif// TILE_BASE_INTERNAL_THREAD_POOL_H
diff --git a/tile/base/internal/thread_pool_test.cc b/tile/base/internal/thread_pool_test.cc
index 37798b7..2130ad5 100644
--- a/tile/base/internal/thread_pool_test.cc
+++ b/tile/base/internal/thread_pool_test.cc
@@ -5,27 +5,28 @@
 namespace tile {
 namespace internal {
 
-TEST(ThreadPool, All) {
-  for (int nice_value : {0, 10}) {
-    std::atomic<int> ct{};
-    ThreadPool tp(10, std::vector<int>(), nice_value);
-    for (int i = 0; i != 1000; ++i) {
-      tp.QueueJob([&] {
-        for (int j = 0; j != 1000; ++j) {
-          tp.QueueJob([&] { ++ct; });
+TEST(ThreadPool, All)
+{
+    for (int nice_value : {0, 10}) {
+        std::atomic<int> ct{};
+        ThreadPool tp(10, std::vector<int>(), nice_value);
+        for (int i = 0; i != 1000; ++i) {
+            tp.QueueJob([&] {
+                for (int j = 0; j != 1000; ++j) {
+                    tp.QueueJob([&] { ++ct; });
+                }
+            });
         }
-      });
+        while (ct != 1000 * 1000) {
+            std::this_thread::yield();
+            // NOTHING.
+        }
+        TILE_LOG_INFO("all task complete.");
+        tp.Stop();
+        tp.Join();
+        ASSERT_EQ(1000 * 1000, ct);// ...
     }
-    while (ct != 1000 * 1000) {
-      std::this_thread::yield();
-      // NOTHING.
-    }
-    TILE_LOG_INFO("all task complete.");
-    tp.Stop();
-    tp.Join();
-    ASSERT_EQ(1000 * 1000, ct); // ...
-  }
 }
 
-} // namespace internal
-} // namespace tile
+}// namespace internal
+}// namespace tile
diff --git a/tile/base/internal/time_keeper.cc b/tile/base/internal/time_keeper.cc
index 22c240b..4f592ad 100644
--- a/tile/base/internal/time_keeper.cc
+++ b/tile/base/internal/time_keeper.cc
@@ -12,133 +12,145 @@ namespace tile {
 namespace internal {
 
 std::atomic<bool> TimeKeeper::exited_{false};
-TimeKeeper *TimeKeeper::Instance() {
-  static NeverDestroyedSingleton<TimeKeeper> time_keeper;
-  return time_keeper.Get();
+
+TimeKeeper *
+TimeKeeper::Instance()
+{
+    static NeverDestroyedSingleton<TimeKeeper> time_keeper;
+    return time_keeper.Get();
 }
 
-void TimeKeeper::Start() {
-  worker_ = std::thread([&] { WorkerProc(); });
+void
+TimeKeeper::Start()
+{
+    worker_ = std::thread([&] { WorkerProc(); });
 }
 
-void TimeKeeper::Stop() {
-  exited_.store(true, std::memory_order_relaxed);
-  ScopedLock _(lock_);
-  cv_.NotifyAll();
-}
-
-void TimeKeeper::Join() { worker_.join(); }
-
-TimerID TimeKeeper::AddTimer(std::chrono::steady_clock::time_point expires_at,
-                             std::chrono::nanoseconds interval,
-                             std::function<void()> cb, bool is_slow_cb) {
-  return AddTimer(expires_at, interval, [cb](TimerID) { cb(); }, is_slow_cb);
-}
-
-TimerID TimeKeeper::AddTimer(std::chrono::steady_clock::time_point expires_at,
-                             std::chrono::nanoseconds interval,
-                             TimerCallback cb, bool is_slow_cb) {
-  if (TILE_UNLIKELY(exited_.load(std::memory_order_relaxed))) {
-    TILE_LOG_WARNING("`AddTime()` after `Stop()`");
-    return -1;
-  }
-  EntryPtr ptr = MakeRefCounted<Entry>();
-
-  // TODO: Add GetEntryTimerID()
-  auto timer_id = reinterpret_cast<TimerID>(ptr.Get());
-  ptr->cb = std::make_shared<TimerCallback>(std::move(cb));
-  ptr->cancelled.store(false, std::memory_order_relaxed);
-  ptr->is_slow_cb = is_slow_cb;
-  ptr->expires_at = std::max(ReadSteadyClock(), expires_at);
-  ptr->interval = interval;
-
-  {
+void
+TimeKeeper::Stop()
+{
+    exited_.store(true, std::memory_order_relaxed);
     ScopedLock _(lock_);
-    timers_.push(ptr);
     cv_.NotifyAll();
-  }
-  return timer_id;
 }
 
-void TimeKeeper::KillTimer(TimerID timer_id) {
-  Entry *timer = reinterpret_cast<Entry *>(timer_id);
-  ScopedLock _(timer->lock);
-  timer->cb = nullptr;
-  timer->cancelled.store(true, std::memory_order_relaxed);
+void
+TimeKeeper::Join()
+{
+    worker_.join();
+}
+
+TimerID
+TimeKeeper::AddTimer(std::chrono::steady_clock::time_point expires_at,
+                     std::chrono::nanoseconds interval,
+                     std::function<void()> cb,
+                     bool is_slow_cb)
+{
+    return AddTimer(expires_at, interval, [cb](TimerID) { cb(); }, is_slow_cb);
+}
+
+TimerID
+TimeKeeper::AddTimer(std::chrono::steady_clock::time_point expires_at,
+                     std::chrono::nanoseconds interval,
+                     TimerCallback cb,
+                     bool is_slow_cb)
+{
+    if (TILE_UNLIKELY(exited_.load(std::memory_order_relaxed))) {
+        TILE_LOG_WARNING("`AddTime()` after `Stop()`");
+        return -1;
+    }
+    EntryPtr ptr = MakeRefCounted<Entry>();
+
+    // TODO: Add GetEntryTimerID()
+    auto timer_id = reinterpret_cast<TimerID>(ptr.Get());
+    ptr->cb       = std::make_shared<TimerCallback>(std::move(cb));
+    ptr->cancelled.store(false, std::memory_order_relaxed);
+    ptr->is_slow_cb = is_slow_cb;
+    ptr->expires_at = std::max(ReadSteadyClock(), expires_at);
+    ptr->interval   = interval;
+
+    {
+        ScopedLock _(lock_);
+        timers_.push(ptr);
+        cv_.NotifyAll();
+    }
+    return timer_id;
+}
+
+void
+TimeKeeper::KillTimer(TimerID timer_id)
+{
+    Entry *timer = reinterpret_cast<Entry *>(timer_id);
+    ScopedLock _(timer->lock);
+    timer->cb = nullptr;
+    timer->cancelled.store(true, std::memory_order_relaxed);
 }
 
 TimeKeeper::TimeKeeper() = default;
 
-void TimeKeeper::WorkerProc() {
-  while (!exited_.load(std::memory_order_relaxed)) {
-    UniqueLock<Mutex> lk(lock_);
-    auto pred = [&] {
-      return !timers_.empty() &&
-             timers_.top()->expires_at <= ReadCoarseSteadyClock();
-    };
+void
+TimeKeeper::WorkerProc()
+{
+    while (!exited_.load(std::memory_order_relaxed)) {
+        UniqueLock<Mutex> lk(lock_);
+        auto pred = [&] { return !timers_.empty() && timers_.top()->expires_at <= ReadCoarseSteadyClock(); };
 
-    if (exited_.load(std::memory_order_relaxed)) {
-      break;
-    }
+        if (exited_.load(std::memory_order_relaxed)) { break; }
 
-    auto next = timers_.empty()
-                    ? ReadCoarseSteadyClock() + std::chrono::seconds(100)
-                    : timers_.top()->expires_at;
-    if (!cv_.WaitUntil(lk, next, pred)) {
-      continue;
-    }
+        auto next = timers_.empty() ? ReadCoarseSteadyClock() + std::chrono::seconds(100) : timers_.top()->expires_at;
+        if (!cv_.WaitUntil(lk, next, pred)) { continue; }
 
-    auto p = timers_.top();
-    timers_.pop();
-    lk.Unlock();
-    if (!p->is_slow_cb.load(std::memory_order_relaxed)) {
-      FireFastTimer(std::move(p));
-    } else {
-      FireSlowTimer(std::move(p));
+        auto p = timers_.top();
+        timers_.pop();
+        lk.Unlock();
+        if (!p->is_slow_cb.load(std::memory_order_relaxed)) {
+            FireFastTimer(std::move(p));
+        } else {
+            FireSlowTimer(std::move(p));
+        }
     }
-  }
 }
 
-void TimeKeeper::FireFastTimer(EntryPtr ptr) {
-  std::shared_ptr<TimerCallback> cb;
-  {
-    ScopedLock _(ptr->lock);
-    cb = ptr->cb;
-    if (ptr->cancelled.load(std::memory_order_relaxed)) {
-      return;
-    }
-  }
-
-  (*cb)(reinterpret_cast<TimerID>(ptr.Get()));
-  ScopedLock _(lock_);
-  ScopedLock __(ptr->lock);
-  if (!ptr->cancelled.load(std::memory_order_relaxed)) {
-    ptr->expires_at += ptr->interval;
-    timers_.push(std::move(ptr));
-  }
-}
-
-void TimeKeeper::FireSlowTimer(EntryPtr ptr) {
-  BackgroundTaskHost::Instance()->Queue([this, ptr] {
+void
+TimeKeeper::FireFastTimer(EntryPtr ptr)
+{
     std::shared_ptr<TimerCallback> cb;
     {
-      ScopedLock _(ptr->lock);
-      cb = ptr->cb;
-      if (ptr->cancelled.load(std::memory_order_relaxed)) {
-        return;
-      }
+        ScopedLock _(ptr->lock);
+        cb = ptr->cb;
+        if (ptr->cancelled.load(std::memory_order_relaxed)) { return; }
     }
 
     (*cb)(reinterpret_cast<TimerID>(ptr.Get()));
     ScopedLock _(lock_);
     ScopedLock __(ptr->lock);
     if (!ptr->cancelled.load(std::memory_order_relaxed)) {
-      ptr->expires_at += ptr->interval;
-      timers_.push(ptr);
-      cv_.NotifyAll();
+        ptr->expires_at += ptr->interval;
+        timers_.push(std::move(ptr));
     }
-  });
 }
 
-} // namespace internal
-} // namespace tile
+void
+TimeKeeper::FireSlowTimer(EntryPtr ptr)
+{
+    BackgroundTaskHost::Instance()->Queue([this, ptr] {
+        std::shared_ptr<TimerCallback> cb;
+        {
+            ScopedLock _(ptr->lock);
+            cb = ptr->cb;
+            if (ptr->cancelled.load(std::memory_order_relaxed)) { return; }
+        }
+
+        (*cb)(reinterpret_cast<TimerID>(ptr.Get()));
+        ScopedLock _(lock_);
+        ScopedLock __(ptr->lock);
+        if (!ptr->cancelled.load(std::memory_order_relaxed)) {
+            ptr->expires_at += ptr->interval;
+            timers_.push(ptr);
+            cv_.NotifyAll();
+        }
+    });
+}
+
+}// namespace internal
+}// namespace tile
diff --git a/tile/base/internal/time_keeper.h b/tile/base/internal/time_keeper.h
index 6c6ef3b..f5996fe 100644
--- a/tile/base/internal/time_keeper.h
+++ b/tile/base/internal/time_keeper.h
@@ -18,75 +18,76 @@
 
 namespace tile {
 namespace internal {
-using TimerID = std::uint64_t;
+using TimerID       = std::uint64_t;
 using TimerCallback = std::function<void(TimerID)>;
+
 class TimeKeeper {
 public:
-  using Clock = std::chrono::steady_clock;
-  static TimeKeeper *Instance();
+    using Clock = std::chrono::steady_clock;
+    static TimeKeeper *Instance();
 
-  // internal interface
-  void Start();
-  void Stop();
-  void Join();
+    // internal interface
+    void Start();
+    void Stop();
+    void Join();
 
-  template <typename Rep, typename Period>
-  TimerID AddTimer(Clock::time_point expires_at,
-                   std::chrono::duration<Rep, Period> interval,
-                   TimerCallback cb, bool is_slow_cb) {
-    return AddTimer(
-        expires_at,
-        std::chrono::duration_cast<std::chrono::nanoseconds>(interval),
-        std::move(cb), is_slow_cb);
-  }
-
-  TimerID AddTimer(std::chrono::steady_clock::time_point expires_at,
-                   std::chrono::nanoseconds interval, std::function<void()> cb,
-                   bool is_slow_cb);
-  TimerID AddTimer(Clock::time_point expires_at,
-                   std::chrono::nanoseconds interval, TimerCallback cb,
-                   bool is_slow_cb);
-
-  void KillTimer(TimerID timer_id);
-
-private:
-  friend class TimeKeeper_TimerIDConv_Test;
-  friend class NeverDestroyedSingleton<TimeKeeper>;
-  struct Entry : public RefCounted<Entry> {
-    Mutex lock;
-    std::atomic<bool> cancelled{false};
-    std::atomic<bool> is_slow_cb;
-    std::atomic<bool> running{false};
-
-    std::shared_ptr<TimerCallback> cb;
-    std::chrono::steady_clock::time_point expires_at;
-    std::chrono::nanoseconds interval;
-  };
-
-  using EntryPtr = RefPtr<Entry>;
-  struct EntryPtrComp {
-    bool operator()(const EntryPtr &x, const EntryPtr &y) const {
-      return x->expires_at > y->expires_at;
+    template<typename Rep, typename Period>
+    TimerID AddTimer(Clock::time_point expires_at,
+                     std::chrono::duration<Rep, Period> interval,
+                     TimerCallback cb,
+                     bool is_slow_cb)
+    {
+        return AddTimer(expires_at, std::chrono::duration_cast<std::chrono::nanoseconds>(interval), std::move(cb),
+                        is_slow_cb);
     }
-  };
 
-  TimeKeeper();
-  TimeKeeper(const TimeKeeper &) = delete;
-  TimeKeeper &operator=(const TimeKeeper &) = delete;
+    TimerID AddTimer(std::chrono::steady_clock::time_point expires_at,
+                     std::chrono::nanoseconds interval,
+                     std::function<void()> cb,
+                     bool is_slow_cb);
+    TimerID
+    AddTimer(Clock::time_point expires_at, std::chrono::nanoseconds interval, TimerCallback cb, bool is_slow_cb);
 
-  void WorkerProc();
-  void FireFastTimer(EntryPtr ptr);
-  void FireSlowTimer(EntryPtr ptr);
+    void KillTimer(TimerID timer_id);
 
 private:
-  static std::atomic<bool> exited_;
-  Mutex lock_;
-  CondVar cv_;
-  std::priority_queue<EntryPtr, std::vector<EntryPtr>, EntryPtrComp> timers_;
-  std::thread worker_;
+    friend class TimeKeeper_TimerIDConv_Test;
+    friend class NeverDestroyedSingleton<TimeKeeper>;
+
+    struct Entry : public RefCounted<Entry> {
+        Mutex lock;
+        std::atomic<bool> cancelled{false};
+        std::atomic<bool> is_slow_cb;
+        std::atomic<bool> running{false};
+
+        std::shared_ptr<TimerCallback> cb;
+        std::chrono::steady_clock::time_point expires_at;
+        std::chrono::nanoseconds interval;
+    };
+
+    using EntryPtr = RefPtr<Entry>;
+
+    struct EntryPtrComp {
+        bool operator()(const EntryPtr &x, const EntryPtr &y) const { return x->expires_at > y->expires_at; }
+    };
+
+    TimeKeeper();
+    TimeKeeper(const TimeKeeper &)            = delete;
+    TimeKeeper &operator=(const TimeKeeper &) = delete;
+
+    void WorkerProc();
+    void FireFastTimer(EntryPtr ptr);
+    void FireSlowTimer(EntryPtr ptr);
+
+private:
+    static std::atomic<bool> exited_;
+    Mutex lock_;
+    CondVar cv_;
+    std::priority_queue<EntryPtr, std::vector<EntryPtr>, EntryPtrComp> timers_;
+    std::thread worker_;
 };
 
-} // namespace internal
-} // namespace tile
+}// namespace internal
+}// namespace tile
 
-#endif // TILE_BASE_INTERNAL_TIME_KEEPER_H
+#endif// TILE_BASE_INTERNAL_TIME_KEEPER_H
diff --git a/tile/base/internal/time_keeper_benchmark.cc b/tile/base/internal/time_keeper_benchmark.cc
index 5a24793..b8746d3 100644
--- a/tile/base/internal/time_keeper_benchmark.cc
+++ b/tile/base/internal/time_keeper_benchmark.cc
@@ -10,48 +10,40 @@ namespace internal {
 // constexpr auto kTimerCount = 10000;
 constexpr auto kInterval = std::chrono::microseconds(10);
 
-void Benchmark_TimeKeeperTimer(benchmark::State &state) {
-  std::atomic<int> expires_count{0};
+void
+Benchmark_TimeKeeperTimer(benchmark::State &state)
+{
+    std::atomic<int> expires_count{0};
 
-  std::vector<TimerID> timer_ids;
-  auto kTimerCount = state.range(1);
-  for (int i = 0; i != kTimerCount; ++i) {
-    timer_ids.push_back(TimeKeeper::Instance()->AddTimer(
-        ReadCoarseSteadyClock(), kInterval,
-        [&](TimerID) { expires_count.fetch_add(1, std::memory_order_acq_rel); },
-        state.range(0)));
-  }
-
-  while (state.KeepRunning()) {
-    while (expires_count.load(std::memory_order_relaxed) < kTimerCount) {
-      std::this_thread::yield();
+    std::vector<TimerID> timer_ids;
+    auto kTimerCount = state.range(1);
+    for (int i = 0; i != kTimerCount; ++i) {
+        timer_ids.push_back(TimeKeeper::Instance()->AddTimer(
+            ReadCoarseSteadyClock(), kInterval, [&](TimerID) { expires_count.fetch_add(1, std::memory_order_acq_rel); },
+            state.range(0)));
     }
-    expires_count.fetch_sub(kTimerCount, std::memory_order_acq_rel);
-  }
 
-  for (auto &&e : timer_ids) {
-    TimeKeeper::Instance()->KillTimer(e);
-  }
+    while (state.KeepRunning()) {
+        while (expires_count.load(std::memory_order_relaxed) < kTimerCount) { std::this_thread::yield(); }
+        expires_count.fetch_sub(kTimerCount, std::memory_order_acq_rel);
+    }
 
-  state.counters["expires_count"] =
-      expires_count.load(std::memory_order_relaxed);
+    for (auto &&e : timer_ids) { TimeKeeper::Instance()->KillTimer(e); }
+
+    state.counters["expires_count"] = expires_count.load(std::memory_order_relaxed);
 }
 
-static void CustomArguments(benchmark::internal::Benchmark *b) {
-  b->ArgNames({"is_slow_cb", "timer"});
-  static constexpr auto kMaxTimerCount = 100000;
-  for (int timer_count = 100; timer_count <= kMaxTimerCount;
-       timer_count *= 10) {
-    b->Args({false, timer_count});
-  }
+static void
+CustomArguments(benchmark::internal::Benchmark *b)
+{
+    b->ArgNames({"is_slow_cb", "timer"});
+    static constexpr auto kMaxTimerCount = 100000;
+    for (int timer_count = 100; timer_count <= kMaxTimerCount; timer_count *= 10) { b->Args({false, timer_count}); }
 
-  for (int timer_count = 100; timer_count <= kMaxTimerCount;
-       timer_count *= 10) {
-    b->Args({true, timer_count});
-  }
+    for (int timer_count = 100; timer_count <= kMaxTimerCount; timer_count *= 10) { b->Args({true, timer_count}); }
 }
 
 BENCHMARK(Benchmark_TimeKeeperTimer)->Threads(5)->Apply(CustomArguments);
 
-} // namespace internal
-} // namespace tile
+}// namespace internal
+}// namespace tile
diff --git a/tile/base/internal/time_keeper_test.cc b/tile/base/internal/time_keeper_test.cc
index f34c591..98b5704 100644
--- a/tile/base/internal/time_keeper_test.cc
+++ b/tile/base/internal/time_keeper_test.cc
@@ -12,45 +12,45 @@ namespace tile {
 namespace internal {
 
 constexpr auto kTestDuration = std::chrono::seconds(5);
-constexpr auto kInterval = std::chrono::milliseconds(10);
-constexpr auto kTimerNum = 1000;
+constexpr auto kInterval     = std::chrono::milliseconds(10);
+constexpr auto kTimerNum     = 1000;
 
-TEST(TimeKeeper, FastTimer) {
-  int x = 0;
-  auto timer_id = TimeKeeper::Instance()->AddTimer(
-      ReadCoarseSteadyClock(), kInterval, [&](TimerID) { ++x; }, false);
-  std::this_thread::sleep_for(kTestDuration);
-  TimeKeeper::Instance()->KillTimer(timer_id);
-  constexpr auto expires_count = kTestDuration / kInterval;
-  constexpr auto eps = expires_count / 10;
-  ASSERT_NEAR(x, expires_count, eps);
+TEST(TimeKeeper, FastTimer)
+{
+    int x         = 0;
+    auto timer_id = TimeKeeper::Instance()->AddTimer(ReadCoarseSteadyClock(), kInterval, [&](TimerID) { ++x; }, false);
+    std::this_thread::sleep_for(kTestDuration);
+    TimeKeeper::Instance()->KillTimer(timer_id);
+    constexpr auto expires_count = kTestDuration / kInterval;
+    constexpr auto eps           = expires_count / 10;
+    ASSERT_NEAR(x, expires_count, eps);
 }
 
-TEST(TimeKeeper, SlowTimer) {
-  std::vector<TimerID> timers;
-  std::atomic<int> x{0};
+TEST(TimeKeeper, SlowTimer)
+{
+    std::vector<TimerID> timers;
+    std::atomic<int> x{0};
 
-  for (int i = 0; i != kTimerNum; ++i) {
-    timers.push_back(TimeKeeper::Instance()->AddTimer(
-        ReadCoarseSteadyClock(), kInterval, [&](TimerID) { ++x; }, true));
-  }
-  std::this_thread::sleep_for(kTestDuration);
-  for (auto &&e : timers) {
-    TimeKeeper::Instance()->KillTimer(e);
-  }
+    for (int i = 0; i != kTimerNum; ++i) {
+        timers.push_back(
+            TimeKeeper::Instance()->AddTimer(ReadCoarseSteadyClock(), kInterval, [&](TimerID) { ++x; }, true));
+    }
+    std::this_thread::sleep_for(kTestDuration);
+    for (auto &&e : timers) { TimeKeeper::Instance()->KillTimer(e); }
 
-  const auto expires_count = kTimerNum * (kTestDuration / kInterval);
-  const auto eps = expires_count / 10;
-  ASSERT_NEAR(x, expires_count, eps);
+    const auto expires_count = kTimerNum * (kTestDuration / kInterval);
+    const auto eps           = expires_count / 10;
+    ASSERT_NEAR(x, expires_count, eps);
 }
 
-TEST(TimeKeeper, TimerIDConv) {
-  TimeKeeper::EntryPtr ptr = MakeRefCounted<TimeKeeper::Entry>();
-  auto timer_id = reinterpret_cast<TimerID>(ptr.Get());
-  auto ptr2 = reinterpret_cast<TimeKeeper::Entry *>(timer_id);
-  ASSERT_EQ(ptr.Get(), ptr2);
-  ASSERT_NE(ptr2, nullptr);
+TEST(TimeKeeper, TimerIDConv)
+{
+    TimeKeeper::EntryPtr ptr = MakeRefCounted<TimeKeeper::Entry>();
+    auto timer_id            = reinterpret_cast<TimerID>(ptr.Get());
+    auto ptr2                = reinterpret_cast<TimeKeeper::Entry *>(timer_id);
+    ASSERT_EQ(ptr.Get(), ptr2);
+    ASSERT_NE(ptr2, nullptr);
 }
 
-} // namespace internal
-} // namespace tile
+}// namespace internal
+}// namespace tile
diff --git a/tile/base/internal/utility.h b/tile/base/internal/utility.h
index b158fe6..8d76725 100644
--- a/tile/base/internal/utility.h
+++ b/tile/base/internal/utility.h
@@ -8,18 +8,23 @@
 
 namespace tile {
 namespace internal {
-template <typename T, class U = T> T Exchange(T &obj, U &&new_value) {
-  T old_value = std::move(obj);
-  obj = std::forward<U>(new_value);
-  return old_value;
+template<typename T, class U = T>
+T
+Exchange(T &obj, U &&new_value)
+{
+    T old_value = std::move(obj);
+    obj         = std::forward<U>(new_value);
+    return old_value;
 }
 
-template <typename T, typename U = T>
-bool TestAndSet(std::atomic<T> &obj, T expected_val, U &&new_value) {
-  return obj.compare_exchange_strong(expected_val, std::forward<U>(new_value));
+template<typename T, typename U = T>
+bool
+TestAndSet(std::atomic<T> &obj, T expected_val, U &&new_value)
+{
+    return obj.compare_exchange_strong(expected_val, std::forward<U>(new_value));
 }
 
-} // namespace internal
-} // namespace tile
+}// namespace internal
+}// namespace tile
 
-#endif // _TILE_BASE_INTERNAL_UTILITY_H
+#endif// _TILE_BASE_INTERNAL_UTILITY_H
diff --git a/tile/base/internal/variant.h b/tile/base/internal/variant.h
index 990a44c..f1b5f3e 100644
--- a/tile/base/internal/variant.h
+++ b/tile/base/internal/variant.h
@@ -241,8 +241,7 @@ namespace std {
 #define MPARK_ALWAYS_INLINE inline
 #endif
 
-#if __has_builtin(__builtin_addressof) || \
-    (defined(__GNUC__) && __GNUC__ >= 7) || defined(_MSC_VER)
+#if __has_builtin(__builtin_addressof) || (defined(__GNUC__) && __GNUC__ >= 7) || defined(_MSC_VER)
 #define MPARK_BUILTIN_ADDRESSOF
 #endif
 
@@ -258,8 +257,8 @@ namespace std {
 #define MPARK_TYPE_PACK_ELEMENT
 #endif
 
-#if defined(__cpp_constexpr) && __cpp_constexpr >= 200704 && \
-    !(defined(__GNUC__) && __GNUC__ == 4 && __GNUC_MINOR__ == 9)
+#if defined(__cpp_constexpr) && __cpp_constexpr >= 200704                                                              \
+    && !(defined(__GNUC__) && __GNUC__ == 4 && __GNUC_MINOR__ == 9)
 #define MPARK_CPP11_CONSTEXPR
 #endif
 
@@ -267,8 +266,7 @@ namespace std {
 #define MPARK_CPP14_CONSTEXPR
 #endif
 
-#if __has_feature(cxx_exceptions) || defined(__cpp_exceptions) || \
-    (defined(_MSC_VER) && defined(_CPPUNWIND))
+#if __has_feature(cxx_exceptions) || defined(__cpp_exceptions) || (defined(_MSC_VER) && defined(_CPPUNWIND))
 #define MPARK_EXCEPTIONS
 #endif
 
@@ -292,12 +290,12 @@ namespace std {
 #define MPARK_VARIABLE_TEMPLATES
 #endif
 
-#if !defined(__GLIBCXX__) || __has_include(<codecvt>)  // >= libstdc++-5
+#if !defined(__GLIBCXX__) || __has_include(<codecvt>)// >= libstdc++-5
 #define MPARK_TRIVIALITY_TYPE_TRAITS
 #define MPARK_INCOMPLETE_TYPE_TRAITS
 #endif
 
-#endif  // MPARK_CONFIG_HPP
+#endif// MPARK_CONFIG_HPP
 
 // MPark.Variant
 //
@@ -311,28 +309,35 @@ namespace std {
 
 #include <cstddef>
 
-
 namespace mpark {
 
-  struct in_place_t { explicit in_place_t() = default; };
+struct in_place_t {
+    explicit in_place_t() = default;
+};
 
-  template <std::size_t I>
-  struct in_place_index_t { explicit in_place_index_t() = default; };
+template<std::size_t I>
+struct in_place_index_t {
+    explicit in_place_index_t() = default;
+};
 
-  template <typename T>
-  struct in_place_type_t { explicit in_place_type_t() = default; };
+template<typename T>
+struct in_place_type_t {
+    explicit in_place_type_t() = default;
+};
 
 #ifdef MPARK_VARIABLE_TEMPLATES
-  constexpr in_place_t in_place{};
+constexpr in_place_t in_place{};
 
-  template <std::size_t I> constexpr in_place_index_t<I> in_place_index{};
+template<std::size_t I>
+constexpr in_place_index_t<I> in_place_index{};
 
-  template <typename T> constexpr in_place_type_t<T> in_place_type{};
+template<typename T>
+constexpr in_place_type_t<T> in_place_type{};
 #endif
 
-}  // namespace mpark
+}// namespace mpark
 
-#endif  // MPARK_IN_PLACE_HPP
+#endif// MPARK_IN_PLACE_HPP
 
 // MPark.Variant
 //
@@ -344,1872 +349,1808 @@ namespace mpark {
 #ifndef MPARK_LIB_HPP
 #define MPARK_LIB_HPP
 
-#include <memory>
 #include <functional>
+#include <memory>
 #include <type_traits>
 #include <utility>
 
-
-#define MPARK_RETURN(...) \
-  noexcept(noexcept(__VA_ARGS__)) -> decltype(__VA_ARGS__) { return __VA_ARGS__; }
+#define MPARK_RETURN(...)                                                                                              \
+    noexcept(noexcept(__VA_ARGS__))->decltype(__VA_ARGS__) { return __VA_ARGS__; }
 
 namespace mpark {
-  namespace lib {
-    template <typename T>
-    struct identity { using type = T; };
+namespace lib {
+template<typename T>
+struct identity {
+    using type = T;
+};
 
-    inline namespace cpp14 {
-      template <typename T, std::size_t N>
-      struct array {
-        constexpr const T &operator[](std::size_t index) const {
-          return data[index];
-        }
+inline namespace cpp14 {
+template<typename T, std::size_t N>
+struct array {
+    constexpr const T &operator[](std::size_t index) const { return data[index]; }
 
-        T data[N == 0 ? 1 : N];
-      };
+    T data[N == 0 ? 1 : N];
+};
 
-      template <typename T>
-      using add_pointer_t = typename std::add_pointer<T>::type;
+template<typename T>
+using add_pointer_t = typename std::add_pointer<T>::type;
 
-      template <typename... Ts>
-      using common_type_t = typename std::common_type<Ts...>::type;
+template<typename... Ts>
+using common_type_t = typename std::common_type<Ts...>::type;
 
-      template <typename T>
-      using decay_t = typename std::decay<T>::type;
+template<typename T>
+using decay_t = typename std::decay<T>::type;
 
-      template <bool B, typename T = void>
-      using enable_if_t = typename std::enable_if<B, T>::type;
+template<bool B, typename T = void>
+using enable_if_t = typename std::enable_if<B, T>::type;
 
-      template <typename T>
-      using remove_const_t = typename std::remove_const<T>::type;
+template<typename T>
+using remove_const_t = typename std::remove_const<T>::type;
 
-      template <typename T>
-      using remove_reference_t = typename std::remove_reference<T>::type;
+template<typename T>
+using remove_reference_t = typename std::remove_reference<T>::type;
 
-      template <typename T>
-      inline constexpr T &&forward(remove_reference_t<T> &t) noexcept {
-        return static_cast<T &&>(t);
-      }
+template<typename T>
+inline constexpr T &&
+forward(remove_reference_t<T> &t) noexcept
+{
+    return static_cast<T &&>(t);
+}
 
-      template <typename T>
-      inline constexpr T &&forward(remove_reference_t<T> &&t) noexcept {
-        static_assert(!std::is_lvalue_reference<T>::value,
-                      "can not forward an rvalue as an lvalue");
-        return static_cast<T &&>(t);
-      }
+template<typename T>
+inline constexpr T &&
+forward(remove_reference_t<T> &&t) noexcept
+{
+    static_assert(!std::is_lvalue_reference<T>::value, "can not forward an rvalue as an lvalue");
+    return static_cast<T &&>(t);
+}
 
-      template <typename T>
-      inline constexpr remove_reference_t<T> &&move(T &&t) noexcept {
-        return static_cast<remove_reference_t<T> &&>(t);
-      }
+template<typename T>
+inline constexpr remove_reference_t<T> &&
+move(T &&t) noexcept
+{
+    return static_cast<remove_reference_t<T> &&>(t);
+}
 
 #ifdef MPARK_INTEGER_SEQUENCE
-      using std::integer_sequence;
-      using std::index_sequence;
-      using std::make_index_sequence;
-      using std::index_sequence_for;
+using std::index_sequence;
+using std::index_sequence_for;
+using std::integer_sequence;
+using std::make_index_sequence;
 #else
-      template <typename T, T... Is>
-      struct integer_sequence {
-        using value_type = T;
-        static constexpr std::size_t size() noexcept { return sizeof...(Is); }
-      };
+template<typename T, T... Is>
+struct integer_sequence {
+    using value_type = T;
 
-      template <std::size_t... Is>
-      using index_sequence = integer_sequence<std::size_t, Is...>;
+    static constexpr std::size_t size() noexcept { return sizeof...(Is); }
+};
 
-      template <typename Lhs, typename Rhs>
-      struct make_index_sequence_concat;
+template<std::size_t... Is>
+using index_sequence = integer_sequence<std::size_t, Is...>;
 
-      template <std::size_t... Lhs, std::size_t... Rhs>
-      struct make_index_sequence_concat<index_sequence<Lhs...>,
-                                        index_sequence<Rhs...>>
-          : identity<index_sequence<Lhs..., (sizeof...(Lhs) + Rhs)...>> {};
+template<typename Lhs, typename Rhs>
+struct make_index_sequence_concat;
 
-      template <std::size_t N>
-      struct make_index_sequence_impl;
+template<std::size_t... Lhs, std::size_t... Rhs>
+struct make_index_sequence_concat<index_sequence<Lhs...>, index_sequence<Rhs...>>
+    : identity<index_sequence<Lhs..., (sizeof...(Lhs) + Rhs)...>> {};
 
-      template <std::size_t N>
-      using make_index_sequence = typename make_index_sequence_impl<N>::type;
+template<std::size_t N>
+struct make_index_sequence_impl;
 
-      template <std::size_t N>
-      struct make_index_sequence_impl
-          : make_index_sequence_concat<make_index_sequence<N / 2>,
-                                       make_index_sequence<N - (N / 2)>> {};
+template<std::size_t N>
+using make_index_sequence = typename make_index_sequence_impl<N>::type;
 
-      template <>
-      struct make_index_sequence_impl<0> : identity<index_sequence<>> {};
+template<std::size_t N>
+struct make_index_sequence_impl
+    : make_index_sequence_concat<make_index_sequence<N / 2>, make_index_sequence<N - (N / 2)>> {};
 
-      template <>
-      struct make_index_sequence_impl<1> : identity<index_sequence<0>> {};
+template<>
+struct make_index_sequence_impl<0> : identity<index_sequence<>> {};
 
-      template <typename... Ts>
-      using index_sequence_for = make_index_sequence<sizeof...(Ts)>;
+template<>
+struct make_index_sequence_impl<1> : identity<index_sequence<0>> {};
+
+template<typename... Ts>
+using index_sequence_for = make_index_sequence<sizeof...(Ts)>;
 #endif
 
-      // <functional>
+// <functional>
 #ifdef MPARK_TRANSPARENT_OPERATORS
-      using equal_to = std::equal_to<>;
+using equal_to = std::equal_to<>;
 #else
-      struct equal_to {
-        template <typename Lhs, typename Rhs>
-        inline constexpr auto operator()(Lhs &&lhs, Rhs &&rhs) const
-          MPARK_RETURN(lib::forward<Lhs>(lhs) == lib::forward<Rhs>(rhs))
-      };
+struct equal_to {
+    template<typename Lhs, typename Rhs>
+    inline constexpr auto operator()(Lhs &&lhs, Rhs &&rhs) const
+        MPARK_RETURN(lib::forward<Lhs>(lhs) == lib::forward<Rhs>(rhs))
+};
 #endif
 
 #ifdef MPARK_TRANSPARENT_OPERATORS
-      using not_equal_to = std::not_equal_to<>;
+using not_equal_to = std::not_equal_to<>;
 #else
-      struct not_equal_to {
-        template <typename Lhs, typename Rhs>
-        inline constexpr auto operator()(Lhs &&lhs, Rhs &&rhs) const
-          MPARK_RETURN(lib::forward<Lhs>(lhs) != lib::forward<Rhs>(rhs))
-      };
+struct not_equal_to {
+    template<typename Lhs, typename Rhs>
+    inline constexpr auto operator()(Lhs &&lhs, Rhs &&rhs) const
+        MPARK_RETURN(lib::forward<Lhs>(lhs) != lib::forward<Rhs>(rhs))
+};
 #endif
 
 #ifdef MPARK_TRANSPARENT_OPERATORS
-      using less = std::less<>;
+using less = std::less<>;
 #else
-      struct less {
-        template <typename Lhs, typename Rhs>
-        inline constexpr auto operator()(Lhs &&lhs, Rhs &&rhs) const
-          MPARK_RETURN(lib::forward<Lhs>(lhs) < lib::forward<Rhs>(rhs))
-      };
+struct less {
+    template<typename Lhs, typename Rhs>
+    inline constexpr auto operator()(Lhs &&lhs, Rhs &&rhs) const
+        MPARK_RETURN(lib::forward<Lhs>(lhs) < lib::forward<Rhs>(rhs))
+};
 #endif
 
 #ifdef MPARK_TRANSPARENT_OPERATORS
-      using greater = std::greater<>;
+using greater = std::greater<>;
 #else
-      struct greater {
-        template <typename Lhs, typename Rhs>
-        inline constexpr auto operator()(Lhs &&lhs, Rhs &&rhs) const
-          MPARK_RETURN(lib::forward<Lhs>(lhs) > lib::forward<Rhs>(rhs))
-      };
+struct greater {
+    template<typename Lhs, typename Rhs>
+    inline constexpr auto operator()(Lhs &&lhs, Rhs &&rhs) const
+        MPARK_RETURN(lib::forward<Lhs>(lhs) > lib::forward<Rhs>(rhs))
+};
 #endif
 
 #ifdef MPARK_TRANSPARENT_OPERATORS
-      using less_equal = std::less_equal<>;
+using less_equal = std::less_equal<>;
 #else
-      struct less_equal {
-        template <typename Lhs, typename Rhs>
-        inline constexpr auto operator()(Lhs &&lhs, Rhs &&rhs) const
-          MPARK_RETURN(lib::forward<Lhs>(lhs) <= lib::forward<Rhs>(rhs))
-      };
+struct less_equal {
+    template<typename Lhs, typename Rhs>
+    inline constexpr auto operator()(Lhs &&lhs, Rhs &&rhs) const
+        MPARK_RETURN(lib::forward<Lhs>(lhs) <= lib::forward<Rhs>(rhs))
+};
 #endif
 
 #ifdef MPARK_TRANSPARENT_OPERATORS
-      using greater_equal = std::greater_equal<>;
+using greater_equal = std::greater_equal<>;
 #else
-      struct greater_equal {
-        template <typename Lhs, typename Rhs>
-        inline constexpr auto operator()(Lhs &&lhs, Rhs &&rhs) const
-          MPARK_RETURN(lib::forward<Lhs>(lhs) >= lib::forward<Rhs>(rhs))
-      };
+struct greater_equal {
+    template<typename Lhs, typename Rhs>
+    inline constexpr auto operator()(Lhs &&lhs, Rhs &&rhs) const
+        MPARK_RETURN(lib::forward<Lhs>(lhs) >= lib::forward<Rhs>(rhs))
+};
 #endif
-    }  // namespace cpp14
+}// namespace cpp14
 
-    inline namespace cpp17 {
+inline namespace cpp17 {
 
-      // <type_traits>
-      template <bool B>
-      using bool_constant = std::integral_constant<bool, B>;
+// <type_traits>
+template<bool B>
+using bool_constant = std::integral_constant<bool, B>;
 
-      template <typename...>
-      struct voider : identity<void> {};
+template<typename...>
+struct voider : identity<void> {};
 
-      template <typename... Ts>
-      using void_t = typename voider<Ts...>::type;
+template<typename... Ts>
+using void_t = typename voider<Ts...>::type;
 
-      namespace detail {
-        namespace swappable {
+namespace detail {
+namespace swappable {
 
-          using std::swap;
+using std::swap;
 
-          template <typename T>
-          struct is_swappable {
-            private:
-            template <typename U,
-                      typename = decltype(swap(std::declval<U &>(),
-                                               std::declval<U &>()))>
-            inline static std::true_type test(int);
+template<typename T>
+struct is_swappable {
+private:
+    template<typename U, typename = decltype(swap(std::declval<U &>(), std::declval<U &>()))>
+    inline static std::true_type test(int);
 
-            template <typename U>
-            inline static std::false_type test(...);
+    template<typename U>
+    inline static std::false_type test(...);
 
-            public:
-            static constexpr bool value = decltype(test<T>(0))::value;
-          };
+public:
+    static constexpr bool value = decltype(test<T>(0))::value;
+};
 
-          template <bool IsSwappable, typename T>
-          struct is_nothrow_swappable {
-            static constexpr bool value =
-                noexcept(swap(std::declval<T &>(), std::declval<T &>()));
-          };
+template<bool IsSwappable, typename T>
+struct is_nothrow_swappable {
+    static constexpr bool value = noexcept(swap(std::declval<T &>(), std::declval<T &>()));
+};
 
-          template <typename T>
-          struct is_nothrow_swappable<false, T> : std::false_type {};
+template<typename T>
+struct is_nothrow_swappable<false, T> : std::false_type {};
 
-        }  // namespace swappable
-      }  // namespace detail
+}// namespace swappable
+}// namespace detail
 
-      using detail::swappable::is_swappable;
+using detail::swappable::is_swappable;
 
-      template <typename T>
-      using is_nothrow_swappable =
-          detail::swappable::is_nothrow_swappable<is_swappable<T>::value, T>;
+template<typename T>
+using is_nothrow_swappable = detail::swappable::is_nothrow_swappable<is_swappable<T>::value, T>;
 
-      // <functional>
-      namespace detail {
+// <functional>
+namespace detail {
 
-        template <typename T>
-        struct is_reference_wrapper : std::false_type {};
+template<typename T>
+struct is_reference_wrapper : std::false_type {};
 
-        template <typename T>
-        struct is_reference_wrapper<std::reference_wrapper<T>>
-            : std::true_type {};
+template<typename T>
+struct is_reference_wrapper<std::reference_wrapper<T>> : std::true_type {};
 
-        template <bool, int>
-        struct Invoke;
+template<bool, int>
+struct Invoke;
 
-        template <>
-        struct Invoke<true /* pmf */, 0 /* is_base_of */> {
-          template <typename R, typename T, typename Arg, typename... Args>
-          inline static constexpr auto invoke(R T::*pmf, Arg &&arg, Args &&... args)
-            MPARK_RETURN((lib::forward<Arg>(arg).*pmf)(lib::forward<Args>(args)...))
-        };
+template<>
+struct Invoke<true /* pmf */, 0 /* is_base_of */> {
+    template<typename R, typename T, typename Arg, typename... Args>
+    inline static constexpr auto invoke(R T::*pmf, Arg &&arg, Args &&...args)
+        MPARK_RETURN((lib::forward<Arg>(arg).*pmf)(lib::forward<Args>(args)...))
+};
 
-        template <>
-        struct Invoke<true /* pmf */, 1 /* is_reference_wrapper */> {
-          template <typename R, typename T, typename Arg, typename... Args>
-          inline static constexpr auto invoke(R T::*pmf, Arg &&arg, Args &&... args)
-            MPARK_RETURN((lib::forward<Arg>(arg).get().*pmf)(lib::forward<Args>(args)...))
-        };
+template<>
+struct Invoke<true /* pmf */, 1 /* is_reference_wrapper */> {
+    template<typename R, typename T, typename Arg, typename... Args>
+    inline static constexpr auto invoke(R T::*pmf, Arg &&arg, Args &&...args)
+        MPARK_RETURN((lib::forward<Arg>(arg).get().*pmf)(lib::forward<Args>(args)...))
+};
 
-        template <>
-        struct Invoke<true /* pmf */, 2 /* otherwise */> {
-          template <typename R, typename T, typename Arg, typename... Args>
-          inline static constexpr auto invoke(R T::*pmf, Arg &&arg, Args &&... args)
-            MPARK_RETURN(((*lib::forward<Arg>(arg)).*pmf)(lib::forward<Args>(args)...))
-        };
+template<>
+struct Invoke<true /* pmf */, 2 /* otherwise */> {
+    template<typename R, typename T, typename Arg, typename... Args>
+    inline static constexpr auto invoke(R T::*pmf, Arg &&arg, Args &&...args)
+        MPARK_RETURN(((*lib::forward<Arg>(arg)).*pmf)(lib::forward<Args>(args)...))
+};
 
-        template <>
-        struct Invoke<false /* pmo */, 0 /* is_base_of */> {
-          template <typename R, typename T, typename Arg>
-          inline static constexpr auto invoke(R T::*pmo, Arg &&arg)
-            MPARK_RETURN(lib::forward<Arg>(arg).*pmo)
-        };
+template<>
+struct Invoke<false /* pmo */, 0 /* is_base_of */> {
+    template<typename R, typename T, typename Arg>
+    inline static constexpr auto invoke(R T::*pmo, Arg &&arg) MPARK_RETURN(lib::forward<Arg>(arg).*pmo)
+};
 
-        template <>
-        struct Invoke<false /* pmo */, 1 /* is_reference_wrapper */> {
-          template <typename R, typename T, typename Arg>
-          inline static constexpr auto invoke(R T::*pmo, Arg &&arg)
-            MPARK_RETURN(lib::forward<Arg>(arg).get().*pmo)
-        };
+template<>
+struct Invoke<false /* pmo */, 1 /* is_reference_wrapper */> {
+    template<typename R, typename T, typename Arg>
+    inline static constexpr auto invoke(R T::*pmo, Arg &&arg) MPARK_RETURN(lib::forward<Arg>(arg).get().*pmo)
+};
 
-        template <>
-        struct Invoke<false /* pmo */, 2 /* otherwise */> {
-          template <typename R, typename T, typename Arg>
-          inline static constexpr auto invoke(R T::*pmo, Arg &&arg)
-              MPARK_RETURN((*lib::forward<Arg>(arg)).*pmo)
-        };
+template<>
+struct Invoke<false /* pmo */, 2 /* otherwise */> {
+    template<typename R, typename T, typename Arg>
+    inline static constexpr auto invoke(R T::*pmo, Arg &&arg) MPARK_RETURN((*lib::forward<Arg>(arg)).*pmo)
+};
 
-        template <typename R, typename T, typename Arg, typename... Args>
-        inline constexpr auto invoke(R T::*f, Arg &&arg, Args &&... args)
-          MPARK_RETURN(
-              Invoke<std::is_function<R>::value,
-                     (std::is_base_of<T, lib::decay_t<Arg>>::value
-                          ? 0
-                          : is_reference_wrapper<lib::decay_t<Arg>>::value
-                                ? 1
-                                : 2)>::invoke(f,
-                                              lib::forward<Arg>(arg),
-                                              lib::forward<Args>(args)...))
+template<typename R, typename T, typename Arg, typename... Args>
+inline constexpr auto
+invoke(R T::*f, Arg &&arg, Args &&...args)
+    MPARK_RETURN(Invoke<std::is_function<R>::value,
+                        (std::is_base_of<T, lib::decay_t<Arg>>::value ? 0
+                             : is_reference_wrapper<lib::decay_t<Arg>>::value
+                             ? 1
+                             : 2)>::invoke(f, lib::forward<Arg>(arg), lib::forward<Args>(args)...))
 
 #ifdef _MSC_VER
 #pragma warning(push)
 #pragma warning(disable : 4100)
 #endif
-        template <typename F, typename... Args>
-        inline constexpr auto invoke(F &&f, Args &&... args)
-          MPARK_RETURN(lib::forward<F>(f)(lib::forward<Args>(args)...))
+        template<typename F, typename... Args>
+        inline constexpr auto invoke(F &&f, Args &&...args)
+            MPARK_RETURN(lib::forward<F>(f)(lib::forward<Args>(args)...))
 #ifdef _MSC_VER
 #pragma warning(pop)
 #endif
-      }  // namespace detail
+}// namespace detail
 
-      template <typename F, typename... Args>
-      inline constexpr auto invoke(F &&f, Args &&... args)
-        MPARK_RETURN(detail::invoke(lib::forward<F>(f),
-                                    lib::forward<Args>(args)...))
+template<typename F, typename... Args>
+inline constexpr auto
+invoke(F &&f, Args &&...args) MPARK_RETURN(detail::invoke(lib::forward<F>(f), lib::forward<Args>(args)...))
 
-      namespace detail {
+    namespace detail
+{
 
-        template <typename Void, typename, typename...>
-        struct invoke_result {};
+    template<typename Void, typename, typename...>
+    struct invoke_result {};
 
-        template <typename F, typename... Args>
-        struct invoke_result<void_t<decltype(lib::invoke(
-                                 std::declval<F>(), std::declval<Args>()...))>,
-                             F,
-                             Args...>
-            : identity<decltype(
-                  lib::invoke(std::declval<F>(), std::declval<Args>()...))> {};
+    template<typename F, typename... Args>
+    struct invoke_result<void_t<decltype(lib::invoke(std::declval<F>(), std::declval<Args>()...))>, F, Args...>
+        : identity<decltype(lib::invoke(std::declval<F>(), std::declval<Args>()...))> {};
 
-      }  // namespace detail
+}// namespace detail
 
-      template <typename F, typename... Args>
-      using invoke_result = detail::invoke_result<void, F, Args...>;
+template<typename F, typename... Args>
+using invoke_result = detail::invoke_result<void, F, Args...>;
 
-      template <typename F, typename... Args>
-      using invoke_result_t = typename invoke_result<F, Args...>::type;
+template<typename F, typename... Args>
+using invoke_result_t = typename invoke_result<F, Args...>::type;
 
-      namespace detail {
+namespace detail {
 
-        template <typename Void, typename, typename...>
-        struct is_invocable : std::false_type {};
+template<typename Void, typename, typename...>
+struct is_invocable : std::false_type {};
 
-        template <typename F, typename... Args>
-        struct is_invocable<void_t<invoke_result_t<F, Args...>>, F, Args...>
-            : std::true_type {};
+template<typename F, typename... Args>
+struct is_invocable<void_t<invoke_result_t<F, Args...>>, F, Args...> : std::true_type {};
 
-        template <typename Void, typename, typename, typename...>
-        struct is_invocable_r : std::false_type {};
+template<typename Void, typename, typename, typename...>
+struct is_invocable_r : std::false_type {};
 
-        template <typename R, typename F, typename... Args>
-        struct is_invocable_r<void_t<invoke_result_t<F, Args...>>,
-                              R,
-                              F,
-                              Args...>
-            : std::is_convertible<invoke_result_t<F, Args...>, R> {};
+template<typename R, typename F, typename... Args>
+struct is_invocable_r<void_t<invoke_result_t<F, Args...>>, R, F, Args...>
+    : std::is_convertible<invoke_result_t<F, Args...>, R> {};
 
-      }  // namespace detail
+}// namespace detail
 
-      template <typename F, typename... Args>
-      using is_invocable = detail::is_invocable<void, F, Args...>;
+template<typename F, typename... Args>
+using is_invocable = detail::is_invocable<void, F, Args...>;
 
-      template <typename R, typename F, typename... Args>
-      using is_invocable_r = detail::is_invocable_r<void, R, F, Args...>;
+template<typename R, typename F, typename... Args>
+using is_invocable_r = detail::is_invocable_r<void, R, F, Args...>;
 
-      namespace detail {
+namespace detail {
 
-        template <bool Invocable, typename F, typename... Args>
-        struct is_nothrow_invocable {
-          static constexpr bool value =
-              noexcept(lib::invoke(std::declval<F>(), std::declval<Args>()...));
-        };
+template<bool Invocable, typename F, typename... Args>
+struct is_nothrow_invocable {
+    static constexpr bool value = noexcept(lib::invoke(std::declval<F>(), std::declval<Args>()...));
+};
 
-        template <typename F, typename... Args>
-        struct is_nothrow_invocable<false, F, Args...> : std::false_type {};
+template<typename F, typename... Args>
+struct is_nothrow_invocable<false, F, Args...> : std::false_type {};
 
-        template <bool Invocable, typename R, typename F, typename... Args>
-        struct is_nothrow_invocable_r {
-          private:
-          inline static R impl() {
-            return lib::invoke(std::declval<F>(), std::declval<Args>()...);
-          }
+template<bool Invocable, typename R, typename F, typename... Args>
+struct is_nothrow_invocable_r {
+private:
+    inline static R impl() { return lib::invoke(std::declval<F>(), std::declval<Args>()...); }
 
-          public:
-          static constexpr bool value = noexcept(impl());
-        };
+public:
+    static constexpr bool value = noexcept(impl());
+};
 
-        template <typename R, typename F, typename... Args>
-        struct is_nothrow_invocable_r<false, R, F, Args...> : std::false_type {};
+template<typename R, typename F, typename... Args>
+struct is_nothrow_invocable_r<false, R, F, Args...> : std::false_type {};
 
-      }  // namespace detail
+}// namespace detail
 
-      template <typename F, typename... Args>
-      using is_nothrow_invocable = detail::
-          is_nothrow_invocable<is_invocable<F, Args...>::value, F, Args...>;
+template<typename F, typename... Args>
+using is_nothrow_invocable = detail::is_nothrow_invocable<is_invocable<F, Args...>::value, F, Args...>;
 
-      template <typename R, typename F, typename... Args>
-      using is_nothrow_invocable_r =
-          detail::is_nothrow_invocable_r<is_invocable_r<R, F, Args...>::value,
-                                         R,
-                                         F,
-                                         Args...>;
+template<typename R, typename F, typename... Args>
+using is_nothrow_invocable_r = detail::is_nothrow_invocable_r<is_invocable_r<R, F, Args...>::value, R, F, Args...>;
 
-      // <memory>
+// <memory>
 #ifdef MPARK_BUILTIN_ADDRESSOF
-      template <typename T>
-      inline constexpr T *addressof(T &arg) noexcept {
-        return __builtin_addressof(arg);
-      }
+template<typename T>
+inline constexpr T *
+addressof(T &arg) noexcept
+{
+    return __builtin_addressof(arg);
+}
 #else
-      namespace detail {
+namespace detail {
 
-        namespace has_addressof_impl {
+namespace has_addressof_impl {
 
-          struct fail;
+struct fail;
 
-          template <typename T>
-          inline fail operator&(T &&);
+template<typename T>
+inline fail operator&(T &&);
 
-          template <typename T>
-          inline static constexpr bool impl() {
-            return (std::is_class<T>::value || std::is_union<T>::value) &&
-                   !std::is_same<decltype(&std::declval<T &>()), fail>::value;
-          }
+template<typename T>
+inline static constexpr bool
+impl()
+{
+    return (std::is_class<T>::value || std::is_union<T>::value)
+        && !std::is_same<decltype(&std::declval<T &>()), fail>::value;
+}
 
-        }  // namespace has_addressof_impl
+}// namespace has_addressof_impl
 
-        template <typename T>
-        using has_addressof = bool_constant<has_addressof_impl::impl<T>()>;
+template<typename T>
+using has_addressof = bool_constant<has_addressof_impl::impl<T>()>;
 
-        template <typename T>
-        inline constexpr T *addressof(T &arg, std::true_type) noexcept {
-          return std::addressof(arg);
-        }
+template<typename T>
+inline constexpr T *
+addressof(T &arg, std::true_type) noexcept
+{
+    return std::addressof(arg);
+}
 
-        template <typename T>
-        inline constexpr T *addressof(T &arg, std::false_type) noexcept {
-          return &arg;
-        }
+template<typename T>
+inline constexpr T *
+addressof(T &arg, std::false_type) noexcept
+{
+    return &arg;
+}
 
-      }  // namespace detail
+}// namespace detail
 
-      template <typename T>
-      inline constexpr T *addressof(T &arg) noexcept {
-        return detail::addressof(arg, detail::has_addressof<T>{});
-      }
+template<typename T>
+inline constexpr T *
+addressof(T &arg) noexcept
+{
+    return detail::addressof(arg, detail::has_addressof<T>{});
+}
 #endif
 
-      template <typename T>
-      inline constexpr T *addressof(const T &&) = delete;
+template<typename T>
+inline constexpr T *addressof(const T &&) = delete;
 
-    }  // namespace cpp17
+}// namespace cpp17
 
-    template <typename T>
-    struct remove_all_extents : identity<T> {};
+template<typename T>
+struct remove_all_extents : identity<T> {};
 
-    template <typename T, std::size_t N>
-    struct remove_all_extents<array<T, N>> : remove_all_extents<T> {};
+template<typename T, std::size_t N>
+struct remove_all_extents<array<T, N>> : remove_all_extents<T> {};
 
-    template <typename T>
-    using remove_all_extents_t = typename remove_all_extents<T>::type;
+template<typename T>
+using remove_all_extents_t = typename remove_all_extents<T>::type;
 
-    template <std::size_t N>
-    using size_constant = std::integral_constant<std::size_t, N>;
+template<std::size_t N>
+using size_constant = std::integral_constant<std::size_t, N>;
 
-    template <std::size_t I, typename T>
-    struct indexed_type : size_constant<I> { using type = T; };
+template<std::size_t I, typename T>
+struct indexed_type : size_constant<I> {
+    using type = T;
+};
 
-    template <bool... Bs>
-    using all = std::is_same<integer_sequence<bool, true, Bs...>,
-                             integer_sequence<bool, Bs..., true>>;
+template<bool... Bs>
+using all = std::is_same<integer_sequence<bool, true, Bs...>, integer_sequence<bool, Bs..., true>>;
 
 #ifdef MPARK_TYPE_PACK_ELEMENT
-    template <std::size_t I, typename... Ts>
-    using type_pack_element_t = __type_pack_element<I, Ts...>;
+template<std::size_t I, typename... Ts>
+using type_pack_element_t = __type_pack_element<I, Ts...>;
 #else
-    template <std::size_t I, typename... Ts>
-    struct type_pack_element_impl {
-      private:
-      template <typename>
-      struct set;
+template<std::size_t I, typename... Ts>
+struct type_pack_element_impl {
+private:
+    template<typename>
+    struct set;
 
-      template <std::size_t... Is>
-      struct set<index_sequence<Is...>> : indexed_type<Is, Ts>... {};
+    template<std::size_t... Is>
+    struct set<index_sequence<Is...>> : indexed_type<Is, Ts>... {};
 
-      template <typename T>
-      inline static std::enable_if<true, T> impl(indexed_type<I, T>);
+    template<typename T>
+    inline static std::enable_if<true, T> impl(indexed_type<I, T>);
 
-      inline static std::enable_if<false> impl(...);
+    inline static std::enable_if<false> impl(...);
 
-      public:
-      using type = decltype(impl(set<index_sequence_for<Ts...>>{}));
-    };
+public:
+    using type = decltype(impl(set<index_sequence_for<Ts...>>{}));
+};
 
-    template <std::size_t I, typename... Ts>
-    using type_pack_element = typename type_pack_element_impl<I, Ts...>::type;
+template<std::size_t I, typename... Ts>
+using type_pack_element = typename type_pack_element_impl<I, Ts...>::type;
 
-    template <std::size_t I, typename... Ts>
-    using type_pack_element_t = typename type_pack_element<I, Ts...>::type;
+template<std::size_t I, typename... Ts>
+using type_pack_element_t = typename type_pack_element<I, Ts...>::type;
 #endif
 
 #ifdef MPARK_TRIVIALITY_TYPE_TRAITS
-    using std::is_trivially_copy_constructible;
-    using std::is_trivially_move_constructible;
-    using std::is_trivially_copy_assignable;
-    using std::is_trivially_move_assignable;
+using std::is_trivially_copy_assignable;
+using std::is_trivially_copy_constructible;
+using std::is_trivially_move_assignable;
+using std::is_trivially_move_constructible;
 #else
-    template <typename T>
-    struct is_trivially_copy_constructible
-        : bool_constant<
-              std::is_copy_constructible<T>::value && __has_trivial_copy(T)> {};
+template<typename T>
+struct is_trivially_copy_constructible : bool_constant<std::is_copy_constructible<T>::value &&__has_trivial_copy(T)> {};
 
-    template <typename T>
-    struct is_trivially_move_constructible : bool_constant<__is_trivial(T)> {};
+template<typename T>
+struct is_trivially_move_constructible : bool_constant<__is_trivial(T)> {};
 
-    template <typename T>
-    struct is_trivially_copy_assignable
-        : bool_constant<
-              std::is_copy_assignable<T>::value && __has_trivial_assign(T)> {};
+template<typename T>
+struct is_trivially_copy_assignable : bool_constant<std::is_copy_assignable<T>::value &&__has_trivial_assign(T)> {};
 
-    template <typename T>
-    struct is_trivially_move_assignable : bool_constant<__is_trivial(T)> {};
+template<typename T>
+struct is_trivially_move_assignable : bool_constant<__is_trivial(T)> {};
 #endif
 
-    template <typename T, bool>
-    struct dependent_type : T {};
+template<typename T, bool>
+struct dependent_type : T {};
 
-    template <typename Is, std::size_t J>
-    struct push_back;
+template<typename Is, std::size_t J>
+struct push_back;
 
-    template <typename Is, std::size_t J>
-    using push_back_t = typename push_back<Is, J>::type;
+template<typename Is, std::size_t J>
+using push_back_t = typename push_back<Is, J>::type;
 
-    template <std::size_t... Is, std::size_t J>
-    struct push_back<index_sequence<Is...>, J> {
-      using type = index_sequence<Is..., J>;
-    };
+template<std::size_t... Is, std::size_t J>
+struct push_back<index_sequence<Is...>, J> {
+    using type = index_sequence<Is..., J>;
+};
 
-  }  // namespace lib
-}  // namespace mpark
+}// namespace lib
+}// namespace mpark
 
 #undef MPARK_RETURN
 
-#endif  // MPARK_LIB_HPP
-
+#endif// MPARK_LIB_HPP
 
 namespace mpark {
 
 #ifdef MPARK_RETURN_TYPE_DEDUCTION
 
 #define AUTO auto
-#define AUTO_RETURN(...) { return __VA_ARGS__; }
+#define AUTO_RETURN(...)                                                                                               \
+    {                                                                                                                  \
+        return __VA_ARGS__;                                                                                            \
+    }
 
 #define AUTO_REFREF auto &&
-#define AUTO_REFREF_RETURN(...) { return __VA_ARGS__; }
+#define AUTO_REFREF_RETURN(...)                                                                                        \
+    {                                                                                                                  \
+        return __VA_ARGS__;                                                                                            \
+    }
 
 #define DECLTYPE_AUTO decltype(auto)
-#define DECLTYPE_AUTO_RETURN(...) { return __VA_ARGS__; }
+#define DECLTYPE_AUTO_RETURN(...)                                                                                      \
+    {                                                                                                                  \
+        return __VA_ARGS__;                                                                                            \
+    }
 
 #else
 
 #define AUTO auto
-#define AUTO_RETURN(...) \
-  -> lib::decay_t<decltype(__VA_ARGS__)> { return __VA_ARGS__; }
+#define AUTO_RETURN(...)                                                                                               \
+    ->lib::decay_t<decltype(__VA_ARGS__)> { return __VA_ARGS__; }
 
 #define AUTO_REFREF auto
-#define AUTO_REFREF_RETURN(...)                                           \
-  -> decltype((__VA_ARGS__)) {                                            \
-    static_assert(std::is_reference<decltype((__VA_ARGS__))>::value, ""); \
-    return __VA_ARGS__;                                                   \
-  }
+#define AUTO_REFREF_RETURN(...)                                                                                        \
+    ->decltype((__VA_ARGS__))                                                                                          \
+    {                                                                                                                  \
+        static_assert(std::is_reference<decltype((__VA_ARGS__))>::value, "");                                          \
+        return __VA_ARGS__;                                                                                            \
+    }
 
 #define DECLTYPE_AUTO auto
-#define DECLTYPE_AUTO_RETURN(...) \
-  -> decltype(__VA_ARGS__) { return __VA_ARGS__; }
+#define DECLTYPE_AUTO_RETURN(...)                                                                                      \
+    ->decltype(__VA_ARGS__) { return __VA_ARGS__; }
 
 #endif
 
-  class bad_variant_access : public std::exception {
-    public:
+class bad_variant_access : public std::exception {
+public:
     virtual const char *what() const noexcept override { return "bad_variant_access"; }
-  };
+};
 
-  [[noreturn]] inline void throw_bad_variant_access() {
+[[noreturn]] inline void
+throw_bad_variant_access()
+{
 #ifdef MPARK_EXCEPTIONS
     throw bad_variant_access{};
 #else
     std::terminate();
     MPARK_BUILTIN_UNREACHABLE;
 #endif
-  }
+}
 
-  template <typename... Ts>
-  class variant;
+template<typename... Ts>
+class variant;
 
-  template <typename T>
-  struct variant_size;
+template<typename T>
+struct variant_size;
 
 #ifdef MPARK_VARIABLE_TEMPLATES
-  template <typename T>
-  constexpr std::size_t variant_size_v = variant_size<T>::value;
+template<typename T>
+constexpr std::size_t variant_size_v = variant_size<T>::value;
 #endif
 
-  template <typename T>
-  struct variant_size<const T> : variant_size<T> {};
+template<typename T>
+struct variant_size<const T> : variant_size<T> {};
 
-  template <typename T>
-  struct variant_size<volatile T> : variant_size<T> {};
+template<typename T>
+struct variant_size<volatile T> : variant_size<T> {};
 
-  template <typename T>
-  struct variant_size<const volatile T> : variant_size<T> {};
+template<typename T>
+struct variant_size<const volatile T> : variant_size<T> {};
 
-  template <typename... Ts>
-  struct variant_size<variant<Ts...>> : lib::size_constant<sizeof...(Ts)> {};
+template<typename... Ts>
+struct variant_size<variant<Ts...>> : lib::size_constant<sizeof...(Ts)> {};
 
-  template <std::size_t I, typename T>
-  struct variant_alternative;
+template<std::size_t I, typename T>
+struct variant_alternative;
 
-  template <std::size_t I, typename T>
-  using variant_alternative_t = typename variant_alternative<I, T>::type;
+template<std::size_t I, typename T>
+using variant_alternative_t = typename variant_alternative<I, T>::type;
 
-  template <std::size_t I, typename T>
-  struct variant_alternative<I, const T>
-      : std::add_const<variant_alternative_t<I, T>> {};
+template<std::size_t I, typename T>
+struct variant_alternative<I, const T> : std::add_const<variant_alternative_t<I, T>> {};
 
-  template <std::size_t I, typename T>
-  struct variant_alternative<I, volatile T>
-      : std::add_volatile<variant_alternative_t<I, T>> {};
+template<std::size_t I, typename T>
+struct variant_alternative<I, volatile T> : std::add_volatile<variant_alternative_t<I, T>> {};
 
-  template <std::size_t I, typename T>
-  struct variant_alternative<I, const volatile T>
-      : std::add_cv<variant_alternative_t<I, T>> {};
+template<std::size_t I, typename T>
+struct variant_alternative<I, const volatile T> : std::add_cv<variant_alternative_t<I, T>> {};
 
-  template <std::size_t I, typename... Ts>
-  struct variant_alternative<I, variant<Ts...>> {
-    static_assert(I < sizeof...(Ts),
-                  "index out of bounds in `std::variant_alternative<>`");
+template<std::size_t I, typename... Ts>
+struct variant_alternative<I, variant<Ts...>> {
+    static_assert(I < sizeof...(Ts), "index out of bounds in `std::variant_alternative<>`");
     using type = lib::type_pack_element_t<I, Ts...>;
-  };
+};
 
-  constexpr std::size_t variant_npos = static_cast<std::size_t>(-1);
+constexpr std::size_t variant_npos = static_cast<std::size_t>(-1);
 
-  namespace detail {
+namespace detail {
 
-    constexpr std::size_t not_found = static_cast<std::size_t>(-1);
-    constexpr std::size_t ambiguous = static_cast<std::size_t>(-2);
+constexpr std::size_t not_found = static_cast<std::size_t>(-1);
+constexpr std::size_t ambiguous = static_cast<std::size_t>(-2);
 
 #ifdef MPARK_CPP14_CONSTEXPR
-    template <typename T, typename... Ts>
-    inline constexpr std::size_t find_index() {
-      constexpr lib::array<bool, sizeof...(Ts)> matches = {
-          {std::is_same<T, Ts>::value...}
-      };
-      std::size_t result = not_found;
-      for (std::size_t i = 0; i < sizeof...(Ts); ++i) {
+template<typename T, typename... Ts>
+inline constexpr std::size_t
+find_index()
+{
+    constexpr lib::array<bool, sizeof...(Ts)> matches = {{std::is_same<T, Ts>::value...}};
+    std::size_t result                                = not_found;
+    for (std::size_t i = 0; i < sizeof...(Ts); ++i) {
         if (matches[i]) {
-          if (result != not_found) {
-            return ambiguous;
-          }
-          result = i;
+            if (result != not_found) { return ambiguous; }
+            result = i;
         }
-      }
-      return result;
     }
+    return result;
+}
 #else
-    inline constexpr std::size_t find_index_impl(std::size_t result,
-                                                 std::size_t) {
-      return result;
-    }
+inline constexpr std::size_t
+find_index_impl(std::size_t result, std::size_t)
+{
+    return result;
+}
 
-    template <typename... Bs>
-    inline constexpr std::size_t find_index_impl(std::size_t result,
-                                                 std::size_t idx,
-                                                 bool b,
-                                                 Bs... bs) {
-      return b ? (result != not_found ? ambiguous
-                                      : find_index_impl(idx, idx + 1, bs...))
-               : find_index_impl(result, idx + 1, bs...);
-    }
+template<typename... Bs>
+inline constexpr std::size_t
+find_index_impl(std::size_t result, std::size_t idx, bool b, Bs... bs)
+{
+    return b ? (result != not_found ? ambiguous : find_index_impl(idx, idx + 1, bs...))
+             : find_index_impl(result, idx + 1, bs...);
+}
 
-    template <typename T, typename... Ts>
-    inline constexpr std::size_t find_index() {
-      return find_index_impl(not_found, 0, std::is_same<T, Ts>::value...);
-    }
+template<typename T, typename... Ts>
+inline constexpr std::size_t
+find_index()
+{
+    return find_index_impl(not_found, 0, std::is_same<T, Ts>::value...);
+}
 #endif
 
-    template <std::size_t I>
-    using find_index_sfinae_impl =
-        lib::enable_if_t<I != not_found && I != ambiguous,
-                         lib::size_constant<I>>;
+template<std::size_t I>
+using find_index_sfinae_impl = lib::enable_if_t<I != not_found && I != ambiguous, lib::size_constant<I>>;
 
-    template <typename T, typename... Ts>
-    using find_index_sfinae = find_index_sfinae_impl<find_index<T, Ts...>()>;
+template<typename T, typename... Ts>
+using find_index_sfinae = find_index_sfinae_impl<find_index<T, Ts...>()>;
 
-    template <std::size_t I>
-    struct find_index_checked_impl : lib::size_constant<I> {
-      static_assert(I != not_found, "the specified type is not found.");
-      static_assert(I != ambiguous, "the specified type is ambiguous.");
-    };
+template<std::size_t I>
+struct find_index_checked_impl : lib::size_constant<I> {
+    static_assert(I != not_found, "the specified type is not found.");
+    static_assert(I != ambiguous, "the specified type is ambiguous.");
+};
 
-    template <typename T, typename... Ts>
-    using find_index_checked = find_index_checked_impl<find_index<T, Ts...>()>;
+template<typename T, typename... Ts>
+using find_index_checked = find_index_checked_impl<find_index<T, Ts...>()>;
 
-    struct valueless_t {};
+struct valueless_t {};
 
-    enum class Trait { TriviallyAvailable, Available, Unavailable };
+enum class Trait { TriviallyAvailable, Available, Unavailable };
 
-    template <typename T,
-              template <typename> class IsTriviallyAvailable,
-              template <typename> class IsAvailable>
-    inline constexpr Trait trait() {
-      return IsTriviallyAvailable<T>::value
-                 ? Trait::TriviallyAvailable
-                 : IsAvailable<T>::value ? Trait::Available
-                                         : Trait::Unavailable;
-    }
+template<typename T, template<typename> class IsTriviallyAvailable, template<typename> class IsAvailable>
+inline constexpr Trait
+trait()
+{
+    return IsTriviallyAvailable<T>::value ? Trait::TriviallyAvailable
+        : IsAvailable<T>::value           ? Trait::Available
+                                          : Trait::Unavailable;
+}
 
 #ifdef MPARK_CPP14_CONSTEXPR
-    template <typename... Traits>
-    inline constexpr Trait common_trait(Traits... traits_) {
-      Trait result = Trait::TriviallyAvailable;
-      lib::array<Trait, sizeof...(Traits)> traits = {{traits_...}};
-      for (std::size_t i = 0; i < sizeof...(Traits); ++i) {
+template<typename... Traits>
+inline constexpr Trait
+common_trait(Traits... traits_)
+{
+    Trait result                                = Trait::TriviallyAvailable;
+    lib::array<Trait, sizeof...(Traits)> traits = {{traits_...}};
+    for (std::size_t i = 0; i < sizeof...(Traits); ++i) {
         Trait t = traits[i];
-        if (static_cast<int>(t) > static_cast<int>(result)) {
-          result = t;
-        }
-      }
-      return result;
+        if (static_cast<int>(t) > static_cast<int>(result)) { result = t; }
     }
+    return result;
+}
 #else
-    inline constexpr Trait common_trait_impl(Trait result) { return result; }
+inline constexpr Trait
+common_trait_impl(Trait result)
+{
+    return result;
+}
 
-    template <typename... Traits>
-    inline constexpr Trait common_trait_impl(Trait result,
-                                             Trait t,
-                                             Traits... ts) {
-      return static_cast<int>(t) > static_cast<int>(result)
-                 ? common_trait_impl(t, ts...)
-                 : common_trait_impl(result, ts...);
-    }
+template<typename... Traits>
+inline constexpr Trait
+common_trait_impl(Trait result, Trait t, Traits... ts)
+{
+    return static_cast<int>(t) > static_cast<int>(result)
+        ? common_trait_impl(t, ts...)
+        : common_trait_impl(result, ts...);
+}
 
-    template <typename... Traits>
-    inline constexpr Trait common_trait(Traits... ts) {
-      return common_trait_impl(Trait::TriviallyAvailable, ts...);
-    }
+template<typename... Traits>
+inline constexpr Trait
+common_trait(Traits... ts)
+{
+    return common_trait_impl(Trait::TriviallyAvailable, ts...);
+}
 #endif
 
-    template <typename... Ts>
-    struct traits {
-      static constexpr Trait copy_constructible_trait =
-          common_trait(trait<Ts,
-                             lib::is_trivially_copy_constructible,
-                             std::is_copy_constructible>()...);
+template<typename... Ts>
+struct traits {
+    static constexpr Trait copy_constructible_trait =
+        common_trait(trait<Ts, lib::is_trivially_copy_constructible, std::is_copy_constructible>()...);
 
-      static constexpr Trait move_constructible_trait =
-          common_trait(trait<Ts,
-                             lib::is_trivially_move_constructible,
-                             std::is_move_constructible>()...);
+    static constexpr Trait move_constructible_trait =
+        common_trait(trait<Ts, lib::is_trivially_move_constructible, std::is_move_constructible>()...);
 
-      static constexpr Trait copy_assignable_trait =
-          common_trait(copy_constructible_trait,
-                       trait<Ts,
-                             lib::is_trivially_copy_assignable,
-                             std::is_copy_assignable>()...);
+    static constexpr Trait copy_assignable_trait =
+        common_trait(copy_constructible_trait,
+                     trait<Ts, lib::is_trivially_copy_assignable, std::is_copy_assignable>()...);
 
-      static constexpr Trait move_assignable_trait =
-          common_trait(move_constructible_trait,
-                       trait<Ts,
-                             lib::is_trivially_move_assignable,
-                             std::is_move_assignable>()...);
+    static constexpr Trait move_assignable_trait =
+        common_trait(move_constructible_trait,
+                     trait<Ts, lib::is_trivially_move_assignable, std::is_move_assignable>()...);
 
-      static constexpr Trait destructible_trait =
-          common_trait(trait<Ts,
-                             std::is_trivially_destructible,
-                             std::is_destructible>()...);
+    static constexpr Trait destructible_trait =
+        common_trait(trait<Ts, std::is_trivially_destructible, std::is_destructible>()...);
+};
+
+namespace access {
+
+struct recursive_union {
+#ifdef MPARK_RETURN_TYPE_DEDUCTION
+    template<typename V>
+    inline static constexpr auto &&get_alt(V &&v, in_place_index_t<0>)
+    {
+        return lib::forward<V>(v).head_;
+    }
+
+    template<typename V, std::size_t I>
+    inline static constexpr auto &&get_alt(V &&v, in_place_index_t<I>)
+    {
+        return get_alt(lib::forward<V>(v).tail_, in_place_index_t<I - 1>{});
+    }
+#else
+    template<std::size_t I, bool Dummy = true>
+    struct get_alt_impl {
+        template<typename V>
+        inline constexpr AUTO_REFREF operator()(V &&v) const
+            AUTO_REFREF_RETURN(get_alt_impl<I - 1>{}(lib::forward<V>(v).tail_))
     };
 
-    namespace access {
+    template<bool Dummy>
+    struct get_alt_impl<0, Dummy> {
+        template<typename V>
+        inline constexpr AUTO_REFREF operator()(V &&v) const AUTO_REFREF_RETURN(lib::forward<V>(v).head_)
+    };
 
-      struct recursive_union {
-#ifdef MPARK_RETURN_TYPE_DEDUCTION
-        template <typename V>
-        inline static constexpr auto &&get_alt(V &&v, in_place_index_t<0>) {
-          return lib::forward<V>(v).head_;
-        }
-
-        template <typename V, std::size_t I>
-        inline static constexpr auto &&get_alt(V &&v, in_place_index_t<I>) {
-          return get_alt(lib::forward<V>(v).tail_, in_place_index_t<I - 1>{});
-        }
-#else
-        template <std::size_t I, bool Dummy = true>
-        struct get_alt_impl {
-          template <typename V>
-          inline constexpr AUTO_REFREF operator()(V &&v) const
-            AUTO_REFREF_RETURN(get_alt_impl<I - 1>{}(lib::forward<V>(v).tail_))
-        };
-
-        template <bool Dummy>
-        struct get_alt_impl<0, Dummy> {
-          template <typename V>
-          inline constexpr AUTO_REFREF operator()(V &&v) const
-            AUTO_REFREF_RETURN(lib::forward<V>(v).head_)
-        };
-
-        template <typename V, std::size_t I>
-        inline static constexpr AUTO_REFREF get_alt(V &&v, in_place_index_t<I>)
-          AUTO_REFREF_RETURN(get_alt_impl<I>{}(lib::forward<V>(v)))
+    template<typename V, std::size_t I>
+    inline static constexpr AUTO_REFREF get_alt(V &&v, in_place_index_t<I>)
+        AUTO_REFREF_RETURN(get_alt_impl<I>{}(lib::forward<V>(v)))
 #endif
-      };
+};
 
-      struct base {
-        template <std::size_t I, typename V>
-        inline static constexpr AUTO_REFREF get_alt(V &&v)
+struct base {
+    template<std::size_t I, typename V>
+    inline static constexpr AUTO_REFREF get_alt(V &&v)
 #ifdef _MSC_VER
-          AUTO_REFREF_RETURN(recursive_union::get_alt(
-              lib::forward<V>(v).data_, in_place_index_t<I>{}))
+        AUTO_REFREF_RETURN(recursive_union::get_alt(lib::forward<V>(v).data_, in_place_index_t<I>{}))
 #else
-          AUTO_REFREF_RETURN(recursive_union::get_alt(
-              data(lib::forward<V>(v)), in_place_index_t<I>{}))
+        AUTO_REFREF_RETURN(recursive_union::get_alt(data(lib::forward<V>(v)), in_place_index_t<I>{}))
 #endif
-      };
+};
 
-      struct variant {
-        template <std::size_t I, typename V>
-        inline static constexpr AUTO_REFREF get_alt(V &&v)
-          AUTO_REFREF_RETURN(base::get_alt<I>(lib::forward<V>(v).impl_))
-      };
+struct variant {
+    template<std::size_t I, typename V>
+    inline static constexpr AUTO_REFREF get_alt(V &&v) AUTO_REFREF_RETURN(base::get_alt<I>(lib::forward<V>(v).impl_))
+};
 
-    }  // namespace access
+}// namespace access
 
-    namespace visitation {
+namespace visitation {
 
 #if defined(MPARK_CPP14_CONSTEXPR) && !defined(_MSC_VER)
 #define MPARK_VARIANT_SWITCH_VISIT
 #endif
 
-      struct base {
-        template <typename Visitor, typename... Vs>
-        using dispatch_result_t = decltype(
-            lib::invoke(std::declval<Visitor>(),
-                        access::base::get_alt<0>(std::declval<Vs>())...));
+struct base {
+    template<typename Visitor, typename... Vs>
+    using dispatch_result_t =
+        decltype(lib::invoke(std::declval<Visitor>(), access::base::get_alt<0>(std::declval<Vs>())...));
 
-        template <typename Expected>
-        struct expected {
-          template <typename Actual>
-          inline static constexpr bool but_got() {
+    template<typename Expected>
+    struct expected {
+        template<typename Actual>
+        inline static constexpr bool but_got()
+        {
             return std::is_same<Expected, Actual>::value;
-          }
-        };
+        }
+    };
 
-        template <typename Expected, typename Actual>
-        struct visit_return_type_check {
-          static_assert(
-              expected<Expected>::template but_got<Actual>(),
-              "`visit` requires the visitor to have a single return type");
+    template<typename Expected, typename Actual>
+    struct visit_return_type_check {
+        static_assert(expected<Expected>::template but_got<Actual>(),
+                      "`visit` requires the visitor to have a single return type");
 
-          template <typename Visitor, typename... Alts>
-          inline static constexpr DECLTYPE_AUTO invoke(Visitor &&visitor,
-                                                       Alts &&... alts)
-            DECLTYPE_AUTO_RETURN(lib::invoke(lib::forward<Visitor>(visitor),
-                                             lib::forward<Alts>(alts)...))
-        };
+        template<typename Visitor, typename... Alts>
+        inline static constexpr DECLTYPE_AUTO invoke(Visitor &&visitor, Alts &&...alts)
+            DECLTYPE_AUTO_RETURN(lib::invoke(lib::forward<Visitor>(visitor), lib::forward<Alts>(alts)...))
+    };
 
 #ifdef MPARK_VARIANT_SWITCH_VISIT
-        template <bool B, typename R, typename... ITs>
-        struct dispatcher;
+    template<bool B, typename R, typename... ITs>
+    struct dispatcher;
 
-        template <typename R, typename... ITs>
-        struct dispatcher<false, R, ITs...> {
-          template <std::size_t B, typename F, typename... Vs>
-          MPARK_ALWAYS_INLINE static constexpr R dispatch(
-              F &&, typename ITs::type &&..., Vs &&...) {
+    template<typename R, typename... ITs>
+    struct dispatcher<false, R, ITs...> {
+        template<std::size_t B, typename F, typename... Vs>
+        MPARK_ALWAYS_INLINE static constexpr R dispatch(F &&, typename ITs::type &&..., Vs &&...)
+        {
             MPARK_BUILTIN_UNREACHABLE;
-          }
+        }
 
-          template <std::size_t I, typename F, typename... Vs>
-          MPARK_ALWAYS_INLINE static constexpr R dispatch_case(F &&, Vs &&...) {
+        template<std::size_t I, typename F, typename... Vs>
+        MPARK_ALWAYS_INLINE static constexpr R dispatch_case(F &&, Vs &&...)
+        {
             MPARK_BUILTIN_UNREACHABLE;
-          }
+        }
 
-          template <std::size_t B, typename F, typename... Vs>
-          MPARK_ALWAYS_INLINE static constexpr R dispatch_at(std::size_t,
-                                                             F &&,
-                                                             Vs &&...) {
+        template<std::size_t B, typename F, typename... Vs>
+        MPARK_ALWAYS_INLINE static constexpr R dispatch_at(std::size_t, F &&, Vs &&...)
+        {
             MPARK_BUILTIN_UNREACHABLE;
-          }
-        };
+        }
+    };
 
-        template <typename R, typename... ITs>
-        struct dispatcher<true, R, ITs...> {
-          template <std::size_t B, typename F>
-          MPARK_ALWAYS_INLINE static constexpr R dispatch(
-              F &&f, typename ITs::type &&... visited_vs) {
+    template<typename R, typename... ITs>
+    struct dispatcher<true, R, ITs...> {
+        template<std::size_t B, typename F>
+        MPARK_ALWAYS_INLINE static constexpr R dispatch(F &&f, typename ITs::type &&...visited_vs)
+        {
             using Expected = R;
-            using Actual = decltype(lib::invoke(
+            using Actual   = decltype(lib::invoke(
                 lib::forward<F>(f),
-                access::base::get_alt<ITs::value>(
-                    lib::forward<typename ITs::type>(visited_vs))...));
+                access::base::get_alt<ITs::value>(lib::forward<typename ITs::type>(visited_vs))...));
             return visit_return_type_check<Expected, Actual>::invoke(
-                lib::forward<F>(f),
-                access::base::get_alt<ITs::value>(
-                    lib::forward<typename ITs::type>(visited_vs))...);
-          }
+                lib::forward<F>(f), access::base::get_alt<ITs::value>(lib::forward<typename ITs::type>(visited_vs))...);
+        }
 
-          template <std::size_t B, typename F, typename V, typename... Vs>
-          MPARK_ALWAYS_INLINE static constexpr R dispatch(
-              F &&f, typename ITs::type &&... visited_vs, V &&v, Vs &&... vs) {
-#define MPARK_DISPATCH(I)                                                   \
-  dispatcher<(I < lib::decay_t<V>::size()),                                 \
-             R,                                                             \
-             ITs...,                                                        \
-             lib::indexed_type<I, V>>::                                     \
-      template dispatch<0>(lib::forward<F>(f),                              \
-                           lib::forward<typename ITs::type>(visited_vs)..., \
-                           lib::forward<V>(v),                              \
-                           lib::forward<Vs>(vs)...)
+        template<std::size_t B, typename F, typename V, typename... Vs>
+        MPARK_ALWAYS_INLINE static constexpr R dispatch(F &&f, typename ITs::type &&...visited_vs, V &&v, Vs &&...vs)
+        {
+#define MPARK_DISPATCH(I)                                                                                              \
+    dispatcher<(I < lib::decay_t<V>::size()), R, ITs..., lib::indexed_type<I, V>>::template dispatch<0>(               \
+        lib::forward<F>(f), lib::forward<typename ITs::type>(visited_vs)..., lib::forward<V>(v),                       \
+        lib::forward<Vs>(vs)...)
 
-#define MPARK_DEFAULT(I)                                                      \
-  dispatcher<(I < lib::decay_t<V>::size()), R, ITs...>::template dispatch<I>( \
-      lib::forward<F>(f),                                                     \
-      lib::forward<typename ITs::type>(visited_vs)...,                        \
-      lib::forward<V>(v),                                                     \
-      lib::forward<Vs>(vs)...)
+#define MPARK_DEFAULT(I)                                                                                               \
+    dispatcher<(I < lib::decay_t<V>::size()), R, ITs...>::template dispatch<I>(                                        \
+        lib::forward<F>(f), lib::forward<typename ITs::type>(visited_vs)..., lib::forward<V>(v),                       \
+        lib::forward<Vs>(vs)...)
 
             switch (v.index()) {
-              case B + 0: return MPARK_DISPATCH(B + 0);
-              case B + 1: return MPARK_DISPATCH(B + 1);
-              case B + 2: return MPARK_DISPATCH(B + 2);
-              case B + 3: return MPARK_DISPATCH(B + 3);
-              case B + 4: return MPARK_DISPATCH(B + 4);
-              case B + 5: return MPARK_DISPATCH(B + 5);
-              case B + 6: return MPARK_DISPATCH(B + 6);
-              case B + 7: return MPARK_DISPATCH(B + 7);
-              case B + 8: return MPARK_DISPATCH(B + 8);
-              case B + 9: return MPARK_DISPATCH(B + 9);
-              case B + 10: return MPARK_DISPATCH(B + 10);
-              case B + 11: return MPARK_DISPATCH(B + 11);
-              case B + 12: return MPARK_DISPATCH(B + 12);
-              case B + 13: return MPARK_DISPATCH(B + 13);
-              case B + 14: return MPARK_DISPATCH(B + 14);
-              case B + 15: return MPARK_DISPATCH(B + 15);
-              case B + 16: return MPARK_DISPATCH(B + 16);
-              case B + 17: return MPARK_DISPATCH(B + 17);
-              case B + 18: return MPARK_DISPATCH(B + 18);
-              case B + 19: return MPARK_DISPATCH(B + 19);
-              case B + 20: return MPARK_DISPATCH(B + 20);
-              case B + 21: return MPARK_DISPATCH(B + 21);
-              case B + 22: return MPARK_DISPATCH(B + 22);
-              case B + 23: return MPARK_DISPATCH(B + 23);
-              case B + 24: return MPARK_DISPATCH(B + 24);
-              case B + 25: return MPARK_DISPATCH(B + 25);
-              case B + 26: return MPARK_DISPATCH(B + 26);
-              case B + 27: return MPARK_DISPATCH(B + 27);
-              case B + 28: return MPARK_DISPATCH(B + 28);
-              case B + 29: return MPARK_DISPATCH(B + 29);
-              case B + 30: return MPARK_DISPATCH(B + 30);
-              case B + 31: return MPARK_DISPATCH(B + 31);
-              default: return MPARK_DEFAULT(B + 32);
+            case B + 0:
+                return MPARK_DISPATCH(B + 0);
+            case B + 1:
+                return MPARK_DISPATCH(B + 1);
+            case B + 2:
+                return MPARK_DISPATCH(B + 2);
+            case B + 3:
+                return MPARK_DISPATCH(B + 3);
+            case B + 4:
+                return MPARK_DISPATCH(B + 4);
+            case B + 5:
+                return MPARK_DISPATCH(B + 5);
+            case B + 6:
+                return MPARK_DISPATCH(B + 6);
+            case B + 7:
+                return MPARK_DISPATCH(B + 7);
+            case B + 8:
+                return MPARK_DISPATCH(B + 8);
+            case B + 9:
+                return MPARK_DISPATCH(B + 9);
+            case B + 10:
+                return MPARK_DISPATCH(B + 10);
+            case B + 11:
+                return MPARK_DISPATCH(B + 11);
+            case B + 12:
+                return MPARK_DISPATCH(B + 12);
+            case B + 13:
+                return MPARK_DISPATCH(B + 13);
+            case B + 14:
+                return MPARK_DISPATCH(B + 14);
+            case B + 15:
+                return MPARK_DISPATCH(B + 15);
+            case B + 16:
+                return MPARK_DISPATCH(B + 16);
+            case B + 17:
+                return MPARK_DISPATCH(B + 17);
+            case B + 18:
+                return MPARK_DISPATCH(B + 18);
+            case B + 19:
+                return MPARK_DISPATCH(B + 19);
+            case B + 20:
+                return MPARK_DISPATCH(B + 20);
+            case B + 21:
+                return MPARK_DISPATCH(B + 21);
+            case B + 22:
+                return MPARK_DISPATCH(B + 22);
+            case B + 23:
+                return MPARK_DISPATCH(B + 23);
+            case B + 24:
+                return MPARK_DISPATCH(B + 24);
+            case B + 25:
+                return MPARK_DISPATCH(B + 25);
+            case B + 26:
+                return MPARK_DISPATCH(B + 26);
+            case B + 27:
+                return MPARK_DISPATCH(B + 27);
+            case B + 28:
+                return MPARK_DISPATCH(B + 28);
+            case B + 29:
+                return MPARK_DISPATCH(B + 29);
+            case B + 30:
+                return MPARK_DISPATCH(B + 30);
+            case B + 31:
+                return MPARK_DISPATCH(B + 31);
+            default:
+                return MPARK_DEFAULT(B + 32);
             }
 
 #undef MPARK_DEFAULT
 #undef MPARK_DISPATCH
-          }
+        }
 
-          template <std::size_t I, typename F, typename... Vs>
-          MPARK_ALWAYS_INLINE static constexpr R dispatch_case(F &&f,
-                                                               Vs &&... vs) {
+        template<std::size_t I, typename F, typename... Vs>
+        MPARK_ALWAYS_INLINE static constexpr R dispatch_case(F &&f, Vs &&...vs)
+        {
             using Expected = R;
-            using Actual = decltype(
-                lib::invoke(lib::forward<F>(f),
-                            access::base::get_alt<I>(lib::forward<Vs>(vs))...));
+            using Actual = decltype(lib::invoke(lib::forward<F>(f), access::base::get_alt<I>(lib::forward<Vs>(vs))...));
             return visit_return_type_check<Expected, Actual>::invoke(
-                lib::forward<F>(f),
-                access::base::get_alt<I>(lib::forward<Vs>(vs))...);
-          }
+                lib::forward<F>(f), access::base::get_alt<I>(lib::forward<Vs>(vs))...);
+        }
 
-          template <std::size_t B, typename F, typename V, typename... Vs>
-          MPARK_ALWAYS_INLINE static constexpr R dispatch_at(std::size_t index,
-                                                             F &&f,
-                                                             V &&v,
-                                                             Vs &&... vs) {
-            static_assert(lib::all<(lib::decay_t<V>::size() ==
-                                    lib::decay_t<Vs>::size())...>::value,
+        template<std::size_t B, typename F, typename V, typename... Vs>
+        MPARK_ALWAYS_INLINE static constexpr R dispatch_at(std::size_t index, F &&f, V &&v, Vs &&...vs)
+        {
+            static_assert(lib::all<(lib::decay_t<V>::size() == lib::decay_t<Vs>::size())...>::value,
                           "all of the variants must be the same size.");
-#define MPARK_DISPATCH_AT(I)                                               \
-  dispatcher<(I < lib::decay_t<V>::size()), R>::template dispatch_case<I>( \
-      lib::forward<F>(f), lib::forward<V>(v), lib::forward<Vs>(vs)...)
+#define MPARK_DISPATCH_AT(I)                                                                                           \
+    dispatcher<(I < lib::decay_t<V>::size()), R>::template dispatch_case<I>(                                           \
+        lib::forward<F>(f), lib::forward<V>(v), lib::forward<Vs>(vs)...)
 
-#define MPARK_DEFAULT(I)                                                 \
-  dispatcher<(I < lib::decay_t<V>::size()), R>::template dispatch_at<I>( \
-      index, lib::forward<F>(f), lib::forward<V>(v), lib::forward<Vs>(vs)...)
+#define MPARK_DEFAULT(I)                                                                                               \
+    dispatcher<(I < lib::decay_t<V>::size()), R>::template dispatch_at<I>(                                             \
+        index, lib::forward<F>(f), lib::forward<V>(v), lib::forward<Vs>(vs)...)
 
             switch (index) {
-              case B + 0: return MPARK_DISPATCH_AT(B + 0);
-              case B + 1: return MPARK_DISPATCH_AT(B + 1);
-              case B + 2: return MPARK_DISPATCH_AT(B + 2);
-              case B + 3: return MPARK_DISPATCH_AT(B + 3);
-              case B + 4: return MPARK_DISPATCH_AT(B + 4);
-              case B + 5: return MPARK_DISPATCH_AT(B + 5);
-              case B + 6: return MPARK_DISPATCH_AT(B + 6);
-              case B + 7: return MPARK_DISPATCH_AT(B + 7);
-              case B + 8: return MPARK_DISPATCH_AT(B + 8);
-              case B + 9: return MPARK_DISPATCH_AT(B + 9);
-              case B + 10: return MPARK_DISPATCH_AT(B + 10);
-              case B + 11: return MPARK_DISPATCH_AT(B + 11);
-              case B + 12: return MPARK_DISPATCH_AT(B + 12);
-              case B + 13: return MPARK_DISPATCH_AT(B + 13);
-              case B + 14: return MPARK_DISPATCH_AT(B + 14);
-              case B + 15: return MPARK_DISPATCH_AT(B + 15);
-              case B + 16: return MPARK_DISPATCH_AT(B + 16);
-              case B + 17: return MPARK_DISPATCH_AT(B + 17);
-              case B + 18: return MPARK_DISPATCH_AT(B + 18);
-              case B + 19: return MPARK_DISPATCH_AT(B + 19);
-              case B + 20: return MPARK_DISPATCH_AT(B + 20);
-              case B + 21: return MPARK_DISPATCH_AT(B + 21);
-              case B + 22: return MPARK_DISPATCH_AT(B + 22);
-              case B + 23: return MPARK_DISPATCH_AT(B + 23);
-              case B + 24: return MPARK_DISPATCH_AT(B + 24);
-              case B + 25: return MPARK_DISPATCH_AT(B + 25);
-              case B + 26: return MPARK_DISPATCH_AT(B + 26);
-              case B + 27: return MPARK_DISPATCH_AT(B + 27);
-              case B + 28: return MPARK_DISPATCH_AT(B + 28);
-              case B + 29: return MPARK_DISPATCH_AT(B + 29);
-              case B + 30: return MPARK_DISPATCH_AT(B + 30);
-              case B + 31: return MPARK_DISPATCH_AT(B + 31);
-              default: return MPARK_DEFAULT(B + 32);
+            case B + 0:
+                return MPARK_DISPATCH_AT(B + 0);
+            case B + 1:
+                return MPARK_DISPATCH_AT(B + 1);
+            case B + 2:
+                return MPARK_DISPATCH_AT(B + 2);
+            case B + 3:
+                return MPARK_DISPATCH_AT(B + 3);
+            case B + 4:
+                return MPARK_DISPATCH_AT(B + 4);
+            case B + 5:
+                return MPARK_DISPATCH_AT(B + 5);
+            case B + 6:
+                return MPARK_DISPATCH_AT(B + 6);
+            case B + 7:
+                return MPARK_DISPATCH_AT(B + 7);
+            case B + 8:
+                return MPARK_DISPATCH_AT(B + 8);
+            case B + 9:
+                return MPARK_DISPATCH_AT(B + 9);
+            case B + 10:
+                return MPARK_DISPATCH_AT(B + 10);
+            case B + 11:
+                return MPARK_DISPATCH_AT(B + 11);
+            case B + 12:
+                return MPARK_DISPATCH_AT(B + 12);
+            case B + 13:
+                return MPARK_DISPATCH_AT(B + 13);
+            case B + 14:
+                return MPARK_DISPATCH_AT(B + 14);
+            case B + 15:
+                return MPARK_DISPATCH_AT(B + 15);
+            case B + 16:
+                return MPARK_DISPATCH_AT(B + 16);
+            case B + 17:
+                return MPARK_DISPATCH_AT(B + 17);
+            case B + 18:
+                return MPARK_DISPATCH_AT(B + 18);
+            case B + 19:
+                return MPARK_DISPATCH_AT(B + 19);
+            case B + 20:
+                return MPARK_DISPATCH_AT(B + 20);
+            case B + 21:
+                return MPARK_DISPATCH_AT(B + 21);
+            case B + 22:
+                return MPARK_DISPATCH_AT(B + 22);
+            case B + 23:
+                return MPARK_DISPATCH_AT(B + 23);
+            case B + 24:
+                return MPARK_DISPATCH_AT(B + 24);
+            case B + 25:
+                return MPARK_DISPATCH_AT(B + 25);
+            case B + 26:
+                return MPARK_DISPATCH_AT(B + 26);
+            case B + 27:
+                return MPARK_DISPATCH_AT(B + 27);
+            case B + 28:
+                return MPARK_DISPATCH_AT(B + 28);
+            case B + 29:
+                return MPARK_DISPATCH_AT(B + 29);
+            case B + 30:
+                return MPARK_DISPATCH_AT(B + 30);
+            case B + 31:
+                return MPARK_DISPATCH_AT(B + 31);
+            default:
+                return MPARK_DEFAULT(B + 32);
             }
 
 #undef MPARK_DEFAULT
 #undef MPARK_DISPATCH_AT
-          }
-        };
+        }
+    };
 #else
-        template <typename T>
-        inline static constexpr const T &at(const T &elem) noexcept {
-          return elem;
-        }
+    template<typename T>
+    inline static constexpr const T &at(const T &elem) noexcept
+    {
+        return elem;
+    }
 
-        template <typename T, std::size_t N, typename... Is>
-        inline static constexpr const lib::remove_all_extents_t<T> &at(
-            const lib::array<T, N> &elems, std::size_t i, Is... is) noexcept {
-          return at(elems[i], is...);
-        }
+    template<typename T, std::size_t N, typename... Is>
+    inline static constexpr const lib::remove_all_extents_t<T> &
+    at(const lib::array<T, N> &elems, std::size_t i, Is... is) noexcept
+    {
+        return at(elems[i], is...);
+    }
 
-        template <typename F, typename... Fs>
-        inline static constexpr lib::array<lib::decay_t<F>, sizeof...(Fs) + 1>
-        make_farray(F &&f, Fs &&... fs) {
-          return {{lib::forward<F>(f), lib::forward<Fs>(fs)...}};
-        }
+    template<typename F, typename... Fs>
+    inline static constexpr lib::array<lib::decay_t<F>, sizeof...(Fs) + 1> make_farray(F &&f, Fs &&...fs)
+    {
+        return {
+            {lib::forward<F>(f), lib::forward<Fs>(fs)...}
+        };
+    }
 
-        template <typename F, typename... Vs>
-        struct make_fmatrix_impl {
+    template<typename F, typename... Vs>
+    struct make_fmatrix_impl {
 
-          template <std::size_t... Is>
-          inline static constexpr dispatch_result_t<F, Vs...> dispatch(
-              F &&f, Vs &&... vs) {
+        template<std::size_t... Is>
+        inline static constexpr dispatch_result_t<F, Vs...> dispatch(F &&f, Vs &&...vs)
+        {
             using Expected = dispatch_result_t<F, Vs...>;
-            using Actual = decltype(lib::invoke(
-                lib::forward<F>(f),
-                access::base::get_alt<Is>(lib::forward<Vs>(vs))...));
+            using Actual =
+                decltype(lib::invoke(lib::forward<F>(f), access::base::get_alt<Is>(lib::forward<Vs>(vs))...));
             return visit_return_type_check<Expected, Actual>::invoke(
-                lib::forward<F>(f),
-                access::base::get_alt<Is>(lib::forward<Vs>(vs))...);
-          }
+                lib::forward<F>(f), access::base::get_alt<Is>(lib::forward<Vs>(vs))...);
+        }
 
 #ifdef MPARK_RETURN_TYPE_DEDUCTION
-          template <std::size_t... Is>
-          inline static constexpr auto impl(lib::index_sequence<Is...>) {
+        template<std::size_t... Is>
+        inline static constexpr auto impl(lib::index_sequence<Is...>)
+        {
             return &dispatch<Is...>;
-          }
+        }
 
-          template <typename Is, std::size_t... Js, typename... Ls>
-          inline static constexpr auto impl(Is,
-                                            lib::index_sequence<Js...>,
-                                            Ls... ls) {
+        template<typename Is, std::size_t... Js, typename... Ls>
+        inline static constexpr auto impl(Is, lib::index_sequence<Js...>, Ls... ls)
+        {
             return make_farray(impl(lib::push_back_t<Is, Js>{}, ls...)...);
-          }
+        }
 #else
-          template <typename...>
-          struct impl;
+        template<typename...>
+        struct impl;
 
-          template <std::size_t... Is>
-          struct impl<lib::index_sequence<Is...>> {
-            inline constexpr AUTO operator()() const
-              AUTO_RETURN(&dispatch<Is...>)
-          };
-
-          template <typename Is, std::size_t... Js, typename... Ls>
-          struct impl<Is, lib::index_sequence<Js...>, Ls...> {
-            inline constexpr AUTO operator()() const
-              AUTO_RETURN(
-                  make_farray(impl<lib::push_back_t<Is, Js>, Ls...>{}()...))
-          };
-#endif
+        template<std::size_t... Is>
+        struct impl<lib::index_sequence<Is...>> {
+            inline constexpr AUTO operator()() const AUTO_RETURN(&dispatch<Is...>)
         };
 
+        template<typename Is, std::size_t... Js, typename... Ls>
+        struct impl<Is, lib::index_sequence<Js...>, Ls...> {
+            inline constexpr AUTO operator()() const
+                AUTO_RETURN(make_farray(impl<lib::push_back_t<Is, Js>, Ls...>{}()...))
+        };
+#endif
+    };
+
 #ifdef MPARK_RETURN_TYPE_DEDUCTION
-        template <typename F, typename... Vs>
-        inline static constexpr auto make_fmatrix() {
-          return make_fmatrix_impl<F, Vs...>::impl(
-              lib::index_sequence<>{},
-              lib::make_index_sequence<lib::decay_t<Vs>::size()>{}...);
-        }
+    template<typename F, typename... Vs>
+    inline static constexpr auto make_fmatrix()
+    {
+        return make_fmatrix_impl<F, Vs...>::impl(
+            lib::index_sequence<>{}, lib::make_index_sequence<lib::decay_t<Vs>::size()>{}...);
+    }
 #else
-        template <typename F, typename... Vs>
-        inline static constexpr AUTO make_fmatrix()
-          AUTO_RETURN(
-              typename make_fmatrix_impl<F, Vs...>::template impl<
-                  lib::index_sequence<>,
-                  lib::make_index_sequence<lib::decay_t<Vs>::size()>...>{}())
+    template<typename F, typename... Vs>
+    inline static constexpr AUTO make_fmatrix() AUTO_RETURN(
+        typename make_fmatrix_impl<F, Vs...>::template impl<lib::index_sequence<>,
+                                                            lib::make_index_sequence<lib::decay_t<Vs>::size()>...>{}())
 #endif
 
-        template <typename F, typename... Vs>
-        struct make_fdiagonal_impl {
-          template <std::size_t I>
-          inline static constexpr dispatch_result_t<F, Vs...> dispatch(
-              F &&f, Vs &&... vs) {
+    template<typename F, typename... Vs>
+    struct make_fdiagonal_impl {
+        template<std::size_t I>
+        inline static constexpr dispatch_result_t<F, Vs...> dispatch(F &&f, Vs &&...vs)
+        {
             using Expected = dispatch_result_t<F, Vs...>;
-            using Actual = decltype(
-                lib::invoke(lib::forward<F>(f),
-                            access::base::get_alt<I>(lib::forward<Vs>(vs))...));
+            using Actual = decltype(lib::invoke(lib::forward<F>(f), access::base::get_alt<I>(lib::forward<Vs>(vs))...));
             return visit_return_type_check<Expected, Actual>::invoke(
-                lib::forward<F>(f),
-                access::base::get_alt<I>(lib::forward<Vs>(vs))...);
-          }
-
-          template <std::size_t... Is>
-          inline static constexpr AUTO impl(lib::index_sequence<Is...>)
-            AUTO_RETURN(make_farray(&dispatch<Is>...))
-        };
-
-        template <typename F, typename V, typename... Vs>
-        inline static constexpr auto make_fdiagonal()
-            -> decltype(make_fdiagonal_impl<F, V, Vs...>::impl(
-                lib::make_index_sequence<lib::decay_t<V>::size()>{})) {
-          static_assert(lib::all<(lib::decay_t<V>::size() ==
-                                  lib::decay_t<Vs>::size())...>::value,
-                        "all of the variants must be the same size.");
-          return make_fdiagonal_impl<F, V, Vs...>::impl(
-              lib::make_index_sequence<lib::decay_t<V>::size()>{});
+                lib::forward<F>(f), access::base::get_alt<I>(lib::forward<Vs>(vs))...);
         }
+
+        template<std::size_t... Is>
+        inline static constexpr AUTO impl(lib::index_sequence<Is...>) AUTO_RETURN(make_farray(&dispatch<Is>...))
+    };
+
+    template<typename F, typename V, typename... Vs>
+    inline static constexpr auto make_fdiagonal()
+        -> decltype(make_fdiagonal_impl<F, V, Vs...>::impl(lib::make_index_sequence<lib::decay_t<V>::size()>{}))
+    {
+        static_assert(lib::all<(lib::decay_t<V>::size() == lib::decay_t<Vs>::size())...>::value,
+                      "all of the variants must be the same size.");
+        return make_fdiagonal_impl<F, V, Vs...>::impl(lib::make_index_sequence<lib::decay_t<V>::size()>{});
+    }
 #endif
-      };
+};
 
-#if !defined(MPARK_VARIANT_SWITCH_VISIT) && \
-    (!defined(_MSC_VER) || _MSC_VER >= 1910)
-      template <typename F, typename... Vs>
-      using fmatrix_t = decltype(base::make_fmatrix<F, Vs...>());
+#if !defined(MPARK_VARIANT_SWITCH_VISIT) && (!defined(_MSC_VER) || _MSC_VER >= 1910)
+template<typename F, typename... Vs>
+using fmatrix_t = decltype(base::make_fmatrix<F, Vs...>());
 
-      template <typename F, typename... Vs>
-      struct fmatrix {
-        static constexpr fmatrix_t<F, Vs...> value =
-            base::make_fmatrix<F, Vs...>();
-      };
+template<typename F, typename... Vs>
+struct fmatrix {
+    static constexpr fmatrix_t<F, Vs...> value = base::make_fmatrix<F, Vs...>();
+};
 
-      template <typename F, typename... Vs>
-      constexpr fmatrix_t<F, Vs...> fmatrix<F, Vs...>::value;
+template<typename F, typename... Vs>
+constexpr fmatrix_t<F, Vs...> fmatrix<F, Vs...>::value;
 
-      template <typename F, typename... Vs>
-      using fdiagonal_t = decltype(base::make_fdiagonal<F, Vs...>());
+template<typename F, typename... Vs>
+using fdiagonal_t = decltype(base::make_fdiagonal<F, Vs...>());
 
-      template <typename F, typename... Vs>
-      struct fdiagonal {
-        static constexpr fdiagonal_t<F, Vs...> value =
-            base::make_fdiagonal<F, Vs...>();
-      };
+template<typename F, typename... Vs>
+struct fdiagonal {
+    static constexpr fdiagonal_t<F, Vs...> value = base::make_fdiagonal<F, Vs...>();
+};
 
-      template <typename F, typename... Vs>
-      constexpr fdiagonal_t<F, Vs...> fdiagonal<F, Vs...>::value;
+template<typename F, typename... Vs>
+constexpr fdiagonal_t<F, Vs...> fdiagonal<F, Vs...>::value;
 #endif
 
-      struct alt {
-        template <typename Visitor, typename... Vs>
-        inline static constexpr DECLTYPE_AUTO visit_alt(Visitor &&visitor,
-                                                        Vs &&... vs)
+struct alt {
+    template<typename Visitor, typename... Vs>
+    inline static constexpr DECLTYPE_AUTO visit_alt(Visitor &&visitor, Vs &&...vs)
 #ifdef MPARK_VARIANT_SWITCH_VISIT
-          DECLTYPE_AUTO_RETURN(
-              base::dispatcher<
-                  true,
-                  base::dispatch_result_t<Visitor,
-                                          decltype(as_base(
-                                              lib::forward<Vs>(vs)))...>>::
-                  template dispatch<0>(lib::forward<Visitor>(visitor),
-                                       as_base(lib::forward<Vs>(vs))...))
+        DECLTYPE_AUTO_RETURN(
+            base::dispatcher<true, base::dispatch_result_t<Visitor, decltype(as_base(lib::forward<Vs>(vs)))...>>::
+                template dispatch<0>(lib::forward<Visitor>(visitor), as_base(lib::forward<Vs>(vs))...))
 #elif !defined(_MSC_VER) || _MSC_VER >= 1910
-          DECLTYPE_AUTO_RETURN(base::at(
-              fmatrix<Visitor &&,
-                      decltype(as_base(lib::forward<Vs>(vs)))...>::value,
-              vs.index()...)(lib::forward<Visitor>(visitor),
-                             as_base(lib::forward<Vs>(vs))...))
+        DECLTYPE_AUTO_RETURN(base::at(fmatrix<Visitor &&, decltype(as_base(lib::forward<Vs>(vs)))...>::value,
+                                      vs.index()...)(lib::forward<Visitor>(visitor), as_base(lib::forward<Vs>(vs))...))
 #else
-          DECLTYPE_AUTO_RETURN(base::at(
-              base::make_fmatrix<Visitor &&,
-                      decltype(as_base(lib::forward<Vs>(vs)))...>(),
-              vs.index()...)(lib::forward<Visitor>(visitor),
-                             as_base(lib::forward<Vs>(vs))...))
+        DECLTYPE_AUTO_RETURN(base::at(base::make_fmatrix<Visitor &&, decltype(as_base(lib::forward<Vs>(vs)))...>(),
+                                      vs.index()...)(lib::forward<Visitor>(visitor), as_base(lib::forward<Vs>(vs))...))
 #endif
 
-        template <typename Visitor, typename... Vs>
-        inline static constexpr DECLTYPE_AUTO visit_alt_at(std::size_t index,
-                                                           Visitor &&visitor,
-                                                           Vs &&... vs)
+            template<typename Visitor, typename... Vs>
+            inline static constexpr DECLTYPE_AUTO
+        visit_alt_at(std::size_t index, Visitor &&visitor, Vs &&...vs)
 #ifdef MPARK_VARIANT_SWITCH_VISIT
-          DECLTYPE_AUTO_RETURN(
-              base::dispatcher<
-                  true,
-                  base::dispatch_result_t<Visitor,
-                                          decltype(as_base(
-                                              lib::forward<Vs>(vs)))...>>::
-                  template dispatch_at<0>(index,
-                                          lib::forward<Visitor>(visitor),
-                                          as_base(lib::forward<Vs>(vs))...))
-#elif !defined(_MSC_VER) || _MSC_VER >= 1910
-          DECLTYPE_AUTO_RETURN(base::at(
-              fdiagonal<Visitor &&,
-                        decltype(as_base(lib::forward<Vs>(vs)))...>::value,
-              index)(lib::forward<Visitor>(visitor),
-                     as_base(lib::forward<Vs>(vs))...))
-#else
-          DECLTYPE_AUTO_RETURN(base::at(
-              base::make_fdiagonal<Visitor &&,
-                        decltype(as_base(lib::forward<Vs>(vs)))...>(),
-              index)(lib::forward<Visitor>(visitor),
-                     as_base(lib::forward<Vs>(vs))...))
-#endif
-      };
-
-      struct variant {
-        private:
-        template <typename Visitor>
-        struct visitor {
-          template <typename... Values>
-          inline static constexpr bool does_not_handle() {
-            return lib::is_invocable<Visitor, Values...>::value;
-          }
-        };
-
-        template <typename Visitor, typename... Values>
-        struct visit_exhaustiveness_check {
-          static_assert(visitor<Visitor>::template does_not_handle<Values...>(),
-                        "`visit` requires the visitor to be exhaustive.");
-
-          inline static constexpr DECLTYPE_AUTO invoke(Visitor &&visitor,
-                                                       Values &&... values)
-            DECLTYPE_AUTO_RETURN(lib::invoke(lib::forward<Visitor>(visitor),
-                                             lib::forward<Values>(values)...))
-        };
-
-        template <typename Visitor>
-        struct value_visitor {
-          Visitor &&visitor_;
-
-          template <typename... Alts>
-          inline constexpr DECLTYPE_AUTO operator()(Alts &&... alts) const
             DECLTYPE_AUTO_RETURN(
-                visit_exhaustiveness_check<
-                    Visitor,
-                    decltype((lib::forward<Alts>(alts).value))...>::
-                    invoke(lib::forward<Visitor>(visitor_),
-                           lib::forward<Alts>(alts).value...))
-        };
+                base::dispatcher<true, base::dispatch_result_t<Visitor, decltype(as_base(lib::forward<Vs>(vs)))...>>::
+                    template dispatch_at<0>(index, lib::forward<Visitor>(visitor), as_base(lib::forward<Vs>(vs))...))
+#elif !defined(_MSC_VER) || _MSC_VER >= 1910
+            DECLTYPE_AUTO_RETURN(base::at(fdiagonal<Visitor &&, decltype(as_base(lib::forward<Vs>(vs)))...>::value,
+                                          index)(lib::forward<Visitor>(visitor), as_base(lib::forward<Vs>(vs))...))
+#else
+            DECLTYPE_AUTO_RETURN(
+                base::at(base::make_fdiagonal<Visitor &&, decltype(as_base(lib::forward<Vs>(vs)))...>(),
+                         index)(lib::forward<Visitor>(visitor), as_base(lib::forward<Vs>(vs))...))
+#endif
+};
 
-        template <typename Visitor>
-        inline static constexpr AUTO make_value_visitor(Visitor &&visitor)
-          AUTO_RETURN(value_visitor<Visitor>{lib::forward<Visitor>(visitor)})
+struct variant {
+private:
+    template<typename Visitor>
+    struct visitor {
+        template<typename... Values>
+        inline static constexpr bool does_not_handle()
+        {
+            return lib::is_invocable<Visitor, Values...>::value;
+        }
+    };
 
-        public:
-        template <typename Visitor, typename... Vs>
-        inline static constexpr DECLTYPE_AUTO visit_alt(Visitor &&visitor,
-                                                        Vs &&... vs)
-          DECLTYPE_AUTO_RETURN(alt::visit_alt(lib::forward<Visitor>(visitor),
-                                              lib::forward<Vs>(vs).impl_...))
+    template<typename Visitor, typename... Values>
+    struct visit_exhaustiveness_check {
+        static_assert(visitor<Visitor>::template does_not_handle<Values...>(),
+                      "`visit` requires the visitor to be exhaustive.");
 
-        template <typename Visitor, typename... Vs>
-        inline static constexpr DECLTYPE_AUTO visit_alt_at(std::size_t index,
-                                                           Visitor &&visitor,
-                                                           Vs &&... vs)
-          DECLTYPE_AUTO_RETURN(
-              alt::visit_alt_at(index,
-                                lib::forward<Visitor>(visitor),
-                                lib::forward<Vs>(vs).impl_...))
+        inline static constexpr DECLTYPE_AUTO invoke(Visitor &&visitor, Values &&...values)
+            DECLTYPE_AUTO_RETURN(lib::invoke(lib::forward<Visitor>(visitor), lib::forward<Values>(values)...))
+    };
 
-        template <typename Visitor, typename... Vs>
-        inline static constexpr DECLTYPE_AUTO visit_value(Visitor &&visitor,
-                                                          Vs &&... vs)
-          DECLTYPE_AUTO_RETURN(
-              visit_alt(make_value_visitor(lib::forward<Visitor>(visitor)),
-                        lib::forward<Vs>(vs)...))
+    template<typename Visitor>
+    struct value_visitor {
+        Visitor &&visitor_;
 
-        template <typename Visitor, typename... Vs>
-        inline static constexpr DECLTYPE_AUTO visit_value_at(std::size_t index,
-                                                             Visitor &&visitor,
-                                                             Vs &&... vs)
-          DECLTYPE_AUTO_RETURN(
-              visit_alt_at(index,
-                           make_value_visitor(lib::forward<Visitor>(visitor)),
-                           lib::forward<Vs>(vs)...))
-      };
+        template<typename... Alts>
+        inline constexpr DECLTYPE_AUTO operator()(Alts &&...alts) const DECLTYPE_AUTO_RETURN(
+            visit_exhaustiveness_check<Visitor, decltype((lib::forward<Alts>(alts).value))...>::invoke(
+                lib::forward<Visitor>(visitor_),
+                lib::forward<Alts>(alts).value...))
+    };
 
-    }  // namespace visitation
+    template<typename Visitor>
+    inline static constexpr AUTO make_value_visitor(Visitor &&visitor)
+        AUTO_RETURN(value_visitor<Visitor>{lib::forward<Visitor>(visitor)})
 
-    template <std::size_t Index, typename T>
-    struct alt {
-      using value_type = T;
+            public
+        : template<typename Visitor, typename... Vs>
+          inline static constexpr DECLTYPE_AUTO visit_alt(Visitor &&visitor, Vs &&...vs)
+              DECLTYPE_AUTO_RETURN(alt::visit_alt(lib::forward<Visitor>(visitor), lib::forward<Vs>(vs).impl_...))
+
+                  template<typename Visitor, typename... Vs>
+                  inline static constexpr DECLTYPE_AUTO
+          visit_alt_at(std::size_t index, Visitor &&visitor, Vs &&...vs) DECLTYPE_AUTO_RETURN(
+              alt::visit_alt_at(index, lib::forward<Visitor>(visitor), lib::forward<Vs>(vs).impl_...))
+
+              template<typename Visitor, typename... Vs>
+              inline static constexpr DECLTYPE_AUTO visit_value(Visitor &&visitor, Vs &&...vs)
+                  DECLTYPE_AUTO_RETURN(visit_alt(make_value_visitor(lib::forward<Visitor>(visitor)),
+                                                 lib::forward<Vs>(vs)...))
+
+                      template<typename Visitor, typename... Vs>
+                      inline static constexpr DECLTYPE_AUTO
+          visit_value_at(std::size_t index, Visitor &&visitor, Vs &&...vs) DECLTYPE_AUTO_RETURN(
+              visit_alt_at(index, make_value_visitor(lib::forward<Visitor>(visitor)), lib::forward<Vs>(vs)...))
+};
+
+}// namespace visitation
+
+template<std::size_t Index, typename T>
+struct alt {
+    using value_type = T;
 
 #ifdef _MSC_VER
 #pragma warning(push)
 #pragma warning(disable : 4244)
 #endif
-      template <typename... Args>
-      inline explicit constexpr alt(in_place_t, Args &&... args)
-          : value(lib::forward<Args>(args)...) {}
+    template<typename... Args>
+    inline explicit constexpr alt(in_place_t, Args &&...args) : value(lib::forward<Args>(args)...)
+    {}
 #ifdef _MSC_VER
 #pragma warning(pop)
 #endif
 
-      T value;
-    };
+    T value;
+};
 
-    template <Trait DestructibleTrait, std::size_t Index, typename... Ts>
-    union recursive_union;
+template<Trait DestructibleTrait, std::size_t Index, typename... Ts>
+union recursive_union;
 
-    template <Trait DestructibleTrait, std::size_t Index>
-    union recursive_union<DestructibleTrait, Index> {};
+template<Trait DestructibleTrait, std::size_t Index>
+union recursive_union<DestructibleTrait, Index> {};
 
-#define MPARK_VARIANT_RECURSIVE_UNION(destructible_trait, destructor)      \
-  template <std::size_t Index, typename T, typename... Ts>                 \
-  union recursive_union<destructible_trait, Index, T, Ts...> {             \
-    public:                                                                \
-    inline explicit constexpr recursive_union(valueless_t) noexcept        \
-        : dummy_{} {}                                                      \
-                                                                           \
-    template <typename... Args>                                            \
-    inline explicit constexpr recursive_union(in_place_index_t<0>,         \
-                                              Args &&... args)             \
-        : head_(in_place_t{}, lib::forward<Args>(args)...) {}              \
-                                                                           \
-    template <std::size_t I, typename... Args>                             \
-    inline explicit constexpr recursive_union(in_place_index_t<I>,         \
-                                              Args &&... args)             \
-        : tail_(in_place_index_t<I - 1>{}, lib::forward<Args>(args)...) {} \
-                                                                           \
-    recursive_union(const recursive_union &) = default;                    \
-    recursive_union(recursive_union &&) = default;                         \
-                                                                           \
-    destructor                                                             \
-                                                                           \
-    recursive_union &operator=(const recursive_union &) = default;         \
-    recursive_union &operator=(recursive_union &&) = default;              \
-                                                                           \
-    private:                                                               \
-    char dummy_;                                                           \
-    alt<Index, T> head_;                                                   \
-    recursive_union<destructible_trait, Index + 1, Ts...> tail_;           \
-                                                                           \
-    friend struct access::recursive_union;                                 \
-  }
+#define MPARK_VARIANT_RECURSIVE_UNION(destructible_trait, destructor)                                                  \
+    template<std::size_t Index, typename T, typename... Ts>                                                            \
+    union recursive_union<destructible_trait, Index, T, Ts...> {                                                       \
+    public:                                                                                                            \
+        inline explicit constexpr recursive_union(valueless_t) noexcept : dummy_{} {}                                  \
+                                                                                                                       \
+        template<typename... Args>                                                                                     \
+        inline explicit constexpr recursive_union(in_place_index_t<0>, Args &&...args)                                 \
+            : head_(in_place_t{}, lib::forward<Args>(args)...)                                                         \
+        {}                                                                                                             \
+                                                                                                                       \
+        template<std::size_t I, typename... Args>                                                                      \
+        inline explicit constexpr recursive_union(in_place_index_t<I>, Args &&...args)                                 \
+            : tail_(in_place_index_t<I - 1>{}, lib::forward<Args>(args)...)                                            \
+        {}                                                                                                             \
+                                                                                                                       \
+        recursive_union(const recursive_union &) = default;                                                            \
+        recursive_union(recursive_union &&)      = default;                                                            \
+                                                                                                                       \
+        destructor                                                                                                     \
+                                                                                                                       \
+            recursive_union &                                                                                          \
+            operator=(const recursive_union &)         = default;                                                      \
+        recursive_union &operator=(recursive_union &&) = default;                                                      \
+                                                                                                                       \
+    private:                                                                                                           \
+        char dummy_;                                                                                                   \
+        alt<Index, T> head_;                                                                                           \
+        recursive_union<destructible_trait, Index + 1, Ts...> tail_;                                                   \
+                                                                                                                       \
+        friend struct access::recursive_union;                                                                         \
+    }
 
-    MPARK_VARIANT_RECURSIVE_UNION(Trait::TriviallyAvailable,
-                                  ~recursive_union() = default;);
-    MPARK_VARIANT_RECURSIVE_UNION(Trait::Available,
-                                  ~recursive_union() {});
-    MPARK_VARIANT_RECURSIVE_UNION(Trait::Unavailable,
-                                  ~recursive_union() = delete;);
+MPARK_VARIANT_RECURSIVE_UNION(Trait::TriviallyAvailable, ~recursive_union() = default;);
+MPARK_VARIANT_RECURSIVE_UNION(Trait::Available, ~recursive_union(){});
+MPARK_VARIANT_RECURSIVE_UNION(Trait::Unavailable, ~recursive_union() = delete;);
 
 #undef MPARK_VARIANT_RECURSIVE_UNION
 
-    using index_t = unsigned int;
+using index_t = unsigned int;
 
-    template <Trait DestructibleTrait, typename... Ts>
-    class base {
-      public:
-      inline explicit constexpr base(valueless_t tag) noexcept
-          : data_(tag), index_(static_cast<index_t>(-1)) {}
+template<Trait DestructibleTrait, typename... Ts>
+class base {
+public:
+    inline explicit constexpr base(valueless_t tag) noexcept : data_(tag), index_(static_cast<index_t>(-1)) {}
 
-      template <std::size_t I, typename... Args>
-      inline explicit constexpr base(in_place_index_t<I>, Args &&... args)
-          : data_(in_place_index_t<I>{}, lib::forward<Args>(args)...),
-            index_(I) {}
+    template<std::size_t I, typename... Args>
+    inline explicit constexpr base(in_place_index_t<I>, Args &&...args)
+        : data_(in_place_index_t<I>{}, lib::forward<Args>(args)...),
+          index_(I)
+    {}
 
-      inline constexpr bool valueless_by_exception() const noexcept {
-        return index_ == static_cast<index_t>(-1);
-      }
+    inline constexpr bool valueless_by_exception() const noexcept { return index_ == static_cast<index_t>(-1); }
 
-      inline constexpr std::size_t index() const noexcept {
-        return valueless_by_exception() ? variant_npos : index_;
-      }
+    inline constexpr std::size_t index() const noexcept { return valueless_by_exception() ? variant_npos : index_; }
 
-      protected:
-      using data_t = recursive_union<DestructibleTrait, 0, Ts...>;
+protected:
+    using data_t = recursive_union<DestructibleTrait, 0, Ts...>;
 
-      friend inline constexpr base &as_base(base &b) { return b; }
-      friend inline constexpr const base &as_base(const base &b) { return b; }
-      friend inline constexpr base &&as_base(base &&b) { return lib::move(b); }
-      friend inline constexpr const base &&as_base(const base &&b) { return lib::move(b); }
+    friend inline constexpr base &as_base(base &b) { return b; }
 
-      friend inline constexpr data_t &data(base &b) { return b.data_; }
-      friend inline constexpr const data_t &data(const base &b) { return b.data_; }
-      friend inline constexpr data_t &&data(base &&b) { return lib::move(b).data_; }
-      friend inline constexpr const data_t &&data(const base &&b) { return lib::move(b).data_; }
+    friend inline constexpr const base &as_base(const base &b) { return b; }
 
-      inline static constexpr std::size_t size() { return sizeof...(Ts); }
+    friend inline constexpr base &&as_base(base &&b) { return lib::move(b); }
 
-      data_t data_;
-      index_t index_;
+    friend inline constexpr const base &&as_base(const base &&b) { return lib::move(b); }
 
-      friend struct access::base;
-      friend struct visitation::base;
-    };
+    friend inline constexpr data_t &data(base &b) { return b.data_; }
 
-    struct dtor {
+    friend inline constexpr const data_t &data(const base &b) { return b.data_; }
+
+    friend inline constexpr data_t &&data(base &&b) { return lib::move(b).data_; }
+
+    friend inline constexpr const data_t &&data(const base &&b) { return lib::move(b).data_; }
+
+    inline static constexpr std::size_t size() { return sizeof...(Ts); }
+
+    data_t data_;
+    index_t index_;
+
+    friend struct access::base;
+    friend struct visitation::base;
+};
+
+struct dtor {
 #ifdef _MSC_VER
 #pragma warning(push)
 #pragma warning(disable : 4100)
 #endif
-      template <typename Alt>
-      inline void operator()(Alt &alt) const noexcept { alt.~Alt(); }
+    template<typename Alt>
+    inline void operator()(Alt &alt) const noexcept
+    {
+        alt.~Alt();
+    }
 #ifdef _MSC_VER
 #pragma warning(pop)
 #endif
-    };
+};
 
 #if !defined(_MSC_VER) || _MSC_VER >= 1910
 #define MPARK_INHERITING_CTOR(type, base) using base::base;
 #else
-#define MPARK_INHERITING_CTOR(type, base)         \
-  template <typename... Args>                     \
-  inline explicit constexpr type(Args &&... args) \
-      : base(lib::forward<Args>(args)...) {}
+#define MPARK_INHERITING_CTOR(type, base)                                                                              \
+    template<typename... Args>                                                                                         \
+    inline explicit constexpr type(Args &&...args) : base(lib::forward<Args>(args)...)                                 \
+    {}
 #endif
 
-    template <typename Traits, Trait = Traits::destructible_trait>
-    class destructor;
+template<typename Traits, Trait = Traits::destructible_trait>
+class destructor;
 
-#define MPARK_VARIANT_DESTRUCTOR(destructible_trait, definition, destroy) \
-  template <typename... Ts>                                               \
-  class destructor<traits<Ts...>, destructible_trait>                     \
-      : public base<destructible_trait, Ts...> {                          \
-    using super = base<destructible_trait, Ts...>;                        \
-                                                                          \
-    public:                                                               \
-    MPARK_INHERITING_CTOR(destructor, super)                              \
-    using super::operator=;                                               \
-                                                                          \
-    destructor(const destructor &) = default;                             \
-    destructor(destructor &&) = default;                                  \
-    definition                                                            \
-    destructor &operator=(const destructor &) = default;                  \
-    destructor &operator=(destructor &&) = default;                       \
-                                                                          \
-    protected:                                                            \
-    destroy                                                               \
-  }
+#define MPARK_VARIANT_DESTRUCTOR(destructible_trait, definition, destroy)                                              \
+    template<typename... Ts>                                                                                           \
+    class destructor<traits<Ts...>, destructible_trait> : public base<destructible_trait, Ts...> {                     \
+        using super = base<destructible_trait, Ts...>;                                                                 \
+                                                                                                                       \
+    public:                                                                                                            \
+        MPARK_INHERITING_CTOR(destructor, super)                                                                       \
+        using super::operator=;                                                                                        \
+                                                                                                                       \
+        destructor(const destructor &)                       = default;                                                \
+        destructor(destructor &&)                            = default;                                                \
+        definition destructor &operator=(const destructor &) = default;                                                \
+        destructor &operator=(destructor &&)                 = default;                                                \
+                                                                                                                       \
+    protected:                                                                                                         \
+        destroy                                                                                                        \
+    }
 
-    MPARK_VARIANT_DESTRUCTOR(
-        Trait::TriviallyAvailable,
-        ~destructor() = default;,
-        inline void destroy() noexcept {
-          this->index_ = static_cast<index_t>(-1);
-        });
+MPARK_VARIANT_DESTRUCTOR(
+    Trait::TriviallyAvailable, ~destructor() = default;
+    , inline void destroy() noexcept { this->index_ = static_cast<index_t>(-1); });
 
-    MPARK_VARIANT_DESTRUCTOR(
-        Trait::Available,
-        ~destructor() { destroy(); },
-        inline void destroy() noexcept {
-          if (!this->valueless_by_exception()) {
-            visitation::alt::visit_alt(dtor{}, *this);
-          }
-          this->index_ = static_cast<index_t>(-1);
-        });
+MPARK_VARIANT_DESTRUCTOR(
+    Trait::Available,
+    ~destructor() { destroy(); },
+    inline void destroy() noexcept {
+        if (!this->valueless_by_exception()) { visitation::alt::visit_alt(dtor{}, *this); }
+        this->index_ = static_cast<index_t>(-1);
+    });
 
-    MPARK_VARIANT_DESTRUCTOR(
-        Trait::Unavailable,
-        ~destructor() = delete;,
-        inline void destroy() noexcept = delete;);
+MPARK_VARIANT_DESTRUCTOR(Trait::Unavailable, ~destructor() = delete;, inline void destroy() noexcept = delete;);
 
 #undef MPARK_VARIANT_DESTRUCTOR
 
-    template <typename Traits>
-    class constructor : public destructor<Traits> {
-      using super = destructor<Traits>;
+template<typename Traits>
+class constructor : public destructor<Traits> {
+    using super = destructor<Traits>;
 
-      public:
-      MPARK_INHERITING_CTOR(constructor, super)
-      using super::operator=;
+public:
+    MPARK_INHERITING_CTOR(constructor, super)
+    using super::operator=;
 
-      protected:
+protected:
 #ifndef MPARK_GENERIC_LAMBDAS
-      struct ctor {
-        template <typename LhsAlt, typename RhsAlt>
-        inline void operator()(LhsAlt &lhs_alt, RhsAlt &&rhs_alt) const {
-          constructor::construct_alt(lhs_alt,
-                                     lib::forward<RhsAlt>(rhs_alt).value);
+    struct ctor {
+        template<typename LhsAlt, typename RhsAlt>
+        inline void operator()(LhsAlt &lhs_alt, RhsAlt &&rhs_alt) const
+        {
+            constructor::construct_alt(lhs_alt, lib::forward<RhsAlt>(rhs_alt).value);
         }
-      };
+    };
 #endif
 
-      template <std::size_t I, typename T, typename... Args>
-      inline static T &construct_alt(alt<I, T> &a, Args &&... args) {
-        auto *result = ::new (static_cast<void *>(lib::addressof(a)))
-            alt<I, T>(in_place_t{}, lib::forward<Args>(args)...);
+    template<std::size_t I, typename T, typename... Args>
+    inline static T &construct_alt(alt<I, T> &a, Args &&...args)
+    {
+        auto *result =
+            ::new (static_cast<void *>(lib::addressof(a))) alt<I, T>(in_place_t{}, lib::forward<Args>(args)...);
         return result->value;
-      }
+    }
 
-      template <typename Rhs>
-      inline static void generic_construct(constructor &lhs, Rhs &&rhs) {
+    template<typename Rhs>
+    inline static void generic_construct(constructor &lhs, Rhs &&rhs)
+    {
         lhs.destroy();
         if (!rhs.valueless_by_exception()) {
-          visitation::alt::visit_alt_at(
-              rhs.index(),
+            visitation::alt::visit_alt_at(
+                rhs.index(),
 #ifdef MPARK_GENERIC_LAMBDAS
-              [](auto &lhs_alt, auto &&rhs_alt) {
-                constructor::construct_alt(
-                    lhs_alt, lib::forward<decltype(rhs_alt)>(rhs_alt).value);
-              }
+                [](auto &lhs_alt, auto &&rhs_alt) {
+                    constructor::construct_alt(lhs_alt, lib::forward<decltype(rhs_alt)>(rhs_alt).value);
+                }
 #else
-              ctor{}
+                ctor{}
 #endif
-              ,
-              lhs,
-              lib::forward<Rhs>(rhs));
-          lhs.index_ = rhs.index_;
+                ,
+                lhs, lib::forward<Rhs>(rhs));
+            lhs.index_ = rhs.index_;
         }
-      }
-    };
+    }
+};
 
-    template <typename Traits, Trait = Traits::move_constructible_trait>
-    class move_constructor;
+template<typename Traits, Trait = Traits::move_constructible_trait>
+class move_constructor;
 
-#define MPARK_VARIANT_MOVE_CONSTRUCTOR(move_constructible_trait, definition) \
-  template <typename... Ts>                                                  \
-  class move_constructor<traits<Ts...>, move_constructible_trait>            \
-      : public constructor<traits<Ts...>> {                                  \
-    using super = constructor<traits<Ts...>>;                                \
-                                                                             \
-    public:                                                                  \
-    MPARK_INHERITING_CTOR(move_constructor, super)                           \
-    using super::operator=;                                                  \
-                                                                             \
-    move_constructor(const move_constructor &) = default;                    \
-    definition                                                               \
-    ~move_constructor() = default;                                           \
-    move_constructor &operator=(const move_constructor &) = default;         \
-    move_constructor &operator=(move_constructor &&) = default;              \
-  }
+#define MPARK_VARIANT_MOVE_CONSTRUCTOR(move_constructible_trait, definition)                                           \
+    template<typename... Ts>                                                                                           \
+    class move_constructor<traits<Ts...>, move_constructible_trait> : public constructor<traits<Ts...>> {              \
+        using super = constructor<traits<Ts...>>;                                                                      \
+                                                                                                                       \
+    public:                                                                                                            \
+        MPARK_INHERITING_CTOR(move_constructor, super)                                                                 \
+        using super::operator=;                                                                                        \
+                                                                                                                       \
+        move_constructor(const move_constructor &)            = default;                                               \
+        definition ~move_constructor()                        = default;                                               \
+        move_constructor &operator=(const move_constructor &) = default;                                               \
+        move_constructor &operator=(move_constructor &&)      = default;                                               \
+    }
 
-    MPARK_VARIANT_MOVE_CONSTRUCTOR(
-        Trait::TriviallyAvailable,
-        move_constructor(move_constructor &&that) = default;);
+MPARK_VARIANT_MOVE_CONSTRUCTOR(Trait::TriviallyAvailable, move_constructor(move_constructor &&that) = default;);
 
-    MPARK_VARIANT_MOVE_CONSTRUCTOR(
-        Trait::Available,
-        move_constructor(move_constructor &&that) noexcept(
-            lib::all<std::is_nothrow_move_constructible<Ts>::value...>::value)
-            : move_constructor(valueless_t{}) {
-          this->generic_construct(*this, lib::move(that));
-        });
+MPARK_VARIANT_MOVE_CONSTRUCTOR(
+    Trait::Available,
+    move_constructor(move_constructor &&that) noexcept(
+        lib::all<std::is_nothrow_move_constructible<Ts>::value...>::value)
+    : move_constructor(valueless_t{}) { this->generic_construct(*this, lib::move(that)); });
 
-    MPARK_VARIANT_MOVE_CONSTRUCTOR(
-        Trait::Unavailable,
-        move_constructor(move_constructor &&) = delete;);
+MPARK_VARIANT_MOVE_CONSTRUCTOR(Trait::Unavailable, move_constructor(move_constructor &&) = delete;);
 
 #undef MPARK_VARIANT_MOVE_CONSTRUCTOR
 
-    template <typename Traits, Trait = Traits::copy_constructible_trait>
-    class copy_constructor;
+template<typename Traits, Trait = Traits::copy_constructible_trait>
+class copy_constructor;
 
-#define MPARK_VARIANT_COPY_CONSTRUCTOR(copy_constructible_trait, definition) \
-  template <typename... Ts>                                                  \
-  class copy_constructor<traits<Ts...>, copy_constructible_trait>            \
-      : public move_constructor<traits<Ts...>> {                             \
-    using super = move_constructor<traits<Ts...>>;                           \
-                                                                             \
-    public:                                                                  \
-    MPARK_INHERITING_CTOR(copy_constructor, super)                           \
-    using super::operator=;                                                  \
-                                                                             \
-    definition                                                               \
-    copy_constructor(copy_constructor &&) = default;                         \
-    ~copy_constructor() = default;                                           \
-    copy_constructor &operator=(const copy_constructor &) = default;         \
-    copy_constructor &operator=(copy_constructor &&) = default;              \
-  }
+#define MPARK_VARIANT_COPY_CONSTRUCTOR(copy_constructible_trait, definition)                                           \
+    template<typename... Ts>                                                                                           \
+    class copy_constructor<traits<Ts...>, copy_constructible_trait> : public move_constructor<traits<Ts...>> {         \
+        using super = move_constructor<traits<Ts...>>;                                                                 \
+                                                                                                                       \
+    public:                                                                                                            \
+        MPARK_INHERITING_CTOR(copy_constructor, super)                                                                 \
+        using super::operator=;                                                                                        \
+                                                                                                                       \
+        definition copy_constructor(copy_constructor &&)      = default;                                               \
+        ~copy_constructor()                                   = default;                                               \
+        copy_constructor &operator=(const copy_constructor &) = default;                                               \
+        copy_constructor &operator=(copy_constructor &&)      = default;                                               \
+    }
 
-    MPARK_VARIANT_COPY_CONSTRUCTOR(
-        Trait::TriviallyAvailable,
-        copy_constructor(const copy_constructor &that) = default;);
+MPARK_VARIANT_COPY_CONSTRUCTOR(Trait::TriviallyAvailable, copy_constructor(const copy_constructor &that) = default;);
 
-    MPARK_VARIANT_COPY_CONSTRUCTOR(
-        Trait::Available,
-        copy_constructor(const copy_constructor &that)
-            : copy_constructor(valueless_t{}) {
-          this->generic_construct(*this, that);
-        });
+MPARK_VARIANT_COPY_CONSTRUCTOR(
+    Trait::Available, copy_constructor(const copy_constructor &that)
+    : copy_constructor(valueless_t{}) { this->generic_construct(*this, that); });
 
-    MPARK_VARIANT_COPY_CONSTRUCTOR(
-        Trait::Unavailable,
-        copy_constructor(const copy_constructor &) = delete;);
+MPARK_VARIANT_COPY_CONSTRUCTOR(Trait::Unavailable, copy_constructor(const copy_constructor &) = delete;);
 
 #undef MPARK_VARIANT_COPY_CONSTRUCTOR
 
-    template <typename Traits>
-    class assignment : public copy_constructor<Traits> {
-      using super = copy_constructor<Traits>;
+template<typename Traits>
+class assignment : public copy_constructor<Traits> {
+    using super = copy_constructor<Traits>;
 
-      public:
-      MPARK_INHERITING_CTOR(assignment, super)
-      using super::operator=;
+public:
+    MPARK_INHERITING_CTOR(assignment, super)
+    using super::operator=;
 
-      template <std::size_t I, typename... Args>
-      inline /* auto & */ auto emplace(Args &&... args)
-          -> decltype(this->construct_alt(access::base::get_alt<I>(*this),
-                                          lib::forward<Args>(args)...)) {
+    template<std::size_t I, typename... Args>
+    inline /* auto & */ auto emplace(Args &&...args)
+        -> decltype(this->construct_alt(access::base::get_alt<I>(*this), lib::forward<Args>(args)...))
+    {
         this->destroy();
-        auto &result = this->construct_alt(access::base::get_alt<I>(*this),
-                                           lib::forward<Args>(args)...);
+        auto &result = this->construct_alt(access::base::get_alt<I>(*this), lib::forward<Args>(args)...);
         this->index_ = I;
         return result;
-      }
+    }
 
-      protected:
+protected:
 #ifndef MPARK_GENERIC_LAMBDAS
-      template <typename That>
-      struct assigner {
-        template <typename ThisAlt, typename ThatAlt>
-        inline void operator()(ThisAlt &this_alt, ThatAlt &&that_alt) const {
-          self->assign_alt(this_alt, lib::forward<ThatAlt>(that_alt).value);
+    template<typename That>
+    struct assigner {
+        template<typename ThisAlt, typename ThatAlt>
+        inline void operator()(ThisAlt &this_alt, ThatAlt &&that_alt) const
+        {
+            self->assign_alt(this_alt, lib::forward<ThatAlt>(that_alt).value);
         }
+
         assignment *self;
-      };
+    };
 #endif
 
-      template <std::size_t I, typename T, typename Arg>
-      inline void assign_alt(alt<I, T> &a, Arg &&arg) {
+    template<std::size_t I, typename T, typename Arg>
+    inline void assign_alt(alt<I, T> &a, Arg &&arg)
+    {
         if (this->index() == I) {
 #ifdef _MSC_VER
 #pragma warning(push)
 #pragma warning(disable : 4244)
 #endif
-          a.value = lib::forward<Arg>(arg);
+            a.value = lib::forward<Arg>(arg);
 #ifdef _MSC_VER
 #pragma warning(pop)
 #endif
         } else {
-          struct {
-            void operator()(std::true_type) const {
-              this_->emplace<I>(lib::forward<Arg>(arg_));
-            }
-            void operator()(std::false_type) const {
-              this_->emplace<I>(T(lib::forward<Arg>(arg_)));
-            }
-            assignment *this_;
-            Arg &&arg_;
-          } impl{this, lib::forward<Arg>(arg)};
-          impl(lib::bool_constant<
-                   std::is_nothrow_constructible<T, Arg>::value ||
-                   !std::is_nothrow_move_constructible<T>::value>{});
-        }
-      }
+            struct {
+                void operator()(std::true_type) const { this_->emplace<I>(lib::forward<Arg>(arg_)); }
 
-      template <typename That>
-      inline void generic_assign(That &&that) {
+                void operator()(std::false_type) const { this_->emplace<I>(T(lib::forward<Arg>(arg_))); }
+
+                assignment *this_;
+                Arg &&arg_;
+            } impl{this, lib::forward<Arg>(arg)};
+
+            impl(lib::bool_constant < std::is_nothrow_constructible<T, Arg>::value
+                 || !std::is_nothrow_move_constructible<T>::value > {});
+        }
+    }
+
+    template<typename That>
+    inline void generic_assign(That &&that)
+    {
         if (this->valueless_by_exception() && that.valueless_by_exception()) {
-          // do nothing.
+            // do nothing.
         } else if (that.valueless_by_exception()) {
-          this->destroy();
+            this->destroy();
         } else {
-          visitation::alt::visit_alt_at(
-              that.index(),
+            visitation::alt::visit_alt_at(
+                that.index(),
 #ifdef MPARK_GENERIC_LAMBDAS
-              [this](auto &this_alt, auto &&that_alt) {
-                this->assign_alt(
-                    this_alt, lib::forward<decltype(that_alt)>(that_alt).value);
-              }
+                [this](auto &this_alt, auto &&that_alt) {
+                    this->assign_alt(this_alt, lib::forward<decltype(that_alt)>(that_alt).value);
+                }
 #else
-              assigner<That>{this}
+                assigner<That>{this}
 #endif
-              ,
-              *this,
-              lib::forward<That>(that));
+                ,
+                *this, lib::forward<That>(that));
         }
-      }
-    };
+    }
+};
 
-    template <typename Traits, Trait = Traits::move_assignable_trait>
-    class move_assignment;
+template<typename Traits, Trait = Traits::move_assignable_trait>
+class move_assignment;
 
-#define MPARK_VARIANT_MOVE_ASSIGNMENT(move_assignable_trait, definition) \
-  template <typename... Ts>                                              \
-  class move_assignment<traits<Ts...>, move_assignable_trait>            \
-      : public assignment<traits<Ts...>> {                               \
-    using super = assignment<traits<Ts...>>;                             \
-                                                                         \
-    public:                                                              \
-    MPARK_INHERITING_CTOR(move_assignment, super)                        \
-    using super::operator=;                                              \
-                                                                         \
-    move_assignment(const move_assignment &) = default;                  \
-    move_assignment(move_assignment &&) = default;                       \
-    ~move_assignment() = default;                                        \
-    move_assignment &operator=(const move_assignment &) = default;       \
-    definition                                                           \
-  }
+#define MPARK_VARIANT_MOVE_ASSIGNMENT(move_assignable_trait, definition)                                               \
+    template<typename... Ts>                                                                                           \
+    class move_assignment<traits<Ts...>, move_assignable_trait> : public assignment<traits<Ts...>> {                   \
+        using super = assignment<traits<Ts...>>;                                                                       \
+                                                                                                                       \
+    public:                                                                                                            \
+        MPARK_INHERITING_CTOR(move_assignment, super)                                                                  \
+        using super::operator=;                                                                                        \
+                                                                                                                       \
+        move_assignment(const move_assignment &)            = default;                                                 \
+        move_assignment(move_assignment &&)                 = default;                                                 \
+        ~move_assignment()                                  = default;                                                 \
+        move_assignment &operator=(const move_assignment &) = default;                                                 \
+        definition                                                                                                     \
+    }
 
-    MPARK_VARIANT_MOVE_ASSIGNMENT(
-        Trait::TriviallyAvailable,
-        move_assignment &operator=(move_assignment &&that) = default;);
+MPARK_VARIANT_MOVE_ASSIGNMENT(Trait::TriviallyAvailable, move_assignment &operator=(move_assignment &&that) = default;);
 
-    MPARK_VARIANT_MOVE_ASSIGNMENT(
-        Trait::Available,
-        move_assignment &
-        operator=(move_assignment &&that) noexcept(
-            lib::all<(std::is_nothrow_move_constructible<Ts>::value &&
-                      std::is_nothrow_move_assignable<Ts>::value)...>::value) {
-          this->generic_assign(lib::move(that));
-          return *this;
-        });
+MPARK_VARIANT_MOVE_ASSIGNMENT(
+    Trait::Available,
+    move_assignment &
+    operator=(move_assignment &&that) noexcept(lib::all<(std::is_nothrow_move_constructible<Ts>::value
+                                                         && std::is_nothrow_move_assignable<Ts>::value)...>::value) {
+        this->generic_assign(lib::move(that));
+        return *this;
+    });
 
-    MPARK_VARIANT_MOVE_ASSIGNMENT(
-        Trait::Unavailable,
-        move_assignment &operator=(move_assignment &&) = delete;);
+MPARK_VARIANT_MOVE_ASSIGNMENT(Trait::Unavailable, move_assignment &operator=(move_assignment &&) = delete;);
 
 #undef MPARK_VARIANT_MOVE_ASSIGNMENT
 
-    template <typename Traits, Trait = Traits::copy_assignable_trait>
-    class copy_assignment;
+template<typename Traits, Trait = Traits::copy_assignable_trait>
+class copy_assignment;
 
-#define MPARK_VARIANT_COPY_ASSIGNMENT(copy_assignable_trait, definition) \
-  template <typename... Ts>                                              \
-  class copy_assignment<traits<Ts...>, copy_assignable_trait>            \
-      : public move_assignment<traits<Ts...>> {                          \
-    using super = move_assignment<traits<Ts...>>;                        \
-                                                                         \
-    public:                                                              \
-    MPARK_INHERITING_CTOR(copy_assignment, super)                        \
-    using super::operator=;                                              \
-                                                                         \
-    copy_assignment(const copy_assignment &) = default;                  \
-    copy_assignment(copy_assignment &&) = default;                       \
-    ~copy_assignment() = default;                                        \
-    definition                                                           \
-    copy_assignment &operator=(copy_assignment &&) = default;            \
-  }
+#define MPARK_VARIANT_COPY_ASSIGNMENT(copy_assignable_trait, definition)                                               \
+    template<typename... Ts>                                                                                           \
+    class copy_assignment<traits<Ts...>, copy_assignable_trait> : public move_assignment<traits<Ts...>> {              \
+        using super = move_assignment<traits<Ts...>>;                                                                  \
+                                                                                                                       \
+    public:                                                                                                            \
+        MPARK_INHERITING_CTOR(copy_assignment, super)                                                                  \
+        using super::operator=;                                                                                        \
+                                                                                                                       \
+        copy_assignment(const copy_assignment &)                  = default;                                           \
+        copy_assignment(copy_assignment &&)                       = default;                                           \
+        ~copy_assignment()                                        = default;                                           \
+        definition copy_assignment &operator=(copy_assignment &&) = default;                                           \
+    }
 
-    MPARK_VARIANT_COPY_ASSIGNMENT(
-        Trait::TriviallyAvailable,
-        copy_assignment &operator=(const copy_assignment &that) = default;);
+MPARK_VARIANT_COPY_ASSIGNMENT(Trait::TriviallyAvailable,
+                              copy_assignment &operator=(const copy_assignment &that) = default;);
 
-    MPARK_VARIANT_COPY_ASSIGNMENT(
-        Trait::Available,
-        copy_assignment &operator=(const copy_assignment &that) {
-          this->generic_assign(that);
-          return *this;
-        });
+MPARK_VARIANT_COPY_ASSIGNMENT(
+    Trait::Available,
+    copy_assignment &
+    operator=(const copy_assignment &that) {
+        this->generic_assign(that);
+        return *this;
+    });
 
-    MPARK_VARIANT_COPY_ASSIGNMENT(
-        Trait::Unavailable,
-        copy_assignment &operator=(const copy_assignment &) = delete;);
+MPARK_VARIANT_COPY_ASSIGNMENT(Trait::Unavailable, copy_assignment &operator=(const copy_assignment &) = delete;);
 
 #undef MPARK_VARIANT_COPY_ASSIGNMENT
 
-    template <typename... Ts>
-    class impl : public copy_assignment<traits<Ts...>> {
-      using super = copy_assignment<traits<Ts...>>;
+template<typename... Ts>
+class impl : public copy_assignment<traits<Ts...>> {
+    using super = copy_assignment<traits<Ts...>>;
 
-      public:
-      MPARK_INHERITING_CTOR(impl, super)
-      using super::operator=;
+public:
+    MPARK_INHERITING_CTOR(impl, super)
+    using super::operator=;
 
-      template <std::size_t I, typename Arg>
-      inline void assign(Arg &&arg) {
-        this->assign_alt(access::base::get_alt<I>(*this),
-                         lib::forward<Arg>(arg));
-      }
+    template<std::size_t I, typename Arg>
+    inline void assign(Arg &&arg)
+    {
+        this->assign_alt(access::base::get_alt<I>(*this), lib::forward<Arg>(arg));
+    }
 
-      inline void swap(impl &that) {
+    inline void swap(impl &that)
+    {
         if (this->valueless_by_exception() && that.valueless_by_exception()) {
-          // do nothing.
+            // do nothing.
         } else if (this->index() == that.index()) {
-          visitation::alt::visit_alt_at(this->index(),
+            visitation::alt::visit_alt_at(
+                this->index(),
 #ifdef MPARK_GENERIC_LAMBDAS
-                                        [](auto &this_alt, auto &that_alt) {
-                                          using std::swap;
-                                          swap(this_alt.value,
-                                               that_alt.value);
-                                        }
+                [](auto &this_alt, auto &that_alt) {
+                    using std::swap;
+                    swap(this_alt.value, that_alt.value);
+                }
 #else
-                                        swapper{}
+                swapper{}
 #endif
-                                        ,
-                                        *this,
-                                        that);
+                ,
+                *this, that);
         } else {
-          impl *lhs = this;
-          impl *rhs = lib::addressof(that);
-          if (lhs->move_nothrow() && !rhs->move_nothrow()) {
-            std::swap(lhs, rhs);
-          }
-          impl tmp(lib::move(*rhs));
+            impl *lhs = this;
+            impl *rhs = lib::addressof(that);
+            if (lhs->move_nothrow() && !rhs->move_nothrow()) { std::swap(lhs, rhs); }
+            impl tmp(lib::move(*rhs));
 #ifdef MPARK_EXCEPTIONS
-          // EXTENSION: When the move construction of `lhs` into `rhs` throws
-          // and `tmp` is nothrow move constructible then we move `tmp` back
-          // into `rhs` and provide the strong exception safety guarantee.
-          try {
-            this->generic_construct(*rhs, lib::move(*lhs));
-          } catch (...) {
-            if (tmp.move_nothrow()) {
-              this->generic_construct(*rhs, lib::move(tmp));
+            // EXTENSION: When the move construction of `lhs` into `rhs` throws
+            // and `tmp` is nothrow move constructible then we move `tmp` back
+            // into `rhs` and provide the strong exception safety guarantee.
+            try {
+                this->generic_construct(*rhs, lib::move(*lhs));
+            } catch (...) {
+                if (tmp.move_nothrow()) { this->generic_construct(*rhs, lib::move(tmp)); }
+                throw;
             }
-            throw;
-          }
 #else
-          this->generic_construct(*rhs, lib::move(*lhs));
+            this->generic_construct(*rhs, lib::move(*lhs));
 #endif
-          this->generic_construct(*lhs, lib::move(tmp));
+            this->generic_construct(*lhs, lib::move(tmp));
         }
-      }
+    }
 
-      private:
+private:
 #ifndef MPARK_GENERIC_LAMBDAS
-      struct swapper {
-        template <typename ThisAlt, typename ThatAlt>
-        inline void operator()(ThisAlt &this_alt, ThatAlt &that_alt) const {
-          using std::swap;
-          swap(this_alt.value, that_alt.value);
+    struct swapper {
+        template<typename ThisAlt, typename ThatAlt>
+        inline void operator()(ThisAlt &this_alt, ThatAlt &that_alt) const
+        {
+            using std::swap;
+            swap(this_alt.value, that_alt.value);
         }
-      };
+    };
 #endif
 
-      inline constexpr bool move_nothrow() const {
-        return this->valueless_by_exception() ||
-               lib::array<bool, sizeof...(Ts)>{
-                   {std::is_nothrow_move_constructible<Ts>::value...}
-               }[this->index()];
-      }
-    };
+    inline constexpr bool move_nothrow() const
+    {
+        return this->valueless_by_exception()
+            || lib::array<bool, sizeof...(Ts)>{{std::is_nothrow_move_constructible<Ts>::value...}}[this->index()];
+    }
+};
 
 #undef MPARK_INHERITING_CTOR
 
-    template <std::size_t I, typename T>
-    struct overload_leaf {
-      using F = lib::size_constant<I> (*)(T);
-      operator F() const { return nullptr; }
-    };
+template<std::size_t I, typename T>
+struct overload_leaf {
+    using F = lib::size_constant<I> (*)(T);
 
-    template <typename... Ts>
-    struct overload_impl {
-      private:
-      template <typename>
-      struct impl;
+    operator F() const { return nullptr; }
+};
 
-      template <std::size_t... Is>
-      struct impl<lib::index_sequence<Is...>> : overload_leaf<Is, Ts>... {};
+template<typename... Ts>
+struct overload_impl {
+private:
+    template<typename>
+    struct impl;
 
-      public:
-      using type = impl<lib::index_sequence_for<Ts...>>;
-    };
+    template<std::size_t... Is>
+    struct impl<lib::index_sequence<Is...>> : overload_leaf<Is, Ts>... {};
 
-    template <typename... Ts>
-    using overload = typename overload_impl<Ts...>::type;
+public:
+    using type = impl<lib::index_sequence_for<Ts...>>;
+};
 
-    template <typename T, typename... Ts>
-    using best_match = lib::invoke_result_t<overload<Ts...>, T &&>;
+template<typename... Ts>
+using overload = typename overload_impl<Ts...>::type;
 
-    template <typename T>
-    struct is_in_place_index : std::false_type {};
+template<typename T, typename... Ts>
+using best_match = lib::invoke_result_t<overload<Ts...>, T &&>;
 
-    template <std::size_t I>
-    struct is_in_place_index<in_place_index_t<I>> : std::true_type {};
+template<typename T>
+struct is_in_place_index : std::false_type {};
 
-    template <typename T>
-    struct is_in_place_type : std::false_type {};
+template<std::size_t I>
+struct is_in_place_index<in_place_index_t<I>> : std::true_type {};
 
-    template <typename T>
-    struct is_in_place_type<in_place_type_t<T>> : std::true_type {};
+template<typename T>
+struct is_in_place_type : std::false_type {};
 
-  }  // detail
+template<typename T>
+struct is_in_place_type<in_place_type_t<T>> : std::true_type {};
 
-  template <typename... Ts>
-  class variant {
-    static_assert(0 < sizeof...(Ts),
-                  "variant must consist of at least one alternative.");
+}// namespace detail
+
+template<typename... Ts>
+class variant {
+    static_assert(0 < sizeof...(Ts), "variant must consist of at least one alternative.");
 
     static_assert(lib::all<!std::is_array<Ts>::value...>::value,
                   "variant can not have an array type as an alternative.");
@@ -2217,310 +2158,285 @@ namespace mpark {
     static_assert(lib::all<!std::is_reference<Ts>::value...>::value,
                   "variant can not have a reference type as an alternative.");
 
-    static_assert(lib::all<!std::is_void<Ts>::value...>::value,
-                  "variant can not have a void type as an alternative.");
+    static_assert(lib::all<!std::is_void<Ts>::value...>::value, "variant can not have a void type as an alternative.");
 
-    public:
-    template <
-        typename Front = lib::type_pack_element_t<0, Ts...>,
-        lib::enable_if_t<std::is_default_constructible<Front>::value, int> = 0>
-    inline constexpr variant() noexcept(
-        std::is_nothrow_default_constructible<Front>::value)
-        : impl_(in_place_index_t<0>{}) {}
+public:
+    template<typename Front                                                     = lib::type_pack_element_t<0, Ts...>,
+             lib::enable_if_t<std::is_default_constructible<Front>::value, int> = 0>
+    inline constexpr variant() noexcept(std::is_nothrow_default_constructible<Front>::value)
+        : impl_(in_place_index_t<0>{})
+    {}
 
     variant(const variant &) = default;
-    variant(variant &&) = default;
+    variant(variant &&)      = default;
 
-    template <
-        typename Arg,
-        typename Decayed = lib::decay_t<Arg>,
-        lib::enable_if_t<!std::is_same<Decayed, variant>::value, int> = 0,
-        lib::enable_if_t<!detail::is_in_place_index<Decayed>::value, int> = 0,
-        lib::enable_if_t<!detail::is_in_place_type<Decayed>::value, int> = 0,
-        std::size_t I = detail::best_match<Arg, Ts...>::value,
-        typename T = lib::type_pack_element_t<I, Ts...>,
-        lib::enable_if_t<std::is_constructible<T, Arg>::value, int> = 0>
-    inline constexpr variant(Arg &&arg) noexcept(
-        std::is_nothrow_constructible<T, Arg>::value)
-        : impl_(in_place_index_t<I>{}, lib::forward<Arg>(arg)) {}
+    template<typename Arg,
+             typename Decayed                                                  = lib::decay_t<Arg>,
+             lib::enable_if_t<!std::is_same<Decayed, variant>::value, int>     = 0,
+             lib::enable_if_t<!detail::is_in_place_index<Decayed>::value, int> = 0,
+             lib::enable_if_t<!detail::is_in_place_type<Decayed>::value, int>  = 0,
+             std::size_t I                                                     = detail::best_match<Arg, Ts...>::value,
+             typename T                                                        = lib::type_pack_element_t<I, Ts...>,
+             lib::enable_if_t<std::is_constructible<T, Arg>::value, int>       = 0>
+    inline constexpr variant(Arg &&arg) noexcept(std::is_nothrow_constructible<T, Arg>::value)
+        : impl_(in_place_index_t<I>{}, lib::forward<Arg>(arg))
+    {}
 
-    template <
-        std::size_t I,
-        typename... Args,
-        typename T = lib::type_pack_element_t<I, Ts...>,
-        lib::enable_if_t<std::is_constructible<T, Args...>::value, int> = 0>
-    inline explicit constexpr variant(
-        in_place_index_t<I>,
-        Args &&... args) noexcept(std::is_nothrow_constructible<T,
-                                                                Args...>::value)
-        : impl_(in_place_index_t<I>{}, lib::forward<Args>(args)...) {}
+    template<std::size_t I,
+             typename... Args,
+             typename T                                                      = lib::type_pack_element_t<I, Ts...>,
+             lib::enable_if_t<std::is_constructible<T, Args...>::value, int> = 0>
+    inline explicit constexpr variant(in_place_index_t<I>,
+                                      Args &&...args) noexcept(std::is_nothrow_constructible<T, Args...>::value)
+        : impl_(in_place_index_t<I>{}, lib::forward<Args>(args)...)
+    {}
 
-    template <
-        std::size_t I,
-        typename Up,
-        typename... Args,
-        typename T = lib::type_pack_element_t<I, Ts...>,
-        lib::enable_if_t<std::is_constructible<T,
-                                               std::initializer_list<Up> &,
-                                               Args...>::value,
-                         int> = 0>
-    inline explicit constexpr variant(
-        in_place_index_t<I>,
-        std::initializer_list<Up> il,
-        Args &&... args) noexcept(std::
-                                      is_nothrow_constructible<
-                                          T,
-                                          std::initializer_list<Up> &,
-                                          Args...>::value)
-        : impl_(in_place_index_t<I>{}, il, lib::forward<Args>(args)...) {}
+    template<std::size_t I,
+             typename Up,
+             typename... Args,
+             typename T = lib::type_pack_element_t<I, Ts...>,
+             lib::enable_if_t<std::is_constructible<T, std::initializer_list<Up> &, Args...>::value, int> = 0>
+    inline explicit constexpr variant(in_place_index_t<I>, std::initializer_list<Up> il, Args &&...args) noexcept(
+        std::is_nothrow_constructible<T, std::initializer_list<Up> &, Args...>::value)
+        : impl_(in_place_index_t<I>{}, il, lib::forward<Args>(args)...)
+    {}
 
-    template <
-        typename T,
-        typename... Args,
-        std::size_t I = detail::find_index_sfinae<T, Ts...>::value,
-        lib::enable_if_t<std::is_constructible<T, Args...>::value, int> = 0>
-    inline explicit constexpr variant(
-        in_place_type_t<T>,
-        Args &&... args) noexcept(std::is_nothrow_constructible<T,
-                                                                Args...>::value)
-        : impl_(in_place_index_t<I>{}, lib::forward<Args>(args)...) {}
+    template<typename T,
+             typename... Args,
+             std::size_t I = detail::find_index_sfinae<T, Ts...>::value,
+             lib::enable_if_t<std::is_constructible<T, Args...>::value, int> = 0>
+    inline explicit constexpr variant(in_place_type_t<T>,
+                                      Args &&...args) noexcept(std::is_nothrow_constructible<T, Args...>::value)
+        : impl_(in_place_index_t<I>{}, lib::forward<Args>(args)...)
+    {}
 
-    template <
-        typename T,
-        typename Up,
-        typename... Args,
-        std::size_t I = detail::find_index_sfinae<T, Ts...>::value,
-        lib::enable_if_t<std::is_constructible<T,
-                                               std::initializer_list<Up> &,
-                                               Args...>::value,
-                         int> = 0>
-    inline explicit constexpr variant(
-        in_place_type_t<T>,
-        std::initializer_list<Up> il,
-        Args &&... args) noexcept(std::
-                                      is_nothrow_constructible<
-                                          T,
-                                          std::initializer_list<Up> &,
-                                          Args...>::value)
-        : impl_(in_place_index_t<I>{}, il, lib::forward<Args>(args)...) {}
+    template<typename T,
+             typename Up,
+             typename... Args,
+             std::size_t I = detail::find_index_sfinae<T, Ts...>::value,
+             lib::enable_if_t<std::is_constructible<T, std::initializer_list<Up> &, Args...>::value, int> = 0>
+    inline explicit constexpr variant(in_place_type_t<T>, std::initializer_list<Up> il, Args &&...args) noexcept(
+        std::is_nothrow_constructible<T, std::initializer_list<Up> &, Args...>::value)
+        : impl_(in_place_index_t<I>{}, il, lib::forward<Args>(args)...)
+    {}
 
-    ~variant() = default;
+    ~variant()                          = default;
 
     variant &operator=(const variant &) = default;
-    variant &operator=(variant &&) = default;
+    variant &operator=(variant &&)      = default;
 
-    template <typename Arg,
-              lib::enable_if_t<!std::is_same<lib::decay_t<Arg>, variant>::value,
-                               int> = 0,
-              std::size_t I = detail::best_match<Arg, Ts...>::value,
-              typename T = lib::type_pack_element_t<I, Ts...>,
-              lib::enable_if_t<(std::is_assignable<T &, Arg>::value &&
-                                std::is_constructible<T, Arg>::value),
-                               int> = 0>
-    inline variant &operator=(Arg &&arg) noexcept(
-        (std::is_nothrow_assignable<T &, Arg>::value &&
-         std::is_nothrow_constructible<T, Arg>::value)) {
-      impl_.template assign<I>(lib::forward<Arg>(arg));
-      return *this;
+    template<typename Arg,
+             lib::enable_if_t<!std::is_same<lib::decay_t<Arg>, variant>::value, int> = 0,
+             std::size_t I = detail::best_match<Arg, Ts...>::value,
+             typename T    = lib::type_pack_element_t<I, Ts...>,
+             lib::enable_if_t<(std::is_assignable<T &, Arg>::value && std::is_constructible<T, Arg>::value), int> = 0>
+    inline variant &operator=(Arg &&arg) noexcept((std::is_nothrow_assignable<T &, Arg>::value
+                                                   && std::is_nothrow_constructible<T, Arg>::value))
+    {
+        impl_.template assign<I>(lib::forward<Arg>(arg));
+        return *this;
     }
 
-    template <
-        std::size_t I,
-        typename... Args,
-        typename T = lib::type_pack_element_t<I, Ts...>,
-        lib::enable_if_t<std::is_constructible<T, Args...>::value, int> = 0>
-    inline T &emplace(Args &&... args) {
-      return impl_.template emplace<I>(lib::forward<Args>(args)...);
+    template<std::size_t I,
+             typename... Args,
+             typename T                                                      = lib::type_pack_element_t<I, Ts...>,
+             lib::enable_if_t<std::is_constructible<T, Args...>::value, int> = 0>
+    inline T &emplace(Args &&...args)
+    {
+        return impl_.template emplace<I>(lib::forward<Args>(args)...);
     }
 
-    template <
-        std::size_t I,
-        typename Up,
-        typename... Args,
-        typename T = lib::type_pack_element_t<I, Ts...>,
-        lib::enable_if_t<std::is_constructible<T,
-                                               std::initializer_list<Up> &,
-                                               Args...>::value,
-                         int> = 0>
-    inline T &emplace(std::initializer_list<Up> il, Args &&... args) {
-      return impl_.template emplace<I>(il, lib::forward<Args>(args)...);
+    template<std::size_t I,
+             typename Up,
+             typename... Args,
+             typename T = lib::type_pack_element_t<I, Ts...>,
+             lib::enable_if_t<std::is_constructible<T, std::initializer_list<Up> &, Args...>::value, int> = 0>
+    inline T &emplace(std::initializer_list<Up> il, Args &&...args)
+    {
+        return impl_.template emplace<I>(il, lib::forward<Args>(args)...);
     }
 
-    template <
-        typename T,
-        typename... Args,
-        std::size_t I = detail::find_index_sfinae<T, Ts...>::value,
-        lib::enable_if_t<std::is_constructible<T, Args...>::value, int> = 0>
-    inline T &emplace(Args &&... args) {
-      return impl_.template emplace<I>(lib::forward<Args>(args)...);
+    template<typename T,
+             typename... Args,
+             std::size_t I = detail::find_index_sfinae<T, Ts...>::value,
+             lib::enable_if_t<std::is_constructible<T, Args...>::value, int> = 0>
+    inline T &emplace(Args &&...args)
+    {
+        return impl_.template emplace<I>(lib::forward<Args>(args)...);
     }
 
-    template <
-        typename T,
-        typename Up,
-        typename... Args,
-        std::size_t I = detail::find_index_sfinae<T, Ts...>::value,
-        lib::enable_if_t<std::is_constructible<T,
-                                               std::initializer_list<Up> &,
-                                               Args...>::value,
-                         int> = 0>
-    inline T &emplace(std::initializer_list<Up> il, Args &&... args) {
-      return impl_.template emplace<I>(il, lib::forward<Args>(args)...);
+    template<typename T,
+             typename Up,
+             typename... Args,
+             std::size_t I = detail::find_index_sfinae<T, Ts...>::value,
+             lib::enable_if_t<std::is_constructible<T, std::initializer_list<Up> &, Args...>::value, int> = 0>
+    inline T &emplace(std::initializer_list<Up> il, Args &&...args)
+    {
+        return impl_.template emplace<I>(il, lib::forward<Args>(args)...);
     }
 
-    inline constexpr bool valueless_by_exception() const noexcept {
-      return impl_.valueless_by_exception();
-    }
+    inline constexpr bool valueless_by_exception() const noexcept { return impl_.valueless_by_exception(); }
 
-    inline constexpr std::size_t index() const noexcept {
-      return impl_.index();
-    }
+    inline constexpr std::size_t index() const noexcept { return impl_.index(); }
 
-    template <bool Dummy = true,
-              lib::enable_if_t<
-                  lib::all<Dummy,
-                           (lib::dependent_type<std::is_move_constructible<Ts>,
-                                                Dummy>::value &&
-                            lib::dependent_type<lib::is_swappable<Ts>,
-                                                Dummy>::value)...>::value,
-                  int> = 0>
+    template<bool Dummy            = true,
+             lib::enable_if_t<lib::all<Dummy,
+                                       (lib::dependent_type<std::is_move_constructible<Ts>, Dummy>::value
+                                        && lib::dependent_type<lib::is_swappable<Ts>, Dummy>::value)...>::value,
+                              int> = 0>
     inline void swap(variant &that) noexcept(
-        lib::all<(std::is_nothrow_move_constructible<Ts>::value &&
-                  lib::is_nothrow_swappable<Ts>::value)...>::value) {
-      impl_.swap(that.impl_);
+        lib::all<(std::is_nothrow_move_constructible<Ts>::value && lib::is_nothrow_swappable<Ts>::value)...>::value)
+    {
+        impl_.swap(that.impl_);
     }
 
-    private:
+private:
     detail::impl<Ts...> impl_;
 
     friend struct detail::access::variant;
     friend struct detail::visitation::variant;
-  };
+};
 
-  template <std::size_t I, typename... Ts>
-  inline constexpr bool holds_alternative(const variant<Ts...> &v) noexcept {
+template<std::size_t I, typename... Ts>
+inline constexpr bool
+holds_alternative(const variant<Ts...> &v) noexcept
+{
     return v.index() == I;
-  }
+}
 
-  template <typename T, typename... Ts>
-  inline constexpr bool holds_alternative(const variant<Ts...> &v) noexcept {
+template<typename T, typename... Ts>
+inline constexpr bool
+holds_alternative(const variant<Ts...> &v) noexcept
+{
     return holds_alternative<detail::find_index_checked<T, Ts...>::value>(v);
-  }
+}
 
-  namespace detail {
-    template <std::size_t I, typename V>
-    struct generic_get_impl {
-      constexpr generic_get_impl(int) noexcept {}
+namespace detail {
+template<std::size_t I, typename V>
+struct generic_get_impl {
+    constexpr generic_get_impl(int) noexcept {}
 
-      constexpr AUTO_REFREF operator()(V &&v) const
-        AUTO_REFREF_RETURN(
-            access::variant::get_alt<I>(lib::forward<V>(v)).value)
-    };
+    constexpr AUTO_REFREF operator()(V &&v) const
+        AUTO_REFREF_RETURN(access::variant::get_alt<I>(lib::forward<V>(v)).value)
+};
 
-    template <std::size_t I, typename V>
-    inline constexpr AUTO_REFREF generic_get(V &&v)
-      AUTO_REFREF_RETURN(generic_get_impl<I, V>(
-          holds_alternative<I>(v) ? 0 : (throw_bad_variant_access(), 0))(
-          lib::forward<V>(v)))
-  }  // namespace detail
+template<std::size_t I, typename V>
+inline constexpr AUTO_REFREF
+generic_get(V &&v) AUTO_REFREF_RETURN(
+    generic_get_impl<I, V>(holds_alternative<I>(v) ? 0 : (throw_bad_variant_access(), 0))(lib::forward<V>(v)))
+}// namespace detail
 
-  template <std::size_t I, typename... Ts>
-  inline constexpr variant_alternative_t<I, variant<Ts...>> &get(
-      variant<Ts...> &v) {
+template<std::size_t I, typename... Ts>
+inline constexpr variant_alternative_t<I, variant<Ts...>> &
+get(variant<Ts...> &v)
+{
     return detail::generic_get<I>(v);
-  }
+}
 
-  template <std::size_t I, typename... Ts>
-  inline constexpr variant_alternative_t<I, variant<Ts...>> &&get(
-      variant<Ts...> &&v) {
+template<std::size_t I, typename... Ts>
+inline constexpr variant_alternative_t<I, variant<Ts...>> &&
+get(variant<Ts...> &&v)
+{
     return detail::generic_get<I>(lib::move(v));
-  }
+}
 
-  template <std::size_t I, typename... Ts>
-  inline constexpr const variant_alternative_t<I, variant<Ts...>> &get(
-      const variant<Ts...> &v) {
+template<std::size_t I, typename... Ts>
+inline constexpr const variant_alternative_t<I, variant<Ts...>> &
+get(const variant<Ts...> &v)
+{
     return detail::generic_get<I>(v);
-  }
+}
 
-  template <std::size_t I, typename... Ts>
-  inline constexpr const variant_alternative_t<I, variant<Ts...>> &&get(
-      const variant<Ts...> &&v) {
+template<std::size_t I, typename... Ts>
+inline constexpr const variant_alternative_t<I, variant<Ts...>> &&
+get(const variant<Ts...> &&v)
+{
     return detail::generic_get<I>(lib::move(v));
-  }
+}
 
-  template <typename T, typename... Ts>
-  inline constexpr T &get(variant<Ts...> &v) {
+template<typename T, typename... Ts>
+inline constexpr T &
+get(variant<Ts...> &v)
+{
     return get<detail::find_index_checked<T, Ts...>::value>(v);
-  }
+}
 
-  template <typename T, typename... Ts>
-  inline constexpr T &&get(variant<Ts...> &&v) {
+template<typename T, typename... Ts>
+inline constexpr T &&
+get(variant<Ts...> &&v)
+{
     return get<detail::find_index_checked<T, Ts...>::value>(lib::move(v));
-  }
+}
 
-  template <typename T, typename... Ts>
-  inline constexpr const T &get(const variant<Ts...> &v) {
+template<typename T, typename... Ts>
+inline constexpr const T &
+get(const variant<Ts...> &v)
+{
     return get<detail::find_index_checked<T, Ts...>::value>(v);
-  }
+}
 
-  template <typename T, typename... Ts>
-  inline constexpr const T &&get(const variant<Ts...> &&v) {
+template<typename T, typename... Ts>
+inline constexpr const T &&
+get(const variant<Ts...> &&v)
+{
     return get<detail::find_index_checked<T, Ts...>::value>(lib::move(v));
-  }
+}
 
-  namespace detail {
+namespace detail {
 
-    template <std::size_t I, typename V>
-    inline constexpr /* auto * */ AUTO generic_get_if(V *v) noexcept
-      AUTO_RETURN(v && holds_alternative<I>(*v)
-                      ? lib::addressof(access::variant::get_alt<I>(*v).value)
-                      : nullptr)
+template<std::size_t I, typename V>
+inline constexpr /* auto * */ AUTO
+generic_get_if(V *v) noexcept
+    AUTO_RETURN(v &&holds_alternative<I>(*v) ? lib::addressof(access::variant::get_alt<I>(*v).value) : nullptr)
 
-  }  // namespace detail
+}// namespace detail
 
-  template <std::size_t I, typename... Ts>
-  inline constexpr lib::add_pointer_t<variant_alternative_t<I, variant<Ts...>>>
-  get_if(variant<Ts...> *v) noexcept {
+template<std::size_t I, typename... Ts>
+inline constexpr lib::add_pointer_t<variant_alternative_t<I, variant<Ts...>>>
+get_if(variant<Ts...> *v) noexcept
+{
     return detail::generic_get_if<I>(v);
-  }
+}
 
-  template <std::size_t I, typename... Ts>
-  inline constexpr lib::add_pointer_t<
-      const variant_alternative_t<I, variant<Ts...>>>
-  get_if(const variant<Ts...> *v) noexcept {
+template<std::size_t I, typename... Ts>
+inline constexpr lib::add_pointer_t<const variant_alternative_t<I, variant<Ts...>>>
+get_if(const variant<Ts...> *v) noexcept
+{
     return detail::generic_get_if<I>(v);
-  }
+}
 
-  template <typename T, typename... Ts>
-  inline constexpr lib::add_pointer_t<T>
-  get_if(variant<Ts...> *v) noexcept {
+template<typename T, typename... Ts>
+inline constexpr lib::add_pointer_t<T>
+get_if(variant<Ts...> *v) noexcept
+{
     return get_if<detail::find_index_checked<T, Ts...>::value>(v);
-  }
+}
 
-  template <typename T, typename... Ts>
-  inline constexpr lib::add_pointer_t<const T>
-  get_if(const variant<Ts...> *v) noexcept {
+template<typename T, typename... Ts>
+inline constexpr lib::add_pointer_t<const T>
+get_if(const variant<Ts...> *v) noexcept
+{
     return get_if<detail::find_index_checked<T, Ts...>::value>(v);
-  }
+}
 
-  namespace detail {
-    template <typename RelOp>
-    struct convert_to_bool {
-      template <typename Lhs, typename Rhs>
-      inline constexpr bool operator()(Lhs &&lhs, Rhs &&rhs) const {
-        static_assert(std::is_convertible<lib::invoke_result_t<RelOp, Lhs, Rhs>,
-                                          bool>::value,
+namespace detail {
+template<typename RelOp>
+struct convert_to_bool {
+    template<typename Lhs, typename Rhs>
+    inline constexpr bool operator()(Lhs &&lhs, Rhs &&rhs) const
+    {
+        static_assert(std::is_convertible<lib::invoke_result_t<RelOp, Lhs, Rhs>, bool>::value,
                       "relational operators must return a type"
                       " implicitly convertible to bool");
-        return lib::invoke(
-            RelOp{}, lib::forward<Lhs>(lhs), lib::forward<Rhs>(rhs));
-      }
-    };
-  }  // namespace detail
+        return lib::invoke(RelOp{}, lib::forward<Lhs>(lhs), lib::forward<Rhs>(rhs));
+    }
+};
+}// namespace detail
 
-  template <typename... Ts>
-  inline constexpr bool operator==(const variant<Ts...> &lhs,
-                                   const variant<Ts...> &rhs) {
+template<typename... Ts>
+inline constexpr bool
+operator==(const variant<Ts...> &lhs, const variant<Ts...> &rhs)
+{
     using detail::visitation::variant;
     using equal_to = detail::convert_to_bool<lib::equal_to>;
 #ifdef MPARK_CPP14_CONSTEXPR
@@ -2528,15 +2444,15 @@ namespace mpark {
     if (lhs.valueless_by_exception()) return true;
     return variant::visit_value_at(lhs.index(), equal_to{}, lhs, rhs);
 #else
-    return lhs.index() == rhs.index() &&
-           (lhs.valueless_by_exception() ||
-            variant::visit_value_at(lhs.index(), equal_to{}, lhs, rhs));
+    return lhs.index() == rhs.index()
+        && (lhs.valueless_by_exception() || variant::visit_value_at(lhs.index(), equal_to{}, lhs, rhs));
 #endif
-  }
+}
 
-  template <typename... Ts>
-  inline constexpr bool operator!=(const variant<Ts...> &lhs,
-                                   const variant<Ts...> &rhs) {
+template<typename... Ts>
+inline constexpr bool
+operator!=(const variant<Ts...> &lhs, const variant<Ts...> &rhs)
+{
     using detail::visitation::variant;
     using not_equal_to = detail::convert_to_bool<lib::not_equal_to>;
 #ifdef MPARK_CPP14_CONSTEXPR
@@ -2544,15 +2460,15 @@ namespace mpark {
     if (lhs.valueless_by_exception()) return false;
     return variant::visit_value_at(lhs.index(), not_equal_to{}, lhs, rhs);
 #else
-    return lhs.index() != rhs.index() ||
-           (!lhs.valueless_by_exception() &&
-            variant::visit_value_at(lhs.index(), not_equal_to{}, lhs, rhs));
+    return lhs.index() != rhs.index()
+        || (!lhs.valueless_by_exception() && variant::visit_value_at(lhs.index(), not_equal_to{}, lhs, rhs));
 #endif
-  }
+}
 
-  template <typename... Ts>
-  inline constexpr bool operator<(const variant<Ts...> &lhs,
-                                  const variant<Ts...> &rhs) {
+template<typename... Ts>
+inline constexpr bool
+operator<(const variant<Ts...> &lhs, const variant<Ts...> &rhs)
+{
     using detail::visitation::variant;
     using less = detail::convert_to_bool<lib::less>;
 #ifdef MPARK_CPP14_CONSTEXPR
@@ -2562,16 +2478,16 @@ namespace mpark {
     if (lhs.index() > rhs.index()) return false;
     return variant::visit_value_at(lhs.index(), less{}, lhs, rhs);
 #else
-    return !rhs.valueless_by_exception() &&
-           (lhs.valueless_by_exception() || lhs.index() < rhs.index() ||
-            (lhs.index() == rhs.index() &&
-             variant::visit_value_at(lhs.index(), less{}, lhs, rhs)));
+    return !rhs.valueless_by_exception()
+        && (lhs.valueless_by_exception() || lhs.index() < rhs.index()
+            || (lhs.index() == rhs.index() && variant::visit_value_at(lhs.index(), less{}, lhs, rhs)));
 #endif
-  }
+}
 
-  template <typename... Ts>
-  inline constexpr bool operator>(const variant<Ts...> &lhs,
-                                  const variant<Ts...> &rhs) {
+template<typename... Ts>
+inline constexpr bool
+operator>(const variant<Ts...> &lhs, const variant<Ts...> &rhs)
+{
     using detail::visitation::variant;
     using greater = detail::convert_to_bool<lib::greater>;
 #ifdef MPARK_CPP14_CONSTEXPR
@@ -2581,16 +2497,16 @@ namespace mpark {
     if (lhs.index() < rhs.index()) return false;
     return variant::visit_value_at(lhs.index(), greater{}, lhs, rhs);
 #else
-    return !lhs.valueless_by_exception() &&
-           (rhs.valueless_by_exception() || lhs.index() > rhs.index() ||
-            (lhs.index() == rhs.index() &&
-             variant::visit_value_at(lhs.index(), greater{}, lhs, rhs)));
+    return !lhs.valueless_by_exception()
+        && (rhs.valueless_by_exception() || lhs.index() > rhs.index()
+            || (lhs.index() == rhs.index() && variant::visit_value_at(lhs.index(), greater{}, lhs, rhs)));
 #endif
-  }
+}
 
-  template <typename... Ts>
-  inline constexpr bool operator<=(const variant<Ts...> &lhs,
-                                   const variant<Ts...> &rhs) {
+template<typename... Ts>
+inline constexpr bool
+operator<=(const variant<Ts...> &lhs, const variant<Ts...> &rhs)
+{
     using detail::visitation::variant;
     using less_equal = detail::convert_to_bool<lib::less_equal>;
 #ifdef MPARK_CPP14_CONSTEXPR
@@ -2600,17 +2516,17 @@ namespace mpark {
     if (lhs.index() > rhs.index()) return false;
     return variant::visit_value_at(lhs.index(), less_equal{}, lhs, rhs);
 #else
-    return lhs.valueless_by_exception() ||
-           (!rhs.valueless_by_exception() &&
-            (lhs.index() < rhs.index() ||
-             (lhs.index() == rhs.index() &&
-              variant::visit_value_at(lhs.index(), less_equal{}, lhs, rhs))));
+    return lhs.valueless_by_exception()
+        || (!rhs.valueless_by_exception()
+            && (lhs.index() < rhs.index()
+                || (lhs.index() == rhs.index() && variant::visit_value_at(lhs.index(), less_equal{}, lhs, rhs))));
 #endif
-  }
+}
 
-  template <typename... Ts>
-  inline constexpr bool operator>=(const variant<Ts...> &lhs,
-                                   const variant<Ts...> &rhs) {
+template<typename... Ts>
+inline constexpr bool
+operator>=(const variant<Ts...> &lhs, const variant<Ts...> &rhs)
+{
     using detail::visitation::variant;
     using greater_equal = detail::convert_to_bool<lib::greater_equal>;
 #ifdef MPARK_CPP14_CONSTEXPR
@@ -2620,123 +2536,134 @@ namespace mpark {
     if (lhs.index() < rhs.index()) return false;
     return variant::visit_value_at(lhs.index(), greater_equal{}, lhs, rhs);
 #else
-    return rhs.valueless_by_exception() ||
-           (!lhs.valueless_by_exception() &&
-            (lhs.index() > rhs.index() ||
-             (lhs.index() == rhs.index() &&
-              variant::visit_value_at(
-                  lhs.index(), greater_equal{}, lhs, rhs))));
+    return rhs.valueless_by_exception()
+        || (!lhs.valueless_by_exception()
+            && (lhs.index() > rhs.index()
+                || (lhs.index() == rhs.index() && variant::visit_value_at(lhs.index(), greater_equal{}, lhs, rhs))));
 #endif
-  }
+}
 
-  struct monostate {};
+struct monostate {};
 
-  inline constexpr bool operator<(monostate, monostate) noexcept {
+inline constexpr bool
+operator<(monostate, monostate) noexcept
+{
     return false;
-  }
+}
 
-  inline constexpr bool operator>(monostate, monostate) noexcept {
+inline constexpr bool
+operator>(monostate, monostate) noexcept
+{
     return false;
-  }
+}
 
-  inline constexpr bool operator<=(monostate, monostate) noexcept {
+inline constexpr bool
+operator<=(monostate, monostate) noexcept
+{
     return true;
-  }
+}
 
-  inline constexpr bool operator>=(monostate, monostate) noexcept {
+inline constexpr bool
+operator>=(monostate, monostate) noexcept
+{
     return true;
-  }
+}
 
-  inline constexpr bool operator==(monostate, monostate) noexcept {
+inline constexpr bool
+operator==(monostate, monostate) noexcept
+{
     return true;
-  }
+}
 
-  inline constexpr bool operator!=(monostate, monostate) noexcept {
+inline constexpr bool
+operator!=(monostate, monostate) noexcept
+{
     return false;
-  }
+}
 
 #ifdef MPARK_CPP14_CONSTEXPR
-  namespace detail {
+namespace detail {
 
-    inline constexpr bool all(std::initializer_list<bool> bs) {
-      for (bool b : bs) {
-        if (!b) {
-          return false;
-        }
-      }
-      return true;
+inline constexpr bool
+all(std::initializer_list<bool> bs)
+{
+    for (bool b : bs) {
+        if (!b) { return false; }
     }
+    return true;
+}
 
-  }  // namespace detail
+}// namespace detail
 
-  template <typename Visitor, typename... Vs>
-  inline constexpr decltype(auto) visit(Visitor &&visitor, Vs &&... vs) {
-    return (detail::all({!vs.valueless_by_exception()...})
-                ? (void)0
-                : throw_bad_variant_access()),
-           detail::visitation::variant::visit_value(
-               lib::forward<Visitor>(visitor), lib::forward<Vs>(vs)...);
-  }
+template<typename Visitor, typename... Vs>
+inline constexpr decltype(auto)
+visit(Visitor &&visitor, Vs &&...vs)
+{
+    return (detail::all({!vs.valueless_by_exception()...}) ? (void) 0 : throw_bad_variant_access()),
+           detail::visitation::variant::visit_value(lib::forward<Visitor>(visitor), lib::forward<Vs>(vs)...);
+}
 #else
-  namespace detail {
+namespace detail {
 
-    template <std::size_t N>
-    inline constexpr bool all_impl(const lib::array<bool, N> &bs,
-                                   std::size_t idx) {
-      return idx >= N || (bs[idx] && all_impl(bs, idx + 1));
-    }
+template<std::size_t N>
+inline constexpr bool
+all_impl(const lib::array<bool, N> &bs, std::size_t idx)
+{
+    return idx >= N || (bs[idx] && all_impl(bs, idx + 1));
+}
 
-    template <std::size_t N>
-    inline constexpr bool all(const lib::array<bool, N> &bs) {
-      return all_impl(bs, 0);
-    }
+template<std::size_t N>
+inline constexpr bool
+all(const lib::array<bool, N> &bs)
+{
+    return all_impl(bs, 0);
+}
 
-  }  // namespace detail
+}// namespace detail
 
-  template <typename Visitor, typename... Vs>
-  inline constexpr DECLTYPE_AUTO visit(Visitor &&visitor, Vs &&... vs)
-    DECLTYPE_AUTO_RETURN(
-        (detail::all(
-             lib::array<bool, sizeof...(Vs)>{{!vs.valueless_by_exception()...}})
-             ? (void)0
-             : throw_bad_variant_access()),
-        detail::visitation::variant::visit_value(lib::forward<Visitor>(visitor),
-                                                 lib::forward<Vs>(vs)...))
+template<typename Visitor, typename... Vs>
+inline constexpr DECLTYPE_AUTO
+visit(Visitor &&visitor, Vs &&...vs) DECLTYPE_AUTO_RETURN(
+    (detail::all(lib::array<bool, sizeof...(Vs)>{{!vs.valueless_by_exception()...}})
+         ? (void) 0
+         : throw_bad_variant_access()),
+    detail::visitation::variant::visit_value(lib::forward<Visitor>(visitor), lib::forward<Vs>(vs)...))
 #endif
 
-  template <typename... Ts>
-  inline auto swap(variant<Ts...> &lhs,
-                   variant<Ts...> &rhs) noexcept(noexcept(lhs.swap(rhs)))
-      -> decltype(lhs.swap(rhs)) {
+template<typename... Ts>
+inline auto
+swap(variant<Ts...> &lhs, variant<Ts...> &rhs) noexcept(noexcept(lhs.swap(rhs))) -> decltype(lhs.swap(rhs))
+{
     lhs.swap(rhs);
-  }
+}
 
-  namespace detail {
+namespace detail {
 
-    template <typename T, typename...>
-    using enabled_type = T;
+template<typename T, typename...>
+using enabled_type = T;
 
-    namespace hash {
+namespace hash {
 
-      template <typename H, typename K>
-      constexpr bool meets_requirements() noexcept {
-        return std::is_copy_constructible<H>::value &&
-               std::is_move_constructible<H>::value &&
-               lib::is_invocable_r<std::size_t, H, const K &>::value;
-      }
+template<typename H, typename K>
+constexpr bool
+meets_requirements() noexcept
+{
+    return std::is_copy_constructible<H>::value && std::is_move_constructible<H>::value
+        && lib::is_invocable_r<std::size_t, H, const K &>::value;
+}
 
-      template <typename K>
-      constexpr bool is_enabled() noexcept {
-        using H = std::hash<K>;
-        return meets_requirements<H, K>() &&
-               std::is_default_constructible<H>::value &&
-               std::is_copy_assignable<H>::value &&
-               std::is_move_assignable<H>::value;
-      }
+template<typename K>
+constexpr bool
+is_enabled() noexcept
+{
+    using H = std::hash<K>;
+    return meets_requirements<H, K>() && std::is_default_constructible<H>::value && std::is_copy_assignable<H>::value
+        && std::is_move_assignable<H>::value;
+}
 
-    }  // namespace hash
+}// namespace hash
 
-  }  // namespace detail
+}// namespace detail
 
 #undef AUTO
 #undef AUTO_RETURN
@@ -2747,67 +2674,67 @@ namespace mpark {
 #undef DECLTYPE_AUTO
 #undef DECLTYPE_AUTO_RETURN
 
-}  // namespace mpark
+}// namespace mpark
 
 namespace std {
 
-  template <typename... Ts>
-  struct hash<mpark::detail::enabled_type<
-      mpark::variant<Ts...>,
-      mpark::lib::enable_if_t<mpark::lib::all<mpark::detail::hash::is_enabled<
-          mpark::lib::remove_const_t<Ts>>()...>::value>>> {
+template<typename... Ts>
+struct hash<mpark::detail::enabled_type<mpark::variant<Ts...>,
+                                        mpark::lib::enable_if_t<mpark::lib::all<mpark::detail::hash::is_enabled<
+                                            mpark::lib::remove_const_t<Ts>>()...>::value>>> {
     using argument_type = mpark::variant<Ts...>;
-    using result_type = std::size_t;
+    using result_type   = std::size_t;
 
-    inline result_type operator()(const argument_type &v) const {
-      using mpark::detail::visitation::variant;
-      std::size_t result =
-          v.valueless_by_exception()
-              ? 299792458  // Random value chosen by the universe upon creation
-              : variant::visit_alt(
+    inline result_type operator()(const argument_type &v) const
+    {
+        using mpark::detail::visitation::variant;
+        std::size_t result = v.valueless_by_exception()
+            ? 299792458// Random value chosen by the universe upon creation
+            : variant::visit_alt(
 #ifdef MPARK_GENERIC_LAMBDAS
-                    [](const auto &alt) {
-                      using alt_type = mpark::lib::decay_t<decltype(alt)>;
-                      using value_type = mpark::lib::remove_const_t<
-                          typename alt_type::value_type>;
+                  [](const auto &alt) {
+                      using alt_type   = mpark::lib::decay_t<decltype(alt)>;
+                      using value_type = mpark::lib::remove_const_t<typename alt_type::value_type>;
                       return hash<value_type>{}(alt.value);
-                    }
+                  }
 #else
-                    hasher{}
+                  hasher{}
 #endif
-                    ,
-                    v);
-      return hash_combine(result, hash<std::size_t>{}(v.index()));
+                  ,
+                  v);
+        return hash_combine(result, hash<std::size_t>{}(v.index()));
     }
 
-    private:
+private:
 #ifndef MPARK_GENERIC_LAMBDAS
     struct hasher {
-      template <typename Alt>
-      inline std::size_t operator()(const Alt &alt) const {
-        using alt_type = mpark::lib::decay_t<Alt>;
-        using value_type =
-            mpark::lib::remove_const_t<typename alt_type::value_type>;
-        return hash<value_type>{}(alt.value);
-      }
+        template<typename Alt>
+        inline std::size_t operator()(const Alt &alt) const
+        {
+            using alt_type   = mpark::lib::decay_t<Alt>;
+            using value_type = mpark::lib::remove_const_t<typename alt_type::value_type>;
+            return hash<value_type>{}(alt.value);
+        }
     };
 #endif
 
-    static std::size_t hash_combine(std::size_t lhs, std::size_t rhs) {
-      return lhs ^= rhs + 0x9e3779b9 + (lhs << 6) + (lhs >> 2);
+    static std::size_t hash_combine(std::size_t lhs, std::size_t rhs)
+    {
+        return lhs ^= rhs + 0x9e3779b9 + (lhs << 6) + (lhs >> 2);
     }
-  };
+};
 
-  template <>
-  struct hash<mpark::monostate> {
+template<>
+struct hash<mpark::monostate> {
     using argument_type = mpark::monostate;
-    using result_type = std::size_t;
+    using result_type   = std::size_t;
 
-    inline result_type operator()(const argument_type &) const noexcept {
-      return 66740831;  // return a fundamentally attractive random value.
+    inline result_type operator()(const argument_type &) const noexcept
+    {
+        return 66740831;// return a fundamentally attractive random value.
     }
-  };
+};
 
-}  // namespace std
+}// namespace std
 
-#endif  // MPARK_VARIANT_HPP
+#endif// MPARK_VARIANT_HPP
diff --git a/tile/base/likely.h b/tile/base/likely.h
index e2ba84e..fb0312f 100644
--- a/tile/base/likely.h
+++ b/tile/base/likely.h
@@ -11,4 +11,4 @@
 #define TILE_UNLIKELY(expr) (expr)
 #endif
 
-#endif // _TILE_BASE_LIKELY_H
+#endif// _TILE_BASE_LIKELY_H
diff --git a/tile/base/logging.h b/tile/base/logging.h
index 9d3cdba..ceda425 100644
--- a/tile/base/logging.h
+++ b/tile/base/logging.h
@@ -104,4 +104,4 @@
 // #define TILE_NOT_IMPLEMENTED(...)
 // #define TILE_UNEXPECTED(...)
 
-#endif // _TILE_BASE_LOGGING_H
+#endif// _TILE_BASE_LOGGING_H
diff --git a/tile/base/make_unique.h b/tile/base/make_unique.h
index b701aab..9893f05 100644
--- a/tile/base/make_unique.h
+++ b/tile/base/make_unique.h
@@ -11,58 +11,57 @@
 namespace tile {
 
 // single elem
-template <typename T, typename... Args>
+template<typename T, typename... Args>
 inline enable_if_t<!std::is_array<T>::value, std::unique_ptr<T>>
-make_unique(Args &&...args) {
-  return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
+make_unique(Args &&...args)
+{
+    return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
 }
 
-template <typename T, typename... Args>
+template<typename T, typename... Args>
 inline enable_if_t<!std::is_array<T>::value, std::unique_ptr<T>>
-make_unique(T *ptr) {
-  return std::unique_ptr<T>(ptr);
+make_unique(T *ptr)
+{
+    return std::unique_ptr<T>(ptr);
 }
 
 // dynamic array
-template <typename T>
-inline enable_if_t<std::is_array<T>::value && std::extent<T>::value == 0,
-                   std::unique_ptr<T>>
-make_unique(std::size_t size) {
-  TILE_DCHECK(size > 0);
-  using U = typename std::remove_extent<T>::type;
-  return std::unique_ptr<T>(new U[size]());
+template<typename T>
+inline enable_if_t<std::is_array<T>::value && std::extent<T>::value == 0, std::unique_ptr<T>>
+make_unique(std::size_t size)
+{
+    TILE_DCHECK(size > 0);
+    using U = typename std::remove_extent<T>::type;
+    return std::unique_ptr<T>(new U[size]());
 }
 
 // int a[100];
 // char b[100];
-template <typename T, typename... Args>
-enable_if_t<std::is_array<T>::value && std::extent<T>::value != 0,
-            std::unique_ptr<T>>
-make_unique(Args &&...) = delete;
+template<typename T, typename... Args>
+enable_if_t<std::is_array<T>::value && std::extent<T>::value != 0, std::unique_ptr<T>> make_unique(Args &&...) = delete;
 
 // == With Deleter
 
-template <typename T, typename D, typename... Args>
+template<typename T, typename D, typename... Args>
 inline enable_if_t<!std::is_array<T>::value, std::unique_ptr<T, D>>
-make_unique_with_deleter(D &&deleter, Args &&...args) {
-  return std::unique_ptr<T, D>(new T(std::forward<Args>(args)...),
-                               std::forward<D>(deleter));
+make_unique_with_deleter(D &&deleter, Args &&...args)
+{
+    return std::unique_ptr<T, D>(new T(std::forward<Args>(args)...), std::forward<D>(deleter));
 }
 
-template <typename T, typename D>
-inline enable_if_t<std::is_array<T>::value && std::extent<T>::value == 0,
-                   std::unique_ptr<T, D>>
-make_unique_with_deleter(D &&deleter, std::size_t size) {
-  TILE_DCHECK(size > 0);
-  using U = typename std::remove_extent<T>::type;
-  return std::unique_ptr<T, D>(new U[size](), std::forward<D>(deleter));
+template<typename T, typename D>
+inline enable_if_t<std::is_array<T>::value && std::extent<T>::value == 0, std::unique_ptr<T, D>>
+make_unique_with_deleter(D &&deleter, std::size_t size)
+{
+    TILE_DCHECK(size > 0);
+    using U = typename std::remove_extent<T>::type;
+    return std::unique_ptr<T, D>(new U[size](), std::forward<D>(deleter));
 }
 
-template <typename T, typename D, typename... Args>
-enable_if_t<std::is_array<T>::value && std::extent<T>::value != 0,
-            std::unique_ptr<T, D>>
+template<typename T, typename D, typename... Args>
+enable_if_t<std::is_array<T>::value && std::extent<T>::value != 0, std::unique_ptr<T, D>>
 make_unique_with_deleter(D &&deleter, Args &&...) = delete;
 
-} // namespace tile
+}// namespace tile
 
-#endif // TILE_BASE_MAKE_UNIQUE_H
+#endif// TILE_BASE_MAKE_UNIQUE_H
diff --git a/tile/base/maybe_owning.h b/tile/base/maybe_owning.h
index 141518f..d82b370 100644
--- a/tile/base/maybe_owning.h
+++ b/tile/base/maybe_owning.h
@@ -12,134 +12,151 @@
 
 namespace tile {
 constexpr struct owning_t {
-  explicit owning_t() = default;
+    explicit owning_t() = default;
 } owning;
 
 constexpr struct non_owning_t {
-  explicit non_owning_t() = default;
+    explicit non_owning_t() = default;
 } non_owning;
 
-template <typename T> class MaybeOwning {
+template<typename T>
+class MaybeOwning {
 public:
-  template <typename U> struct is_convertible_from {
-    static constexpr bool value =
-        std::is_convertible<U *, T *>::value &&
-        (std::is_same<typename std::remove_cv<T>::type,
-                      typename std::remove_cv<U>::type>::value ||
-         std::has_virtual_destructor<T>::value);
-  };
+    template<typename U>
+    struct is_convertible_from {
+        static constexpr bool value = std::is_convertible<U *, T *>::value
+            && (std::is_same<typename std::remove_cv<T>::type, typename std::remove_cv<U>::type>::value
+                || std::has_virtual_destructor<T>::value);
+    };
 
-  constexpr MaybeOwning() noexcept : owning_(false), ptr_(nullptr) {}
+    constexpr MaybeOwning() noexcept : owning_(false), ptr_(nullptr) {}
 
-  MaybeOwning(std::nullptr_t) noexcept : MaybeOwning() {}
+    MaybeOwning(std::nullptr_t) noexcept : MaybeOwning() {}
 
-  constexpr MaybeOwning(owning_t, T *ptr) noexcept : MaybeOwning(ptr, true) {}
-  constexpr MaybeOwning(non_owning_t, T *ptr) noexcept
-      : MaybeOwning(ptr, false) {}
-  constexpr MaybeOwning(T *ptr, bool owning) noexcept
-      : owning_(owning), ptr_(ptr) {}
-  template <typename U, typename = enable_if_t<is_convertible_from<U>::value>>
-  constexpr MaybeOwning(std::unique_ptr<U> ptr) noexcept
-      : owning_(!!ptr), ptr_(ptr.release()) {}
+    constexpr MaybeOwning(owning_t, T *ptr) noexcept : MaybeOwning(ptr, true) {}
 
-  template <typename U, typename = enable_if_t<is_convertible_from<U>::value>>
-  MaybeOwning(MaybeOwning<U> &&ptr) noexcept
-      : owning_(ptr.owning_), ptr_(ptr.ptr_) {
-    ptr.owning_ = false;
-    ptr.ptr_ = nullptr;
-  }
+    constexpr MaybeOwning(non_owning_t, T *ptr) noexcept : MaybeOwning(ptr, false) {}
 
-  MaybeOwning(MaybeOwning &&other) noexcept
-      : owning_(other.owning_), ptr_(other.ptr_) {
-    other.owning_ = false;
-    other.ptr_ = nullptr;
-  }
+    constexpr MaybeOwning(T *ptr, bool owning) noexcept : owning_(owning), ptr_(ptr) {}
 
-  MaybeOwning &operator=(MaybeOwning &&other) noexcept {
-    if (&other != this) {
-      Reset();
-      std::swap(owning_, other.owning_);
-      std::swap(ptr_, other.ptr_);
+    template<typename U, typename = enable_if_t<is_convertible_from<U>::value>>
+    constexpr MaybeOwning(std::unique_ptr<U> ptr) noexcept
+        : owning_(!!ptr),
+          ptr_(ptr.release())
+    {}
+
+    template<typename U, typename = enable_if_t<is_convertible_from<U>::value>>
+    MaybeOwning(MaybeOwning<U> &&ptr) noexcept
+        : owning_(ptr.owning_),
+          ptr_(ptr.ptr_)
+    {
+        ptr.owning_ = false;
+        ptr.ptr_    = nullptr;
     }
-    return *this;
-  }
 
-  MaybeOwning(const MaybeOwning &) = delete;
-  MaybeOwning &operator=(const MaybeOwning &) = delete;
-
-  MaybeOwning &operator=(std::nullptr_t) noexcept {
-    Reset();
-    return *this;
-  }
-
-  ~MaybeOwning() {
-    if (owning_) {
-      delete ptr_;
+    MaybeOwning(MaybeOwning &&other) noexcept : owning_(other.owning_), ptr_(other.ptr_)
+    {
+        other.owning_ = false;
+        other.ptr_    = nullptr;
     }
-  }
 
-  constexpr T *Get() const noexcept { return ptr_; }
-  constexpr T *operator->() const noexcept { return Get(); }
-  constexpr T &operator*() const noexcept { return Get(); }
-  constexpr explicit operator bool() const noexcept { return !!ptr_; }
-  constexpr bool Owning() const noexcept { return owning_; }
+    MaybeOwning &operator=(MaybeOwning &&other) noexcept
+    {
+        if (&other != this) {
+            Reset();
+            std::swap(owning_, other.owning_);
+            std::swap(ptr_, other.ptr_);
+        }
+        return *this;
+    }
 
-  TILE_NODISCARD T *Leak() noexcept {
-    TILE_CHECK(owning_,
-               "Calling `Leak()` on non-owning `MaybeOwning<T>` is undefined");
-    owning_ = false;
-    T *rc = nullptr;
-    std::swap(rc, ptr_);
-    return rc;
-  }
+    MaybeOwning(const MaybeOwning &)            = delete;
+    MaybeOwning &operator=(const MaybeOwning &) = delete;
 
-  void Reset(owning_t, T *ptr) noexcept { Reset(ptr, true); }
-  void Reset(non_owning_t, T *ptr) noexcept { Reset(ptr, false); }
+    MaybeOwning &operator=(std::nullptr_t) noexcept
+    {
+        Reset();
+        return *this;
+    }
+
+    ~MaybeOwning()
+    {
+        if (owning_) { delete ptr_; }
+    }
+
+    constexpr T *Get() const noexcept { return ptr_; }
+
+    constexpr T *operator->() const noexcept { return Get(); }
+
+    constexpr T &operator*() const noexcept { return Get(); }
+
+    constexpr explicit operator bool() const noexcept { return !!ptr_; }
+
+    constexpr bool Owning() const noexcept { return owning_; }
+
+    TILE_NODISCARD T *Leak() noexcept
+    {
+        TILE_CHECK(owning_, "Calling `Leak()` on non-owning `MaybeOwning<T>` is undefined");
+        owning_ = false;
+        T *rc   = nullptr;
+        std::swap(rc, ptr_);
+        return rc;
+    }
+
+    void Reset(owning_t, T *ptr) noexcept { Reset(ptr, true); }
+
+    void Reset(non_owning_t, T *ptr) noexcept { Reset(ptr, false); }
 
 private:
-  // for gtest
-  // FRIEND_TEST(MaybeOwning, Reset);
-  friend class MaybeOwning_Reset_Test;
+    // for gtest
+    // FRIEND_TEST(MaybeOwning, Reset);
+    friend class MaybeOwning_Reset_Test;
 
-  void Reset() noexcept { Reset(nullptr, false); }
-  void Reset(T *ptr, bool owning) noexcept {
-    if (owning_) {
-      TILE_CHECK(ptr_);
-      delete ptr_;
+    void Reset() noexcept { Reset(nullptr, false); }
+
+    void Reset(T *ptr, bool owning) noexcept
+    {
+        if (owning_) {
+            TILE_CHECK(ptr_);
+            delete ptr_;
+        }
+
+        // don't allow owning a `nullptr`
+        TILE_CHECK(!owning || ptr_,
+                   "Pasing a `nullptr` to `ptr` while specifying `owning` as `true` does "
+                   "not make much sense, I think");
+
+        owning_ = owning;
+        ptr_    = ptr;
     }
 
-    // don't allow owning a `nullptr`
-    TILE_CHECK(
-        !owning || ptr_,
-        "Pasing a `nullptr` to `ptr` while specifying `owning` as `true` does "
-        "not make much sense, I think");
-
-    owning_ = owning;
-    ptr_ = ptr;
-  }
-
 private:
-  template <typename U> friend class MaybeOwning;
+    template<typename U>
+    friend class MaybeOwning;
 
-  bool owning_;
-  T *ptr_;
+    bool owning_;
+    T *ptr_;
 };
 
-template <typename T> class MaybeOwning<T[]>; // Not implemented
+template<typename T>
+class MaybeOwning<T[]>;// Not implemented
 
-template <typename T> class MaybeOwningArgument {
+template<typename T>
+class MaybeOwningArgument {
 public:
-  template <typename U,
-            typename = decltype(MaybeOwning<T>(std::declval<U &&>()))>
-  MaybeOwningArgument(U &&ptr) : ptr_(std::forward<U>(ptr)) {}
-  template <typename U, typename = enable_if_t<MaybeOwning<
-                            T>::template is_convertible_from<U>::value>>
-  MaybeOwningArgument(U *ptr) : ptr_(non_owning, ptr) {}
-  operator MaybeOwning<T>() && noexcept { return std::move(ptr_); }
+    template<typename U, typename = decltype(MaybeOwning<T>(std::declval<U &&>()))>
+    MaybeOwningArgument(U &&ptr) : ptr_(std::forward<U>(ptr))
+    {}
+
+    template<typename U, typename = enable_if_t<MaybeOwning<T>::template is_convertible_from<U>::value>>
+    MaybeOwningArgument(U *ptr) : ptr_(non_owning, ptr)
+    {}
+
+    operator MaybeOwning<T>() && noexcept { return std::move(ptr_); }
 
 private:
-  MaybeOwning<T> ptr_;
+    MaybeOwning<T> ptr_;
 };
-} // namespace tile
+}// namespace tile
 
-#endif // TILE_BASE_MAYBE_OWNING_H
+#endif// TILE_BASE_MAYBE_OWNING_H
diff --git a/tile/base/maybe_owning_test.cc b/tile/base/maybe_owning_test.cc
index aeaacb0..17f8a1f 100644
--- a/tile/base/maybe_owning_test.cc
+++ b/tile/base/maybe_owning_test.cc
@@ -4,179 +4,199 @@
 
 namespace tile {
 int dtor_called = 0;
+
 struct C {
-  ~C() { ++dtor_called; }
+    ~C() { ++dtor_called; }
 };
 
 struct Base {
-  virtual ~Base() = default;
+    virtual ~Base() = default;
 };
 
 struct Drived : Base {};
 
-void AcceptMaybeOwningArgument(MaybeOwningArgument<int> ptr) {}
+void
+AcceptMaybeOwningArgument(MaybeOwningArgument<int> ptr)
+{}
 
-void AcceptMaybeOwningArgumentBase(MaybeOwningArgument<Base> ptr) {}
+void
+AcceptMaybeOwningArgumentBase(MaybeOwningArgument<Base> ptr)
+{}
 
-TEST(MaybeOwning, Owning) {
-  dtor_called = 0;
-  C *ptr = new C();
-  {
-    MaybeOwning<C> holder(ptr, true);
-    ASSERT_EQ(0, dtor_called);
-  }
-  ASSERT_EQ(1, dtor_called);
+TEST(MaybeOwning, Owning)
+{
+    dtor_called = 0;
+    C *ptr      = new C();
+    {
+        MaybeOwning<C> holder(ptr, true);
+        ASSERT_EQ(0, dtor_called);
+    }
+    ASSERT_EQ(1, dtor_called);
 }
 
-TEST(MaybeOwning, OwningTag) {
-  dtor_called = 0;
-  C *ptr = new C();
-  {
-    MaybeOwning<C> unholder(owning_t{}, ptr);
-    ASSERT_EQ(0, dtor_called);
-  }
-  ASSERT_EQ(1, dtor_called);
+TEST(MaybeOwning, OwningTag)
+{
+    dtor_called = 0;
+    C *ptr      = new C();
+    {
+        MaybeOwning<C> unholder(owning_t{}, ptr);
+        ASSERT_EQ(0, dtor_called);
+    }
+    ASSERT_EQ(1, dtor_called);
 }
 
-TEST(MaybeOwning, NonOwning) {
-  dtor_called = 0;
-  C *ptr = new C();
-  {
-    MaybeOwning<C> unholder(ptr, false);
+TEST(MaybeOwning, NonOwning)
+{
+    dtor_called = 0;
+    C *ptr      = new C();
+    {
+        MaybeOwning<C> unholder(ptr, false);
+        ASSERT_EQ(0, dtor_called);
+    }
     ASSERT_EQ(0, dtor_called);
-  }
-  ASSERT_EQ(0, dtor_called);
-  delete ptr;
-  ASSERT_EQ(1, dtor_called);
+    delete ptr;
+    ASSERT_EQ(1, dtor_called);
 }
 
-TEST(MaybeOwning, NonOwningTag) {
-  dtor_called = 0;
-  C *ptr = new C();
-  {
-    MaybeOwning<C> holder(non_owning_t{}, ptr);
+TEST(MaybeOwning, NonOwningTag)
+{
+    dtor_called = 0;
+    C *ptr      = new C();
+    {
+        MaybeOwning<C> holder(non_owning_t{}, ptr);
+        ASSERT_EQ(0, dtor_called);
+    }
     ASSERT_EQ(0, dtor_called);
-  }
-  ASSERT_EQ(0, dtor_called);
-  delete ptr;
-  ASSERT_EQ(1, dtor_called);
+    delete ptr;
+    ASSERT_EQ(1, dtor_called);
 }
 
-TEST(MaybeOwning, FromUniquePtr) {
-  dtor_called = 0;
-  std::unique_ptr<C> p;
-  {
-    MaybeOwning<C> holder(std::move(p));
-    ASSERT_EQ(0, dtor_called);
-  }
+TEST(MaybeOwning, FromUniquePtr)
+{
+    dtor_called = 0;
+    std::unique_ptr<C> p;
+    {
+        MaybeOwning<C> holder(std::move(p));
+        ASSERT_EQ(0, dtor_called);
+    }
 }
 
-TEST(MaybeOwning, Move) {
-  dtor_called = 0;
-  {
+TEST(MaybeOwning, Move)
+{
+    dtor_called = 0;
+    {
+        MaybeOwning<C> holder(new C(), true);
+        ASSERT_EQ(0, dtor_called);
+
+        // move constructor 1
+        MaybeOwning<C> holder2(std::move(holder));
+        ASSERT_FALSE(!!holder);
+        ASSERT_TRUE(!!holder2);
+        ASSERT_EQ(0, dtor_called);
+
+        // move assign 1
+        MaybeOwning<C> holder3;
+        ASSERT_FALSE(!!holder3);
+
+        // move from non-owning
+        holder3 = std::move(holder);
+        ASSERT_FALSE(!!holder3);
+
+        // move from owning
+        holder3 = std::move(holder2);
+        ASSERT_FALSE(!!holder2);
+        ASSERT_TRUE(!!holder3);
+        ASSERT_EQ(0, dtor_called);
+    }
+    ASSERT_EQ(1, dtor_called);
+}
+
+TEST(MaybeOwning, Reset)
+{
+    dtor_called = 0;
+    MaybeOwning<C> holder(make_unique<C>());
+    ASSERT_EQ(0, dtor_called);
+    holder.Reset();
+    ASSERT_EQ(1, dtor_called);
+}
+
+TEST(MaybeOwning, MoveIntoNonNull)
+{
+    dtor_called = 0;
+    {
+        MaybeOwning<C> holder(make_unique<C>());
+        MaybeOwning<C> holder2(make_unique<C>());
+        ASSERT_EQ(0, dtor_called);
+        holder = std::move(holder2);
+        ASSERT_EQ(1, dtor_called);
+    }
+    ASSERT_EQ(2, dtor_called);
+}
+
+TEST(MaybeOwning, SelfMove)
+{
+    dtor_called = 0;
+    {
+        MaybeOwning<C> holder(make_unique<C>());
+        ASSERT_EQ(0, dtor_called);
+        holder = std::move(holder);
+        ASSERT_EQ(0, dtor_called);
+    }
+    ASSERT_EQ(1, dtor_called);
+}
+
+TEST(MaybeOwning, ConversionToConst)
+{
     MaybeOwning<C> holder(new C(), true);
-    ASSERT_EQ(0, dtor_called);
+    MaybeOwning<const C> holder2(std::move(holder));
 
-    // move constructor 1
-    MaybeOwning<C> holder2(std::move(holder));
     ASSERT_FALSE(!!holder);
     ASSERT_TRUE(!!holder2);
-    ASSERT_EQ(0, dtor_called);
-
-    // move assign 1
-    MaybeOwning<C> holder3;
-    ASSERT_FALSE(!!holder3);
-
-    // move from non-owning
-    holder3 = std::move(holder);
-    ASSERT_FALSE(!!holder3);
-
-    // move from owning
-    holder3 = std::move(holder2);
-    ASSERT_FALSE(!!holder2);
-    ASSERT_TRUE(!!holder3);
-    ASSERT_EQ(0, dtor_called);
-  }
-  ASSERT_EQ(1, dtor_called);
 }
 
-TEST(MaybeOwning, Reset) {
-  dtor_called = 0;
-  MaybeOwning<C> holder(make_unique<C>());
-  ASSERT_EQ(0, dtor_called);
-  holder.Reset();
-  ASSERT_EQ(1, dtor_called);
+TEST(MaybeOwning, ConversionToConst2)
+{
+    MaybeOwning<C> holder(new C(), true);
+    MaybeOwning<const C> holder2;
+    holder2 = std::move(holder);
+    ASSERT_FALSE(!!holder);
+    ASSERT_TRUE(!!holder2);
 }
 
-TEST(MaybeOwning, MoveIntoNonNull) {
-  dtor_called = 0;
-  {
-    MaybeOwning<C> holder(make_unique<C>());
-    MaybeOwning<C> holder2(make_unique<C>());
-    ASSERT_EQ(0, dtor_called);
-    holder = std::move(holder2);
-    ASSERT_EQ(1, dtor_called);
-  }
-  ASSERT_EQ(2, dtor_called);
+TEST(MaybeOwning, ConversionToUniquePtr)
+{
+    auto uptr = make_unique<C>();
+    MaybeOwning<C> holder(std::move(uptr));
+    ASSERT_FALSE(!!uptr);
+    ASSERT_TRUE(!!holder);
 }
 
-TEST(MaybeOwning, SelfMove) {
-  dtor_called = 0;
-  {
-    MaybeOwning<C> holder(make_unique<C>());
-    ASSERT_EQ(0, dtor_called);
-    holder = std::move(holder);
-    ASSERT_EQ(0, dtor_called);
-  }
-  ASSERT_EQ(1, dtor_called);
+TEST(MaybeOwning, ConversionToUniquePtr2)
+{
+    auto uptr = make_unique<C>();
+    MaybeOwning<const C> holder;
+    holder = std::move(uptr);
+    ASSERT_FALSE(!!uptr);
+    ASSERT_TRUE(!!holder);
 }
 
-TEST(MaybeOwning, ConversionToConst) {
-  MaybeOwning<C> holder(new C(), true);
-  MaybeOwning<const C> holder2(std::move(holder));
-
-  ASSERT_FALSE(!!holder);
-  ASSERT_TRUE(!!holder2);
-}
-TEST(MaybeOwning, ConversionToConst2) {
-  MaybeOwning<C> holder(new C(), true);
-  MaybeOwning<const C> holder2;
-  holder2 = std::move(holder);
-  ASSERT_FALSE(!!holder);
-  ASSERT_TRUE(!!holder2);
+TEST(MaybeOwning, DeductionGuides)
+{
+    MaybeOwning<C> holder(new C(), true);
+    ASSERT_TRUE(!!holder);
 }
 
-TEST(MaybeOwning, ConversionToUniquePtr) {
-  auto uptr = make_unique<C>();
-  MaybeOwning<C> holder(std::move(uptr));
-  ASSERT_FALSE(!!uptr);
-  ASSERT_TRUE(!!holder);
+TEST(MaybeOwning, Argument)
+{
+    int x = 0;
+    AcceptMaybeOwningArgument(&x);
+    AcceptMaybeOwningArgument(make_unique<int>());
+    AcceptMaybeOwningArgument(nullptr);
+
+    Drived drived;
+    AcceptMaybeOwningArgumentBase(&drived);
+
+    static_assert(std::is_convertible<Drived *, MaybeOwningArgument<Base>>::value, "");
 }
 
-TEST(MaybeOwning, ConversionToUniquePtr2) {
-  auto uptr = make_unique<C>();
-  MaybeOwning<const C> holder;
-  holder = std::move(uptr);
-  ASSERT_FALSE(!!uptr);
-  ASSERT_TRUE(!!holder);
-}
-
-TEST(MaybeOwning, DeductionGuides) {
-  MaybeOwning<C> holder(new C(), true);
-  ASSERT_TRUE(!!holder);
-}
-
-TEST(MaybeOwning, Argument) {
-  int x = 0;
-  AcceptMaybeOwningArgument(&x);
-  AcceptMaybeOwningArgument(make_unique<int>());
-  AcceptMaybeOwningArgument(nullptr);
-
-  Drived drived;
-  AcceptMaybeOwningArgumentBase(&drived);
-
-  static_assert(std::is_convertible<Drived *, MaybeOwningArgument<Base>>::value,
-                "");
-}
-
-} // namespace tile
+}// namespace tile
diff --git a/tile/base/net/detail/android/ifaddrs.h b/tile/base/net/detail/android/ifaddrs.h
index 9373220..c7dac12 100644
--- a/tile/base/net/detail/android/ifaddrs.h
+++ b/tile/base/net/detail/android/ifaddrs.h
@@ -10,4 +10,4 @@ int getifaddrs(struct ifaddrs **ifap);
 void freeifaddrs(struct ifaddrs *ifa);
 __END_DECLS
 
-#endif // TILE_BASE_NET_DETAIL_ANDROID_IFADDRS_H
+#endif// TILE_BASE_NET_DETAIL_ANDROID_IFADDRS_H
diff --git a/tile/base/net/endpoint.cc b/tile/base/net/endpoint.cc
index f7d6ee3..777e366 100644
--- a/tile/base/net/endpoint.cc
+++ b/tile/base/net/endpoint.cc
@@ -23,406 +23,418 @@ namespace tile {
 namespace {
 constexpr auto kOffsetSunPath = offsetof(sockaddr_un, sun_path);
 
-std::string SockAddrToString(const sockaddr *addr, socklen_t length) {
-  auto af = addr->sa_family;
-  switch (af) {
-  case AF_INET: {
-    auto p = reinterpret_cast<const sockaddr_in *>(addr);
-    uint32_t s_addr = NetworkToHost32(p->sin_addr.s_addr);
-    return Format("{}.{}.{}.{}:{}", (s_addr >> 24) & 0xff,
-                  (s_addr >> 16) & 0xff, (s_addr >> 8) & 0xff, s_addr & 0xff,
-                  NetworkToHost16(p->sin_port));
-  }
-  case AF_INET6: {
-    auto p = reinterpret_cast<const sockaddr_in6 *>(addr);
-    char ip[INET6_ADDRSTRLEN];
-    TILE_CHECK(inet_ntop(af, &p->sin6_addr, ip, INET6_ADDRSTRLEN));
-    return Format("[{}]:{}", ip, NetworkToHost16(p->sin6_port));
-  }
-  case AF_UNIX: {
-    auto p = reinterpret_cast<const sockaddr_un *>(addr);
-    if (p->sun_path[0] == '\0' && p->sun_path[1] != '\0') {
-      return Format("@{}", Slice(p->sun_path + 1, length - 1 - kOffsetSunPath));
-    } else {
-      return std::string(p->sun_path, length - kOffsetSunPath);
+std::string
+SockAddrToString(const sockaddr *addr, socklen_t length)
+{
+    auto af = addr->sa_family;
+    switch (af) {
+    case AF_INET: {
+        auto p          = reinterpret_cast<const sockaddr_in *>(addr);
+        uint32_t s_addr = NetworkToHost32(p->sin_addr.s_addr);
+        return Format("{}.{}.{}.{}:{}", (s_addr >> 24) & 0xff, (s_addr >> 16) & 0xff, (s_addr >> 8) & 0xff,
+                      s_addr & 0xff, NetworkToHost16(p->sin_port));
+    }
+    case AF_INET6: {
+        auto p = reinterpret_cast<const sockaddr_in6 *>(addr);
+        char ip[INET6_ADDRSTRLEN];
+        TILE_CHECK(inet_ntop(af, &p->sin6_addr, ip, INET6_ADDRSTRLEN));
+        return Format("[{}]:{}", ip, NetworkToHost16(p->sin6_port));
+    }
+    case AF_UNIX: {
+        auto p = reinterpret_cast<const sockaddr_un *>(addr);
+        if (p->sun_path[0] == '\0' && p->sun_path[1] != '\0') {
+            return Format("@{}", Slice(p->sun_path + 1, length - 1 - kOffsetSunPath));
+        } else {
+            return std::string(p->sun_path, length - kOffsetSunPath);
+        }
+    }
+    default: {
+        return Format("TODO: Endpoint::ToString() for AF #{}.", af);
+    }
     }
-  }
-  default: {
-    return Format("TODO: Endpoint::ToString() for AF #{}.", af);
-  }
-  }
 }
-} // namespace
+}// namespace
 
 #define INTERNAL_PTR() (*reinterpret_cast<sockaddr_storage **>(&storage_))
-#define INTERNAL_CPTR()                                                        \
-  (*reinterpret_cast<sockaddr_storage *const *>(&storage_))
+#define INTERNAL_CPTR() (*reinterpret_cast<sockaddr_storage *const *>(&storage_))
 
-sockaddr *EndpointRetriever::RetrieveAddr() {
-  return reinterpret_cast<sockaddr *>(&storage_);
+sockaddr *
+EndpointRetriever::RetrieveAddr()
+{
+    return reinterpret_cast<sockaddr *>(&storage_);
 }
 
-socklen_t *EndpointRetriever::RetrieveLength() { return &length_; }
-
-Endpoint EndpointRetriever::Build() {
-  return Endpoint(RetrieveAddr(), length_);
+socklen_t *
+EndpointRetriever::RetrieveLength()
+{
+    return &length_;
 }
 
-Endpoint::Endpoint(const sockaddr *addr, socklen_t length) : length_(length) {
-  if (IsTriviallyCopyable()) {
-    memcpy(&storage_, addr, length);
-  } else {
-    INTERNAL_PTR() = new sockaddr_storage;
-    memcpy(INTERNAL_PTR(), addr, length);
-  }
+Endpoint
+EndpointRetriever::Build()
+{
+    return Endpoint(RetrieveAddr(), length_);
 }
 
-void Endpoint::SlowDestroy() { delete INTERNAL_PTR(); }
-void Endpoint::SlowCopyUninitialized(const Endpoint &ep) {
-  length_ = ep.length_;
-  INTERNAL_PTR() = new sockaddr_storage;
-  memcpy(INTERNAL_PTR(), ep.Get(), ep.length_);
+Endpoint::Endpoint(const sockaddr *addr, socklen_t length) : length_(length)
+{
+    if (IsTriviallyCopyable()) {
+        memcpy(&storage_, addr, length);
+    } else {
+        INTERNAL_PTR() = new sockaddr_storage;
+        memcpy(INTERNAL_PTR(), addr, length);
+    }
 }
-void Endpoint::SlowCopy(const Endpoint &ep) {
-  if (!IsTriviallyCopyable()) {
-    SlowDestroy();
-  }
-  if (ep.IsTriviallyCopyable()) {
-    length_ = ep.length_;
-    memcpy(&storage_, &ep.storage_, length_);
-  } else {
-    length_ = ep.length_;
+
+void
+Endpoint::SlowDestroy()
+{
+    delete INTERNAL_PTR();
+}
+
+void
+Endpoint::SlowCopyUninitialized(const Endpoint &ep)
+{
+    length_        = ep.length_;
     INTERNAL_PTR() = new sockaddr_storage;
     memcpy(INTERNAL_PTR(), ep.Get(), ep.length_);
-  }
 }
 
-const sockaddr *Endpoint::SlowGet() const {
-  return reinterpret_cast<const sockaddr *>(INTERNAL_CPTR());
+void
+Endpoint::SlowCopy(const Endpoint &ep)
+{
+    if (!IsTriviallyCopyable()) { SlowDestroy(); }
+    if (ep.IsTriviallyCopyable()) {
+        length_ = ep.length_;
+        memcpy(&storage_, &ep.storage_, length_);
+    } else {
+        length_        = ep.length_;
+        INTERNAL_PTR() = new sockaddr_storage;
+        memcpy(INTERNAL_PTR(), ep.Get(), ep.length_);
+    }
 }
 
-std::string Endpoint::ToString() const {
-  if (TILE_UNLIKELY(Empty())) {
-    return "(null)";
-  }
-
-  return SockAddrToString(Get(), Length());
+const sockaddr *
+Endpoint::SlowGet() const
+{
+    return reinterpret_cast<const sockaddr *>(INTERNAL_CPTR());
 }
 
-bool operator==(const Endpoint &lhs, const Endpoint &rhs) {
-  return memcmp(lhs.Get(), rhs.Get(), lhs.Length()) == 0;
+std::string
+Endpoint::ToString() const
+{
+    if (TILE_UNLIKELY(Empty())) { return "(null)"; }
+
+    return SockAddrToString(Get(), Length());
 }
 
-Endpoint EndpointFromIpv4(const std::string &ip, std::uint16_t port) {
-  EndpointRetriever er;
-  auto addr_ptr = er.RetrieveAddr();
-  auto p = reinterpret_cast<sockaddr_in *>(addr_ptr);
-  memset(p, 0, sizeof(sockaddr_in));
-  TILE_PCHECK(inet_pton(AF_INET, ip.c_str(), &p->sin_addr), "Cannot parse [{}]",
-              ip);
-  p->sin_port = HostToNetwork16(port);
-  p->sin_family = AF_INET;
-  *er.RetrieveLength() = sizeof(sockaddr_in);
-  return er.Build();
+bool
+operator==(const Endpoint &lhs, const Endpoint &rhs)
+{
+    return memcmp(lhs.Get(), rhs.Get(), lhs.Length()) == 0;
 }
 
-Endpoint EndpointFromIpv6(const std::string &ip, std::uint16_t port) {
-  EndpointRetriever er;
-  auto addr_ptr = er.RetrieveAddr();
-  auto p = reinterpret_cast<sockaddr_in6 *>(addr_ptr);
-  memset(p, 0, sizeof(sockaddr_in6));
-  TILE_PCHECK(inet_pton(AF_INET6, ip.c_str(), &p->sin6_addr),
-              "Cannot parse [{}]", ip);
-  p->sin6_port = HostToNetwork16(port);
-  p->sin6_family = AF_INET6;
-  *er.RetrieveLength() = sizeof(sockaddr_in6);
-  return er.Build();
+Endpoint
+EndpointFromIpv4(const std::string &ip, std::uint16_t port)
+{
+    EndpointRetriever er;
+    auto addr_ptr = er.RetrieveAddr();
+    auto p        = reinterpret_cast<sockaddr_in *>(addr_ptr);
+    memset(p, 0, sizeof(sockaddr_in));
+    TILE_PCHECK(inet_pton(AF_INET, ip.c_str(), &p->sin_addr), "Cannot parse [{}]", ip);
+    p->sin_port          = HostToNetwork16(port);
+    p->sin_family        = AF_INET;
+    *er.RetrieveLength() = sizeof(sockaddr_in);
+    return er.Build();
 }
 
-Endpoint EndpointFromUnix(const std::string &path) {
-  EndpointRetriever er;
-
-  auto addr_ptr = er.RetrieveAddr();
-  auto p = reinterpret_cast<sockaddr_un *>(addr_ptr);
-  memset(p, 0, sizeof(sockaddr_un));
-  TILE_PCHECK(path.size() <= sizeof(p->sun_path), "path is too long");
-  if (path[0] == '@') {
-    p->sun_path[0] = '\0';
-    memcpy(p->sun_path + 1, path.data() + 1, path.size() - 1);
-  } else {
-    memcpy(p->sun_path, path.data(), path.size());
-  }
-  p->sun_family = AF_UNIX;
-
-  static_assert(kOffsetSunPath == sizeof(sockaddr_un) - sizeof(p->sun_path),
-                "");
-
-  *er.RetrieveLength() = kOffsetSunPath + path.size();
-
-  return er.Build();
+Endpoint
+EndpointFromIpv6(const std::string &ip, std::uint16_t port)
+{
+    EndpointRetriever er;
+    auto addr_ptr = er.RetrieveAddr();
+    auto p        = reinterpret_cast<sockaddr_in6 *>(addr_ptr);
+    memset(p, 0, sizeof(sockaddr_in6));
+    TILE_PCHECK(inet_pton(AF_INET6, ip.c_str(), &p->sin6_addr), "Cannot parse [{}]", ip);
+    p->sin6_port         = HostToNetwork16(port);
+    p->sin6_family       = AF_INET6;
+    *er.RetrieveLength() = sizeof(sockaddr_in6);
+    return er.Build();
 }
 
-std::string EndpointGetIp(const Endpoint &endpoint) {
-  std::string result;
-  if (endpoint.Family() == AF_INET) {
-    result.resize(INET_ADDRSTRLEN + 1);
-    TILE_PCHECK(inet_ntop(endpoint.Family(),
-                          &endpoint.UnsafeGet<sockaddr_in>()->sin_addr,
-                          const_cast<char *>(result.data()), result.size()));
-  } else if (endpoint.Family() == AF_INET6) {
-    result.resize(INET6_ADDRSTRLEN + 1);
-    TILE_PCHECK(inet_ntop(endpoint.Family(),
-                          &endpoint.UnsafeGet<sockaddr_in6>()->sin6_addr,
-                          const_cast<char *>(result.data()), result.size()));
-  } else {
-    TILE_CHECK(
-        0, "Unexpected: Address family #{} is not is valid IP address family.",
-        endpoint.Family());
-  }
-  return result.substr(0, result.find('\x00'));
+Endpoint
+EndpointFromUnix(const std::string &path)
+{
+    EndpointRetriever er;
+
+    auto addr_ptr = er.RetrieveAddr();
+    auto p        = reinterpret_cast<sockaddr_un *>(addr_ptr);
+    memset(p, 0, sizeof(sockaddr_un));
+    TILE_PCHECK(path.size() <= sizeof(p->sun_path), "path is too long");
+    if (path[0] == '@') {
+        p->sun_path[0] = '\0';
+        memcpy(p->sun_path + 1, path.data() + 1, path.size() - 1);
+    } else {
+        memcpy(p->sun_path, path.data(), path.size());
+    }
+    p->sun_family = AF_UNIX;
+
+    static_assert(kOffsetSunPath == sizeof(sockaddr_un) - sizeof(p->sun_path), "");
+
+    *er.RetrieveLength() = kOffsetSunPath + path.size();
+
+    return er.Build();
 }
 
-std::uint16_t EndpointGetPort(const Endpoint &endpoint) {
-  TILE_CHECK(endpoint.Family() == AF_INET || endpoint.Family() == AF_INET6,
-             "Unexpected: Address family #{} is not valid IP address family.",
-             endpoint.Family());
-  if (endpoint.Family() == AF_INET) {
-    return NetworkToHost16(
-        reinterpret_cast<const sockaddr_in *>(endpoint.Get())->sin_port);
-  } else if (endpoint.Family() == AF_INET6) {
-    return NetworkToHost16(
-        reinterpret_cast<const sockaddr_in6 *>(endpoint.Get())->sin6_port);
-  }
-  TILE_NOT_IMPLEMENTED("Unsupported family [{}]", endpoint.Family());
-  // crash
-  return 0;
+std::string
+EndpointGetIp(const Endpoint &endpoint)
+{
+    std::string result;
+    if (endpoint.Family() == AF_INET) {
+        result.resize(INET_ADDRSTRLEN + 1);
+        TILE_PCHECK(inet_ntop(endpoint.Family(), &endpoint.UnsafeGet<sockaddr_in>()->sin_addr,
+                              const_cast<char *>(result.data()), result.size()));
+    } else if (endpoint.Family() == AF_INET6) {
+        result.resize(INET6_ADDRSTRLEN + 1);
+        TILE_PCHECK(inet_ntop(endpoint.Family(), &endpoint.UnsafeGet<sockaddr_in6>()->sin6_addr,
+                              const_cast<char *>(result.data()), result.size()));
+    } else {
+        TILE_CHECK(0, "Unexpected: Address family #{} is not is valid IP address family.", endpoint.Family());
+    }
+    return result.substr(0, result.find('\x00'));
+}
+
+std::uint16_t
+EndpointGetPort(const Endpoint &endpoint)
+{
+    TILE_CHECK(endpoint.Family() == AF_INET || endpoint.Family() == AF_INET6,
+               "Unexpected: Address family #{} is not valid IP address family.", endpoint.Family());
+    if (endpoint.Family() == AF_INET) {
+        return NetworkToHost16(reinterpret_cast<const sockaddr_in *>(endpoint.Get())->sin_port);
+    } else if (endpoint.Family() == AF_INET6) {
+        return NetworkToHost16(reinterpret_cast<const sockaddr_in6 *>(endpoint.Get())->sin6_port);
+    }
+    TILE_NOT_IMPLEMENTED("Unsupported family [{}]", endpoint.Family());
+    // crash
+    return 0;
 }
 
 std::expected<std::vector<Endpoint>, int>
-ResolveDomain(const std::string &domain, uint16_t port) {
-  std::vector<Endpoint> ret;
-  addrinfo hints, *result;
-  memset(&hints, 0, sizeof(struct addrinfo));
-  hints.ai_family = AF_UNSPEC;
-  hints.ai_socktype = SOCK_STREAM;
-  auto port_str = std::to_string(port);
-  auto service = (port != 0) ? port_str.c_str() : nullptr;
+ResolveDomain(const std::string &domain, uint16_t port)
+{
+    std::vector<Endpoint> ret;
+    addrinfo hints, *result;
+    memset(&hints, 0, sizeof(struct addrinfo));
+    hints.ai_family   = AF_UNSPEC;
+    hints.ai_socktype = SOCK_STREAM;
+    auto port_str     = std::to_string(port);
+    auto service      = (port != 0) ? port_str.c_str() : nullptr;
 
-  int rt = getaddrinfo(domain.c_str(), service, &hints, &result);
-  if (rt != 0) {
-    TILE_LOG_WARNING("getaddrinfo failed: {}", gai_strerror(rt));
-    return std::make_unexpected(rt);
-  }
+    int rt            = getaddrinfo(domain.c_str(), service, &hints, &result);
+    if (rt != 0) {
+        TILE_LOG_WARNING("getaddrinfo failed: {}", gai_strerror(rt));
+        return std::make_unexpected(rt);
+    }
 
-  for (auto curr = result; curr != nullptr; curr = curr->ai_next) {
+    for (auto curr = result; curr != nullptr; curr = curr->ai_next) {
+        EndpointRetriever er;
+        auto addr = er.RetrieveAddr();
+        memcpy(addr, curr->ai_addr, curr->ai_addrlen);
+        *er.RetrieveLength() = curr->ai_addrlen;
+        ret.emplace_back(er.Build());
+    }
+
+    freeaddrinfo(result);
+    return ret;
+}
+
+std::vector<Endpoint>
+GetInterfaceAddresses()
+{
+    ifaddrs *ifs_raw;
+    TILE_PCHECK(getifaddrs(&ifs_raw) == 0, "Cannot enumerate NICs");
+    std::unique_ptr<ifaddrs, decltype(&freeifaddrs)> ifs(ifs_raw, &freeifaddrs);
+
+    std::vector<Endpoint> result;
+
+    for (auto current = ifs.get(); current; current = current->ifa_next) {
+        auto addr = current->ifa_addr;
+        if (!addr) {
+            TILE_LOG_WARNING_ONCE("Skipping device [{}] when enumerating interface addresses. No "
+                                  "address is assigned to this device",
+                                  current->ifa_name);
+            continue;
+        }
+
+        EndpointRetriever er;
+        auto af = addr->sa_family;
+#define TEST_AF_AND_COPY(AddressFamily, Storage)                                                                       \
+    case AddressFamily: {                                                                                              \
+        memcpy(er.RetrieveAddr(), addr, sizeof(Storage));                                                              \
+        *er.RetrieveLength() = sizeof(Storage);                                                                        \
+        break;                                                                                                         \
+    }
+
+        switch (af) {
+            TEST_AF_AND_COPY(AF_INET, sockaddr_in)
+            TEST_AF_AND_COPY(AF_INET6, sockaddr_in6)
+            TEST_AF_AND_COPY(AF_UNIX, sockaddr_in6)
+#ifdef AF_PACKET
+        case AF_PACKET: {
+            continue;
+        }
+#endif
+        default: {
+            TILE_LOG_WARNING_ONCE("Unrecognized address family #{} is ignored.", af);
+            continue;
+        }
+        }
+        result.push_back(er.Build());
+    }
+
+    return result;
+}
+
+bool
+IsPrivateIpv4AddressRfc(const Endpoint &addr)
+{
+    // <mask, expected>
+    // ip & mask == expected
+    static std::pair<std::uint32_t, std::uint32_t> kRanges[] = {
+        {0xFF000000, 0x0A000000}, // 10.0.0.0/8
+        {0xFFF00000, 0xAC100000}, // 172.16.0.0/12
+        {0xFFFF0000, 0xC0A80000}, // 192.168.0.0/16
+    };
+
+    if (addr.Family() != AF_INET) { return false; }
+
+    auto ip = NetworkToHost32(addr.UnsafeGet<sockaddr_in>()->sin_addr.s_addr);
+    for (auto &&item : kRanges) {
+        if ((ip & item.first) == item.second) { return true; }
+    }
+
+    return false;
+}
+
+bool
+IsPrivateIpv4AddressCorp(const Endpoint &addr)
+{
+    static std::pair<std::uint32_t, std::uint32_t> kRanges[] = {
+        {0xFF000000, 0x0A000000}, // 10.0.0.0/8
+        {0xFFC00000, 0x64400000}, // 100.64.0.0/10
+        {0xFFF00000, 0xAC100000}, // 172.16.0.0/12
+        {0xFFFF0000, 0xC0A80000}, // 192.168.0.0/16
+
+        {0xFF000000, 0x09000000}, // 9.0.0.0/8
+        {0xFF000000, 0x0B000000}, // 11.0.0.0/8
+        {0xFF000000, 0x1E000000}, // 30.0.0.0/8
+    };
+    if (addr.Family() != AF_INET) { return false; }
+
+    auto ip = NetworkToHost32(addr.UnsafeGet<sockaddr_in>()->sin_addr.s_addr);
+    for (auto &&item : kRanges) {
+        auto &mask     = item.first;
+        auto &expected = item.second;
+        if ((ip & mask) == expected) { return true; }
+    }
+    return false;
+}
+
+bool
+IsGuaIpv6Address(const Endpoint &addr)
+{
+    if (addr.Family() != AF_INET6) { return false; }
+    auto v6 = addr.UnsafeGet<sockaddr_in6>()->sin6_addr;
+    // 2000::/3
+    return v6.s6_addr[0] >= 0x20 && v6.s6_addr[0] <= 0x3f;
+}
+
+std::ostream &
+operator<<(std::ostream &os, const Endpoint &endpoint)
+{
+    return os << endpoint.ToString();
+}
+
+std::optional<Endpoint>
+TryParseTraits<Endpoint>::TryParse(Slice s, from_ipv4_t)
+{
+    // auto s = str.ToSsring();
+    auto pos = s.find(':');
+    if (pos == Slice::npos) { return {}; }
+    auto ip   = s.substr(0, pos).ToString();
+    auto port = tile::TryParse<std::uint16_t>(s.substr(pos + 1));
+    if (!port) { return {}; }
     EndpointRetriever er;
     auto addr = er.RetrieveAddr();
-    memcpy(addr, curr->ai_addr, curr->ai_addrlen);
-    *er.RetrieveLength() = curr->ai_addrlen;
-    ret.emplace_back(er.Build());
-  }
-
-  freeaddrinfo(result);
-  return ret;
+    auto p    = reinterpret_cast<sockaddr_in *>(addr);
+    memset(p, 0, sizeof(sockaddr_in));
+    if (inet_pton(AF_INET, ip.c_str(), &p->sin_addr) != 1) { return {}; }
+    p->sin_port          = HostToNetwork16(*port);
+    p->sin_family        = AF_INET;
+    *er.RetrieveLength() = sizeof(sockaddr_in);
+    return er.Build();
 }
 
-std::vector<Endpoint> GetInterfaceAddresses() {
-  ifaddrs *ifs_raw;
-  TILE_PCHECK(getifaddrs(&ifs_raw) == 0, "Cannot enumerate NICs");
-  std::unique_ptr<ifaddrs, decltype(&freeifaddrs)> ifs(ifs_raw, &freeifaddrs);
-
-  std::vector<Endpoint> result;
-
-  for (auto current = ifs.get(); current; current = current->ifa_next) {
-    auto addr = current->ifa_addr;
-    if (!addr) {
-      TILE_LOG_WARNING_ONCE(
-          "Skipping device [{}] when enumerating interface addresses. No "
-          "address is assigned to this device",
-          current->ifa_name);
-      continue;
-    }
-
+std::optional<Endpoint>
+TryParseTraits<Endpoint>::TryParse(Slice s, from_ipv6_t)
+{
+    auto pos = s.find_last_of(':');
+    if (pos == std::string::npos) { return {}; }
+    if (pos < 2) { return {}; }
+    auto ip   = s.substr(1, pos - 2).ToString();
+    auto port = tile::TryParse<std::uint16_t>(s.substr(pos + 1));
+    if (!port) { return {}; }
     EndpointRetriever er;
-    auto af = addr->sa_family;
-#define TEST_AF_AND_COPY(AddressFamily, Storage)                               \
-  case AddressFamily: {                                                        \
-    memcpy(er.RetrieveAddr(), addr, sizeof(Storage));                          \
-    *er.RetrieveLength() = sizeof(Storage);                                    \
-    break;                                                                     \
-  }
+    auto addr = er.RetrieveAddr();
+    auto p    = reinterpret_cast<sockaddr_in6 *>(addr);
+    memset(p, 0, sizeof(sockaddr_in6));
+    if (inet_pton(AF_INET6, ip.c_str(), &p->sin6_addr) != 1) { return {}; }
+    p->sin6_port         = HostToNetwork16(*port);
+    p->sin6_family       = AF_INET6;
+    *er.RetrieveLength() = sizeof(sockaddr_in6);
+    return er.Build();
+}
 
-    switch (af) {
-      TEST_AF_AND_COPY(AF_INET, sockaddr_in)
-      TEST_AF_AND_COPY(AF_INET6, sockaddr_in6)
-      TEST_AF_AND_COPY(AF_UNIX, sockaddr_in6)
-#ifdef AF_PACKET
-    case AF_PACKET: {
-      continue;
+std::optional<Endpoint>
+TryParseTraits<Endpoint>::TryParse(Slice s, from_unix_t)
+{
+    EndpointRetriever er;
+
+    auto addr = er.RetrieveAddr();
+    auto p    = reinterpret_cast<sockaddr_un *>(addr);
+    memset(p, 0, sizeof(sockaddr_un));
+
+    if (s.size() > sizeof(p->sun_path)) { return {}; }
+
+    if (s[0] == '@') {
+        p->sun_path[0] = '\0';
+        memcpy(p->sun_path + 1, s.data() + 1, s.size() - 1);
+    } else {
+        memcpy(p->sun_path, s.data(), s.size());
     }
-#endif
-    default: {
-      TILE_LOG_WARNING_ONCE("Unrecognized address family #{} is ignored.", af);
-      continue;
+    p->sun_family        = AF_UNIX;
+
+    *er.RetrieveLength() = kOffsetSunPath + s.size();
+
+    return er.Build();
+}
+
+std::optional<Endpoint>
+TryParseTraits<Endpoint>::TryParse(Slice s)
+{
+    if (auto opt = TryParse(s, from_ipv4)) {
+        return opt;
+    } else {
+        return TryParse(s, from_ipv6);
     }
-    }
-    result.push_back(er.Build());
-  }
-
-  return result;
 }
 
-bool IsPrivateIpv4AddressRfc(const Endpoint &addr) {
-  // <mask, expected>
-  // ip & mask == expected
-  static std::pair<std::uint32_t, std::uint32_t> kRanges[] = {
-      {0xFF000000, 0x0A000000}, // 10.0.0.0/8
-      {0xFFF00000, 0xAC100000}, // 172.16.0.0/12
-      {0xFFFF0000, 0xC0A80000}, // 192.168.0.0/16
-  };
-
-  if (addr.Family() != AF_INET) {
-    return false;
-  }
-
-  auto ip = NetworkToHost32(addr.UnsafeGet<sockaddr_in>()->sin_addr.s_addr);
-  for (auto &&item : kRanges) {
-    if ((ip & item.first) == item.second) {
-      return true;
-    }
-  }
-
-  return false;
+Endpoint
+EndpointFromString(Slice ip_port)
+{
+    auto opt = TryParse<Endpoint>(ip_port);
+    TILE_CHECK(!!opt, "Cannot parse endpoint [{}].", ip_port);
+    return *opt;
 }
 
-bool IsPrivateIpv4AddressCorp(const Endpoint &addr) {
-  static std::pair<std::uint32_t, std::uint32_t> kRanges[] = {
-      {0xFF000000, 0x0A000000}, // 10.0.0.0/8
-      {0xFFC00000, 0x64400000}, // 100.64.0.0/10
-      {0xFFF00000, 0xAC100000}, // 172.16.0.0/12
-      {0xFFFF0000, 0xC0A80000}, // 192.168.0.0/16
-
-      {0xFF000000, 0x09000000}, // 9.0.0.0/8
-      {0xFF000000, 0x0B000000}, // 11.0.0.0/8
-      {0xFF000000, 0x1E000000}, // 30.0.0.0/8
-  };
-  if (addr.Family() != AF_INET) {
-    return false;
-  }
-
-  auto ip = NetworkToHost32(addr.UnsafeGet<sockaddr_in>()->sin_addr.s_addr);
-  for (auto &&item : kRanges) {
-    auto &mask = item.first;
-    auto &expected = item.second;
-    if ((ip & mask) == expected) {
-      return true;
-    }
-  }
-  return false;
-}
-
-bool IsGuaIpv6Address(const Endpoint &addr) {
-  if (addr.Family() != AF_INET6) {
-    return false;
-  }
-  auto v6 = addr.UnsafeGet<sockaddr_in6>()->sin6_addr;
-  // 2000::/3
-  return v6.s6_addr[0] >= 0x20 && v6.s6_addr[0] <= 0x3f;
-}
-
-std::ostream &operator<<(std::ostream &os, const Endpoint &endpoint) {
-  return os << endpoint.ToString();
-}
-
-std::optional<Endpoint> TryParseTraits<Endpoint>::TryParse(Slice s,
-                                                           from_ipv4_t) {
-  // auto s = str.ToSsring();
-  auto pos = s.find(':');
-  if (pos == Slice::npos) {
-    return {};
-  }
-  auto ip = s.substr(0, pos).ToString();
-  auto port = tile::TryParse<std::uint16_t>(s.substr(pos + 1));
-  if (!port) {
-    return {};
-  }
-  EndpointRetriever er;
-  auto addr = er.RetrieveAddr();
-  auto p = reinterpret_cast<sockaddr_in *>(addr);
-  memset(p, 0, sizeof(sockaddr_in));
-  if (inet_pton(AF_INET, ip.c_str(), &p->sin_addr) != 1) {
-    return {};
-  }
-  p->sin_port = HostToNetwork16(*port);
-  p->sin_family = AF_INET;
-  *er.RetrieveLength() = sizeof(sockaddr_in);
-  return er.Build();
-}
-
-std::optional<Endpoint> TryParseTraits<Endpoint>::TryParse(Slice s,
-                                                           from_ipv6_t) {
-  auto pos = s.find_last_of(':');
-  if (pos == std::string::npos) {
-    return {};
-  }
-  if (pos < 2) {
-    return {};
-  }
-  auto ip = s.substr(1, pos - 2).ToString();
-  auto port = tile::TryParse<std::uint16_t>(s.substr(pos + 1));
-  if (!port) {
-    return {};
-  }
-  EndpointRetriever er;
-  auto addr = er.RetrieveAddr();
-  auto p = reinterpret_cast<sockaddr_in6 *>(addr);
-  memset(p, 0, sizeof(sockaddr_in6));
-  if (inet_pton(AF_INET6, ip.c_str(), &p->sin6_addr) != 1) {
-    return {};
-  }
-  p->sin6_port = HostToNetwork16(*port);
-  p->sin6_family = AF_INET6;
-  *er.RetrieveLength() = sizeof(sockaddr_in6);
-  return er.Build();
-}
-
-std::optional<Endpoint> TryParseTraits<Endpoint>::TryParse(Slice s,
-                                                           from_unix_t) {
-  EndpointRetriever er;
-
-  auto addr = er.RetrieveAddr();
-  auto p = reinterpret_cast<sockaddr_un *>(addr);
-  memset(p, 0, sizeof(sockaddr_un));
-
-  if (s.size() > sizeof(p->sun_path)) {
-    return {};
-  }
-
-  if (s[0] == '@') {
-    p->sun_path[0] = '\0';
-    memcpy(p->sun_path + 1, s.data() + 1, s.size() - 1);
-  } else {
-    memcpy(p->sun_path, s.data(), s.size());
-  }
-  p->sun_family = AF_UNIX;
-
-  *er.RetrieveLength() = kOffsetSunPath + s.size();
-
-  return er.Build();
-}
-
-std::optional<Endpoint> TryParseTraits<Endpoint>::TryParse(Slice s) {
-  if (auto opt = TryParse(s, from_ipv4)) {
-    return opt;
-  } else {
-    return TryParse(s, from_ipv6);
-  }
-}
-
-Endpoint EndpointFromString(Slice ip_port) {
-  auto opt = TryParse<Endpoint>(ip_port);
-  TILE_CHECK(!!opt, "Cannot parse endpoint [{}].", ip_port);
-  return *opt;
-}
-
-} // namespace tile
+}// namespace tile
diff --git a/tile/base/net/endpoint.h b/tile/base/net/endpoint.h
index 20b7f33..b712eb3 100644
--- a/tile/base/net/endpoint.h
+++ b/tile/base/net/endpoint.h
@@ -19,61 +19,68 @@
 
 namespace tile {
 class Endpoint;
+
 class EndpointRetriever {
 public:
-  sockaddr *RetrieveAddr();
-  socklen_t *RetrieveLength();
-  Endpoint Build();
+    sockaddr *RetrieveAddr();
+    socklen_t *RetrieveLength();
+    Endpoint Build();
 
 private:
-  sockaddr_storage storage_;
-  socklen_t length_ = sizeof(sockaddr_storage);
+    sockaddr_storage storage_;
+    socklen_t length_ = sizeof(sockaddr_storage);
 };
 
 class alignas(alignof(sockaddr_storage)) Endpoint {
 public:
-  Endpoint() : length_(0) {}
-  ~Endpoint();
+    Endpoint() : length_(0) {}
 
-  Endpoint(const Endpoint &ep);
-  Endpoint &operator=(const Endpoint &ep);
-  Endpoint(Endpoint &&ep) noexcept;
-  Endpoint &operator=(Endpoint &&ep) noexcept;
+    ~Endpoint();
 
-  bool Empty() const noexcept { return length_ == 0; }
-  const sockaddr *Get() const noexcept {
-    if (TILE_LIKELY(IsTriviallyCopyable())) {
-      return reinterpret_cast<const sockaddr *>(&storage_);
+    Endpoint(const Endpoint &ep);
+    Endpoint &operator=(const Endpoint &ep);
+    Endpoint(Endpoint &&ep) noexcept;
+    Endpoint &operator=(Endpoint &&ep) noexcept;
+
+    bool Empty() const noexcept { return length_ == 0; }
+
+    const sockaddr *Get() const noexcept
+    {
+        if (TILE_LIKELY(IsTriviallyCopyable())) { return reinterpret_cast<const sockaddr *>(&storage_); }
+        return SlowGet();
     }
-    return SlowGet();
-  }
 
-  template <typename T> const T *UnsafeGet() const noexcept {
-    return reinterpret_cast<const T *>(Get());
-  }
+    template<typename T>
+    const T *UnsafeGet() const noexcept
+    {
+        return reinterpret_cast<const T *>(Get());
+    }
 
-  socklen_t Length() const noexcept { return length_; }
-  sa_family_t Family() const noexcept { return Get()->sa_family; }
+    socklen_t Length() const noexcept { return length_; }
 
-  std::string ToString() const;
+    sa_family_t Family() const noexcept { return Get()->sa_family; }
+
+    std::string ToString() const;
 
 private:
-  friend class EndpointRetriever;
-  Endpoint(const sockaddr *addr, socklen_t len);
-  bool IsTriviallyCopyable() const { return length_ <= kOptimizedSize; }
-  void SlowDestroy();
-  void SlowCopyUninitialized(const Endpoint &ep);
-  void SlowCopy(const Endpoint &ep);
-  const sockaddr *SlowGet() const;
+    friend class EndpointRetriever;
+    Endpoint(const sockaddr *addr, socklen_t len);
+
+    bool IsTriviallyCopyable() const { return length_ <= kOptimizedSize; }
+
+    void SlowDestroy();
+    void SlowCopyUninitialized(const Endpoint &ep);
+    void SlowCopy(const Endpoint &ep);
+    const sockaddr *SlowGet() const;
 
 private:
-  static constexpr auto kOptimizedSize = sizeof(sockaddr_in6);
+    static constexpr auto kOptimizedSize = sizeof(sockaddr_in6);
 
-  // Storaege MUST be the first element of Endpoint
-  using Storage = typename std::aligned_storage<kOptimizedSize, 1>::type;
+    // Storaege MUST be the first element of Endpoint
+    using Storage = typename std::aligned_storage<kOptimizedSize, 1>::type;
 
-  Storage storage_;
-  socklen_t length_;
+    Storage storage_;
+    socklen_t length_;
 };
 
 bool operator==(const Endpoint &lhs, const Endpoint &rhs);
@@ -86,8 +93,7 @@ std::uint16_t EndpointGetPort(const Endpoint &ep);
 
 std::vector<Endpoint> GetInterfaceAddresses();
 
-std::expected<std::vector<Endpoint>, int>
-ResolveDomain(const std::string &domain, std::uint16_t port = 0);
+std::expected<std::vector<Endpoint>, int> ResolveDomain(const std::string &domain, std::uint16_t port = 0);
 
 bool IsPrivateIpv4AddressRfc(const Endpoint &addr);
 bool IsPrivateIpv4AddressCorp(const Endpoint &addr);
@@ -95,15 +101,15 @@ bool IsPrivateIpv4AddressCorp(const Endpoint &addr);
 bool IsGuaIpv6Address(const Endpoint &addr);
 
 struct from_ipv4_t {
-  constexpr explicit from_ipv4_t() = default;
+    constexpr explicit from_ipv4_t() = default;
 };
 
 struct from_ipv6_t {
-  constexpr explicit from_ipv6_t() = default;
+    constexpr explicit from_ipv6_t() = default;
 };
 
 struct from_unix_t {
-  constexpr explicit from_unix_t() = default;
+    constexpr explicit from_unix_t() = default;
 };
 
 constexpr from_ipv4_t from_ipv4 = from_ipv4_t();
@@ -112,62 +118,65 @@ constexpr from_unix_t from_unix = from_unix_t();
 
 std::ostream &operator<<(std::ostream &os, const Endpoint &ep);
 
-inline Endpoint::~Endpoint() {
-  if (TILE_LIKELY(IsTriviallyCopyable())) {
-    return;
-  }
-  SlowDestroy();
+inline Endpoint::~Endpoint()
+{
+    if (TILE_LIKELY(IsTriviallyCopyable())) { return; }
+    SlowDestroy();
 }
 
-inline Endpoint::Endpoint(const Endpoint &ep) {
-  if (TILE_LIKELY(ep.IsTriviallyCopyable())) {
-    memcpy(reinterpret_cast<void *>(this), reinterpret_cast<const void *>(&ep),
-           sizeof(Endpoint));
-  } else {
-    SlowCopyUninitialized(ep);
-  }
+inline Endpoint::Endpoint(const Endpoint &ep)
+{
+    if (TILE_LIKELY(ep.IsTriviallyCopyable())) {
+        memcpy(reinterpret_cast<void *>(this), reinterpret_cast<const void *>(&ep), sizeof(Endpoint));
+    } else {
+        SlowCopyUninitialized(ep);
+    }
 }
 
-inline Endpoint &Endpoint::operator=(const Endpoint &ep) {
-  if (TILE_LIKELY(ep.IsTriviallyCopyable())) {
-    memcpy(reinterpret_cast<void *>(this), reinterpret_cast<const void *>(&ep),
-           sizeof(Endpoint));
-  } else {
-    SlowCopy(ep);
-  }
-  return *this;
+inline Endpoint &
+Endpoint::operator=(const Endpoint &ep)
+{
+    if (TILE_LIKELY(ep.IsTriviallyCopyable())) {
+        memcpy(reinterpret_cast<void *>(this), reinterpret_cast<const void *>(&ep), sizeof(Endpoint));
+    } else {
+        SlowCopy(ep);
+    }
+    return *this;
 }
 
-inline Endpoint::Endpoint(Endpoint &&ep) noexcept {
-  if (TILE_LIKELY(ep.IsTriviallyCopyable())) {
-    memcpy(reinterpret_cast<void *>(this), reinterpret_cast<void *>(&ep),
-           sizeof(Endpoint));
-  } else {
-    SlowCopyUninitialized(ep);
-  }
+inline Endpoint::Endpoint(Endpoint &&ep) noexcept
+{
+    if (TILE_LIKELY(ep.IsTriviallyCopyable())) {
+        memcpy(reinterpret_cast<void *>(this), reinterpret_cast<void *>(&ep), sizeof(Endpoint));
+    } else {
+        SlowCopyUninitialized(ep);
+    }
 }
 
-inline Endpoint &Endpoint::operator=(Endpoint &&ep) noexcept {
-  if (TILE_LIKELY(ep.IsTriviallyCopyable())) {
-    memcpy(reinterpret_cast<void *>(this), reinterpret_cast<void *>(&ep),
-           sizeof(Endpoint));
-  } else {
-    SlowCopy(ep);
-  }
-  return *this;
+inline Endpoint &
+Endpoint::operator=(Endpoint &&ep) noexcept
+{
+    if (TILE_LIKELY(ep.IsTriviallyCopyable())) {
+        memcpy(reinterpret_cast<void *>(this), reinterpret_cast<void *>(&ep), sizeof(Endpoint));
+    } else {
+        SlowCopy(ep);
+    }
+    return *this;
 }
 
-template <typename T, typename> struct TryParseTraits;
+template<typename T, typename>
+struct TryParseTraits;
 
-template <> struct TryParseTraits<Endpoint, void> {
-  static std::optional<Endpoint> TryParse(Slice s, from_ipv4_t);
-  static std::optional<Endpoint> TryParse(Slice s, from_ipv6_t);
-  static std::optional<Endpoint> TryParse(Slice s, from_unix_t);
-  static std::optional<Endpoint> TryParse(Slice s);
+template<>
+struct TryParseTraits<Endpoint, void> {
+    static std::optional<Endpoint> TryParse(Slice s, from_ipv4_t);
+    static std::optional<Endpoint> TryParse(Slice s, from_ipv6_t);
+    static std::optional<Endpoint> TryParse(Slice s, from_unix_t);
+    static std::optional<Endpoint> TryParse(Slice s);
 };
 
 Endpoint EndpointFromString(Slice ip_port);
 
-} // namespace tile
+}// namespace tile
 
-#endif // TILE_BASE_NET_ENDPOINT_H
+#endif// TILE_BASE_NET_ENDPOINT_H
diff --git a/tile/base/net/endpoint_test.cc b/tile/base/net/endpoint_test.cc
index 0d89a96..25c4097 100644
--- a/tile/base/net/endpoint_test.cc
+++ b/tile/base/net/endpoint_test.cc
@@ -12,184 +12,192 @@
 
 namespace tile {
 
-TEST(EndpointBuilder, Retrieve) {
-  EndpointRetriever er;
-  auto ep2 = EndpointFromIpv4("192.0.2.1", 5678);
-  ASSERT_EQ(ep2.Family(), AF_INET);
-  ASSERT_EQ(ep2.Length(), sizeof(struct sockaddr_in));
+TEST(EndpointBuilder, Retrieve)
+{
+    EndpointRetriever er;
+    auto ep2 = EndpointFromIpv4("192.0.2.1", 5678);
+    ASSERT_EQ(ep2.Family(), AF_INET);
+    ASSERT_EQ(ep2.Length(), sizeof(struct sockaddr_in));
 
-  memcpy(er.RetrieveAddr(), ep2.Get(), ep2.Length());
-  *er.RetrieveLength() = ep2.Length();
-  ASSERT_EQ("192.0.2.1:5678", er.Build().ToString());
+    memcpy(er.RetrieveAddr(), ep2.Get(), ep2.Length());
+    *er.RetrieveLength() = ep2.Length();
+    ASSERT_EQ("192.0.2.1:5678", er.Build().ToString());
 }
 
-TEST(Endpoint, ToString) {
-  ASSERT_EQ("192.0.2.1:5678", EndpointFromIpv4("192.0.2.1", 5678).ToString());
+TEST(Endpoint, ToString) { ASSERT_EQ("192.0.2.1:5678", EndpointFromIpv4("192.0.2.1", 5678).ToString()); }
+
+TEST(Endpoint, ToString2)
+{
+    Endpoint ep;
+    auto ep2 = EndpointFromIpv4("192.0.2.1", 5678);
+    ep       = ep2;
+    ASSERT_EQ("192.0.2.1:5678", ep.ToString());
 }
 
-TEST(Endpoint, ToString2) {
-  Endpoint ep;
-  auto ep2 = EndpointFromIpv4("192.0.2.1", 5678);
-  ep = ep2;
-  ASSERT_EQ("192.0.2.1:5678", ep.ToString());
+TEST(Endpoint, ToString3) { ASSERT_EQ("192.0.2.1:5678", Format("{}", EndpointFromIpv4("192.0.2.1", 5678))); }
+
+TEST(Endpoint, ToString4)
+{
+    auto ep = EndpointFromUnix("/tmp/test.sock");
+    ASSERT_EQ("/tmp/test.sock", ep.ToString());
+
+    auto ep2 = EndpointFromUnix("@/tmp/test2.sock");
+    ASSERT_EQ("@/tmp/test2.sock", ep2.ToString());
 }
 
-TEST(Endpoint, ToString3) {
-  ASSERT_EQ("192.0.2.1:5678",
-            Format("{}", EndpointFromIpv4("192.0.2.1", 5678)));
+TEST(Endpoint, MoveToEmpty)
+{
+    Endpoint ep;
+    auto ep2 = EndpointFromIpv4("192.0.2.1", 5678);
+    ep       = ep2;
+    ASSERT_EQ("192.0.2.1:5678", ep.ToString());
 }
 
-TEST(Endpoint, ToString4) {
-  auto ep = EndpointFromUnix("/tmp/test.sock");
-  ASSERT_EQ("/tmp/test.sock", ep.ToString());
-
-  auto ep2 = EndpointFromUnix("@/tmp/test2.sock");
-  ASSERT_EQ("@/tmp/test2.sock", ep2.ToString());
+TEST(Endpoint, MoveFromEmpty)
+{
+    Endpoint ep;
+    auto ep2 = EndpointFromIpv4("192.0.2.1", 5678);
+    ep2      = std::move(ep);
+    ASSERT_TRUE(ep2.Empty());
 }
 
-TEST(Endpoint, MoveToEmpty) {
-  Endpoint ep;
-  auto ep2 = EndpointFromIpv4("192.0.2.1", 5678);
-  ep = ep2;
-  ASSERT_EQ("192.0.2.1:5678", ep.ToString());
+TEST(Endpoint, EndpointFromString)
+{
+    auto ep = EndpointFromString("192.0.2.1:5678");
+    ASSERT_EQ("192.0.2.1:5678", ep.ToString());
+
+    ep = EndpointFromString("[2001:db8:8714:3a90::12]:1234");
+    ASSERT_EQ("[2001:db8:8714:3a90::12]:1234", ep.ToString());
 }
 
-TEST(Endpoint, MoveFromEmpty) {
-  Endpoint ep;
-  auto ep2 = EndpointFromIpv4("192.0.2.1", 5678);
-  ep2 = std::move(ep);
-  ASSERT_TRUE(ep2.Empty());
+TEST(Endpoint, EndpointCompare)
+{
+    auto ep1 = EndpointFromString("192.0.2.1:5678");
+    auto ep2 = EndpointFromString("192.0.2.1:5678");
+    auto ep3 = EndpointFromString("192.0.2.1:9999");
+    ASSERT_EQ(ep1, ep2);
+    ASSERT_FALSE(ep1 == ep3);
 }
 
-TEST(Endpoint, EndpointFromString) {
-  auto ep = EndpointFromString("192.0.2.1:5678");
-  ASSERT_EQ("192.0.2.1:5678", ep.ToString());
+TEST(Endpoint, EndpointCopy)
+{
+    auto ep1 = EndpointFromString("192.0.2.1:5678");
+    auto ep2 = ep1;
+    Endpoint ep3;
 
-  ep = EndpointFromString("[2001:db8:8714:3a90::12]:1234");
-  ASSERT_EQ("[2001:db8:8714:3a90::12]:1234", ep.ToString());
+    ep3 = ep1;
+    ASSERT_EQ(ep1, ep2);
+    ASSERT_EQ(ep1, ep3);
+    ASSERT_EQ(ep2, ep3);
 }
 
-TEST(Endpoint, EndpointCompare) {
-  auto ep1 = EndpointFromString("192.0.2.1:5678");
-  auto ep2 = EndpointFromString("192.0.2.1:5678");
-  auto ep3 = EndpointFromString("192.0.2.1:9999");
-  ASSERT_EQ(ep1, ep2);
-  ASSERT_FALSE(ep1 == ep3);
+TEST(Endpoint, TryParse)
+{
+    auto ep = TryParse<Endpoint>("192.0.2.1:5678");
+    ASSERT_TRUE(ep);
+    ASSERT_EQ("192.0.2.1:5678", ep->ToString());
+
+    ep = TryParse<Endpoint>("[2001:db8:8714:3a90::12]:1234");
+    ASSERT_TRUE(ep);
+    ASSERT_EQ("[2001:db8:8714:3a90::12]:1234", ep->ToString());
 }
 
-TEST(Endpoint, EndpointCopy) {
-  auto ep1 = EndpointFromString("192.0.2.1:5678");
-  auto ep2 = ep1;
-  Endpoint ep3;
+TEST(Endpoint, TryParse2)
+{
+    auto ep = TryParse<Endpoint>("192.0.2.1:5678", from_ipv4);
+    ASSERT_TRUE(ep);
+    ASSERT_EQ("192.0.2.1:5678", ep->ToString());
 
-  ep3 = ep1;
-  ASSERT_EQ(ep1, ep2);
-  ASSERT_EQ(ep1, ep3);
-  ASSERT_EQ(ep2, ep3);
+    ep = TryParse<Endpoint>("[2001:db8:8714:3a90::12]:1234", from_ipv6);
+    ASSERT_TRUE(ep);
+    ASSERT_EQ("[2001:db8:8714:3a90::12]:1234", ep->ToString());
 }
 
-TEST(Endpoint, TryParse) {
-  auto ep = TryParse<Endpoint>("192.0.2.1:5678");
-  ASSERT_TRUE(ep);
-  ASSERT_EQ("192.0.2.1:5678", ep->ToString());
-
-  ep = TryParse<Endpoint>("[2001:db8:8714:3a90::12]:1234");
-  ASSERT_TRUE(ep);
-  ASSERT_EQ("[2001:db8:8714:3a90::12]:1234", ep->ToString());
+TEST(Endpoint, TryParse3)
+{
+    auto ep = TryParse<Endpoint>("192.0.2.1:5678", from_ipv6);
+    ASSERT_FALSE(ep);
+    ep = TryParse<Endpoint>("[2001:db8:8714:3a90::12]:1234", from_ipv4);
+    ASSERT_FALSE(ep);
 }
 
-TEST(Endpoint, TryParse2) {
-  auto ep = TryParse<Endpoint>("192.0.2.1:5678", from_ipv4);
-  ASSERT_TRUE(ep);
-  ASSERT_EQ("192.0.2.1:5678", ep->ToString());
-
-  ep = TryParse<Endpoint>("[2001:db8:8714:3a90::12]:1234", from_ipv6);
-  ASSERT_TRUE(ep);
-  ASSERT_EQ("[2001:db8:8714:3a90::12]:1234", ep->ToString());
+TEST(Endpoint, GetIpPortV4)
+{
+    auto ep = TryParse<Endpoint>("192.0.2.1:5678");
+    ASSERT_TRUE(ep);
+    ASSERT_EQ("192.0.2.1", EndpointGetIp(*ep));
+    ASSERT_EQ(5678, EndpointGetPort(*ep));
 }
 
-TEST(Endpoint, TryParse3) {
-  auto ep = TryParse<Endpoint>("192.0.2.1:5678", from_ipv6);
-  ASSERT_FALSE(ep);
-  ep = TryParse<Endpoint>("[2001:db8:8714:3a90::12]:1234", from_ipv4);
-  ASSERT_FALSE(ep);
+TEST(Endpoint, GetIpPortV6)
+{
+    auto ep = TryParse<Endpoint>("[2001:db8:8714:3a90::12]:1234");
+    ASSERT_TRUE(ep);
+    ASSERT_EQ("2001:db8:8714:3a90::12", EndpointGetIp(*ep));
+    ASSERT_EQ(1234, EndpointGetPort(*ep));
 }
 
-TEST(Endpoint, GetIpPortV4) {
-  auto ep = TryParse<Endpoint>("192.0.2.1:5678");
-  ASSERT_TRUE(ep);
-  ASSERT_EQ("192.0.2.1", EndpointGetIp(*ep));
-  ASSERT_EQ(5678, EndpointGetPort(*ep));
+TEST(Endpoint, GetUnixDomain)
+{
+    auto ep = TryParse<Endpoint>("/tmp/test10086.sock", from_unix);
+    ASSERT_TRUE(ep);
+    ASSERT_EQ("/tmp/test10086.sock", ep->ToString());
 }
 
-TEST(Endpoint, GetIpPortV6) {
-  auto ep = TryParse<Endpoint>("[2001:db8:8714:3a90::12]:1234");
-  ASSERT_TRUE(ep);
-  ASSERT_EQ("2001:db8:8714:3a90::12", EndpointGetIp(*ep));
-  ASSERT_EQ(1234, EndpointGetPort(*ep));
+TEST(Endpoint, ResolveDomainName)
+{
+    const std::string test_domain = "www.baidu.com";
+
+    auto eps                      = ResolveDomain(test_domain, 80);
+    ASSERT_TRUE(eps) << eps.error();
+    for (auto &ep : *eps) {
+        std::cout << Format("Get IP From {}: {}", test_domain, ep.ToString()) << std::endl;
+        ASSERT_EQ(EndpointGetPort(ep), 80);
+    }
+    ASSERT_GT(eps->size(), 0);
 }
 
-TEST(Endpoint, GetUnixDomain) {
-  auto ep = TryParse<Endpoint>("/tmp/test10086.sock", from_unix);
-  ASSERT_TRUE(ep);
-  ASSERT_EQ("/tmp/test10086.sock", ep->ToString());
+TEST(Endpoint, GetInterfaceAddresses)
+{
+    auto ifaddrs = GetInterfaceAddresses();
+    for (auto &&e : ifaddrs) { std::cout << Format("Get address: {}", e.ToString()) << std::endl; }
+    ASSERT_GT(ifaddrs.size(), 0);// At least 127.0.0.1 should be there.
 }
 
-TEST(Endpoint, ResolveDomainName) {
-  const std::string test_domain = "www.baidu.com";
+TEST(Endpoint, IsPrivateIpv4Address)
+{
+    EXPECT_FALSE(IsPrivateIpv4AddressRfc(EndpointFromIpv6("2001:db8:8714:3a90::12", 5678)));
+    EXPECT_FALSE(IsPrivateIpv4AddressCorp(EndpointFromIpv6("2001:db8:8714:3a90::12", 5678)));
 
-  auto eps = ResolveDomain(test_domain, 80);
-  ASSERT_TRUE(eps) << eps.error();
-  for (auto &ep : *eps) {
-    std::cout << Format("Get IP From {}: {}", test_domain, ep.ToString())
-              << std::endl;
-    ASSERT_EQ(EndpointGetPort(ep), 80);
-  }
-  ASSERT_GT(eps->size(), 0);
+    EXPECT_FALSE(IsPrivateIpv4AddressRfc(EndpointFromIpv4("192.0.2.1", 5678)));
+    EXPECT_FALSE(IsPrivateIpv4AddressCorp(EndpointFromIpv4("192.0.2.1", 5678)));
+
+    EXPECT_TRUE(IsPrivateIpv4AddressRfc(EndpointFromIpv4("10.0.0.1", 5678)));
+    EXPECT_TRUE(IsPrivateIpv4AddressCorp(EndpointFromIpv4("10.0.0.1", 5678)));
+
+    EXPECT_FALSE(IsPrivateIpv4AddressRfc(EndpointFromIpv4("9.0.0.1", 5678)));
+    EXPECT_TRUE(IsPrivateIpv4AddressCorp(EndpointFromIpv4("9.0.0.1", 5678)));
+    EXPECT_FALSE(IsPrivateIpv4AddressRfc(EndpointFromIpv4("11.0.0.1", 5678)));
+    EXPECT_TRUE(IsPrivateIpv4AddressCorp(EndpointFromIpv4("11.0.0.1", 5678)));
+    EXPECT_FALSE(IsPrivateIpv4AddressRfc(EndpointFromIpv4("30.0.0.1", 5678)));
+    EXPECT_TRUE(IsPrivateIpv4AddressCorp(EndpointFromIpv4("30.0.0.1", 5678)));
 }
 
-TEST(Endpoint, GetInterfaceAddresses) {
-  auto ifaddrs = GetInterfaceAddresses();
-  for (auto &&e : ifaddrs) {
-    std::cout << Format("Get address: {}", e.ToString()) << std::endl;
-  }
-  ASSERT_GT(ifaddrs.size(), 0); // At least 127.0.0.1 should be there.
+TEST(Endpoint, IsGuaIpv6Address)
+{
+    EXPECT_FALSE(IsGuaIpv6Address(EndpointFromIpv4("192.0.2.1", 5678)));
+    EXPECT_FALSE(IsGuaIpv6Address(EndpointFromIpv6("::", 5678)));
+    EXPECT_TRUE(IsGuaIpv6Address(EndpointFromIpv6("2001:db8:8714:3a90::12", 5678)));
 }
 
-TEST(Endpoint, IsPrivateIpv4Address) {
-  EXPECT_FALSE(IsPrivateIpv4AddressRfc(
-      EndpointFromIpv6("2001:db8:8714:3a90::12", 5678)));
-  EXPECT_FALSE(IsPrivateIpv4AddressCorp(
-      EndpointFromIpv6("2001:db8:8714:3a90::12", 5678)));
-
-  EXPECT_FALSE(IsPrivateIpv4AddressRfc(EndpointFromIpv4("192.0.2.1", 5678)));
-  EXPECT_FALSE(IsPrivateIpv4AddressCorp(EndpointFromIpv4("192.0.2.1", 5678)));
-
-  EXPECT_TRUE(IsPrivateIpv4AddressRfc(EndpointFromIpv4("10.0.0.1", 5678)));
-  EXPECT_TRUE(IsPrivateIpv4AddressCorp(EndpointFromIpv4("10.0.0.1", 5678)));
-
-  EXPECT_FALSE(IsPrivateIpv4AddressRfc(EndpointFromIpv4("9.0.0.1", 5678)));
-  EXPECT_TRUE(IsPrivateIpv4AddressCorp(EndpointFromIpv4("9.0.0.1", 5678)));
-  EXPECT_FALSE(IsPrivateIpv4AddressRfc(EndpointFromIpv4("11.0.0.1", 5678)));
-  EXPECT_TRUE(IsPrivateIpv4AddressCorp(EndpointFromIpv4("11.0.0.1", 5678)));
-  EXPECT_FALSE(IsPrivateIpv4AddressRfc(EndpointFromIpv4("30.0.0.1", 5678)));
-  EXPECT_TRUE(IsPrivateIpv4AddressCorp(EndpointFromIpv4("30.0.0.1", 5678)));
-}
-
-TEST(Endpoint, IsGuaIpv6Address) {
-  EXPECT_FALSE(IsGuaIpv6Address(EndpointFromIpv4("192.0.2.1", 5678)));
-  EXPECT_FALSE(IsGuaIpv6Address(EndpointFromIpv6("::", 5678)));
-  EXPECT_TRUE(
-      IsGuaIpv6Address(EndpointFromIpv6("2001:db8:8714:3a90::12", 5678)));
-}
-
-TEST(Endpoint, StreamOperator) {
-  std::stringstream ss;
-  ss << EndpointFromIpv4("192.0.2.1", 5678);
-  EXPECT_EQ(ss.str(), "192.0.2.1:5678");
+TEST(Endpoint, StreamOperator)
+{
+    std::stringstream ss;
+    ss << EndpointFromIpv4("192.0.2.1", 5678);
+    EXPECT_EQ(ss.str(), "192.0.2.1:5678");
 }
 
 // TODO(luobogao): UT for AF_UNIX. AF_UNIX takes different code path than
 // AF_INET(6), and should be tested in its own.
 
-} // namespace tile
+}// namespace tile
diff --git a/tile/base/net/uri.h b/tile/base/net/uri.h
index 4327811..6c22c66 100644
--- a/tile/base/net/uri.h
+++ b/tile/base/net/uri.h
@@ -10,50 +10,59 @@
 #include <array>
 
 namespace tile {
-template <typename T, typename> struct TryParseTraits;
+template<typename T, typename>
+struct TryParseTraits;
+
 class Uri {
 public:
-  Uri() = default;
+    Uri() = default;
 
-  explicit Uri(Slice from);
+    explicit Uri(Slice from);
 
-  Slice scheme() const noexcept { return GetComponent(kScheme); };
-  Slice userinfo() const noexcept { return GetComponent(kUserInfo); };
-  Slice host() const noexcept { return GetComponent(kHost); };
-  Slice port() const noexcept { return GetComponent(kPort); };
-  Slice path() const noexcept { return GetComponent(kPath); };
-  Slice query() const noexcept { return GetComponent(kQuery); };
-  Slice fragment() const noexcept { return GetComponent(kFragment); }
+    Slice scheme() const noexcept { return GetComponent(kScheme); };
 
-  std::string ToString() const { return uri_; }
+    Slice userinfo() const noexcept { return GetComponent(kUserInfo); };
+
+    Slice host() const noexcept { return GetComponent(kHost); };
+
+    Slice port() const noexcept { return GetComponent(kPort); };
+
+    Slice path() const noexcept { return GetComponent(kPath); };
+
+    Slice query() const noexcept { return GetComponent(kQuery); };
+
+    Slice fragment() const noexcept { return GetComponent(kFragment); }
+
+    std::string ToString() const { return uri_; }
 
 private:
-  enum Component {
-    kScheme = 0,
-    kUserInfo = 1,
-    kHost = 2,
-    kPort = 3,
-    kPath = 4,
-    kQuery = 5,
-    kFragment = 6,
-    kComponentCount = 7,
-  };
+    enum Component {
+        kScheme         = 0,
+        kUserInfo       = 1,
+        kHost           = 2,
+        kPort           = 3,
+        kPath           = 4,
+        kQuery          = 5,
+        kFragment       = 6,
+        kComponentCount = 7,
+    };
 
-  using ComponentView = std::pair<std::uint16_t, std::uint16_t>;
-  using Components = std::array<ComponentView, kComponentCount>;
+    using ComponentView = std::pair<std::uint16_t, std::uint16_t>;
+    using Components    = std::array<ComponentView, kComponentCount>;
 
-  Slice GetComponent(Component component) const noexcept;
+    Slice GetComponent(Component component) const noexcept;
 
 private:
-  std::string uri_;
-  Components comps_;
-  std::uint16_t port_;
+    std::string uri_;
+    Components comps_;
+    std::uint16_t port_;
 };
 
-template <> struct TryParseTraits<Uri, void> {
-  tile::optional<Uri> TryParse(Slice s);
+template<>
+struct TryParseTraits<Uri, void> {
+    tile::optional<Uri> TryParse(Slice s);
 };
 
-} // namespace tile
+}// namespace tile
 
-#endif // _TILE_BASE_NET_URI_H
+#endif// _TILE_BASE_NET_URI_H
diff --git a/tile/base/never_destroyed.h b/tile/base/never_destroyed.h
index d481ce8..f4341e3 100644
--- a/tile/base/never_destroyed.h
+++ b/tile/base/never_destroyed.h
@@ -8,61 +8,69 @@
 
 namespace tile {
 namespace detail {
-template <typename T> class NeverDestroyedImpl {
+template<typename T>
+class NeverDestroyedImpl {
 public:
-  NeverDestroyedImpl(const NeverDestroyedImpl &) = delete;
-  NeverDestroyedImpl &operator=(const NeverDestroyedImpl &) = delete;
+    NeverDestroyedImpl(const NeverDestroyedImpl &)            = delete;
+    NeverDestroyedImpl &operator=(const NeverDestroyedImpl &) = delete;
 
-  T *Get() { return reinterpret_cast<T *>(&storage_); }
-  const T *Get() const { return reinterpret_cast<const T *>(&storage_); }
+    T *Get() { return reinterpret_cast<T *>(&storage_); }
 
-  T *operator->() { return Get(); }
-  const T *operator->() const { return Get(); }
-  T &operator*() { return *Get(); }
-  const T &operator*() const { return *Get(); }
+    const T *Get() const { return reinterpret_cast<const T *>(&storage_); }
+
+    T *operator->() { return Get(); }
+
+    const T *operator->() const { return Get(); }
+
+    T &operator*() { return *Get(); }
+
+    const T &operator*() const { return *Get(); }
 
 protected:
-  NeverDestroyedImpl() = default;
+    NeverDestroyedImpl() = default;
 
 protected:
-  typename std::aligned_storage<sizeof(T), alignof(T)>::type storage_;
+    typename std::aligned_storage<sizeof(T), alignof(T)>::type storage_;
 };
-} // namespace detail
+}// namespace detail
 
-template <class T>
+template<class T>
 class NeverDestroyed final : private detail::NeverDestroyedImpl<T> {
-  using Impl = detail::NeverDestroyedImpl<T>;
+    using Impl = detail::NeverDestroyedImpl<T>;
 
 public:
-  template <class... Ts> explicit NeverDestroyed(Ts &&...args) {
-    new (&this->storage_) T(std::forward<Ts>(args)...);
-  }
+    template<class... Ts>
+    explicit NeverDestroyed(Ts &&...args)
+    {
+        new (&this->storage_) T(std::forward<Ts>(args)...);
+    }
 
-  using Impl::Get;
-  using Impl::operator->;
-  using Impl::operator*;
+    using Impl::Get;
+    using Impl::operator->;
+    using Impl::operator*;
 };
 
 // Same as `NeverDestroyed`, except that it's constructor is only accessible to
 // `T`. This class is useful when `T` is intended to be used as singleton.
-template <class T>
-class NeverDestroyedSingleton final
-    : private tile::detail::NeverDestroyedImpl<T> {
-  using Impl = detail::NeverDestroyedImpl<T>;
+template<class T>
+class NeverDestroyedSingleton final : private tile::detail::NeverDestroyedImpl<T> {
+    using Impl = detail::NeverDestroyedImpl<T>;
 
 public:
-  using Impl::Get;
-  using Impl::operator->;
-  using Impl::operator*;
+    using Impl::Get;
+    using Impl::operator->;
+    using Impl::operator*;
 
 private:
-  friend T;
+    friend T;
 
-  template <class... Ts> explicit NeverDestroyedSingleton(Ts &&...args) {
-    new (&this->storage_) T(std::forward<Ts>(args)...);
-  }
+    template<class... Ts>
+    explicit NeverDestroyedSingleton(Ts &&...args)
+    {
+        new (&this->storage_) T(std::forward<Ts>(args)...);
+    }
 };
 
-} // namespace tile
+}// namespace tile
 
-#endif // _TILE_BASE_NEVER_DESTROYED_H
+#endif// _TILE_BASE_NEVER_DESTROYED_H
diff --git a/tile/base/object_pool.h b/tile/base/object_pool.h
index 4b0de7c..5200b68 100644
--- a/tile/base/object_pool.h
+++ b/tile/base/object_pool.h
@@ -17,194 +17,248 @@
 namespace tile {
 enum class PoolType { Disabled, ThreadLocal, MemoryNodeShared, Global };
 
-template <typename T> struct PoolTraits {
-  // general attribute
-  // ======
-  // static constexpr tile::PoolType kType = tile::PoolType::Disabled;
+template<typename T>
+struct PoolTraits {
+    // general attribute
+    // ======
+    // static constexpr tile::PoolType kType = tile::PoolType::Disabled;
 
-  // ======
-  // thread_local attribute
-  // static constexpr std::size_t kLowWaterMark = 0;
-  // static constexpr std::size_t kHighWaterMark = 0;
-  // static constexpr std::chrono::duration<A,B> kMaxIdle =
-  // std::chrono::milliseconds(3000);
-  //
-  // 1. if the number of objects in the pool is greate than `kHighWaterMark`,
-  //   the object will be destroyed.
-  // 2. if the last_used time of the object is greater than `kMaxIdle` and the
-  // number of objects in the pool is greater than `kLowWaterMark`, the object
-  // will be destroyed.
+    // ======
+    // thread_local attribute
+    // static constexpr std::size_t kLowWaterMark = 0;
+    // static constexpr std::size_t kHighWaterMark = 0;
+    // static constexpr std::chrono::duration<A,B> kMaxIdle =
+    // std::chrono::milliseconds(3000);
+    //
+    // 1. if the number of objects in the pool is greate than `kHighWaterMark`,
+    //   the object will be destroyed.
+    // 2. if the last_used time of the object is greater than `kMaxIdle` and the
+    // number of objects in the pool is greater than `kLowWaterMark`, the object
+    // will be destroyed.
 
-  // hooks
-  // T * Create();
-  // void  Destroy(T* ptr);
-  // void OnGet(T* ptr);
-  // void OnPut(T* ptr);
+    // hooks
+    // T * Create();
+    // void  Destroy(T* ptr);
+    // void OnGet(T* ptr);
+    // void OnPut(T* ptr);
 
-  static_assert(sizeof(T) == 0,
-                "You need to specialize `tile::object_pool::PoolTraits` to "
-                "specify parameters before using `object_pool::Xxx`.");
+    static_assert(sizeof(T) == 0,
+                  "You need to specialize `tile::object_pool::PoolTraits` to "
+                  "specify parameters before using `object_pool::Xxx`.");
 };
 
 namespace object_pool {
 namespace detail {
 
 // disabled
-template <typename T>
+template<typename T>
 inline tile::enable_if_t<PoolTraits<T>::kType == PoolType::Disabled> *
-GetWithoutHook() {
-  return disabled::Get(*GetTypeDesc<T>());
+GetWithoutHook()
+{
+    return disabled::Get(*GetTypeDesc<T>());
 }
 
-template <typename T>
+template<typename T>
 inline tile::enable_if_t<PoolTraits<T>::kType == PoolType::Disabled>
-PutWithoutHook(void *ptr) {
-  disabled::Put(*GetTypeDesc<T>(), ptr);
+PutWithoutHook(void *ptr)
+{
+    disabled::Put(*GetTypeDesc<T>(), ptr);
 }
 
 // thread_local
-template <typename T>
+template<typename T>
 inline tile::enable_if_t<PoolTraits<T>::kType == PoolType::ThreadLocal> *
-GetWithoutHook() {
-  return tls::Get(*GetTypeDesc<T>(), tls::GetThradLocalPool<T>());
+GetWithoutHook()
+{
+    return tls::Get(*GetTypeDesc<T>(), tls::GetThradLocalPool<T>());
 }
-template <typename T>
+
+template<typename T>
 inline tile::enable_if_t<PoolTraits<T>::kType == PoolType::ThreadLocal>
-PutWithoutHook(void *ptr) {
-  return tls::Put(*GetTypeDesc<T>(), tls::GetThradLocalPool<T>(), ptr);
+PutWithoutHook(void *ptr)
+{
+    return tls::Put(*GetTypeDesc<T>(), tls::GetThradLocalPool<T>(), ptr);
 }
 
 // global
-template <typename T>
+template<typename T>
 inline tile::enable_if_t<PoolTraits<T>::kType == PoolType::Global> *
-GetWithoutHook() {
-  return global::Get(*GetTypeDesc<T>());
+GetWithoutHook()
+{
+    return global::Get(*GetTypeDesc<T>());
 }
-template <typename T>
+
+template<typename T>
 inline tile::enable_if_t<PoolTraits<T>::kType == PoolType::Global>
-PutWithoutHook(void *ptr) {
-  return global::Put(*GetTypeDesc<T>(), ptr);
+PutWithoutHook(void *ptr)
+{
+    return global::Put(*GetTypeDesc<T>(), ptr);
 }
 
 // memory node shared
-template <typename T>
+template<typename T>
 inline tile::enable_if_t<PoolTraits<T>::kType == PoolType::MemoryNodeShared> *
-GetWithoutHook() {
-  return tls::Get(*GetTypeDesc<T>(), tls::GetThradLocalPool<T>());
+GetWithoutHook()
+{
+    return tls::Get(*GetTypeDesc<T>(), tls::GetThradLocalPool<T>());
 }
-template <typename T>
+
+template<typename T>
 inline tile::enable_if_t<PoolTraits<T>::kType == PoolType::MemoryNodeShared>
-PutWithoutHook(void *ptr) {
-  return tls::Put(*GetTypeDesc<T>(), tls::GetThradLocalPool<T>(), ptr);
+PutWithoutHook(void *ptr)
+{
+    return tls::Put(*GetTypeDesc<T>(), tls::GetThradLocalPool<T>(), ptr);
 }
 
-template <typename T> inline void *Get() {
-  auto rc = GetWithoutHook<T>();
-  OnGetHook<T>(rc);
-  return rc;
+template<typename T>
+inline void *
+Get()
+{
+    auto rc = GetWithoutHook<T>();
+    OnGetHook<T>(rc);
+    return rc;
 }
 
-template <typename T> inline void Put(void *ptr) {
-  TILE_DCHECK(ptr, "I'm pretty sure null pointer is not what you got when you "
-                   "called `Get`.");
-  OnPutHook<T>(ptr);
-  PutWithoutHook<T>(ptr);
+template<typename T>
+inline void
+Put(void *ptr)
+{
+    TILE_DCHECK(ptr,
+                "I'm pretty sure null pointer is not what you got when you "
+                "called `Get`.");
+    OnPutHook<T>(ptr);
+    PutWithoutHook<T>(ptr);
 }
 
-} // namespace detail
-} // namespace object_pool
+}// namespace detail
+}// namespace object_pool
 
-template <typename T> class PooledPtr final {
+template<typename T>
+class PooledPtr final {
 public:
-  constexpr PooledPtr();
-  ~PooledPtr();
+    constexpr PooledPtr();
+    ~PooledPtr();
 
-  constexpr PooledPtr(std::nullptr_t);
-  constexpr explicit PooledPtr(T *ptr) : ptr_(ptr) {}
-  PooledPtr(PooledPtr &&ptr) noexcept;
-  PooledPtr &operator=(PooledPtr &&ptr) noexcept;
-  constexpr explicit operator bool() const noexcept;
+    constexpr PooledPtr(std::nullptr_t);
 
-  constexpr T *Get() const noexcept;
-  constexpr T *operator->() const noexcept;
-  constexpr T &operator*() const noexcept;
-  PooledPtr &operator=(std::nullptr_t);
+    constexpr explicit PooledPtr(T *ptr) : ptr_(ptr) {}
 
-  // `ptr` must be obtained from calling `Leak()` on another `PooledPtr`.
-  void Reset(T *ptr = nullptr) noexcept;
+    PooledPtr(PooledPtr &&ptr) noexcept;
+    PooledPtr &operator=(PooledPtr &&ptr) noexcept;
+    constexpr explicit operator bool() const noexcept;
 
-  // Ownership is transferred to caller.
-  TILE_NODISCARD T *Leak() noexcept;
+    constexpr T *Get() const noexcept;
+    constexpr T *operator->() const noexcept;
+    constexpr T &operator*() const noexcept;
+    PooledPtr &operator=(std::nullptr_t);
+
+    // `ptr` must be obtained from calling `Leak()` on another `PooledPtr`.
+    void Reset(T *ptr = nullptr) noexcept;
+
+    // Ownership is transferred to caller.
+    TILE_NODISCARD T *Leak() noexcept;
 
 private:
-  T *ptr_;
+    T *ptr_;
 };
 
 namespace object_pool {
-template <typename T> PooledPtr<T> Get() {
-  return PooledPtr<T>(static_cast<T *>(detail::Get<T>()));
-}
-template <typename T> void Put(typename std::common_type<T>::type *ptr) {
-  detail::Put<T>(ptr);
+template<typename T>
+PooledPtr<T>
+Get()
+{
+    return PooledPtr<T>(static_cast<T *>(detail::Get<T>()));
 }
 
-} // namespace object_pool
-
-template <typename T> constexpr PooledPtr<T>::PooledPtr() : ptr_(nullptr) {}
-template <typename T> PooledPtr<T>::~PooledPtr() {
-  if (ptr_) {
-    object_pool::Put<T>(ptr_);
-  }
+template<typename T>
+void
+Put(typename std::common_type<T>::type *ptr)
+{
+    detail::Put<T>(ptr);
 }
 
-template <typename T>
-PooledPtr<T>::PooledPtr(PooledPtr &&ptr) noexcept : ptr_(ptr.ptr_) {
-  ptr.ptr_ = nullptr;
+}// namespace object_pool
+
+template<typename T>
+constexpr PooledPtr<T>::PooledPtr() : ptr_(nullptr)
+{}
+
+template<typename T>
+PooledPtr<T>::~PooledPtr()
+{
+    if (ptr_) { object_pool::Put<T>(ptr_); }
 }
 
-template <typename T>
-PooledPtr<T> &PooledPtr<T>::operator=(PooledPtr &&ptr) noexcept {
-  if (TILE_LIKELY(this != &ptr)) {
-    Reset(ptr.Leak());
-  }
-  return *this;
-}
-template <typename T> constexpr PooledPtr<T>::operator bool() const noexcept {
-  return !!ptr_;
+template<typename T>
+PooledPtr<T>::PooledPtr(PooledPtr &&ptr) noexcept : ptr_(ptr.ptr_)
+{
+    ptr.ptr_ = nullptr;
 }
 
-template <typename T> constexpr T *PooledPtr<T>::Get() const noexcept {
-  return ptr_;
+template<typename T>
+PooledPtr<T> &
+PooledPtr<T>::operator=(PooledPtr &&ptr) noexcept
+{
+    if (TILE_LIKELY(this != &ptr)) { Reset(ptr.Leak()); }
+    return *this;
 }
 
-template <typename T> constexpr T *PooledPtr<T>::operator->() const noexcept {
-  return ptr_;
-}
-template <typename T> constexpr T &PooledPtr<T>::operator*() const noexcept {
-  return *ptr_;
+template<typename T>
+constexpr PooledPtr<T>::operator bool() const noexcept
+{
+    return !!ptr_;
 }
 
-template <typename T> void PooledPtr<T>::Reset(T *ptr) noexcept {
-  if (ptr_) {
-    object_pool::Put<T>(ptr_);
-  }
-  ptr_ = ptr;
+template<typename T>
+constexpr T *
+PooledPtr<T>::Get() const noexcept
+{
+    return ptr_;
 }
 
-template <typename T> T *PooledPtr<T>::Leak() noexcept {
-  T *rc = nullptr;
-  std::swap(rc, ptr_);
-  return rc;
+template<typename T>
+constexpr T *
+PooledPtr<T>::operator->() const noexcept
+{
+    return ptr_;
 }
 
-template <typename T>
-constexpr bool operator==(const PooledPtr<T> &ptr, std::nullptr_t) {
-  return ptr.Get() == nullptr;
+template<typename T>
+constexpr T &
+PooledPtr<T>::operator*() const noexcept
+{
+    return *ptr_;
 }
 
-template <typename T>
-constexpr bool operator==(std::nullptr_t, const PooledPtr<T> &ptr) {
-  return ptr.Get() == nullptr;
+template<typename T>
+void
+PooledPtr<T>::Reset(T *ptr) noexcept
+{
+    if (ptr_) { object_pool::Put<T>(ptr_); }
+    ptr_ = ptr;
 }
-} // namespace tile
-#endif // _TILE_BASE_OBJECT_POOL_H
+
+template<typename T>
+T *
+PooledPtr<T>::Leak() noexcept
+{
+    T *rc = nullptr;
+    std::swap(rc, ptr_);
+    return rc;
+}
+
+template<typename T>
+constexpr bool
+operator==(const PooledPtr<T> &ptr, std::nullptr_t)
+{
+    return ptr.Get() == nullptr;
+}
+
+template<typename T>
+constexpr bool
+operator==(std::nullptr_t, const PooledPtr<T> &ptr)
+{
+    return ptr.Get() == nullptr;
+}
+}// namespace tile
+#endif// _TILE_BASE_OBJECT_POOL_H
diff --git a/tile/base/object_pool/disabled.cc b/tile/base/object_pool/disabled.cc
index d695c5c..6c1feda 100644
--- a/tile/base/object_pool/disabled.cc
+++ b/tile/base/object_pool/disabled.cc
@@ -5,15 +5,21 @@ namespace object_pool {
 namespace detail {
 namespace disabled {
 
-void *Get(const TypeDescriptor &desc) {
-  auto rc = desc.create();
-  return rc;
+void *
+Get(const TypeDescriptor &desc)
+{
+    auto rc = desc.create();
+    return rc;
 }
 
-void Put(const TypeDescriptor &desc, void *ptr) { desc.destroy(ptr); }
+void
+Put(const TypeDescriptor &desc, void *ptr)
+{
+    desc.destroy(ptr);
+}
 
-} // namespace disabled
-} // namespace detail
+}// namespace disabled
+}// namespace detail
 
-} // namespace object_pool
-} // namespace tile
+}// namespace object_pool
+}// namespace tile
diff --git a/tile/base/object_pool/disabled.h b/tile/base/object_pool/disabled.h
index 04a21ca..5efb7ba 100644
--- a/tile/base/object_pool/disabled.h
+++ b/tile/base/object_pool/disabled.h
@@ -11,9 +11,9 @@ namespace detail {
 namespace disabled {
 void *Get(const TypeDescriptor &desc);
 void Put(const TypeDescriptor &desc, void *ptr);
-} // namespace disabled
-} // namespace detail
-} // namespace object_pool
-} // namespace tile
+}// namespace disabled
+}// namespace detail
+}// namespace object_pool
+}// namespace tile
 
-#endif // _TILE_BASE_OBJECT_POOL_DISABLED_H
+#endif// _TILE_BASE_OBJECT_POOL_DISABLED_H
diff --git a/tile/base/object_pool/disabled_test.cc b/tile/base/object_pool/disabled_test.cc
index edf3d56..bf9cd1d 100644
--- a/tile/base/object_pool/disabled_test.cc
+++ b/tile/base/object_pool/disabled_test.cc
@@ -9,27 +9,28 @@ namespace tile {
 static int alive = 0;
 
 struct Obj {
-  Obj() { ++alive; }
-  ~Obj() { --alive; }
+    Obj() { ++alive; }
+
+    ~Obj() { --alive; }
 };
 
-template <> struct PoolTraits<Obj> {
-  static constexpr auto kType = PoolType::Disabled;
+template<>
+struct PoolTraits<Obj> {
+    static constexpr auto kType = PoolType::Disabled;
 };
 
 namespace object_pool {
 
-TEST(DisabledPool, All) {
-  std::vector<PooledPtr<Obj>> ptrs;
-  for (int i = 0; i != 1000; ++i) {
-    ptrs.push_back(Get<Obj>());
-  }
-  ASSERT_EQ(1000, alive);
-  ptrs.clear();
-  ASSERT_EQ(0, alive);
-  Get<Obj>();
-  ASSERT_EQ(0, alive);
+TEST(DisabledPool, All)
+{
+    std::vector<PooledPtr<Obj>> ptrs;
+    for (int i = 0; i != 1000; ++i) { ptrs.push_back(Get<Obj>()); }
+    ASSERT_EQ(1000, alive);
+    ptrs.clear();
+    ASSERT_EQ(0, alive);
+    Get<Obj>();
+    ASSERT_EQ(0, alive);
 }
 
-} // namespace object_pool
-} // namespace tile
+}// namespace object_pool
+}// namespace tile
diff --git a/tile/base/object_pool/global.cc b/tile/base/object_pool/global.cc
index 11208a3..38b486a 100644
--- a/tile/base/object_pool/global.cc
+++ b/tile/base/object_pool/global.cc
@@ -5,17 +5,21 @@ namespace tile {
 namespace object_pool {
 namespace detail {
 namespace global {
-void *Get(const TypeDescriptor &desc) {
-  // TILE_NOT_IMPLEMENTED("");
-  return desc.create();
+void *
+Get(const TypeDescriptor &desc)
+{
+    // TILE_NOT_IMPLEMENTED("");
+    return desc.create();
 }
 
-void Put(const TypeDescriptor &desc, void *ptr) {
-  // TILE_NOT_IMPLEMENTED("");
-  desc.destroy(ptr);
+void
+Put(const TypeDescriptor &desc, void *ptr)
+{
+    // TILE_NOT_IMPLEMENTED("");
+    desc.destroy(ptr);
 }
 
-} // namespace global
-} // namespace detail
-} // namespace object_pool
-} // namespace tile
+}// namespace global
+}// namespace detail
+}// namespace object_pool
+}// namespace tile
diff --git a/tile/base/object_pool/global.h b/tile/base/object_pool/global.h
index beec358..20cdcdc 100644
--- a/tile/base/object_pool/global.h
+++ b/tile/base/object_pool/global.h
@@ -12,9 +12,9 @@ namespace global {
 void *Get(const TypeDescriptor &desc);
 void Put(const TypeDescriptor &desc, void *ptr);
 
-} // namespace global
-} // namespace detail
-} // namespace object_pool
-} // namespace tile
+}// namespace global
+}// namespace detail
+}// namespace object_pool
+}// namespace tile
 
-#endif // TILE_BASE_OBJECT_POOL_GLOBAL_H
+#endif// TILE_BASE_OBJECT_POOL_GLOBAL_H
diff --git a/tile/base/object_pool/thread_local.cc b/tile/base/object_pool/thread_local.cc
index 1772e0e..0259bda 100644
--- a/tile/base/object_pool/thread_local.cc
+++ b/tile/base/object_pool/thread_local.cc
@@ -11,90 +11,93 @@ namespace detail {
 namespace tls {
 
 constexpr std::size_t kMinimumFreePerWash = 32;
-constexpr auto kMinmumWashInterval = std::chrono::milliseconds(5);
+constexpr auto kMinmumWashInterval        = std::chrono::milliseconds(5);
+
 namespace {
 // return value in [upto/2, upto]
-std::size_t GetFreeCount(std::size_t upto) {
-  return std::min(upto, std::max(upto / 2, kMinimumFreePerWash));
+std::size_t
+GetFreeCount(std::size_t upto)
+{
+    return std::min(upto, std::max(upto / 2, kMinimumFreePerWash));
 }
 
-void WashOutCache(PoolDescriptor *pool) {
-  auto now = ReadCoarseSteadyClock();
-  if (now < pool->last_wash + kMinmumWashInterval) {
-    return;
-  } else {
-    pool->last_wash = now;
-  }
-
-  auto &&primary = pool->primary_cache;
-  auto &&secondary = pool->secondary_cache;
-  auto move_to_secondary_or_free = [&](std::size_t count) {
-    while (count-- > 0) {
-      if (secondary.size() < pool->low_water_mark) {
-        secondary.push_back(std::move(primary.front()));
-      }
-      primary.pop_front();
-    }
-  };
-
-  if (primary.size() > pool->high_water_mark) {
-    auto upto = GetFreeCount(primary.size() - pool->high_water_mark);
-    move_to_secondary_or_free(upto);
-    if (upto >= kMinimumFreePerWash) {
-      return;
-    }
-  }
-
-#ifndef NDEBUG
-  std::size_t objects_had =
-      pool->primary_cache.size() + pool->secondary_cache.size();
-#endif
-
-  // move idle objects to secondary cache or free
-  auto idle_objects = std::find_if(primary.begin(), primary.end(),
-                                   [&](const TimestampedObject &e) {
-                                     return now - e.last_used < pool->max_idle;
-                                   }) -
-                      primary.begin();
-  move_to_secondary_or_free(GetFreeCount(idle_objects));
-#ifndef NDEBUG
-  if (objects_had >= pool->low_water_mark) {
-    TILE_CHECK_GE(pool->primary_cache.size() + pool->secondary_cache.size(),
-                  pool->low_water_mark);
-  }
-#endif
-}
-
-} // namespace
-
-void *Get(const TypeDescriptor &desc, PoolDescriptor *pool) {
-  if (pool->primary_cache.empty()) {
-    if (!pool->secondary_cache.empty()) {
-      // primary empty, secondary not empty
-      pool->primary_cache = std::move(pool->secondary_cache);
-      for (auto &&e : pool->primary_cache) {
-        e.last_used = ReadCoarseSteadyClock();
-      }
+void
+WashOutCache(PoolDescriptor *pool)
+{
+    auto now = ReadCoarseSteadyClock();
+    if (now < pool->last_wash + kMinmumWashInterval) {
+        return;
     } else {
-      // primary empty, secondary_cache empty
-      pool->primary_cache.push_back(
-          TimestampedObject{.ptr = {desc.create(), desc.destroy},
-                            .last_used = ReadCoarseSteadyClock()});
+        pool->last_wash = now;
     }
-  }
-  TILE_DCHECK(!pool->primary_cache.empty());
 
-  auto rc = std::move(pool->primary_cache.back());
-  pool->primary_cache.pop_back();
-  return rc.ptr.Leak();
-}
-void Put(const TypeDescriptor &desc, PoolDescriptor *pool, void *ptr) {
-  ScopedDeferred _([&] { WashOutCache(pool); });
-  pool->primary_cache.push_back(TimestampedObject{
-      .ptr = {ptr, desc.destroy}, .last_used = ReadCoarseSteadyClock()});
+    auto &&primary                 = pool->primary_cache;
+    auto &&secondary               = pool->secondary_cache;
+    auto move_to_secondary_or_free = [&](std::size_t count) {
+        while (count-- > 0) {
+            if (secondary.size() < pool->low_water_mark) { secondary.push_back(std::move(primary.front())); }
+            primary.pop_front();
+        }
+    };
+
+    if (primary.size() > pool->high_water_mark) {
+        auto upto = GetFreeCount(primary.size() - pool->high_water_mark);
+        move_to_secondary_or_free(upto);
+        if (upto >= kMinimumFreePerWash) { return; }
+    }
+
+#ifndef NDEBUG
+    std::size_t objects_had = pool->primary_cache.size() + pool->secondary_cache.size();
+#endif
+
+    // move idle objects to secondary cache or free
+    auto idle_objects = std::find_if(primary.begin(), primary.end(),
+                                     [&](const TimestampedObject &e) { return now - e.last_used < pool->max_idle; })
+        - primary.begin();
+    move_to_secondary_or_free(GetFreeCount(idle_objects));
+#ifndef NDEBUG
+    if (objects_had >= pool->low_water_mark) {
+        TILE_CHECK_GE(pool->primary_cache.size() + pool->secondary_cache.size(), pool->low_water_mark);
+    }
+#endif
 }
 
-} // namespace tls
-} // namespace detail
-} // namespace object_pool
-} // namespace tile
+}// namespace
+
+void *
+Get(const TypeDescriptor &desc, PoolDescriptor *pool)
+{
+    if (pool->primary_cache.empty()) {
+        if (!pool->secondary_cache.empty()) {
+            // primary empty, secondary not empty
+            pool->primary_cache = std::move(pool->secondary_cache);
+            for (auto &&e : pool->primary_cache) { e.last_used = ReadCoarseSteadyClock(); }
+        } else {
+            // primary empty, secondary_cache empty
+            pool->primary_cache.push_back(TimestampedObject{
+                .ptr       = {desc.create(), desc.destroy},
+                .last_used = ReadCoarseSteadyClock()
+            });
+        }
+    }
+    TILE_DCHECK(!pool->primary_cache.empty());
+
+    auto rc = std::move(pool->primary_cache.back());
+    pool->primary_cache.pop_back();
+    return rc.ptr.Leak();
+}
+
+void
+Put(const TypeDescriptor &desc, PoolDescriptor *pool, void *ptr)
+{
+    ScopedDeferred _([&] { WashOutCache(pool); });
+    pool->primary_cache.push_back(TimestampedObject{
+        .ptr       = {ptr, desc.destroy},
+        .last_used = ReadCoarseSteadyClock()
+    });
+}
+
+}// namespace tls
+}// namespace detail
+}// namespace object_pool
+}// namespace tile
diff --git a/tile/base/object_pool/thread_local.h b/tile/base/object_pool/thread_local.h
index ed8d0c7..be3c953 100644
--- a/tile/base/object_pool/thread_local.h
+++ b/tile/base/object_pool/thread_local.h
@@ -14,49 +14,49 @@ namespace object_pool {
 namespace detail {
 namespace tls {
 struct TimestampedObject {
-  ErasedPtr ptr;
-  std::chrono::steady_clock::time_point last_used;
+    ErasedPtr ptr;
+    std::chrono::steady_clock::time_point last_used;
 };
 
 struct PoolDescriptor {
-  PoolDescriptor(std::size_t low_water_mark, std::size_t high_water_mark,
-                 std::chrono::nanoseconds max_idle)
-      : low_water_mark(low_water_mark), high_water_mark(high_water_mark),
-        max_idle(max_idle) {}
+    PoolDescriptor(std::size_t low_water_mark, std::size_t high_water_mark, std::chrono::nanoseconds max_idle)
+        : low_water_mark(low_water_mark),
+          high_water_mark(high_water_mark),
+          max_idle(max_idle)
+    {}
 
-  const std::size_t low_water_mark;
-  const std::size_t high_water_mark;
-  std::chrono::nanoseconds max_idle;
-  std::chrono::steady_clock::time_point last_wash{
-      std::chrono::steady_clock::now()};
+    const std::size_t low_water_mark;
+    const std::size_t high_water_mark;
+    std::chrono::nanoseconds max_idle;
+    std::chrono::steady_clock::time_point last_wash{std::chrono::steady_clock::now()};
 
-  std::deque<TimestampedObject> primary_cache;
-  std::deque<TimestampedObject> secondary_cache;
+    std::deque<TimestampedObject> primary_cache;
+    std::deque<TimestampedObject> secondary_cache;
 };
 
-template <typename T> PoolDescriptor *GetThradLocalPool() {
-  static_assert(PoolTraits<T>::kHighWaterMark > PoolTraits<T>::kLowWaterMark,
-                "You should leave some room between the water marks.");
-  constexpr auto kEffectiveHighWaterMark =
-      PoolTraits<T>::kHighWaterMark - PoolTraits<T>::kLowWaterMark;
-  static thread_local PoolDescriptor pool =
-      PoolDescriptor(PoolTraits<T>::kLowWaterMark,
-                     PoolTraits<T>::kHighWaterMark, PoolTraits<T>::kMaxIdle);
+template<typename T>
+PoolDescriptor *
+GetThradLocalPool()
+{
+    static_assert(PoolTraits<T>::kHighWaterMark > PoolTraits<T>::kLowWaterMark,
+                  "You should leave some room between the water marks.");
+    constexpr auto kEffectiveHighWaterMark = PoolTraits<T>::kHighWaterMark - PoolTraits<T>::kLowWaterMark;
+    static thread_local PoolDescriptor pool =
+        PoolDescriptor(PoolTraits<T>::kLowWaterMark, PoolTraits<T>::kHighWaterMark, PoolTraits<T>::kMaxIdle);
 
-  TILE_DCHECK((pool.low_water_mark == PoolTraits<T>::kLowWaterMark) &&
-                  (pool.high_water_mark == PoolTraits<T>::kHighWaterMark) &&
-                  (pool.max_idle == PoolTraits<T>::kMaxIdle),
-              "You likely had am ODR-violation when customizing type [{}]",
-              GetTypeName<T>());
-  return &pool;
+    TILE_DCHECK((pool.low_water_mark == PoolTraits<T>::kLowWaterMark)
+                    && (pool.high_water_mark == PoolTraits<T>::kHighWaterMark)
+                    && (pool.max_idle == PoolTraits<T>::kMaxIdle),
+                "You likely had am ODR-violation when customizing type [{}]", GetTypeName<T>());
+    return &pool;
 }
 
 void *Get(const TypeDescriptor &desc, PoolDescriptor *pool);
 void Put(const TypeDescriptor &desc, PoolDescriptor *pool, void *ptr);
 
-} // namespace tls
-} // namespace detail
-} // namespace object_pool
-} // namespace tile
+}// namespace tls
+}// namespace detail
+}// namespace object_pool
+}// namespace tile
 
-#endif // TILE_BASE_OBJECT_POOL_THREAD_LOCAL_H
+#endif// TILE_BASE_OBJECT_POOL_THREAD_LOCAL_H
diff --git a/tile/base/object_pool/thread_local_test.cc b/tile/base/object_pool/thread_local_test.cc
index c504032..4895428 100644
--- a/tile/base/object_pool/thread_local_test.cc
+++ b/tile/base/object_pool/thread_local_test.cc
@@ -12,37 +12,41 @@ namespace tile {
 int alive = 0;
 
 struct C {
-  C() { ++alive; }
-  ~C() { --alive; }
+    C() { ++alive; }
+
+    ~C() { --alive; }
 };
 
-template <> struct PoolTraits<C> {
-  static constexpr auto kType = PoolType::ThreadLocal;
-  static constexpr std::size_t kLowWaterMark = 16;
-  static constexpr std::size_t kHighWaterMark = 128;
-  static constexpr std::chrono::milliseconds kMaxIdle =
-      std::chrono::milliseconds(3000);
+template<>
+struct PoolTraits<C> {
+    static constexpr auto kType                         = PoolType::ThreadLocal;
+    static constexpr std::size_t kLowWaterMark          = 16;
+    static constexpr std::size_t kHighWaterMark         = 128;
+    static constexpr std::chrono::milliseconds kMaxIdle = std::chrono::milliseconds(3000);
 };
+
 constexpr PoolType PoolTraits<C>::kType;
 constexpr std::size_t PoolTraits<C>::kLowWaterMark;
 constexpr std::size_t PoolTraits<C>::kHighWaterMark;
 constexpr std::chrono::milliseconds PoolTraits<C>::kMaxIdle;
 
 struct D {
-  int x;
-  static int put_called;
+    int x;
+    static int put_called;
 };
+
 int D::put_called = 0;
 
-template <> struct PoolTraits<D> {
-  static constexpr auto kType = PoolType::ThreadLocal;
-  static constexpr std::size_t kLowWaterMark = 16;
-  static constexpr std::size_t kHighWaterMark = 128;
-  static constexpr std::chrono::milliseconds kMaxIdle =
-      std::chrono::milliseconds(3000);
+template<>
+struct PoolTraits<D> {
+    static constexpr auto kType                         = PoolType::ThreadLocal;
+    static constexpr std::size_t kLowWaterMark          = 16;
+    static constexpr std::size_t kHighWaterMark         = 128;
+    static constexpr std::chrono::milliseconds kMaxIdle = std::chrono::milliseconds(3000);
 
-  static void OnGet(D *p) { p->x = 0; }
-  static void OnPut(D *) { ++D::put_called; }
+    static void OnGet(D *p) { p->x = 0; }
+
+    static void OnPut(D *) { ++D::put_called; }
 };
 
 constexpr PoolType PoolTraits<D>::kType;
@@ -50,71 +54,72 @@ constexpr std::size_t PoolTraits<D>::kLowWaterMark;
 constexpr std::size_t PoolTraits<D>::kHighWaterMark;
 constexpr std::chrono::milliseconds PoolTraits<D>::kMaxIdle;
 
-template <typename Rep, typename Period>
-static void BusySleep(std::chrono::duration<Rep, Period> dur) {
-  auto end = ReadCoarseSteadyClock() + dur;
-  while (ReadCoarseSteadyClock() < end) {
-    RelaxCpu();
-  }
+template<typename Rep, typename Period>
+static void
+BusySleep(std::chrono::duration<Rep, Period> dur)
+{
+    auto end = ReadCoarseSteadyClock() + dur;
+    while (ReadCoarseSteadyClock() < end) { RelaxCpu(); }
 }
 
 namespace object_pool {
 
-TEST(ThreadLocalPool, All) {
-  auto start = ReadCoarseSteadyClock();
-  // create 1000 unref objects;
-  ASSERT_EQ(alive, 0);
-  {
-    std::vector<PooledPtr<C>> ptrs;
-    for (int i = 0; i != 1000; ++i) {
-      ptrs.push_back(Get<C>());
+TEST(ThreadLocalPool, All)
+{
+    auto start = ReadCoarseSteadyClock();
+    // create 1000 unref objects;
+    ASSERT_EQ(alive, 0);
+    {
+        std::vector<PooledPtr<C>> ptrs;
+        for (int i = 0; i != 1000; ++i) { ptrs.push_back(Get<C>()); }
+        ASSERT_EQ(alive, 1000);
+        ptrs.clear();
+    }
+    for (int i = 0; i != 200; ++i) {
+        // std::this_thread::sleep_for(std::chrono::milliseconds(10));
+        BusySleep(std::chrono::milliseconds(10));
+        Get<C>().Reset();// Trigger wash out if possible.
+    }
+    if ((ReadCoarseSteadyClock() - start) < PoolTraits<C>::kMaxIdle) {
+        ASSERT_EQ(PoolTraits<C>::kHighWaterMark + PoolTraits<C>::kLowWaterMark,
+                  alive);// High-water mark.
     }
-    ASSERT_EQ(alive, 1000);
-    ptrs.clear();
-  }
-  for (int i = 0; i != 200; ++i) {
-    // std::this_thread::sleep_for(std::chrono::milliseconds(10));
-    BusySleep(std::chrono::milliseconds(10));
-    Get<C>().Reset(); // Trigger wash out if possible.
-  }
-  if ((ReadCoarseSteadyClock() - start) < PoolTraits<C>::kMaxIdle) {
-    ASSERT_EQ(PoolTraits<C>::kHighWaterMark + PoolTraits<C>::kLowWaterMark,
-              alive); // High-water mark.
-  }
 
-  // Max idle not reached. No effect.
-  Get<C>().Reset();
-  if ((ReadCoarseSteadyClock() - start) < PoolTraits<C>::kMaxIdle) {
-    ASSERT_EQ(PoolTraits<C>::kHighWaterMark + PoolTraits<C>::kLowWaterMark,
-              alive);
-  }
+    // Max idle not reached. No effect.
+    Get<C>().Reset();
+    if ((ReadCoarseSteadyClock() - start) < PoolTraits<C>::kMaxIdle) {
+        ASSERT_EQ(PoolTraits<C>::kHighWaterMark + PoolTraits<C>::kLowWaterMark, alive);
+    }
 
-  BusySleep(std::chrono::milliseconds(5000));
-  // std::this_thread::sleep_for(std::chrono::milliseconds(5000));
-  for (int i = 0; i != 100; ++i) {
-    Get<C>().Reset(); // We have a limit on objects to loop per call. So we may
-                      // need several calls to lower alive objects to low-water
-                      // mark.
-    BusySleep(std::chrono::milliseconds(10));
-    // std::this_thread::sleep_for(
-    //     std::chrono::milliseconds(10)); // The limit on wash interval..
-  }
-  // Low-water mark. + 1 for the object just freed (as it's fresh and won't be
-  // affected by low-water mark.).
-  ASSERT_EQ(PoolTraits<C>::kLowWaterMark + 1, alive);
+    BusySleep(std::chrono::milliseconds(5000));
+    // std::this_thread::sleep_for(std::chrono::milliseconds(5000));
+    for (int i = 0; i != 100; ++i) {
+        Get<C>().Reset();// We have a limit on objects to loop per call. So we may
+                         // need several calls to lower alive objects to low-water
+                         // mark.
+        BusySleep(std::chrono::milliseconds(10));
+        // std::this_thread::sleep_for(
+        //     std::chrono::milliseconds(10)); // The limit on wash interval..
+    }
+    // Low-water mark. + 1 for the object just freed (as it's fresh and won't be
+    // affected by low-water mark.).
+    ASSERT_EQ(PoolTraits<C>::kLowWaterMark + 1, alive);
 
-  Put<C>(Get<C>().Leak()); // Don't leak.
-  ASSERT_EQ(PoolTraits<C>::kLowWaterMark + 1, alive);
+    Put<C>(Get<C>().Leak());// Don't leak.
+    ASSERT_EQ(PoolTraits<C>::kLowWaterMark + 1, alive);
 }
 
-TEST(ThreadLocalPool, OnGetHook) {
-  { auto ptr = Get<D>(); }
-  {
-    auto ptr = Get<D>();
-    ASSERT_EQ(0, ptr->x);
-  }
-  ASSERT_EQ(2, D::put_called);
+TEST(ThreadLocalPool, OnGetHook)
+{
+    {
+        auto ptr = Get<D>();
+    }
+    {
+        auto ptr = Get<D>();
+        ASSERT_EQ(0, ptr->x);
+    }
+    ASSERT_EQ(2, D::put_called);
 }
 
-} // namespace object_pool
-} // namespace tile
+}// namespace object_pool
+}// namespace tile
diff --git a/tile/base/object_pool/types.h b/tile/base/object_pool/types.h
index cbc56c1..5a98b35 100644
--- a/tile/base/object_pool/types.h
+++ b/tile/base/object_pool/types.h
@@ -25,193 +25,245 @@ constexpr auto is_valid(F&& f) {
 */
 
 namespace tile {
-template <typename T> struct PoolTraits;
+template<typename T>
+struct PoolTraits;
 }
 
 namespace tile {
 namespace object_pool {
 namespace detail {
 struct TypeDescriptor {
-  TypeIndex type;
+    TypeIndex type;
 
-  void *(*create)();
-  void (*destroy)(void *);
+    void *(*create)();
+    void (*destroy)(void *);
 };
 
 // Has PoolTraits<T>::Create()
-template <typename T> struct PoolTraitsHasCreate {
-  template <typename U,
-            decltype(std::declval<PoolTraits<U>>().Create()) * = nullptr>
-  static int Test(int);
-  template <typename> static char Test(...);
-  static constexpr bool value = std::is_same<decltype(Test<T>(0)), int>::value;
+template<typename T>
+struct PoolTraitsHasCreate {
+    template<typename U, decltype(std::declval<PoolTraits<U>>().Create()) * = nullptr>
+    static int Test(int);
+    template<typename>
+    static char Test(...);
+    static constexpr bool value = std::is_same<decltype(Test<T>(0)), int>::value;
 };
 
 // Has PoolTraits<T>::Destroy(T*)
-template <typename T> struct PoolTraitsHasDestroy {
-  template <typename U, decltype(std::declval<PoolTraits<U>>().Destroy(
-                            std::declval<U *>())) * = nullptr>
-  static int Test(int);
-  template <typename> static char Test(...);
-  static constexpr bool value = std::is_same<decltype(Test<T>(0)), int>::value;
+template<typename T>
+struct PoolTraitsHasDestroy {
+    template<typename U, decltype(std::declval<PoolTraits<U>>().Destroy(std::declval<U *>())) * = nullptr>
+    static int Test(int);
+    template<typename>
+    static char Test(...);
+    static constexpr bool value = std::is_same<decltype(Test<T>(0)), int>::value;
 };
 
 // Has PoolTraits<T>::OnGet(T*)
-template <typename T> struct PoolTraitsHasOnGet {
-  template <typename U, decltype(std::declval<PoolTraits<U>>().OnGet(
-                            std::declval<U *>())) * = nullptr>
-  static int Test(int);
-  template <typename> static char Test(...);
-  static constexpr bool value = std::is_same<decltype(Test<T>(0)), int>::value;
+template<typename T>
+struct PoolTraitsHasOnGet {
+    template<typename U, decltype(std::declval<PoolTraits<U>>().OnGet(std::declval<U *>())) * = nullptr>
+    static int Test(int);
+    template<typename>
+    static char Test(...);
+    static constexpr bool value = std::is_same<decltype(Test<T>(0)), int>::value;
 };
 
 // Has PoolTraits<T>::OnPut(T*)
-template <typename T> struct PoolTraitsHasOnPut {
-  template <typename U, decltype(std::declval<PoolTraits<U>>().OnPut(
-                            std::declval<U *>())) * = nullptr>
-  static int Test(int);
-  template <typename> static char Test(...);
-  static constexpr bool value = std::is_same<decltype(Test<T>(0)), int>::value;
+template<typename T>
+struct PoolTraitsHasOnPut {
+    template<typename U, decltype(std::declval<PoolTraits<U>>().OnPut(std::declval<U *>())) * = nullptr>
+    static int Test(int);
+    template<typename>
+    static char Test(...);
+    static constexpr bool value = std::is_same<decltype(Test<T>(0)), int>::value;
 };
 
-template <typename T> constexpr bool PoolTraitsHasCreate<T>::value;
-template <typename T> constexpr bool PoolTraitsHasDestroy<T>::value;
-template <typename T> constexpr bool PoolTraitsHasOnGet<T>::value;
-template <typename T> constexpr bool PoolTraitsHasOnPut<T>::value;
+template<typename T>
+constexpr bool PoolTraitsHasCreate<T>::value;
+template<typename T>
+constexpr bool PoolTraitsHasDestroy<T>::value;
+template<typename T>
+constexpr bool PoolTraitsHasOnGet<T>::value;
+template<typename T>
+constexpr bool PoolTraitsHasOnPut<T>::value;
 
-template <typename T> struct PoolTraitsInvokeHook {
-  template <typename U, enable_if_t<PoolTraitsHasOnPut<U>::value> * = nullptr>
-  static void OnPutProxy(void *p) {
-    PoolTraits<U>::OnPut(static_cast<T *>(p));
-  }
-  template <typename U, enable_if_t<!PoolTraitsHasOnPut<U>::value> * = nullptr>
-  static void OnPutProxy(void *p) {}
+template<typename T>
+struct PoolTraitsInvokeHook {
+    template<typename U, enable_if_t<PoolTraitsHasOnPut<U>::value> * = nullptr>
+    static void OnPutProxy(void *p)
+    {
+        PoolTraits<U>::OnPut(static_cast<T *>(p));
+    }
 
-  template <typename U, enable_if_t<PoolTraitsHasOnGet<U>::value> * = nullptr>
-  static void OnGetProxy(void *p) {
-    PoolTraits<U>::OnGet(static_cast<T *>(p));
-  }
-  template <typename U, enable_if_t<!PoolTraitsHasOnGet<U>::value> * = nullptr>
-  static void OnGetProxy(void *p) {}
+    template<typename U, enable_if_t<!PoolTraitsHasOnPut<U>::value> * = nullptr>
+    static void OnPutProxy(void *p)
+    {}
 
-  template <typename U, enable_if_t<PoolTraitsHasDestroy<U>::value> * = nullptr>
-  static void OnDestroyProxy(void *p) {
-    PoolTraits<U>::Destroy(static_cast<T *>(p));
-  }
-  template <typename U,
-            enable_if_t<!PoolTraitsHasDestroy<U>::value> * = nullptr>
-  static void OnDestroyProxy(void *p) {
-    delete static_cast<T *>(p);
-  }
+    template<typename U, enable_if_t<PoolTraitsHasOnGet<U>::value> * = nullptr>
+    static void OnGetProxy(void *p)
+    {
+        PoolTraits<U>::OnGet(static_cast<T *>(p));
+    }
 
-  template <typename U, enable_if_t<PoolTraitsHasCreate<U>::value> * = nullptr>
-  static void *OnCreateProxy() {
-    return static_cast<void *>(PoolTraits<U>::Create());
-  }
-  template <typename U, enable_if_t<!PoolTraitsHasCreate<U>::value> * = nullptr>
-  static void *OnCreateProxy() {
-    return new U();
-  }
+    template<typename U, enable_if_t<!PoolTraitsHasOnGet<U>::value> * = nullptr>
+    static void OnGetProxy(void *p)
+    {}
 
-  static void OnPut(void *p) { OnPutProxy<T>(p); }
-  static void OnGet(void *p) { OnGetProxy<T>(p); }
-  static void *Create() { return OnCreateProxy<T>(); }
-  static void Destroy(void *p) { OnDestroyProxy<T>(p); }
+    template<typename U, enable_if_t<PoolTraitsHasDestroy<U>::value> * = nullptr>
+    static void OnDestroyProxy(void *p)
+    {
+        PoolTraits<U>::Destroy(static_cast<T *>(p));
+    }
+
+    template<typename U, enable_if_t<!PoolTraitsHasDestroy<U>::value> * = nullptr>
+    static void OnDestroyProxy(void *p)
+    {
+        delete static_cast<T *>(p);
+    }
+
+    template<typename U, enable_if_t<PoolTraitsHasCreate<U>::value> * = nullptr>
+    static void *OnCreateProxy()
+    {
+        return static_cast<void *>(PoolTraits<U>::Create());
+    }
+
+    template<typename U, enable_if_t<!PoolTraitsHasCreate<U>::value> * = nullptr>
+    static void *OnCreateProxy()
+    {
+        return new U();
+    }
+
+    static void OnPut(void *p) { OnPutProxy<T>(p); }
+
+    static void OnGet(void *p) { OnGetProxy<T>(p); }
+
+    static void *Create() { return OnCreateProxy<T>(); }
+
+    static void Destroy(void *p) { OnDestroyProxy<T>(p); }
 };
 
-template <typename T> void OnPutHook(void *p) {
-  PoolTraitsInvokeHook<T>::OnPut(p);
-  // if (PoolTraitsHasOnPut<T>::value) {
-  //   PoolTraits<T>::OnPut(static_cast<T *>(p));
-  // }
-}
-template <typename T> void OnGetHook(void *p) {
-  PoolTraitsInvokeHook<T>::OnGet(p);
-  // if (PoolTraitsHasOnGet<T>::value) {
-  //   PoolTraits<T>::OnGet(static_cast<T *>(p));
-  // }
+template<typename T>
+void
+OnPutHook(void *p)
+{
+    PoolTraitsInvokeHook<T>::OnPut(p);
+    // if (PoolTraitsHasOnPut<T>::value) {
+    //   PoolTraits<T>::OnPut(static_cast<T *>(p));
+    // }
 }
 
-template <typename T> void *CreateObject() {
-  return PoolTraitsInvokeHook<T>::Create();
-  // if (PoolTraitsHasCreate<T>::value) {
-  //   return PoolTraits<T>::Create();
-  // } else {
-  //   return new T();
-  // }
+template<typename T>
+void
+OnGetHook(void *p)
+{
+    PoolTraitsInvokeHook<T>::OnGet(p);
+    // if (PoolTraitsHasOnGet<T>::value) {
+    //   PoolTraits<T>::OnGet(static_cast<T *>(p));
+    // }
 }
 
-template <typename T> void DestroyObject(void *ptr) {
-  PoolTraitsInvokeHook<T>::Destroy(ptr);
-  // auto p = static_cast<T *>(ptr);
-  // if (PoolTraitsHasDestroy<T>::value) {
-  //   PoolTraits<T>::Destroy(p);
-  // } else {
-  //   delete p;
-  // }
+template<typename T>
+void *
+CreateObject()
+{
+    return PoolTraitsInvokeHook<T>::Create();
+    // if (PoolTraitsHasCreate<T>::value) {
+    //   return PoolTraits<T>::Create();
+    // } else {
+    //   return new T();
+    // }
 }
 
-template <typename T> const TypeDescriptor *GetTypeDesc() {
-  static const TypeDescriptor desc = {.type = GetTypeIndex<T>(),
-                                      .create = CreateObject<T>,
-                                      .destroy = DestroyObject<T>};
-  return &desc;
+template<typename T>
+void
+DestroyObject(void *ptr)
+{
+    PoolTraitsInvokeHook<T>::Destroy(ptr);
+    // auto p = static_cast<T *>(ptr);
+    // if (PoolTraitsHasDestroy<T>::value) {
+    //   PoolTraits<T>::Destroy(p);
+    // } else {
+    //   delete p;
+    // }
+}
+
+template<typename T>
+const TypeDescriptor *
+GetTypeDesc()
+{
+    static const TypeDescriptor desc = {.type    = GetTypeIndex<T>(),
+                                        .create  = CreateObject<T>,
+                                        .destroy = DestroyObject<T>};
+    return &desc;
 }
 
 class FixedVector {
 public:
-  FixedVector() = default;
-  explicit FixedVector(void (*deleter)(void *), std::size_t size)
-      : deleter_(deleter),
-        // objects_(std::unique_ptr<void *[]>(new void *[size])),
-        objects_(make_unique<void *[]>(size)), current_(objects_.get()),
-        end_(objects_.get() + size) {
-    TILE_CHECK(deleter_);
-    TILE_CHECK(size >= 0);
-  }
+    FixedVector() = default;
 
-  ~FixedVector() {
-    while (!empty()) {
-      deleter_(pop_back());
+    explicit FixedVector(void (*deleter)(void *), std::size_t size)
+        : deleter_(deleter),
+          // objects_(std::unique_ptr<void *[]>(new void *[size])),
+          objects_(make_unique<void *[]>(size)),
+          current_(objects_.get()),
+          end_(objects_.get() + size)
+    {
+        TILE_CHECK(deleter_);
+        TILE_CHECK(size >= 0);
     }
-  }
 
-  bool empty() const noexcept { return current_ == objects_.get(); }
-  std::size_t size() const noexcept { return current_ - objects_.get(); }
-  bool full() const noexcept { return current_ == end_; }
-  void emplace_back(void *ptr) noexcept {
-    TILE_DCHECK_LT(current_, end_);
-    TILE_DCHECK_GE(current_, objects_.get());
-    *current_++ = ptr;
-  }
-  void *pop_back() noexcept {
-    TILE_DCHECK_LE(current_, end_);
-    TILE_DCHECK_GE(current_, objects_.get());
-    return *--current_;
-  }
-  void refill_from(void **from, std::size_t count) {
-    TILE_DCHECK(empty());
-    TILE_DCHECK_LE(count, end_ - objects_.get());
-    memcpy(objects_.get(), from, count * sizeof(void *));
-    current_ = objects_.get() + count;
-  }
-  void **move_out(std::size_t count) {
-    TILE_DCHECK_LE(count, size());
-    current_ -= count;
-    return current_;
-  }
+    ~FixedVector()
+    {
+        while (!empty()) { deleter_(pop_back()); }
+    }
+
+    bool empty() const noexcept { return current_ == objects_.get(); }
+
+    std::size_t size() const noexcept { return current_ - objects_.get(); }
+
+    bool full() const noexcept { return current_ == end_; }
+
+    void emplace_back(void *ptr) noexcept
+    {
+        TILE_DCHECK_LT(current_, end_);
+        TILE_DCHECK_GE(current_, objects_.get());
+        *current_++ = ptr;
+    }
+
+    void *pop_back() noexcept
+    {
+        TILE_DCHECK_LE(current_, end_);
+        TILE_DCHECK_GE(current_, objects_.get());
+        return *--current_;
+    }
+
+    void refill_from(void **from, std::size_t count)
+    {
+        TILE_DCHECK(empty());
+        TILE_DCHECK_LE(count, end_ - objects_.get());
+        memcpy(objects_.get(), from, count * sizeof(void *));
+        current_ = objects_.get() + count;
+    }
+
+    void **move_out(std::size_t count)
+    {
+        TILE_DCHECK_LE(count, size());
+        current_ -= count;
+        return current_;
+    }
 
 private:
-  void (*deleter_)(void *);
-  std::unique_ptr<void *[]> objects_;
-  void **current_;
-  void **end_;
+    void (*deleter_)(void *);
+    std::unique_ptr<void *[]> objects_;
+    void **current_;
+    void **end_;
 };
 
-} // namespace detail
+}// namespace detail
 
-} // namespace object_pool
+}// namespace object_pool
 
-} // namespace tile
+}// namespace tile
 
-#endif // TILE_BASE_OBJECT_POOL_TYPES_H
+#endif// TILE_BASE_OBJECT_POOL_TYPES_H
diff --git a/tile/base/object_pool/types_test.cc b/tile/base/object_pool/types_test.cc
index 36581f8..1541f85 100644
--- a/tile/base/object_pool/types_test.cc
+++ b/tile/base/object_pool/types_test.cc
@@ -4,99 +4,117 @@
 
 namespace tile {
 struct HasObject {};
+
 struct NoObject {};
 
-template <> struct PoolTraits<HasObject> {
-  static void *Create() {
-    last_create_ptr = new HasObject();
-    return last_create_ptr;
-  }
-  static void Destroy(void *p) {
-    last_destroy_ptr = p;
-    delete static_cast<HasObject *>(p);
-  }
-  static void OnGet(void *p) { last_get_ptr = p; }
-  static void OnPut(void *p) { last_put_ptr = p; }
+template<>
+struct PoolTraits<HasObject> {
+    static void *Create()
+    {
+        last_create_ptr = new HasObject();
+        return last_create_ptr;
+    }
 
-  static void *last_create_ptr;
-  static void *last_destroy_ptr;
-  static void *last_get_ptr;
-  static void *last_put_ptr;
+    static void Destroy(void *p)
+    {
+        last_destroy_ptr = p;
+        delete static_cast<HasObject *>(p);
+    }
+
+    static void OnGet(void *p) { last_get_ptr = p; }
+
+    static void OnPut(void *p) { last_put_ptr = p; }
+
+    static void *last_create_ptr;
+    static void *last_destroy_ptr;
+    static void *last_get_ptr;
+    static void *last_put_ptr;
 };
 
-void *PoolTraits<HasObject>::last_create_ptr = nullptr;
-void *PoolTraits<HasObject>::last_get_ptr = nullptr;
-void *PoolTraits<HasObject>::last_put_ptr = nullptr;
+void *PoolTraits<HasObject>::last_create_ptr  = nullptr;
+void *PoolTraits<HasObject>::last_get_ptr     = nullptr;
+void *PoolTraits<HasObject>::last_put_ptr     = nullptr;
 void *PoolTraits<HasObject>::last_destroy_ptr = nullptr;
 
 namespace object_pool {
 namespace detail {
 
-TEST(PoolTraitsHas, All) {
-  ASSERT_TRUE(PoolTraitsHasCreate<HasObject>::value);
-  ASSERT_TRUE(PoolTraitsHasDestroy<HasObject>::value);
-  ASSERT_TRUE(PoolTraitsHasOnGet<HasObject>::value);
-  ASSERT_TRUE(PoolTraitsHasOnPut<HasObject>::value);
+TEST(PoolTraitsHas, All)
+{
+    ASSERT_TRUE(PoolTraitsHasCreate<HasObject>::value);
+    ASSERT_TRUE(PoolTraitsHasDestroy<HasObject>::value);
+    ASSERT_TRUE(PoolTraitsHasOnGet<HasObject>::value);
+    ASSERT_TRUE(PoolTraitsHasOnPut<HasObject>::value);
 
-  ASSERT_FALSE(PoolTraitsHasCreate<NoObject>::value);
-  ASSERT_FALSE(PoolTraitsHasDestroy<NoObject>::value);
-  ASSERT_FALSE(PoolTraitsHasOnGet<NoObject>::value);
-  ASSERT_FALSE(PoolTraitsHasOnPut<NoObject>::value);
+    ASSERT_FALSE(PoolTraitsHasCreate<NoObject>::value);
+    ASSERT_FALSE(PoolTraitsHasDestroy<NoObject>::value);
+    ASSERT_FALSE(PoolTraitsHasOnGet<NoObject>::value);
+    ASSERT_FALSE(PoolTraitsHasOnPut<NoObject>::value);
 }
 
-TEST(PoolTraitsInvikeHook, HasPoolTraits) {
-  void *obj = CreateObject<HasObject>();
-  ASSERT_EQ(obj, PoolTraits<HasObject>::last_create_ptr);
-  OnGetHook<HasObject>(obj);
-  ASSERT_EQ(obj, PoolTraits<HasObject>::last_get_ptr);
-  OnPutHook<HasObject>(obj);
-  ASSERT_EQ(obj, PoolTraits<HasObject>::last_put_ptr);
-  DestroyObject<HasObject>(obj);
-  ASSERT_EQ(obj, PoolTraits<HasObject>::last_destroy_ptr);
+TEST(PoolTraitsInvikeHook, HasPoolTraits)
+{
+    void *obj = CreateObject<HasObject>();
+    ASSERT_EQ(obj, PoolTraits<HasObject>::last_create_ptr);
+    OnGetHook<HasObject>(obj);
+    ASSERT_EQ(obj, PoolTraits<HasObject>::last_get_ptr);
+    OnPutHook<HasObject>(obj);
+    ASSERT_EQ(obj, PoolTraits<HasObject>::last_put_ptr);
+    DestroyObject<HasObject>(obj);
+    ASSERT_EQ(obj, PoolTraits<HasObject>::last_destroy_ptr);
 }
-TEST(PoolTraitsInvikeHook, NoPoolTraits) {
-  void *obj = CreateObject<NoObject>();
-  ASSERT_NE(obj, nullptr);
-  OnGetHook<NoObject>(obj);
-  OnPutHook<NoObject>(obj);
-  DestroyObject<NoObject>(obj);
+
+TEST(PoolTraitsInvikeHook, NoPoolTraits)
+{
+    void *obj = CreateObject<NoObject>();
+    ASSERT_NE(obj, nullptr);
+    OnGetHook<NoObject>(obj);
+    OnPutHook<NoObject>(obj);
+    DestroyObject<NoObject>(obj);
 }
-TEST(PoolTraits, CreateAndDestroy) {
-  int active = 0;
-  struct NoObjectTest {
-    NoObjectTest() {}
-    ~NoObjectTest() { --*val; }
-    void SetValAndAdd(int *val) {
-      this->val = val;
-      ++*val;
+
+TEST(PoolTraits, CreateAndDestroy)
+{
+    int active = 0;
+
+    struct NoObjectTest {
+        NoObjectTest() {}
+
+        ~NoObjectTest() { --*val; }
+
+        void SetValAndAdd(int *val)
+        {
+            this->val = val;
+            ++*val;
+        }
+
+        int *val;
+    };
+
+    std::vector<void *> ptrs;
+    for (int i = 0; i < 100; ++i) {
+        ASSERT_EQ(active, i);
+        ptrs.push_back(CreateObject<NoObjectTest>());
+        static_cast<NoObjectTest *>(ptrs.back())->SetValAndAdd(&active);
+        ASSERT_EQ(active, i + 1);
     }
 
-    int *val;
-  };
-
-  std::vector<void *> ptrs;
-  for (int i = 0; i < 100; ++i) {
-    ASSERT_EQ(active, i);
-    ptrs.push_back(CreateObject<NoObjectTest>());
-    static_cast<NoObjectTest *>(ptrs.back())->SetValAndAdd(&active);
-    ASSERT_EQ(active, i + 1);
-  }
-
-  while (!ptrs.empty()) {
-    ASSERT_EQ(active, ptrs.size());
-    DestroyObject<NoObjectTest>(ptrs.back());
-    ptrs.pop_back();
-    ASSERT_EQ(active, ptrs.size());
-  }
+    while (!ptrs.empty()) {
+        ASSERT_EQ(active, ptrs.size());
+        DestroyObject<NoObjectTest>(ptrs.back());
+        ptrs.pop_back();
+        ASSERT_EQ(active, ptrs.size());
+    }
 }
 
-TEST(TypeDescriptor, GetTypeDesc) {
-  const TypeDescriptor *desc = GetTypeDesc<NoObject>();
-  void *obj = desc->create();
-  ASSERT_NE(obj, nullptr);
-  desc->destroy(obj);
+TEST(TypeDescriptor, GetTypeDesc)
+{
+    const TypeDescriptor *desc = GetTypeDesc<NoObject>();
+    void *obj                  = desc->create();
+    ASSERT_NE(obj, nullptr);
+    desc->destroy(obj);
 }
 
-} // namespace detail
-} // namespace object_pool
-} // namespace tile
+}// namespace detail
+}// namespace object_pool
+}// namespace tile
diff --git a/tile/base/option.cc b/tile/base/option.cc
index 817ebad..71d5964 100644
--- a/tile/base/option.cc
+++ b/tile/base/option.cc
@@ -8,16 +8,30 @@ namespace tile {
 
 namespace option {
 
-void InitializeOptions() { option::OptionService::Instance()->ResolveAll(); }
-
-void ShutdownOptions() { option::OptionService::Instance()->Shutdown(); }
-
-void SynchronizeOptions() {
-  option::OptionService::Instance()->UpdateOptions();
+void
+InitializeOptions()
+{
+    option::OptionService::Instance()->ResolveAll();
 }
 
-Json::Value DumpOptions() { return option::OptionService::Instance()->Dump(); }
+void
+ShutdownOptions()
+{
+    option::OptionService::Instance()->Shutdown();
+}
 
-} // namespace option
+void
+SynchronizeOptions()
+{
+    option::OptionService::Instance()->UpdateOptions();
+}
 
-} // namespace tile
+Json::Value
+DumpOptions()
+{
+    return option::OptionService::Instance()->Dump();
+}
+
+}// namespace option
+
+}// namespace tile
diff --git a/tile/base/option.h b/tile/base/option.h
index f313894..d9c661a 100644
--- a/tile/base/option.h
+++ b/tile/base/option.h
@@ -15,16 +15,15 @@
 namespace tile {
 
 struct fixed_option_t {
-  constexpr explicit fixed_option_t() = default;
-};
-struct dynamic_option_t {
-  constexpr explicit dynamic_option_t() = default;
+    constexpr explicit fixed_option_t() = default;
 };
 
-constexpr auto fixed_option =
-    fixed_option_t(); // Option is NOT reloaded after initialization.
-constexpr auto dynamic_option =
-    dynamic_option_t(); // Option is reloaded periodically.
+struct dynamic_option_t {
+    constexpr explicit dynamic_option_t() = default;
+};
+
+constexpr auto fixed_option   = fixed_option_t();  // Option is NOT reloaded after initialization.
+constexpr auto dynamic_option = dynamic_option_t();// Option is reloaded periodically.
 
 // You can use `Option<T>` to import options from external configuration system
 // (with the help of option provider (@sa: `option/option_provider.h`).
@@ -54,42 +53,46 @@ constexpr auto dynamic_option =
 //   }
 // }
 // ```
-template <class T,
-          class Parser = option::detail::IdentityParser<
-              option::detail::remove_optional_t<T>>,
-          class = void>
+template<class T, class Parser = option::detail::IdentityParser<option::detail::remove_optional_t<T>>, class = void>
 class Option : private option::OptionImpl<T, Parser> {
-  // Exactly `T` for primitive types, otherwise it's `const T&`.
-  using value_or_ref = typename option::OptionImpl<T, Parser>::value_or_ref;
+    // Exactly `T` for primitive types, otherwise it's `const T&`.
+    using value_or_ref = typename option::OptionImpl<T, Parser>::value_or_ref;
 
 public:
-  // Fixed options are only resolved once, at start-up time. If you cannot
-  // handle option change well during execution, this overload is what you
-  // should use.
-  Option(fixed_option_t, const std::string &provider, option::MultiKey name,
-         T default_value = T(), std::function<bool(T)> validator = nullptr)
-      : option::OptionImpl<T, Parser>(provider, std::move(name),
-                                      std::move(default_value),
-                                      std::move(validator), true) {}
+    // Fixed options are only resolved once, at start-up time. If you cannot
+    // handle option change well during execution, this overload is what you
+    // should use.
+    Option(fixed_option_t,
+           const std::string &provider,
+           option::MultiKey name,
+           T default_value                  = T(),
+           std::function<bool(T)> validator = nullptr)
+        : option::OptionImpl<T, Parser>(provider, std::move(name), std::move(default_value), std::move(validator), true)
+    {}
 
-  // For dynamic options, they can change at any time (calling `Get()`
-  // concurrently is safe, don't worry), you must be prepared to handle value
-  // change.
-  Option(dynamic_option_t, const std::string &provider, option::MultiKey name,
-         T default_value = T(), std::function<bool(T)> validator = nullptr)
-      : option::OptionImpl<T, Parser>(provider, std::move(name),
-                                      std::move(default_value),
-                                      std::move(validator), false) {}
+    // For dynamic options, they can change at any time (calling `Get()`
+    // concurrently is safe, don't worry), you must be prepared to handle value
+    // change.
+    Option(dynamic_option_t,
+           const std::string &provider,
+           option::MultiKey name,
+           T default_value                  = T(),
+           std::function<bool(T)> validator = nullptr)
+        : option::OptionImpl<T,
+                             Parser>(provider, std::move(name), std::move(default_value), std::move(validator), false)
+    {}
 
-  // If neither `fixed_option` nor `dynamic_option` is given to constructor, by
-  // default a "dynamic" one is constructed.
-  Option(const std::string &provider, option::MultiKey name,
-         T default_value = T(), std::function<bool(T)> validator = nullptr)
-      : Option(dynamic_option, provider, std::move(name),
-               std::move(default_value), std::move(validator)) {}
+    // If neither `fixed_option` nor `dynamic_option` is given to constructor, by
+    // default a "dynamic" one is constructed.
+    Option(const std::string &provider,
+           option::MultiKey name,
+           T default_value                  = T(),
+           std::function<bool(T)> validator = nullptr)
+        : Option(dynamic_option, provider, std::move(name), std::move(default_value), std::move(validator))
+    {}
 
-  using option::OptionImpl<T, Parser>::Get;
-  using option::OptionImpl<T, Parser>::operator value_or_ref;
+    using option::OptionImpl<T, Parser>::Get;
+    using option::OptionImpl<T, Parser>::operator value_or_ref;
 };
 
 // Uses "GFlags" as option provider.
@@ -97,17 +100,16 @@ public:
 // YOU SHOULDN'T BE USING THIS ONE, IT PROVIDES ABSOLUTELY NO BENIFITS OVER
 // USING GFLAGS DIRECTLY. THIS CLASS IS ONLY A PROOF-OF-CONCEPT (mainly for
 // testing purpose, for you and for us.).
-template <class T, class Parser = option::detail::IdentityParser<
-                       option::detail::remove_optional_t<T>>>
+template<class T, class Parser = option::detail::IdentityParser<option::detail::remove_optional_t<T>>>
 class GflagsOptions : public Option<T, Parser> {
 public:
-  // Reading from GFlags should never fail, so no default value is needed.
-  //
-  // `GflagsOptions`s are always dynamic. If you don't want them to change, do
-  // not allow GFlags to change.
-  explicit GflagsOptions(option::Key name)
-      : Option<T, Parser>(dynamic_option, "gflags",
-                          option::MultiKey(std::move(name))) {}
+    // Reading from GFlags should never fail, so no default value is needed.
+    //
+    // `GflagsOptions`s are always dynamic. If you don't want them to change, do
+    // not allow GFlags to change.
+    explicit GflagsOptions(option::Key name)
+        : Option<T, Parser>(dynamic_option, "gflags", option::MultiKey(std::move(name)))
+    {}
 };
 
 namespace option {
@@ -129,7 +131,7 @@ void SynchronizeOptions();
 // Dump all registered options, along with their values.
 Json::Value DumpOptions();
 
-} // namespace option
+}// namespace option
 
 //////////////////////////////////////////////
 // Implementation goes below.               //
@@ -138,37 +140,39 @@ Json::Value DumpOptions();
 // Operator overloaded for easier use.
 //
 // 3-way comparison should simplify the code.
-#define FLARE_OPTION_DEFINE_OPERATOR_OVERLOAD_FOR(op)                          \
-  template <class... Ts, class U>                                              \
-  auto operator op(const Option<Ts...> &x, const U &y)                         \
-      ->decltype(x.Get() op std::declval<U>()) {                               \
-    return x.Get() op y;                                                       \
-  }                                                                            \
-  template <class... Ts, class U>                                              \
-  auto operator op(const U &x, const Option<Ts...> &y)                         \
-      ->decltype(std::declval<U>() op y.Get()) {                               \
-    return x op y.Get();                                                       \
-  }
+#define FLARE_OPTION_DEFINE_OPERATOR_OVERLOAD_FOR(op)                                                                  \
+    template<class... Ts, class U>                                                                                     \
+    auto operator op(const Option<Ts...> &x, const U &y)->decltype(x.Get() op std::declval<U>())                       \
+    {                                                                                                                  \
+        return x.Get() op y;                                                                                           \
+    }                                                                                                                  \
+    template<class... Ts, class U>                                                                                     \
+    auto operator op(const U &x, const Option<Ts...> &y)->decltype(std::declval<U>() op y.Get())                       \
+    {                                                                                                                  \
+        return x op y.Get();                                                                                           \
+    }
 
-FLARE_OPTION_DEFINE_OPERATOR_OVERLOAD_FOR(==) // NOLINT
-FLARE_OPTION_DEFINE_OPERATOR_OVERLOAD_FOR(!=) // NOLINT
-FLARE_OPTION_DEFINE_OPERATOR_OVERLOAD_FOR(<)  // NOLINT
-FLARE_OPTION_DEFINE_OPERATOR_OVERLOAD_FOR(<=) // NOLINT
-FLARE_OPTION_DEFINE_OPERATOR_OVERLOAD_FOR(>)  // NOLINT
-FLARE_OPTION_DEFINE_OPERATOR_OVERLOAD_FOR(>=) // NOLINT
-FLARE_OPTION_DEFINE_OPERATOR_OVERLOAD_FOR(&)  // NOLINT
-FLARE_OPTION_DEFINE_OPERATOR_OVERLOAD_FOR(|)  // NOLINT
-FLARE_OPTION_DEFINE_OPERATOR_OVERLOAD_FOR(&&) // NOLINT
-FLARE_OPTION_DEFINE_OPERATOR_OVERLOAD_FOR(||) // NOLINT
+FLARE_OPTION_DEFINE_OPERATOR_OVERLOAD_FOR(==)// NOLINT
+FLARE_OPTION_DEFINE_OPERATOR_OVERLOAD_FOR(!=)// NOLINT
+FLARE_OPTION_DEFINE_OPERATOR_OVERLOAD_FOR(<) // NOLINT
+FLARE_OPTION_DEFINE_OPERATOR_OVERLOAD_FOR(<=)// NOLINT
+FLARE_OPTION_DEFINE_OPERATOR_OVERLOAD_FOR(>) // NOLINT
+FLARE_OPTION_DEFINE_OPERATOR_OVERLOAD_FOR(>=)// NOLINT
+FLARE_OPTION_DEFINE_OPERATOR_OVERLOAD_FOR(&) // NOLINT
+FLARE_OPTION_DEFINE_OPERATOR_OVERLOAD_FOR(|) // NOLINT
+FLARE_OPTION_DEFINE_OPERATOR_OVERLOAD_FOR(&&)// NOLINT
+FLARE_OPTION_DEFINE_OPERATOR_OVERLOAD_FOR(||)// NOLINT
 
 #undef FLARE_OPTION_DEFINE_OPERATOR_OVERLOAD_FOR
 
 // Support for iostream.
-template <class... Ts>
-std::ostream &operator<<(std::ostream &os, const Option<Ts...> &opt) {
-  return os << opt.Get();
+template<class... Ts>
+std::ostream &
+operator<<(std::ostream &os, const Option<Ts...> &opt)
+{
+    return os << opt.Get();
 }
 
-} // namespace tile
+}// namespace tile
 
-#endif // TILE_BASE_OPTION_H
+#endif// TILE_BASE_OPTION_H
diff --git a/tile/base/option/dynamically_changed.h b/tile/base/option/dynamically_changed.h
index 6488862..22580af 100644
--- a/tile/base/option/dynamically_changed.h
+++ b/tile/base/option/dynamically_changed.h
@@ -10,26 +10,30 @@
 namespace tile {
 namespace option {
 namespace detail {
-template <typename T> class DynamicallyChanged {
+template<typename T>
+class DynamicallyChanged {
 public:
-  explicit DynamicallyChanged(T default_value = {})
-      : value_(std::move(default_value)) {}
-  const T &Get() const noexcept {
-    ScopedLock _(m);
-    return value_;
-  }
+    explicit DynamicallyChanged(T default_value = {}) : value_(std::move(default_value)) {}
 
-  template <typename... Us> void Emplace(Us &&...us) {
-    ScopedLock _(m);
-    value_ = T(std::forward<Us>(us)...);
-  }
+    const T &Get() const noexcept
+    {
+        ScopedLock _(m);
+        return value_;
+    }
+
+    template<typename... Us>
+    void Emplace(Us &&...us)
+    {
+        ScopedLock _(m);
+        value_ = T(std::forward<Us>(us)...);
+    }
 
 private:
-  T value_;
-  mutable Mutex m;
+    T value_;
+    mutable Mutex m;
 };
-} // namespace detail
-} // namespace option
-} // namespace tile
+}// namespace detail
+}// namespace option
+}// namespace tile
 
-#endif // TILE_BASE_OPTION_DYNAMICALLY_CHANGED_H
+#endif// TILE_BASE_OPTION_DYNAMICALLY_CHANGED_H
diff --git a/tile/base/option/gflags_provider.cc b/tile/base/option/gflags_provider.cc
index 8c9f87a..b9f9aef 100644
--- a/tile/base/option/gflags_provider.cc
+++ b/tile/base/option/gflags_provider.cc
@@ -11,46 +11,44 @@ namespace tile {
 namespace option {
 class GFLagsProvider : public OptionPassiveProvider {
 public:
-  GFLagsProvider() { TILE_LOG_INFO("Initializing GFlagsProvider."); }
-  bool GetAll(const std::vector<const option::MultiKey *> &names) override {
-    return true;
-  }
-#define DEFINE_GFLAGS_PROVIDER_IMPL_FOR(Type, TypeName, GFlagTypeName)         \
-  Status Get##TypeName(const option::MultiKey &name,                           \
-                       std::optional<Type> *value) override {                  \
-    auto &&info =                                                              \
-        gflags::GetCommandLineFlagInfoOrDie(name.ToString().c_str());          \
-    auto val_opt = TryParse<Type>(info.current_value);                         \
-    TILE_CHECK(val_opt, "Failed to read flag [{}] of type [{}].",              \
-               name.ToString(), #Type);                                        \
-    TILE_CHECK_EQ(info.type, GFlagTypeName, "Type mismatch on flag [{}].",     \
-                  name.ToString());                                            \
-    *value = *val_opt;                                                         \
-    return Status(0);                                                          \
-  }
+    GFLagsProvider() { TILE_LOG_INFO("Initializing GFlagsProvider."); }
 
-  DEFINE_GFLAGS_PROVIDER_IMPL_FOR(bool, Bool, "bool")
-  DEFINE_GFLAGS_PROVIDER_IMPL_FOR(std::int32_t, Int32, "int32");
-  DEFINE_GFLAGS_PROVIDER_IMPL_FOR(std::int64_t, Int64, "int64");
-  DEFINE_GFLAGS_PROVIDER_IMPL_FOR(std::uint32_t, UInt32, "uint32")
-  DEFINE_GFLAGS_PROVIDER_IMPL_FOR(std::uint64_t, UInt64, "uint64")
-  DEFINE_GFLAGS_PROVIDER_IMPL_FOR(double, Double, "double");
+    bool GetAll(const std::vector<const option::MultiKey *> &names) override { return true; }
+
+#define DEFINE_GFLAGS_PROVIDER_IMPL_FOR(Type, TypeName, GFlagTypeName)                                                 \
+    Status Get##TypeName(const option::MultiKey &name, std::optional<Type> *value) override                            \
+    {                                                                                                                  \
+        auto &&info  = gflags::GetCommandLineFlagInfoOrDie(name.ToString().c_str());                                   \
+        auto val_opt = TryParse<Type>(info.current_value);                                                             \
+        TILE_CHECK(val_opt, "Failed to read flag [{}] of type [{}].", name.ToString(), #Type);                         \
+        TILE_CHECK_EQ(info.type, GFlagTypeName, "Type mismatch on flag [{}].", name.ToString());                       \
+        *value = *val_opt;                                                                                             \
+        return Status(0);                                                                                              \
+    }
+
+    DEFINE_GFLAGS_PROVIDER_IMPL_FOR(bool, Bool, "bool")
+    DEFINE_GFLAGS_PROVIDER_IMPL_FOR(std::int32_t, Int32, "int32");
+    DEFINE_GFLAGS_PROVIDER_IMPL_FOR(std::int64_t, Int64, "int64");
+    DEFINE_GFLAGS_PROVIDER_IMPL_FOR(std::uint32_t, UInt32, "uint32")
+    DEFINE_GFLAGS_PROVIDER_IMPL_FOR(std::uint64_t, UInt64, "uint64")
+    DEFINE_GFLAGS_PROVIDER_IMPL_FOR(double, Double, "double");
 #undef DEFINE_GFLAGS_PROVIDER_IMPL_FOR
 
-  TILE_OPTION_NOT_SUPPORTED_IMPL_FOR(GFlags, std::int8_t, Int8);
-  TILE_OPTION_NOT_SUPPORTED_IMPL_FOR(GFlags, std::uint8_t, UInt8);
-  TILE_OPTION_NOT_SUPPORTED_IMPL_FOR(GFlags, std::int16_t, Int16);
-  TILE_OPTION_NOT_SUPPORTED_IMPL_FOR(GFlags, std::uint16_t, UInt16);
-  TILE_OPTION_NOT_SUPPORTED_IMPL_FOR(GFlags, float, Float);
+    TILE_OPTION_NOT_SUPPORTED_IMPL_FOR(GFlags, std::int8_t, Int8);
+    TILE_OPTION_NOT_SUPPORTED_IMPL_FOR(GFlags, std::uint8_t, UInt8);
+    TILE_OPTION_NOT_SUPPORTED_IMPL_FOR(GFlags, std::int16_t, Int16);
+    TILE_OPTION_NOT_SUPPORTED_IMPL_FOR(GFlags, std::uint16_t, UInt16);
+    TILE_OPTION_NOT_SUPPORTED_IMPL_FOR(GFlags, float, Float);
 
-  Status GetString(const option::MultiKey &name,
-                   std::optional<std::string> *value) override {
-    auto info = gflags::GetCommandLineFlagInfoOrDie(name.ToString().c_str());
-    TILE_CHECK_EQ(info.type, "string", "Type mismatch on flag [{}].");
-    *value = info.current_value;
-    return Status(0);
-  }
+    Status GetString(const option::MultiKey &name, std::optional<std::string> *value) override
+    {
+        auto info = gflags::GetCommandLineFlagInfoOrDie(name.ToString().c_str());
+        TILE_CHECK_EQ(info.type, "string", "Type mismatch on flag [{}].");
+        *value = info.current_value;
+        return Status(0);
+    }
 };
-} // namespace option
-} // namespace tile
+}// namespace option
+}// namespace tile
+
 TILE_OPTION_REGISTER_OPTION_PROVIDER("gflags", ::tile::option::GFLagsProvider);
diff --git a/tile/base/option/json_parser.cc b/tile/base/option/json_parser.cc
index f921a86..a879b81 100644
--- a/tile/base/option/json_parser.cc
+++ b/tile/base/option/json_parser.cc
@@ -2,17 +2,15 @@
 
 namespace tile {
 namespace option {
-std::optional<Json::Value> JsonParser::TryParse(const std::string &str) {
-  if (str.empty()) {
-    return Json::Value();
-  }
-  Json::Value value;
-  Json::Reader reader;
-  if (reader.parse(str, value) && !value.isNull()) {
-    return value;
-  }
-  return std::nullopt;
+std::optional<Json::Value>
+JsonParser::TryParse(const std::string &str)
+{
+    if (str.empty()) { return Json::Value(); }
+    Json::Value value;
+    Json::Reader reader;
+    if (reader.parse(str, value) && !value.isNull()) { return value; }
+    return std::nullopt;
 }
-} // namespace option
+}// namespace option
 
-} // namespace tile
+}// namespace tile
diff --git a/tile/base/option/json_parser.h b/tile/base/option/json_parser.h
index a85def4..85ada0a 100644
--- a/tile/base/option/json_parser.h
+++ b/tile/base/option/json_parser.h
@@ -12,10 +12,10 @@ namespace tile {
 namespace option {
 
 struct JsonParser {
-  std::optional<Json::Value> TryParse(const std::string &str);
+    std::optional<Json::Value> TryParse(const std::string &str);
 };
 
-} // namespace option
-} // namespace tile
+}// namespace option
+}// namespace tile
 
-#endif // TILE_BASE_OPTION_JSON_PARSER_H
+#endif// TILE_BASE_OPTION_JSON_PARSER_H
diff --git a/tile/base/option/json_parser_test.cc b/tile/base/option/json_parser_test.cc
index 1673193..214bffa 100644
--- a/tile/base/option/json_parser_test.cc
+++ b/tile/base/option/json_parser_test.cc
@@ -4,11 +4,12 @@
 
 namespace tile {
 namespace option {
-TEST(JsonParser, Ok) {
-  auto parsed = JsonParser().TryParse(R"({"key": "value"})");
-  ASSERT_TRUE(parsed);
-  EXPECT_TRUE(parsed->get("key", 1).isString());
-  EXPECT_EQ("value", parsed->get("key", "unknown").asString());
+TEST(JsonParser, Ok)
+{
+    auto parsed = JsonParser().TryParse(R"({"key": "value"})");
+    ASSERT_TRUE(parsed);
+    EXPECT_TRUE(parsed->get("key", 1).isString());
+    EXPECT_EQ("value", parsed->get("key", "unknown").asString());
 }
-} // namespace option
-} // namespace tile
+}// namespace option
+}// namespace tile
diff --git a/tile/base/option/key.cc b/tile/base/option/key.cc
index e53f903..c6ded44 100644
--- a/tile/base/option/key.cc
+++ b/tile/base/option/key.cc
@@ -13,64 +13,79 @@ namespace option {
 namespace {
 std::mutex dynamic_key_store_lock;
 std::unordered_map<std::string, std::string> dynamic_key_store;
-} // namespace
+}// namespace
 
 Key::Key(std::string name) : Key(FixedKey(std::move(name))) {}
 
-std::string Key::Get() const { return impl_->Get(); }
-
-bool Key::Ready() const noexcept { return impl_->Ready(); }
-
-MultiKey::MultiKey(MultiKey &&first, Key &&second)
-    : keys_(std::move(first.keys_)) {
-  keys_.push_back(std::move(second));
+std::string
+Key::Get() const
+{
+    return impl_->Get();
 }
 
-MultiKey::MultiKey(MultiKey &&first, MultiKey &&second)
-    : keys_(std::move(first.keys_)) {
-  for (auto &key : second.keys_) {
-    keys_.push_back(std::move(key));
-  }
+bool
+Key::Ready() const noexcept
+{
+    return impl_->Ready();
+}
+
+MultiKey::MultiKey(MultiKey &&first, Key &&second) : keys_(std::move(first.keys_))
+{
+    keys_.push_back(std::move(second));
+}
+
+MultiKey::MultiKey(MultiKey &&first, MultiKey &&second) : keys_(std::move(first.keys_))
+{
+    for (auto &key : second.keys_) { keys_.push_back(std::move(key)); }
 }
 
 MultiKey::MultiKey(std::string name) : MultiKey(Key(std::move(name))) {}
 
 MultiKey::MultiKey(const char *name) : MultiKey(std::string(name)) {}
 
-const std::vector<Key> &MultiKey::GetKeys() const noexcept { return keys_; }
-
-bool MultiKey::Ready() const noexcept {
-  return std::all_of(keys_.begin(), keys_.end(),
-                     [](const Key &e) { return e.Ready(); });
+const std::vector<Key> &
+MultiKey::GetKeys() const noexcept
+{
+    return keys_;
 }
 
-std::string MultiKey::ToString() const {
-  std::vector<std::string> strs;
-  for (auto &&e : keys_) {
-    strs.push_back(e.Get());
-  }
-  return Join(strs, "/");
+bool
+MultiKey::Ready() const noexcept
+{
+    return std::all_of(keys_.begin(), keys_.end(), [](const Key &e) { return e.Ready(); });
 }
 
-std::string DynamicKey::Get() const {
-  std::lock_guard<std::mutex> _(dynamic_key_store_lock);
-  auto iter = dynamic_key_store.find(name_);
-  if (iter != dynamic_key_store.end()) {
-    return iter->second;
-  }
-  return "(not ready yet.)";
+std::string
+MultiKey::ToString() const
+{
+    std::vector<std::string> strs;
+    for (auto &&e : keys_) { strs.push_back(e.Get()); }
+    return Join(strs, "/");
 }
 
-bool DynamicKey::Ready() const noexcept {
-  std::lock_guard<std::mutex> _(dynamic_key_store_lock);
-  return dynamic_key_store.find(name_) != dynamic_key_store.end();
+std::string
+DynamicKey::Get() const
+{
+    std::lock_guard<std::mutex> _(dynamic_key_store_lock);
+    auto iter = dynamic_key_store.find(name_);
+    if (iter != dynamic_key_store.end()) { return iter->second; }
+    return "(not ready yet.)";
 }
 
-void SetDynamicKey(const std::string &name, std::string value) {
-  // std::scoped_lock _(dynamic_key_store_lock);
-  std::lock_guard<std::mutex> _(dynamic_key_store_lock);
-  dynamic_key_store[name] = value;
+bool
+DynamicKey::Ready() const noexcept
+{
+    std::lock_guard<std::mutex> _(dynamic_key_store_lock);
+    return dynamic_key_store.find(name_) != dynamic_key_store.end();
 }
 
-} // namespace option
-} // namespace tile
+void
+SetDynamicKey(const std::string &name, std::string value)
+{
+    // std::scoped_lock _(dynamic_key_store_lock);
+    std::lock_guard<std::mutex> _(dynamic_key_store_lock);
+    dynamic_key_store[name] = value;
+}
+
+}// namespace option
+}// namespace tile
diff --git a/tile/base/option/key.h b/tile/base/option/key.h
index bb6895a..0070deb 100644
--- a/tile/base/option/key.h
+++ b/tile/base/option/key.h
@@ -18,140 +18,161 @@ class Key;
 
 namespace detail {
 
-template <typename To, typename From, typename... Args>
+template<typename To, typename From, typename... Args>
 struct is_convertible_multi_impl {
-  static constexpr bool value = std::is_convertible<From, To>::value &&
-                                is_convertible_multi_impl<To, Args...>::value;
+    static constexpr bool value = std::is_convertible<From, To>::value && is_convertible_multi_impl<To, Args...>::value;
 };
 
-template <typename To, typename From>
+template<typename To, typename From>
 struct is_convertible_multi_impl<To, From> {
-  static constexpr bool value = std::is_convertible<From, To>::value;
+    static constexpr bool value = std::is_convertible<From, To>::value;
 };
 
-template <typename To, typename... Args> struct is_convertible_multi {
-  static constexpr bool value = is_convertible_multi_impl<To, Args...>::value;
+template<typename To, typename... Args>
+struct is_convertible_multi {
+    static constexpr bool value = is_convertible_multi_impl<To, Args...>::value;
 };
 
-} // namespace detail
+}// namespace detail
 
 class Key {
 public:
-  template <typename T, typename = decltype(std::declval<T>().Get())>
-  Key(T &&impl)
-      : impl_(CreateImpl<typename std::decay<T>::type>(std::forward<T>(impl))) {
-  }
-  Key(std::string name);
-  Key(const char *name) : Key(std::string(name)) {}
+    template<typename T, typename = decltype(std::declval<T>().Get())>
+    Key(T &&impl) : impl_(CreateImpl<typename std::decay<T>::type>(std::forward<T>(impl)))
+    {}
 
-  std::string Get() const;
-  bool Ready() const noexcept;
+    Key(std::string name);
+
+    Key(const char *name) : Key(std::string(name)) {}
+
+    std::string Get() const;
+    bool Ready() const noexcept;
 
 private:
-  class AbstractKey;
-  template <typename T> class KeyImpl;
+    class AbstractKey;
+    template<typename T>
+    class KeyImpl;
 
-  template <typename T, typename U>
-  static std::unique_ptr<AbstractKey> CreateImpl(U &&impl);
+    template<typename T, typename U>
+    static std::unique_ptr<AbstractKey> CreateImpl(U &&impl);
 
-  std::unique_ptr<AbstractKey> impl_;
+    std::unique_ptr<AbstractKey> impl_;
 };
 
 // Multi-part key
 class MultiKey {
 public:
-  template <typename... Args,
-            typename = enable_if_t<
-                detail::is_convertible_multi_impl<Key, Args...>::value>>
-  MultiKey(Args &&...keys);
+    template<typename... Args, typename = enable_if_t<detail::is_convertible_multi_impl<Key, Args...>::value>>
+    MultiKey(Args &&...keys);
 
-  MultiKey(MultiKey &&first, Key &&second);
-  MultiKey(MultiKey &&first, MultiKey &&second);
+    MultiKey(MultiKey &&first, Key &&second);
+    MultiKey(MultiKey &&first, MultiKey &&second);
 
-  MultiKey(std::string name);
-  MultiKey(const char *name);
+    MultiKey(std::string name);
+    MultiKey(const char *name);
 
-  const std::vector<Key> &GetKeys() const noexcept;
-  bool Ready() const noexcept;
-  std::string ToString() const;
+    const std::vector<Key> &GetKeys() const noexcept;
+    bool Ready() const noexcept;
+    std::string ToString() const;
 
 private:
-  std::vector<Key> keys_;
+    std::vector<Key> keys_;
 };
 
 class FixedKey {
 public:
-  explicit FixedKey(std::string s) : str_(std::move(s)) {}
-  std::string Get() const { return str_; }
-  bool Ready() const noexcept { return true; }
+    explicit FixedKey(std::string s) : str_(std::move(s)) {}
+
+    std::string Get() const { return str_; }
+
+    bool Ready() const noexcept { return true; }
 
 private:
-  std::string str_;
+    std::string str_;
 };
 
 class DynamicKey {
 public:
-  explicit DynamicKey(std::string name) : name_(std::move(name)) {}
-  std::string Get() const;
-  bool Ready() const noexcept;
+    explicit DynamicKey(std::string name) : name_(std::move(name)) {}
+
+    std::string Get() const;
+    bool Ready() const noexcept;
 
 private:
-  std::string name_;
+    std::string name_;
 };
 
 class ReferencingKey {
 public:
-  explicit ReferencingKey(const std::string &ref) : ref_(&ref) {}
-  explicit ReferencingKey(std::string &&ref) = delete;
-  std::string Get() const { return *ref_; }
-  bool Ready() const noexcept { return true; }
+    explicit ReferencingKey(const std::string &ref) : ref_(&ref) {}
+
+    explicit ReferencingKey(std::string &&ref) = delete;
+
+    std::string Get() const { return *ref_; }
+
+    bool Ready() const noexcept { return true; }
 
 private:
-  const std::string *ref_;
+    const std::string *ref_;
 };
 
 void SetDynamicKey(const std::string &name, std::string value);
+
 class Key::AbstractKey {
 public:
-  virtual ~AbstractKey() = default;
-  virtual std::string Get() const = 0;
-  virtual bool Ready() const noexcept = 0;
+    virtual ~AbstractKey()              = default;
+    virtual std::string Get() const     = 0;
+    virtual bool Ready() const noexcept = 0;
 };
 
-template <typename T> class Key::KeyImpl : public Key::AbstractKey {
+template<typename T>
+class Key::KeyImpl : public Key::AbstractKey {
 public:
-  template <typename U>
-  explicit KeyImpl(U &&impl) : impl_(std::forward<U>(impl)) {}
+    template<typename U>
+    explicit KeyImpl(U &&impl) : impl_(std::forward<U>(impl))
+    {}
 
-  std::string Get() const override { return impl_.Get(); }
-  bool Ready() const noexcept override { return impl_.Ready(); }
+    std::string Get() const override { return impl_.Get(); }
+
+    bool Ready() const noexcept override { return impl_.Ready(); }
 
 private:
-  T impl_;
+    T impl_;
 };
 
-template <typename T, typename U>
-std::unique_ptr<Key::AbstractKey> Key::CreateImpl(U &&impl) {
-  return make_unique<KeyImpl<T>>(std::forward<U>(impl));
+template<typename T, typename U>
+std::unique_ptr<Key::AbstractKey>
+Key::CreateImpl(U &&impl)
+{
+    return make_unique<KeyImpl<T>>(std::forward<U>(impl));
 }
+
 namespace detail {
-template <typename T> void AppendKeys(std::vector<Key> &keys, T &&key) {
-  keys.emplace_back(std::forward<T>(key));
+template<typename T>
+void
+AppendKeys(std::vector<Key> &keys, T &&key)
+{
+    keys.emplace_back(std::forward<T>(key));
 }
+
 // append keys
-template <typename T, typename... Args>
-void AppendKeys(std::vector<Key> &keys, T &&key, Args &&...args) {
-  keys.emplace_back(std::forward<T>(key));
-  AppendKeys(keys, std::forward<Args>(args)...);
+template<typename T, typename... Args>
+void
+AppendKeys(std::vector<Key> &keys, T &&key, Args &&...args)
+{
+    keys.emplace_back(std::forward<T>(key));
+    AppendKeys(keys, std::forward<Args>(args)...);
 }
 
-} // namespace detail
+}// namespace detail
 
-template <typename... Args, typename> MultiKey::MultiKey(Args &&...keys) {
-  detail::AppendKeys(keys_, std::forward<Args>(keys)...);
+template<typename... Args, typename>
+MultiKey::MultiKey(Args &&...keys)
+{
+    detail::AppendKeys(keys_, std::forward<Args>(keys)...);
 }
 
-} // namespace option
-} // namespace tile
+}// namespace option
+}// namespace tile
 
-#endif // TILE_BASE_OPTION_KEY_H
+#endif// TILE_BASE_OPTION_KEY_H
diff --git a/tile/base/option/key_test.cc b/tile/base/option/key_test.cc
index 3906ea2..3577675 100644
--- a/tile/base/option/key_test.cc
+++ b/tile/base/option/key_test.cc
@@ -5,38 +5,43 @@
 namespace tile {
 namespace option {
 
-TEST(Key, MultiKey) {
-  MultiKey key(DynamicKey("name"), FixedKey("fixed"));
-  SetDynamicKey("name", "dynamic");
+TEST(Key, MultiKey)
+{
+    MultiKey key(DynamicKey("name"), FixedKey("fixed"));
+    SetDynamicKey("name", "dynamic");
 
-  ASSERT_EQ("dynamic", key.GetKeys()[0].Get());
-  ASSERT_EQ("fixed", key.GetKeys()[1].Get());
-  ASSERT_EQ("dynamic/fixed", key.ToString());
+    ASSERT_EQ("dynamic", key.GetKeys()[0].Get());
+    ASSERT_EQ("fixed", key.GetKeys()[1].Get());
+    ASSERT_EQ("dynamic/fixed", key.ToString());
 }
 
-TEST(Key, FromStr) {
-  Key key("asdf");
-  ASSERT_EQ("asdf", key.Get());
+TEST(Key, FromStr)
+{
+    Key key("asdf");
+    ASSERT_EQ("asdf", key.Get());
 }
 
-TEST(Key, FixedKey) {
-  Key key(FixedKey("asdf"));
-  ASSERT_EQ("asdf", key.Get());
+TEST(Key, FixedKey)
+{
+    Key key(FixedKey("asdf"));
+    ASSERT_EQ("asdf", key.Get());
 }
 
-TEST(Key, DynamicKey) {
-  Key key(DynamicKey("key name"));
-  SetDynamicKey("key name", "value");
-  ASSERT_EQ("value", key.Get());
+TEST(Key, DynamicKey)
+{
+    Key key(DynamicKey("key name"));
+    SetDynamicKey("key name", "value");
+    ASSERT_EQ("value", key.Get());
 }
 
 std::string refee;
 
-TEST(Key, ReferencingKey) {
-  refee = "abcd";
-  Key key{ReferencingKey(refee)};
-  ASSERT_EQ("abcd", key.Get());
+TEST(Key, ReferencingKey)
+{
+    refee = "abcd";
+    Key key{ReferencingKey(refee)};
+    ASSERT_EQ("abcd", key.Get());
 }
 
-} // namespace option
-} // namespace tile
+}// namespace option
+}// namespace tile
diff --git a/tile/base/option/option_impl.h b/tile/base/option/option_impl.h
index 6acbd43..ffe7b0d 100644
--- a/tile/base/option/option_impl.h
+++ b/tile/base/option/option_impl.h
@@ -12,90 +12,93 @@
 namespace tile {
 namespace option {
 namespace detail {
-template <typename T> struct IdentityParser {
-  static std::optional<T> TryParse(const T &value) { return value; }
+template<typename T>
+struct IdentityParser {
+    static std::optional<T> TryParse(const T &value) { return value; }
 };
 
-template <typename T> struct remove_optional {
-  using type = T;
+template<typename T>
+struct remove_optional {
+    using type = T;
 };
 
-template <typename T> struct remove_optional<std::optional<T>> {
-  using type = T;
+template<typename T>
+struct remove_optional<std::optional<T>> {
+    using type = T;
 };
 
-template <typename T>
+template<typename T>
 using remove_optional_t = typename remove_optional<T>::type;
-} // namespace detail
+}// namespace detail
 
-template <typename T, typename Parser> class OptionImpl {
+template<typename T, typename Parser>
+class OptionImpl {
 public:
-  using parsed_t =
-      typename decltype(Parser::TryParse(std::declval<T>()))::value_type;
-  using value_or_ref =
-      decltype(std::declval<detail::DynamicallyChanged<parsed_t>>().Get());
+    using parsed_t     = typename decltype(Parser::TryParse(std::declval<T>()))::value_type;
+    using value_or_ref = decltype(std::declval<detail::DynamicallyChanged<parsed_t>>().Get());
 
-  OptionImpl(const std::string &provider, option::MultiKey name,
-             T default_value, std::function<bool(T)> validator, bool fixed)
-      : provider_(provider), name_(std::move(name)),
-        value_(ParseDefaultValue(std::move(default_value))) {
-    option_id_ = option::OptionService::Instance()->RegisterOptionWatcher<T>(
-        provider, &name_, fixed,
-        [=](std::optional<T> value) { return OnChanged(std::move(value)); });
-  }
-  ~OptionImpl() {
-    option::OptionService::Instance()->DeregisterOptionWatcher(option_id_);
-  }
+    OptionImpl(const std::string &provider,
+               option::MultiKey name,
+               T default_value,
+               std::function<bool(T)> validator,
+               bool fixed)
+        : provider_(provider),
+          name_(std::move(name)),
+          value_(ParseDefaultValue(std::move(default_value)))
+    {
+        option_id_ = option::OptionService::Instance()->RegisterOptionWatcher<T>(
+            provider, &name_, fixed, [=](std::optional<T> value) { return OnChanged(std::move(value)); });
+    }
 
-  OptionImpl(OptionImpl &&) = default;
-  OptionImpl &operator=(OptionImpl &&) = default;
+    ~OptionImpl() { option::OptionService::Instance()->DeregisterOptionWatcher(option_id_); }
 
-  value_or_ref Get() const noexcept { return value_.Get(); }
+    OptionImpl(OptionImpl &&)            = default;
+    OptionImpl &operator=(OptionImpl &&) = default;
 
-  operator value_or_ref() const noexcept { return Get(); }
+    value_or_ref Get() const noexcept { return value_.Get(); }
+
+    operator value_or_ref() const noexcept { return Get(); }
 
 private:
-  bool OnChanged(std::optional<T> value) {
-    if (!value) {
-      TILE_LOG_WARNING_EVERY_SECOND(
-          "Key [{}] is not recognized by provider [{}].", name_.ToString(),
-          provider_);
-      return false;
+    bool OnChanged(std::optional<T> value)
+    {
+        if (!value) {
+            TILE_LOG_WARNING_EVERY_SECOND("Key [{}] is not recognized by provider [{}].", name_.ToString(), provider_);
+            return false;
+        }
+
+        if (validator_ && !validator_(*value)) {
+            TILE_LOG_WARNING_EVERY_SECOND("New value [{}] of option [{}] from provider [{}] didn't pass "
+                                          "validatioin. Keep use the old value.",
+                                          *value, name_.ToString(), provider_);
+        }
+
+        auto parsed = Parser{}.TryParse(std::move(*value));
+        if (!parsed) {
+            TILE_LOG_WARNING_EVERY_SECOND("Use-supplied parser failed. Keep using the old value.");
+            return false;
+        }
+
+        value_.Emplace(std::move(*parsed));
+        return true;
     }
 
-    if (validator_ && !validator_(*value)) {
-      TILE_LOG_WARNING_EVERY_SECOND(
-          "New value [{}] of option [{}] from provider [{}] didn't pass "
-          "validatioin. Keep use the old value.",
-          *value, name_.ToString(), provider_);
+    static parsed_t ParseDefaultValue(T &&default_value)
+    {
+        auto parsed = Parser{}.TryParse(std::move(default_value));
+        TILE_CHECK(parsed, "Value parser failed to parse the default value.");
+        return *parsed;
     }
 
-    auto parsed = Parser{}.TryParse(std::move(*value));
-    if (!parsed) {
-      TILE_LOG_WARNING_EVERY_SECOND(
-          "Use-supplied parser failed. Keep using the old value.");
-      return false;
-    }
-
-    value_.Emplace(std::move(*parsed));
-    return true;
-  }
-
-  static parsed_t ParseDefaultValue(T &&default_value) {
-    auto parsed = Parser{}.TryParse(std::move(default_value));
-    TILE_CHECK(parsed, "Value parser failed to parse the default value.");
-    return *parsed;
-  }
-
 private:
-  std::uint64_t option_id_;
-  std::string provider_;
-  MultiKey name_;
-  detail::DynamicallyChanged<parsed_t> value_;
-  std::function<bool(T)> validator_;
+    std::uint64_t option_id_;
+    std::string provider_;
+    MultiKey name_;
+    detail::DynamicallyChanged<parsed_t> value_;
+    std::function<bool(T)> validator_;
 };
 
-} // namespace option
-} // namespace tile
+}// namespace option
+}// namespace tile
 
-#endif // TILE_BASE_OPTION_OPTION_IMPL_H
+#endif// TILE_BASE_OPTION_OPTION_IMPL_H
diff --git a/tile/base/option/option_provider.cc b/tile/base/option/option_provider.cc
index bfc52e7..58e62be 100644
--- a/tile/base/option/option_provider.cc
+++ b/tile/base/option/option_provider.cc
@@ -1,6 +1,5 @@
 #include "tile/base/option/option_provider.h"
 
 namespace tile {
-TILE_DEFINE_OBJECT_DEPENDENCY_REGISTRY(option_passive_provider_registry,
-                                       OptionPassiveProvider);
+TILE_DEFINE_OBJECT_DEPENDENCY_REGISTRY(option_passive_provider_registry, OptionPassiveProvider);
 }
diff --git a/tile/base/option/option_provider.h b/tile/base/option/option_provider.h
index 7942056..b9d1f63 100644
--- a/tile/base/option/option_provider.h
+++ b/tile/base/option/option_provider.h
@@ -11,53 +11,38 @@
 namespace tile {
 class OptionPassiveProvider {
 public:
-  virtual ~OptionPassiveProvider() = default;
+    virtual ~OptionPassiveProvider()                                                            = default;
 
-  virtual bool GetAll(const std::vector<const option::MultiKey *> &names) = 0;
+    virtual bool GetAll(const std::vector<const option::MultiKey *> &names)                     = 0;
 
-  virtual Status GetBool(const option::MultiKey &name,
-                         std::optional<bool> *value) = 0;
-  virtual Status GetInt8(const option::MultiKey &name,
-                         std::optional<std::int8_t> *value) = 0;
-  virtual Status GetUInt8(const option::MultiKey &name,
-                          std::optional<std::uint8_t> *value) = 0;
-  virtual Status GetInt16(const option::MultiKey &name,
-                          std::optional<std::int16_t> *value) = 0;
-  virtual Status GetUInt16(const option::MultiKey &name,
-                           std::optional<std::uint16_t> *value) = 0;
-  virtual Status GetInt32(const option::MultiKey &name,
-                          std::optional<std::int32_t> *value) = 0;
-  virtual Status GetUInt32(const option::MultiKey &name,
-                           std::optional<std::uint32_t> *value) = 0;
-  virtual Status GetInt64(const option::MultiKey &name,
-                          std::optional<std::int64_t> *value) = 0;
-  virtual Status GetUInt64(const option::MultiKey &name,
-                           std::optional<std::uint64_t> *value) = 0;
-  virtual Status GetFloat(const option::MultiKey &name,
-                          std::optional<float> *value) = 0;
-  virtual Status GetDouble(const option::MultiKey &name,
-                           std::optional<double> *value) = 0;
-  virtual Status GetString(const option::MultiKey &name,
-                           std::optional<std::string> *value) = 0;
+    virtual Status GetBool(const option::MultiKey &name, std::optional<bool> *value)            = 0;
+    virtual Status GetInt8(const option::MultiKey &name, std::optional<std::int8_t> *value)     = 0;
+    virtual Status GetUInt8(const option::MultiKey &name, std::optional<std::uint8_t> *value)   = 0;
+    virtual Status GetInt16(const option::MultiKey &name, std::optional<std::int16_t> *value)   = 0;
+    virtual Status GetUInt16(const option::MultiKey &name, std::optional<std::uint16_t> *value) = 0;
+    virtual Status GetInt32(const option::MultiKey &name, std::optional<std::int32_t> *value)   = 0;
+    virtual Status GetUInt32(const option::MultiKey &name, std::optional<std::uint32_t> *value) = 0;
+    virtual Status GetInt64(const option::MultiKey &name, std::optional<std::int64_t> *value)   = 0;
+    virtual Status GetUInt64(const option::MultiKey &name, std::optional<std::uint64_t> *value) = 0;
+    virtual Status GetFloat(const option::MultiKey &name, std::optional<float> *value)          = 0;
+    virtual Status GetDouble(const option::MultiKey &name, std::optional<double> *value)        = 0;
+    virtual Status GetString(const option::MultiKey &name, std::optional<std::string> *value)   = 0;
 
-#define TILE_OPTION_NOT_SUPPORTED_IMPL_FOR(ProviderName, Type, TypeName)       \
-  Status Get##TypeName(const option::MultiKey &name,                           \
-                       std::optional<Type> *value) override {                  \
-    TILE_CHECK(false,                                                          \
-               "Not supported: provider [{}] does not allow type [{}].",       \
-               #ProviderName, #TypeName);                                      \
-    return Status(-1);                                                         \
-  }
+#define TILE_OPTION_NOT_SUPPORTED_IMPL_FOR(ProviderName, Type, TypeName)                                               \
+    Status Get##TypeName(const option::MultiKey &name, std::optional<Type> *value) override                            \
+    {                                                                                                                  \
+        TILE_CHECK(false, "Not supported: provider [{}] does not allow type [{}].", #ProviderName, #TypeName);         \
+        return Status(-1);                                                                                             \
+    }
 
-}; // namespace tile
+};// namespace tile
 
-TILE_DECLARE_OBJECT_DEPENDENCY_REGISTRY(option_passive_provider_registry,
-                                        OptionPassiveProvider);
-#define TILE_OPTION_REGISTER_OPTION_PROVIDER(Name, Implementation)             \
-  TILE_REGISTER_OBJECT_DEPENDENCY(                                             \
-      ::tile::option_passive_provider_registry, Name,                          \
-      [] { return ::tile::make_unique<Implementation>(); })
+TILE_DECLARE_OBJECT_DEPENDENCY_REGISTRY(option_passive_provider_registry, OptionPassiveProvider);
+#define TILE_OPTION_REGISTER_OPTION_PROVIDER(Name, Implementation)                                                     \
+    TILE_REGISTER_OBJECT_DEPENDENCY(::tile::option_passive_provider_registry, Name, [] {                               \
+        return ::tile::make_unique<Implementation>();                                                                  \
+    })
 
-} // namespace tile
+}// namespace tile
 
-#endif // TILE_BASE_OPTION_OPTION_PROVIDER_H
+#endif// TILE_BASE_OPTION_OPTION_PROVIDER_H
diff --git a/tile/base/option/option_service.cc b/tile/base/option/option_service.cc
index 31f3e42..be3619d 100644
--- a/tile/base/option/option_service.cc
+++ b/tile/base/option/option_service.cc
@@ -8,7 +8,8 @@
 
 #include "gflags/gflags.h"
 
-DEFINE_int32(tile_option_update_interval, 10,
+DEFINE_int32(tile_option_update_interval,
+             10,
              "Interval between update values of `Option<T>`, in seconds, "
              "Do NOT set it too low, or you'll overload "
              "the server or your program (or both)");
@@ -17,178 +18,173 @@ namespace tile {
 namespace option {
 
 OptionService::OptionService() {}
+
 OptionService::~OptionService() {}
 
-OptionService *OptionService::Instance() {
-  static NeverDestroyed<OptionService> os;
-  return os.Get();
+OptionService *
+OptionService::Instance()
+{
+    static NeverDestroyed<OptionService> os;
+    return os.Get();
 }
 
-bool OptionService::ResolveAll() {
-  bool all_success = true;
-  std::lock_guard<std::mutex> _(lock_);
-  for (auto &&item : options_) {
-    const auto &provider_name = item.first;
-    auto &options = item.second;
+bool
+OptionService::ResolveAll()
+{
+    bool all_success = true;
+    std::lock_guard<std::mutex> _(lock_);
+    for (auto &&item : options_) {
+        const auto &provider_name = item.first;
+        auto &options             = item.second;
 
-    auto p = options.provider =
-        option_passive_provider_registry.Get(provider_name);
+        auto p = options.provider = option_passive_provider_registry.Get(provider_name);
 
-    std::vector<const option::MultiKey *> keys;
-    for (auto &&e : options.watchers) {
-      if (!e->is_fixed && e->name_ref->Ready()) {
-        keys.push_back(e->name_ref);
-      }
-    }
-
-    if (!options.provider->GetAll(keys)) {
-      TILE_LOG_ERROR("Initial try of reading options from [{}] failed. Failing "
-                     "back to defaults.",
-                     provider_name);
-      all_success = false;
-      continue;
-    }
-
-    for (auto &&e : options.watchers) {
-      if (!internal::Exchange(e->initial_resolution_done, true) &&
-          e->name_ref->Ready()) {
-        auto status = e->read_cb(p);
-        if (!status.ok()) {
-          TILE_LOG_ERROR("Initial try of reading [{}] from [{}] failed, "
-                         "failing back to the defaults: {}",
-                         e->name_ref->ToString(), provider_name,
-                         status.ToString());
-          all_success = false;
+        std::vector<const option::MultiKey *> keys;
+        for (auto &&e : options.watchers) {
+            if (!e->is_fixed && e->name_ref->Ready()) { keys.push_back(e->name_ref); }
         }
-        e->initial_resolution_done = true;
-      }
-    }
-  }
 
-  resolve_all_done_ = true;
-  // update interval
-  TILE_CHECK_EQ(timer_id_, 0, "OptionService has been started.");
-  timer_id_ = internal::TimeKeeper::Instance()->AddTimer(
-      {}, FLAGS_tile_option_update_interval * std::chrono::seconds(1),
-      [this](internal::TimerID) { UpdateOptions(); }, true);
-  return all_success;
+        if (!options.provider->GetAll(keys)) {
+            TILE_LOG_ERROR("Initial try of reading options from [{}] failed. Failing "
+                           "back to defaults.",
+                           provider_name);
+            all_success = false;
+            continue;
+        }
+
+        for (auto &&e : options.watchers) {
+            if (!internal::Exchange(e->initial_resolution_done, true) && e->name_ref->Ready()) {
+                auto status = e->read_cb(p);
+                if (!status.ok()) {
+                    TILE_LOG_ERROR("Initial try of reading [{}] from [{}] failed, "
+                                   "failing back to the defaults: {}",
+                                   e->name_ref->ToString(), provider_name, status.ToString());
+                    all_success = false;
+                }
+                e->initial_resolution_done = true;
+            }
+        }
+    }
+
+    resolve_all_done_ = true;
+    // update interval
+    TILE_CHECK_EQ(timer_id_, 0, "OptionService has been started.");
+    timer_id_ = internal::TimeKeeper::Instance()->AddTimer(
+        {}, FLAGS_tile_option_update_interval * std::chrono::seconds(1), [this](internal::TimerID) { UpdateOptions(); },
+        true);
+    return all_success;
 }
 
-void OptionService::DeregisterOptionWatcher(std::uint64_t id) {
-  std::lock_guard<std::mutex> _(lock_);
-  for (auto &&item : options_) {
-    auto &&k = item.first;
-    auto &&v = item.second;
-    for (auto iter = v.watchers.begin(); iter != v.watchers.end(); ++iter) {
-      if ((*iter)->id == id) {
-        v.watchers.erase(iter);
-        return;
-      }
+void
+OptionService::DeregisterOptionWatcher(std::uint64_t id)
+{
+    std::lock_guard<std::mutex> _(lock_);
+    for (auto &&item : options_) {
+        auto &&k = item.first;
+        auto &&v = item.second;
+        for (auto iter = v.watchers.begin(); iter != v.watchers.end(); ++iter) {
+            if ((*iter)->id == id) {
+                v.watchers.erase(iter);
+                return;
+            }
+        }
     }
-  }
-  TILE_CHECK(0, "Option #{} is not recognized.", id);
+    TILE_CHECK(0, "Option #{} is not recognized.", id);
 }
 
-void OptionService::UpdateOptions() {
-  std::lock_guard<std::mutex> _(lock_);
-  for (auto &&item : options_) {
-    const auto &provider_name = item.first;
-    auto &options = item.second;
+void
+OptionService::UpdateOptions()
+{
+    std::lock_guard<std::mutex> _(lock_);
+    for (auto &&item : options_) {
+        const auto &provider_name = item.first;
+        auto &options             = item.second;
 
-    if (!options.provider) {
-      // run before `ResolveAll()`
-      continue;
+        if (!options.provider) {
+            // run before `ResolveAll()`
+            continue;
+        }
+
+        std::vector<const MultiKey *> keys;
+        for (auto &&e : options.watchers) {
+            if (!e->is_fixed && e->name_ref->Ready()) { keys.push_back(e->name_ref); }
+        }
+
+        if (!options.provider->GetAll(keys)) {
+            TILE_LOG_WARNING_EVERY_SECOND(
+                "Failed to read options from [{}]. Keep using current values.", provider_name);
+            continue;
+        }
+
+        for (auto &&e : options.watchers) {
+            if (e->is_fixed || !e->name_ref->Ready()) { continue; }
+
+            auto status = e->read_cb(options.provider);
+            if (!status.ok()) {
+                TILE_LOG_WARNING_EVERY_SECOND("Failed to read option [{}] from [{}], keep using current "
+                                              "value: {}",
+                                              e->name_ref->ToString(), provider_name, status.ToString());
+            }
+        }
     }
-
-    std::vector<const MultiKey *> keys;
-    for (auto &&e : options.watchers) {
-      if (!e->is_fixed && e->name_ref->Ready()) {
-        keys.push_back(e->name_ref);
-      }
-    }
-
-    if (!options.provider->GetAll(keys)) {
-      TILE_LOG_WARNING_EVERY_SECOND(
-          "Failed to read options from [{}]. Keep using current values.",
-          provider_name);
-      continue;
-    }
-
-    for (auto &&e : options.watchers) {
-      if (e->is_fixed || !e->name_ref->Ready()) {
-        continue;
-      }
-
-      auto status = e->read_cb(options.provider);
-      if (!status.ok()) {
-        TILE_LOG_WARNING_EVERY_SECOND(
-            "Failed to read option [{}] from [{}], keep using current "
-            "value: {}",
-            e->name_ref->ToString(), provider_name, status.ToString());
-      }
-    }
-  }
 }
 
-Json::Value OptionService::Dump() const {
-  Json::Value data;
-  std::lock_guard<std::mutex> _(lock_);
-  for (auto &&item : options_) {
-    auto &&provider_name = item.first;
-    auto &&options = item.second;
+Json::Value
+OptionService::Dump() const
+{
+    Json::Value data;
+    std::lock_guard<std::mutex> _(lock_);
+    for (auto &&item : options_) {
+        auto &&provider_name = item.first;
+        auto &&options       = item.second;
 
-    auto &&opts = data[provider_name];
+        auto &&opts          = data[provider_name];
 
-    for (auto &&e : options.watchers) {
-      if (!e->name_ref->Ready()) {
-        continue;
-      }
+        for (auto &&e : options.watchers) {
+            if (!e->name_ref->Ready()) { continue; }
 
-      auto current_path = &opts;
-      for (auto &&key : e->name_ref->GetKeys()) {
-        current_path = &(*current_path)[key.Get()];
-      }
-      *current_path = e->current_value_as_json;
+            auto current_path = &opts;
+            for (auto &&key : e->name_ref->GetKeys()) { current_path = &(*current_path)[key.Get()]; }
+            *current_path = e->current_value_as_json;
+        }
     }
-  }
 
-  return data;
+    return data;
 }
 
-void OptionService::Shutdown() {
-  TILE_CHECK_NE(timer_id_, 0, "OptionService has not been started.");
-  auto timer_id = internal::Exchange(timer_id_, internal::TimerID(0));
-  internal::TimeKeeper::Instance()->KillTimer(timer_id);
+void
+OptionService::Shutdown()
+{
+    TILE_CHECK_NE(timer_id_, 0, "OptionService has not been started.");
+    auto timer_id = internal::Exchange(timer_id_, internal::TimerID(0));
+    internal::TimeKeeper::Instance()->KillTimer(timer_id);
 }
 
-#define TILE_DETAIL_OPTION_DEFINE_CREATE_WATCHER_FOR(Type, TypeName)           \
-  OptionService::ReadCallback OptionService::CreateReader(                     \
-      const std::string &provider, const MultiKey *name,                       \
-      std::function<bool(std::optional<Type>)> cb,                             \
-      Json::Value *current_value) {                                            \
-    auto last = std::optional<std::optional<Type>>();                          \
-    return [cb, provider, name, current_value,                                 \
-            last](OptionPassiveProvider *p) mutable {                          \
-      std::optional<Type> value;                                               \
-      auto status = p->Get##TypeName(*name, &value);                           \
-      if (status.ok()) {                                                       \
-        if (last && *last == value) {                                          \
-          return Status(0); /* No change. */                                   \
-        }                                                                      \
-        last = value;                                                          \
-        if (cb(value)) {                                                       \
-          if (value) {                                                         \
-            *current_value = ToJson(*value);                                   \
-          } else {                                                             \
-            *current_value = Json::Value();                                    \
-          }                                                                    \
-          return Status(0);                                                    \
-        }                                                                      \
-        return Status(-1);                                                     \
-      }                                                                        \
-      return status;                                                           \
-    };                                                                         \
-  }
+#define TILE_DETAIL_OPTION_DEFINE_CREATE_WATCHER_FOR(Type, TypeName)                                                   \
+    OptionService::ReadCallback OptionService::CreateReader(                                                           \
+        const std::string &provider, const MultiKey *name, std::function<bool(std::optional<Type>)> cb,                \
+        Json::Value *current_value)                                                                                    \
+    {                                                                                                                  \
+        auto last = std::optional<std::optional<Type>>();                                                              \
+        return [cb, provider, name, current_value, last](OptionPassiveProvider *p) mutable {                           \
+            std::optional<Type> value;                                                                                 \
+            auto status = p->Get##TypeName(*name, &value);                                                             \
+            if (status.ok()) {                                                                                         \
+                if (last && *last == value) { return Status(0); /* No change. */ }                                     \
+                last = value;                                                                                          \
+                if (cb(value)) {                                                                                       \
+                    if (value) {                                                                                       \
+                        *current_value = ToJson(*value);                                                               \
+                    } else {                                                                                           \
+                        *current_value = Json::Value();                                                                \
+                    }                                                                                                  \
+                    return Status(0);                                                                                  \
+                }                                                                                                      \
+                return Status(-1);                                                                                     \
+            }                                                                                                          \
+            return status;                                                                                             \
+        };                                                                                                             \
+    }
 
 TILE_DETAIL_OPTION_DEFINE_CREATE_WATCHER_FOR(bool, Bool)
 TILE_DETAIL_OPTION_DEFINE_CREATE_WATCHER_FOR(std::int8_t, Int8)
@@ -205,5 +201,5 @@ TILE_DETAIL_OPTION_DEFINE_CREATE_WATCHER_FOR(std::string, String)
 
 #undef TILE_DETAIL_OPTION_DEFINE_CREATE_WATCHER_FOR
 
-} // namespace option
-} // namespace tile
+}// namespace option
+}// namespace tile
diff --git a/tile/base/option/option_service.h b/tile/base/option/option_service.h
index 6fb0175..aa61e96 100644
--- a/tile/base/option/option_service.h
+++ b/tile/base/option/option_service.h
@@ -20,97 +20,95 @@ namespace tile {
 namespace option {
 class OptionService {
 public:
-  OptionService();
-  ~OptionService();
+    OptionService();
+    ~OptionService();
 
-  static OptionService *Instance();
+    static OptionService *Instance();
 
-  bool ResolveAll();
+    bool ResolveAll();
 
-  template <typename T>
-  std::uint64_t
-  RegisterOptionWatcher(const std::string &provider, const MultiKey *name_ref,
-                        bool is_fixed,
-                        std::function<bool(std::optional<T>)> cb) {
-    auto option_provider_id = ++option_id_;
+    template<typename T>
+    std::uint64_t RegisterOptionWatcher(const std::string &provider,
+                                        const MultiKey *name_ref,
+                                        bool is_fixed,
+                                        std::function<bool(std::optional<T>)> cb)
     {
-      std::lock_guard<std::mutex> _(lock_);
-      auto &&opt = options_[provider];
+        auto option_provider_id = ++option_id_;
+        {
+            std::lock_guard<std::mutex> _(lock_);
+            auto &&opt = options_[provider];
 
-      for (auto &&watcher : opt.watchers) {
-        TILE_LOG_FATAL_IF(watcher->name_ref->ToString() == name_ref->ToString(),
-                          "Option [{}] from [{}] has already been registered.",
-                          name_ref->ToString(), provider);
-      }
+            for (auto &&watcher : opt.watchers) {
+                TILE_LOG_FATAL_IF(watcher->name_ref->ToString() == name_ref->ToString(),
+                                  "Option [{}] from [{}] has already been registered.", name_ref->ToString(), provider);
+            }
 
-      auto watcher = make_unique<WatchedOption>();
-      watcher->id = option_provider_id;
-      watcher->name_ref = name_ref;
-      watcher->is_fixed = is_fixed;
-      watcher->read_cb = CreateReader(provider, name_ref, std::move(cb),
-                                      &watcher->current_value_as_json);
+            auto watcher      = make_unique<WatchedOption>();
+            watcher->id       = option_provider_id;
+            watcher->name_ref = name_ref;
+            watcher->is_fixed = is_fixed;
+            watcher->read_cb  = CreateReader(provider, name_ref, std::move(cb), &watcher->current_value_as_json);
 
-      options_[provider].watchers.push_back(std::move(watcher));
+            options_[provider].watchers.push_back(std::move(watcher));
+        }
+
+        if (resolve_all_done_) { ResolveAll(); }
+
+        return option_provider_id;
     }
 
-    if (resolve_all_done_) {
-      ResolveAll();
-    }
+    void DeregisterOptionWatcher(std::uint64_t id);
 
-    return option_provider_id;
-  }
+    void UpdateOptions();
 
-  void DeregisterOptionWatcher(std::uint64_t id);
+    Json::Value Dump() const;
 
-  void UpdateOptions();
-
-  Json::Value Dump() const;
-
-  void Shutdown();
+    void Shutdown();
 
 private:
-  using ReadCallback = std::function<Status(OptionPassiveProvider *)>;
-  struct WatchedOption {
-    bool initial_resolution_done{false};
-    std::uint64_t id;
-    const MultiKey *name_ref;
-    bool is_fixed;
-    ReadCallback read_cb;
-    Json::Value current_value_as_json;
-  };
-  struct Options {
-    OptionPassiveProvider *provider = nullptr;
-    std::vector<std::unique_ptr<WatchedOption>> watchers;
-  };
+    using ReadCallback = std::function<Status(OptionPassiveProvider *)>;
 
-#define TILE_DETAIL_OPTION_DECLARE_CREATE_WATCHER_FOR(Type)                    \
-  ReadCallback CreateReader(const std::string &provider, const MultiKey *name, \
-                            std::function<bool(std::optional<Type>)> cb,       \
-                            Json::Value *current_value);
+    struct WatchedOption {
+        bool initial_resolution_done{false};
+        std::uint64_t id;
+        const MultiKey *name_ref;
+        bool is_fixed;
+        ReadCallback read_cb;
+        Json::Value current_value_as_json;
+    };
 
-  TILE_DETAIL_OPTION_DECLARE_CREATE_WATCHER_FOR(bool)
-  TILE_DETAIL_OPTION_DECLARE_CREATE_WATCHER_FOR(std::int8_t)
-  TILE_DETAIL_OPTION_DECLARE_CREATE_WATCHER_FOR(std::uint8_t)
-  TILE_DETAIL_OPTION_DECLARE_CREATE_WATCHER_FOR(std::int16_t)
-  TILE_DETAIL_OPTION_DECLARE_CREATE_WATCHER_FOR(std::uint16_t)
-  TILE_DETAIL_OPTION_DECLARE_CREATE_WATCHER_FOR(std::int32_t)
-  TILE_DETAIL_OPTION_DECLARE_CREATE_WATCHER_FOR(std::uint32_t)
-  TILE_DETAIL_OPTION_DECLARE_CREATE_WATCHER_FOR(std::int64_t)
-  TILE_DETAIL_OPTION_DECLARE_CREATE_WATCHER_FOR(std::uint64_t)
-  TILE_DETAIL_OPTION_DECLARE_CREATE_WATCHER_FOR(float)
-  TILE_DETAIL_OPTION_DECLARE_CREATE_WATCHER_FOR(double)
-  TILE_DETAIL_OPTION_DECLARE_CREATE_WATCHER_FOR(std::string)
+    struct Options {
+        OptionPassiveProvider *provider = nullptr;
+        std::vector<std::unique_ptr<WatchedOption>> watchers;
+    };
+
+#define TILE_DETAIL_OPTION_DECLARE_CREATE_WATCHER_FOR(Type)                                                            \
+    ReadCallback CreateReader(const std::string &provider, const MultiKey *name,                                       \
+                              std::function<bool(std::optional<Type>)> cb, Json::Value *current_value);
+
+    TILE_DETAIL_OPTION_DECLARE_CREATE_WATCHER_FOR(bool)
+    TILE_DETAIL_OPTION_DECLARE_CREATE_WATCHER_FOR(std::int8_t)
+    TILE_DETAIL_OPTION_DECLARE_CREATE_WATCHER_FOR(std::uint8_t)
+    TILE_DETAIL_OPTION_DECLARE_CREATE_WATCHER_FOR(std::int16_t)
+    TILE_DETAIL_OPTION_DECLARE_CREATE_WATCHER_FOR(std::uint16_t)
+    TILE_DETAIL_OPTION_DECLARE_CREATE_WATCHER_FOR(std::int32_t)
+    TILE_DETAIL_OPTION_DECLARE_CREATE_WATCHER_FOR(std::uint32_t)
+    TILE_DETAIL_OPTION_DECLARE_CREATE_WATCHER_FOR(std::int64_t)
+    TILE_DETAIL_OPTION_DECLARE_CREATE_WATCHER_FOR(std::uint64_t)
+    TILE_DETAIL_OPTION_DECLARE_CREATE_WATCHER_FOR(float)
+    TILE_DETAIL_OPTION_DECLARE_CREATE_WATCHER_FOR(double)
+    TILE_DETAIL_OPTION_DECLARE_CREATE_WATCHER_FOR(std::string)
 
 #undef TILE_DETAIL_OPTION_DECLARE_CREATE_WATCHER_FOR
 
 private:
-  std::uint64_t timer_id_{};
-  std::atomic<bool> resolve_all_done_{false};
-  std::atomic<std::uint64_t> option_id_{};
-  mutable std::mutex lock_;
-  std::unordered_map<std::string, Options> options_;
+    std::uint64_t timer_id_{};
+    std::atomic<bool> resolve_all_done_{false};
+    std::atomic<std::uint64_t> option_id_{};
+    mutable std::mutex lock_;
+    std::unordered_map<std::string, Options> options_;
 };
-} // namespace option
-} // namespace tile
+}// namespace option
+}// namespace tile
 
-#endif // TILE_BASE_OPTION_OPTION_SERVICE_H
+#endif// TILE_BASE_OPTION_OPTION_SERVICE_H
diff --git a/tile/base/option/option_service_test.cc b/tile/base/option/option_service_test.cc
index 0281ae8..c26699f 100644
--- a/tile/base/option/option_service_test.cc
+++ b/tile/base/option/option_service_test.cc
@@ -16,19 +16,20 @@ GflagsOptions<int> opt_int("int_test");
 GflagsOptions<std::int64_t> opt_int64("int64_test");
 GflagsOptions<std::string> opt_str("string_test");
 
-TEST(OptionService, Dump) {
-  auto options = OptionService::Instance()->Dump();
+TEST(OptionService, Dump)
+{
+    auto options = OptionService::Instance()->Dump();
 
-  ASSERT_EQ(3, options["gflags"].size());
-  ASSERT_EQ(1, options["gflags"]["int_test"].asInt());
-  ASSERT_EQ(2, options["gflags"]["int64_test"].asInt64());
-  ASSERT_EQ("abc", options["gflags"]["string_test"].asString());
+    ASSERT_EQ(3, options["gflags"].size());
+    ASSERT_EQ(1, options["gflags"]["int_test"].asInt());
+    ASSERT_EQ(2, options["gflags"]["int64_test"].asInt64());
+    ASSERT_EQ("abc", options["gflags"]["string_test"].asString());
 
-  FLAGS_int64_test = 5;
-  SynchronizeOptions();
-  options = OptionService::Instance()->Dump();
-  ASSERT_EQ(5, options["gflags"]["int64_test"].asInt64());
+    FLAGS_int64_test = 5;
+    SynchronizeOptions();
+    options = OptionService::Instance()->Dump();
+    ASSERT_EQ(5, options["gflags"]["int64_test"].asInt64());
 }
 
-} // namespace option
-} // namespace tile
+}// namespace option
+}// namespace tile
diff --git a/tile/base/optional.h b/tile/base/optional.h
index fc52a4f..f1f20d4 100644
--- a/tile/base/optional.h
+++ b/tile/base/optional.h
@@ -6,9 +6,10 @@
 #include <optional>
 #else
 #include "tile/base/internal/optional.h"
+
 namespace std {
 using namespace tl;
 }
 #endif
 
-#endif // TILE_BASE_OPTIONAL_H
+#endif// TILE_BASE_OPTIONAL_H
diff --git a/tile/base/random.h b/tile/base/random.h
index cfca32b..08a6158 100644
--- a/tile/base/random.h
+++ b/tile/base/random.h
@@ -8,37 +8,46 @@
 
 namespace tile {
 namespace random {
-inline std::mt19937_64 &Engine() {
-  thread_local auto engine = [] {
-    std::random_device r;
-    std::seed_seq seeds{r(), r(), r(), r(), r(), r(), r(), r()};
+inline std::mt19937_64 &
+Engine()
+{
+    thread_local auto engine = [] {
+        std::random_device r;
+        std::seed_seq seeds{r(), r(), r(), r(), r(), r(), r(), r()};
+
+        std::mt19937_64 engine(seeds);
+        return engine;
+    }();
 
-    std::mt19937_64 engine(seeds);
     return engine;
-  }();
-
-  return engine;
 }
-} // namespace random
+}// namespace random
 
-template <typename T = std::uint64_t,
-          typename = typename std::enable_if<std::is_integral<T>::value>::type>
-T Random() {
-  return random::Engine()();
+template<typename T = std::uint64_t, typename = typename std::enable_if<std::is_integral<T>::value>::type>
+T
+Random()
+{
+    return random::Engine()();
 }
 
-template <typename T> T Random(T min, T max) {
-  using Distribution =
-      typename std::conditional<std::is_floating_point<T>::value,
-                                std::uniform_real_distribution<T>,
-                                std::uniform_int_distribution<T>>::type;
+template<typename T>
+T
+Random(T min, T max)
+{
+    using Distribution = typename std::conditional<std::is_floating_point<T>::value, std::uniform_real_distribution<T>,
+                                                   std::uniform_int_distribution<T>>::type;
 
-  Distribution dist(min, max);
-  return dist(random::Engine());
+    Distribution dist(min, max);
+    return dist(random::Engine());
 }
 
-template <typename T> T Random(T max) { return Random<T>(T(0), max); }
+template<typename T>
+T
+Random(T max)
+{
+    return Random<T>(T(0), max);
+}
 
-} // namespace tile
+}// namespace tile
 
-#endif // _TILE_BASE_RANDOM_H
+#endif// _TILE_BASE_RANDOM_H
diff --git a/tile/base/ref_ptr.h b/tile/base/ref_ptr.h
index 35f000b..611f7f6 100644
--- a/tile/base/ref_ptr.h
+++ b/tile/base/ref_ptr.h
@@ -38,89 +38,92 @@ namespace tile {
 // } // namespace detail
 
 struct ref_ptr_t {
-  explicit ref_ptr_t() = default;
+    explicit ref_ptr_t() = default;
 };
 
 struct adopt_ptr_t {
-  explicit adopt_ptr_t() = default;
+    explicit adopt_ptr_t() = default;
 };
 
-constexpr auto ref_ptr = ref_ptr_t();
+constexpr auto ref_ptr   = ref_ptr_t();
 constexpr auto adopt_ptr = adopt_ptr_t();
 
-template <typename T, typename = void> struct RefTraits {
-  static void Reference(T *ptr) noexcept {
-    static_assert(
-        sizeof(T) == 0,
-        "To use `RefPtr<T>`, you need either inherit from `RefCounted<T>` "
-        "(which you dind't), or specialize `RefTraits<T>`");
-  }
+template<typename T, typename = void>
+struct RefTraits {
+    static void Reference(T *ptr) noexcept
+    {
+        static_assert(sizeof(T) == 0,
+                      "To use `RefPtr<T>`, you need either inherit from `RefCounted<T>` "
+                      "(which you dind't), or specialize `RefTraits<T>`");
+    }
 
-  static void Dereference(T *ptr) noexcept {
-    static_assert(
-        sizeof(T) == 0,
-        "To use `RefPtr<T>`, you need either inherit from `RefCounted<T>` "
-        "(which you dind't), or specialize `RefTraits<T>`");
-  }
+    static void Dereference(T *ptr) noexcept
+    {
+        static_assert(sizeof(T) == 0,
+                      "To use `RefPtr<T>`, you need either inherit from `RefCounted<T>` "
+                      "(which you dind't), or specialize `RefTraits<T>`");
+    }
 };
 
-template <typename T, typename Deleter = std::default_delete<T>>
+template<typename T, typename Deleter = std::default_delete<T>>
 class RefCounted {
 public:
-  void Ref() noexcept {
-    auto was = ref_count_.fetch_add(1, std::memory_order_relaxed);
-    TILE_DCHECK_GT(was, 0);
-  }
-
-  void Deref() noexcept {
-    auto was = ref_count_.fetch_sub(1, std::memory_order_acq_rel);
-    if (was == 1) {
-      Deleter()(static_cast<T *>(this));
-    } else {
-      TILE_DCHECK_GT(was, 1);
+    void Ref() noexcept
+    {
+        auto was = ref_count_.fetch_add(1, std::memory_order_relaxed);
+        TILE_DCHECK_GT(was, 0);
     }
-  }
-  std::uint32_t UnsafeRefCount() const noexcept {
-    return ref_count_.load(std::memory_order_relaxed);
-  }
+
+    void Deref() noexcept
+    {
+        auto was = ref_count_.fetch_sub(1, std::memory_order_acq_rel);
+        if (was == 1) {
+            Deleter()(static_cast<T *>(this));
+        } else {
+            TILE_DCHECK_GT(was, 1);
+        }
+    }
+
+    std::uint32_t UnsafeRefCount() const noexcept { return ref_count_.load(std::memory_order_relaxed); }
 
 protected:
-  RefCounted() = default;
+    RefCounted() = default;
 
-  // Recycle dead object for custom deleter
-  void Save() noexcept {
-    bool is_dead = ref_count_.fetch_add(1, std::memory_order_relaxed) == 0;
-    TILE_CHECK(is_dead);
-  }
+    // Recycle dead object for custom deleter
+    void Save() noexcept
+    {
+        bool is_dead = ref_count_.fetch_add(1, std::memory_order_relaxed) == 0;
+        TILE_CHECK(is_dead);
+    }
 
 private:
-  friend Deleter;
-  std::atomic<std::uint32_t> ref_count_{1};
+    friend Deleter;
+    std::atomic<std::uint32_t> ref_count_{1};
 };
 
-static_assert(sizeof(RefCounted<int>) == sizeof(std::atomic<std::uint32_t>),
-              "");
+static_assert(sizeof(RefCounted<int>) == sizeof(std::atomic<std::uint32_t>), "");
 
 namespace detail {
 
 struct not_ref_counted_tag_t {
-  explicit not_ref_counted_tag_t() = default;
+    explicit not_ref_counted_tag_t() = default;
 };
 
 struct not_ref_counted_type_tag_t {
-  explicit not_ref_counted_type_tag_t() = default;
+    explicit not_ref_counted_type_tag_t() = default;
 };
 
-template <class T, class... Us>
+template<class T, class... Us>
 RefCounted<T, Us...> GetRefCountedType(const RefCounted<T, Us...> *);
-template <class T> int GetRefCountedType(...);
-int GetRefCountedType(...); // Match failure.
+template<class T>
+int GetRefCountedType(...);
+int GetRefCountedType(...);// Match failure.
 
 // Extract `T` from `RefCounted<T, ...>`.
 //
 // We're returning `std::common_type<T>` instead of `T` so as not to require `T`
 // to be complete.
-template <class T, class... Us>
+template<class T, class... Us>
 std::common_type<T> GetRefeeType(const RefCounted<T, Us...> *);
 std::common_type<int> GetRefeeType(...);
 
@@ -146,61 +149,61 @@ std::common_type<int> GetRefeeType(...);
 //                    int>::value;
 // };
 
-template <class T>
-using refee_t =
-    typename decltype(GetRefeeType(reinterpret_cast<const T *>(0)))::type;
+template<class T>
+using refee_t = typename decltype(GetRefeeType(reinterpret_cast<const T *>(0)))::type;
 
 // If `T` inherits from `RefCounted<T, ...>` directly, `T` is returned,
 // otherwise `int` (which can never inherits `RefCounted<int, ...>`) is
 // returned.
-template <class T>
-using direct_refee_t =
-    refee_t<decltype(GetRefCountedType<T>(reinterpret_cast<const T *>(0)))>;
+template<class T>
+using direct_refee_t = refee_t<decltype(GetRefCountedType<T>(reinterpret_cast<const T *>(0)))>;
 
 // Test if `T` is a subclass of some `RefCounted<T, ...>`.
-template <class T> struct is_ref_counted_directly {
-  static constexpr bool value = !std::is_same<int, direct_refee_t<T>>::value;
+template<class T>
+struct is_ref_counted_directly {
+    static constexpr bool value = !std::is_same<int, direct_refee_t<T>>::value;
 };
 
 // If `T` is inheriting from some `RefCounted<U, ...>` unambiguously, this
 // method returns `U`. Otherwise it returns `int`.
-template <class T>
-using indirect_refee_t =
-    refee_t<decltype(GetRefCountedType(reinterpret_cast<const T *>(0)))>;
+template<class T>
+using indirect_refee_t = refee_t<decltype(GetRefCountedType(reinterpret_cast<const T *>(0)))>;
 
 // `T` is inherited from `RefCounted<U, ...>` indirectly;   (1)
 // `T` is inherited from `RefCounted<U, ...>` directly;     (2)
 // `U` has a virtual destructor                             (3)
-template <typename T> struct is_ref_counted_indirectly_safe {
-  static constexpr bool value =
-      !is_ref_counted_directly<T>::value &&                    // 1
-      is_ref_counted_directly<indirect_refee_t<T>>::value &&   // 2
-      std::has_virtual_destructor<indirect_refee_t<T>>::value; // 3
+template<typename T>
+struct is_ref_counted_indirectly_safe {
+    static constexpr bool value = !is_ref_counted_directly<T>::value &&// 1
+        is_ref_counted_directly<indirect_refee_t<T>>::value &&         // 2
+        std::has_virtual_destructor<indirect_refee_t<T>>::value;       // 3
 };
 
-template <class T>
-using as_ref_counted_t =
-    decltype(GetRefCountedType(reinterpret_cast<const T *>(0)));
+template<class T>
+using as_ref_counted_t = decltype(GetRefCountedType(reinterpret_cast<const T *>(0)));
 
 // - `T` is directly inheriting `RefCounted<T,...>`
 //   (destructor does not have to be `virtual`)
 // - `T` inherits from `RefCounted<U, ...>` and `U`'s destructor is virtual
-template <typename T> struct is_default_ref_traits_safe {
-  static constexpr bool value =
-      detail::is_ref_counted_directly<T>::value ||
-      detail::is_ref_counted_indirectly_safe<T>::value;
+template<typename T>
+struct is_default_ref_traits_safe {
+    static constexpr bool value =
+        detail::is_ref_counted_directly<T>::value || detail::is_ref_counted_indirectly_safe<T>::value;
 };
 
-template <typename T> struct is_ref_type {
-  template <typename U = T, typename = decltype(std::declval<U>().Ref()),
-            typename = decltype(std::declval<U>().Deref()),
-            typename = decltype(std::declval<U>().UnsafeRefCount())>
-  static int Test(int);
-  template <typename> static char Test(...);
-  static constexpr bool value = std::is_same<decltype(Test<T>(0)), int>::value;
+template<typename T>
+struct is_ref_type {
+    template<typename U = T,
+             typename   = decltype(std::declval<U>().Ref()),
+             typename   = decltype(std::declval<U>().Deref()),
+             typename   = decltype(std::declval<U>().UnsafeRefCount())>
+    static int Test(int);
+    template<typename>
+    static char Test(...);
+    static constexpr bool value = std::is_same<decltype(Test<T>(0)), int>::value;
 };
 
-} // namespace detail
+}// namespace detail
 
 // template <typename T>
 // struct RefTraits<T, enable_if_t<detail::is_ref_type<T>::value>> {
@@ -216,17 +219,19 @@ template <typename T> struct is_ref_type {
 // };
 
 // RefTraits for `RefCounted`
-template <typename T, typename Deleter>
+template<typename T, typename Deleter>
 struct RefTraits<RefCounted<T, Deleter>> {
-  static void Reference(RefCounted<T, Deleter> *ptr) noexcept {
-    TILE_DCHECK_GT(ptr->UnsafeRefCount(), 0);
-    ptr->Ref();
-  }
+    static void Reference(RefCounted<T, Deleter> *ptr) noexcept
+    {
+        TILE_DCHECK_GT(ptr->UnsafeRefCount(), 0);
+        ptr->Ref();
+    }
 
-  static void Dereference(RefCounted<T, Deleter> *ptr) noexcept {
-    TILE_DCHECK_GT(ptr->UnsafeRefCount(), 0);
-    ptr->Deref();
-  }
+    static void Dereference(RefCounted<T, Deleter> *ptr) noexcept
+    {
+        TILE_DCHECK_GT(ptr->UnsafeRefCount(), 0);
+        ptr->Deref();
+    }
 };
 
 // template <typename T>
@@ -238,130 +243,145 @@ struct RefTraits<RefCounted<T, Deleter>> {
 // };
 
 // RefTraits for the subclass of `RefCounted`
-template <typename T>
+template<typename T>
 struct RefTraits<
-    T, enable_if_t<!std::is_same<detail::as_ref_counted_t<T>, T>::value &&
-                   detail::is_default_ref_traits_safe<T>::value>>
+    T,
+    enable_if_t<!std::is_same<detail::as_ref_counted_t<T>, T>::value && detail::is_default_ref_traits_safe<T>::value>>
     : public RefTraits<detail::as_ref_counted_t<T>> {};
 
-template <typename T> class RefPtr final {
-  using Traits = RefTraits<T>;
+template<typename T>
+class RefPtr final {
+    using Traits = RefTraits<T>;
 
 public:
-  constexpr RefPtr() noexcept : ptr_(nullptr) {}
-  constexpr RefPtr(std::nullptr_t) noexcept : ptr_(nullptr) {}
-  ~RefPtr() noexcept {
-    if (ptr_) {
-      Traits::Dereference(ptr_);
-    }
-  }
+    constexpr RefPtr() noexcept : ptr_(nullptr) {}
 
-  RefPtr(ref_ptr_t, T *ptr) noexcept : ptr_(ptr) {
-    if (ptr_) {
-      Traits::Reference(ptr);
-    }
-  }
-  RefPtr(adopt_ptr_t, T *ptr) noexcept : ptr_(ptr) {}
+    constexpr RefPtr(std::nullptr_t) noexcept : ptr_(nullptr) {}
 
-  template <typename U,
-            typename = enable_if_t<std::is_convertible<U *, T *>::value>>
-  constexpr RefPtr(RefPtr<U> ptr) noexcept : ptr_(ptr.Leak()) {}
-
-  RefPtr(const RefPtr &other) noexcept : ptr_(other.ptr_) {
-    if (ptr_) {
-      Traits::Reference(ptr_);
-    }
-  }
-
-  RefPtr(RefPtr &&other) noexcept : ptr_(other.ptr_) { other.ptr_ = nullptr; }
-
-  RefPtr &operator=(const RefPtr &other) noexcept {
-    if (TILE_UNLIKELY(&other == this)) {
-      return *this;
+    ~RefPtr() noexcept
+    {
+        if (ptr_) { Traits::Dereference(ptr_); }
     }
 
-    if (ptr_) {
-      Traits::Dereference(ptr_);
+    RefPtr(ref_ptr_t, T *ptr) noexcept : ptr_(ptr)
+    {
+        if (ptr_) { Traits::Reference(ptr); }
     }
 
-    ptr_ = other.ptr_;
+    RefPtr(adopt_ptr_t, T *ptr) noexcept : ptr_(ptr) {}
 
-    if (ptr_) {
-      Traits::Reference(ptr_);
+    template<typename U, typename = enable_if_t<std::is_convertible<U *, T *>::value>>
+    constexpr RefPtr(RefPtr<U> ptr) noexcept : ptr_(ptr.Leak())
+    {}
+
+    RefPtr(const RefPtr &other) noexcept : ptr_(other.ptr_)
+    {
+        if (ptr_) { Traits::Reference(ptr_); }
     }
-    return *this;
-  }
 
-  RefPtr &operator=(RefPtr &&ptr) noexcept {
-    if (TILE_UNLIKELY(&ptr == this)) {
-      return *this;
+    RefPtr(RefPtr &&other) noexcept : ptr_(other.ptr_) { other.ptr_ = nullptr; }
+
+    RefPtr &operator=(const RefPtr &other) noexcept
+    {
+        if (TILE_UNLIKELY(&other == this)) { return *this; }
+
+        if (ptr_) { Traits::Dereference(ptr_); }
+
+        ptr_ = other.ptr_;
+
+        if (ptr_) { Traits::Reference(ptr_); }
+        return *this;
     }
-    if (ptr_) {
-      Traits::Dereference(ptr_);
+
+    RefPtr &operator=(RefPtr &&ptr) noexcept
+    {
+        if (TILE_UNLIKELY(&ptr == this)) { return *this; }
+        if (ptr_) { Traits::Dereference(ptr_); }
+        ptr_     = ptr.ptr_;
+        ptr.ptr_ = nullptr;
+        return *this;
     }
-    ptr_ = ptr.ptr_;
-    ptr.ptr_ = nullptr;
-    return *this;
-  }
 
-  RefPtr &operator=(std::nullptr_t) noexcept {
-    Reset();
-    return *this;
-  }
-
-  constexpr T *operator->() const noexcept { return ptr_; }
-  constexpr T &operator*() const noexcept { return *ptr_; }
-  constexpr T *Get() const noexcept { return ptr_; }
-
-  constexpr explicit operator bool() const noexcept { return !!ptr_; }
-
-  void Reset() noexcept {
-    if (ptr_) {
-      Traits::Dereference(ptr_);
-      ptr_ = nullptr;
+    RefPtr &operator=(std::nullptr_t) noexcept
+    {
+        Reset();
+        return *this;
     }
-  }
-  void Reset(ref_ptr_t, T *ptr) noexcept {
-    Reset();
-    ptr_ = ptr;
-    Traits::Reference(ptr);
-  }
-  void Reset(adopt_ptr_t, T *ptr) noexcept {
-    Reset();
-    ptr_ = ptr;
-  }
 
-  TILE_NODISCARD T *Leak() noexcept {
-    return internal::Exchange(ptr_, nullptr);
-  }
+    constexpr T *operator->() const noexcept { return ptr_; }
 
-  template <typename U> bool Is() const noexcept { return isa<U>(ptr_); }
+    constexpr T &operator*() const noexcept { return *ptr_; }
 
-  template <typename U> RefPtr<U> As() const noexcept {
-    return RefPtr<U>(ref_ptr, down_cast<U>(ptr_));
-  }
+    constexpr T *Get() const noexcept { return ptr_; }
+
+    constexpr explicit operator bool() const noexcept { return !!ptr_; }
+
+    void Reset() noexcept
+    {
+        if (ptr_) {
+            Traits::Dereference(ptr_);
+            ptr_ = nullptr;
+        }
+    }
+
+    void Reset(ref_ptr_t, T *ptr) noexcept
+    {
+        Reset();
+        ptr_ = ptr;
+        Traits::Reference(ptr);
+    }
+
+    void Reset(adopt_ptr_t, T *ptr) noexcept
+    {
+        Reset();
+        ptr_ = ptr;
+    }
+
+    TILE_NODISCARD T *Leak() noexcept { return internal::Exchange(ptr_, nullptr); }
+
+    template<typename U>
+    bool Is() const noexcept
+    {
+        return isa<U>(ptr_);
+    }
+
+    template<typename U>
+    RefPtr<U> As() const noexcept
+    {
+        return RefPtr<U>(ref_ptr, down_cast<U>(ptr_));
+    }
 
 private:
-  T *ptr_;
+    T *ptr_;
 };
 
-template <typename T, typename... Args>
-RefPtr<T> MakeRefCounted(Args &&...args) {
-  return RefPtr<T>(adopt_ptr, new T(std::forward<Args>(args)...));
+template<typename T, typename... Args>
+RefPtr<T>
+MakeRefCounted(Args &&...args)
+{
+    return RefPtr<T>(adopt_ptr, new T(std::forward<Args>(args)...));
 }
 
-template <typename T>
-constexpr bool operator==(const RefPtr<T> &lhs, const RefPtr<T> &rhs) noexcept {
-  return lhs.Get() == rhs.Get();
+template<typename T>
+constexpr bool
+operator==(const RefPtr<T> &lhs, const RefPtr<T> &rhs) noexcept
+{
+    return lhs.Get() == rhs.Get();
 }
-template <typename T>
-constexpr bool operator==(const RefPtr<T> &lhs, std::nullptr_t) noexcept {
-  return lhs.Get() == nullptr;
-}
-template <typename T>
-constexpr bool operator==(std::nullptr_t, const RefPtr<T> &rhs) noexcept {
-  return nullptr == rhs.Get();
-}
-}; // namespace tile
 
-#endif // TILE_BASE_REF_PTR_H
+template<typename T>
+constexpr bool
+operator==(const RefPtr<T> &lhs, std::nullptr_t) noexcept
+{
+    return lhs.Get() == nullptr;
+}
+
+template<typename T>
+constexpr bool
+operator==(std::nullptr_t, const RefPtr<T> &rhs) noexcept
+{
+    return nullptr == rhs.Get();
+}
+};// namespace tile
+
+#endif// TILE_BASE_REF_PTR_H
diff --git a/tile/base/ref_ptr_test.cc b/tile/base/ref_ptr_test.cc
index b916bea..a6562ee 100644
--- a/tile/base/ref_ptr_test.cc
+++ b/tile/base/ref_ptr_test.cc
@@ -12,44 +12,56 @@
 namespace tile {
 
 struct RefCounted1 {
-  std::atomic<int> ref_count{1};
-  RefCounted1() { ++instances; }
-  ~RefCounted1() { --instances; }
-  int xxx = 12345;
-  static int instances;
+    std::atomic<int> ref_count{1};
+
+    RefCounted1() { ++instances; }
+
+    ~RefCounted1() { --instances; }
+
+    int xxx = 12345;
+    static int instances;
 };
+
 int RefCounted1::instances = 0;
 
-template <> struct RefTraits<RefCounted1> {
-  static void Reference(RefCounted1 *rc) {
-    rc->ref_count.fetch_add(1, std::memory_order_relaxed);
-  }
-  static void Dereference(RefCounted1 *rc) {
-    if (rc->ref_count.fetch_sub(1, std::memory_order_acq_rel) == 1) {
-      delete rc;
+template<>
+struct RefTraits<RefCounted1> {
+    static void Reference(RefCounted1 *rc) { rc->ref_count.fetch_add(1, std::memory_order_relaxed); }
+
+    static void Dereference(RefCounted1 *rc)
+    {
+        if (rc->ref_count.fetch_sub(1, std::memory_order_acq_rel) == 1) { delete rc; }
     }
-  }
 };
 
 struct RefCounted2 : RefCounted<RefCounted2> {
-  RefCounted2() { ++instances; }
-  ~RefCounted2() { --instances; }
-  static int instances;
+    RefCounted2() { ++instances; }
+
+    ~RefCounted2() { --instances; }
+
+    static int instances;
 };
+
 int RefCounted2::instances = 0;
 
 struct RefCountedVirtual : RefCounted<RefCountedVirtual> {
-  RefCountedVirtual() { ++instances; }
-  virtual ~RefCountedVirtual() { --instances; }
-  static int instances;
+    RefCountedVirtual() { ++instances; }
+
+    virtual ~RefCountedVirtual() { --instances; }
+
+    static int instances;
 };
+
 int RefCountedVirtual::instances = 0;
 
 struct RefCounted3 : RefCountedVirtual {
-  RefCounted3() { ++instances; }
-  ~RefCounted3() { --instances; }
-  static int instances;
+    RefCounted3() { ++instances; }
+
+    ~RefCounted3() { --instances; }
+
+    static int instances;
 };
+
 int RefCounted3::instances = 0;
 
 // Case 1
@@ -62,107 +74,116 @@ static_assert(detail::is_ref_counted_directly<RefCountedVirtual>::value, "");
 // Case 4
 static_assert(!detail::is_ref_counted_directly<RefCounted3>::value, "");
 // static_assert(!detail::is_ref_counted<RefCounted3>::value, "");
-static_assert(detail::is_ref_counted_directly<
-                  detail::indirect_refee_t<RefCounted3>>::value,
-              "");
+static_assert(detail::is_ref_counted_directly<detail::indirect_refee_t<RefCounted3>>::value, "");
 static_assert(detail::is_ref_counted_indirectly_safe<RefCounted3>::value, "");
 
-TEST(RefPtr, ReferenceCount) {
-  {
-    auto ptr = new RefCounted1();
-    ptr->ref_count = 0;
-    ASSERT_EQ(1, RefCounted1::instances);
-    RefPtr<RefCounted1> p1(ref_ptr, ptr);
-    ASSERT_EQ(1, ptr->ref_count);
+TEST(RefPtr, ReferenceCount)
+{
     {
-      RefPtr<RefCounted1> p2(p1);
-      ASSERT_EQ(2, ptr->ref_count);
-      RefPtr<RefCounted1> p3(std::move(p2));
-      ASSERT_EQ(2, ptr->ref_count);
+        auto ptr       = new RefCounted1();
+        ptr->ref_count = 0;
+        ASSERT_EQ(1, RefCounted1::instances);
+        RefPtr<RefCounted1> p1(ref_ptr, ptr);
+        ASSERT_EQ(1, ptr->ref_count);
+        {
+            RefPtr<RefCounted1> p2(p1);
+            ASSERT_EQ(2, ptr->ref_count);
+            RefPtr<RefCounted1> p3(std::move(p2));
+            ASSERT_EQ(2, ptr->ref_count);
+        }
+        {
+            RefPtr<RefCounted1> p2(p1);
+            ASSERT_EQ(2, ptr->ref_count);
+            p2.Reset();
+            ASSERT_EQ(1, ptr->ref_count);
+        }
+        {
+            RefPtr<RefCounted1> p2(p1);
+            ASSERT_EQ(2, ptr->ref_count);
+            auto ptr = p2.Leak();
+            ASSERT_EQ(2, ptr->ref_count);
+            RefPtr<RefCounted1> p3(adopt_ptr, ptr);
+            ASSERT_EQ(2, ptr->ref_count);
+        }
+        ASSERT_EQ(1, ptr->ref_count);
     }
+    ASSERT_EQ(0, RefCounted1::instances);
+}
+
+TEST(RefPtr, RefCounted)
+{
     {
-      RefPtr<RefCounted1> p2(p1);
-      ASSERT_EQ(2, ptr->ref_count);
-      p2.Reset();
-      ASSERT_EQ(1, ptr->ref_count);
+        auto ptr = new RefCounted2();
+        ASSERT_EQ(1, RefCounted2::instances);
+        RefPtr<RefCounted2> p1(adopt_ptr, ptr);
     }
+    ASSERT_EQ(0, RefCounted2::instances);
+}
+
+TEST(RefPtr, RefCountedVirtualDtor)
+{
     {
-      RefPtr<RefCounted1> p2(p1);
-      ASSERT_EQ(2, ptr->ref_count);
-      auto ptr = p2.Leak();
-      ASSERT_EQ(2, ptr->ref_count);
-      RefPtr<RefCounted1> p3(adopt_ptr, ptr);
-      ASSERT_EQ(2, ptr->ref_count);
+        auto ptr = new RefCounted3();
+        ASSERT_EQ(1, RefCounted3::instances);
+        ASSERT_EQ(1, RefCountedVirtual::instances);
+        RefPtr<RefCountedVirtual> p1(adopt_ptr, ptr);
     }
-    ASSERT_EQ(1, ptr->ref_count);
-  }
-  ASSERT_EQ(0, RefCounted1::instances);
+    ASSERT_EQ(0, RefCounted3::instances);
 }
 
-TEST(RefPtr, RefCounted) {
-  {
-    auto ptr = new RefCounted2();
-    ASSERT_EQ(1, RefCounted2::instances);
-    RefPtr<RefCounted2> p1(adopt_ptr, ptr);
-  }
-  ASSERT_EQ(0, RefCounted2::instances);
+TEST(RefPtr, ImplicitlyCast)
+{
+    {
+        RefPtr<RefCounted3> ptr = MakeRefCounted<RefCounted3>();
+        ASSERT_EQ(1, RefCounted3::instances);
+        ASSERT_EQ(1, RefCountedVirtual::instances);
+        RefPtr<RefCountedVirtual> p1(ptr);
+        ASSERT_EQ(1, RefCounted3::instances);
+        ASSERT_EQ(1, RefCountedVirtual::instances);
+        RefPtr<RefCountedVirtual> p2(std::move(ptr));
+        ASSERT_EQ(1, RefCounted3::instances);
+        ASSERT_EQ(1, RefCountedVirtual::instances);
+    }
+    ASSERT_EQ(0, RefCounted3::instances);
+    ASSERT_EQ(0, RefCountedVirtual::instances);
 }
 
-TEST(RefPtr, RefCountedVirtualDtor) {
-  {
-    auto ptr = new RefCounted3();
-    ASSERT_EQ(1, RefCounted3::instances);
-    ASSERT_EQ(1, RefCountedVirtual::instances);
-    RefPtr<RefCountedVirtual> p1(adopt_ptr, ptr);
-  }
-  ASSERT_EQ(0, RefCounted3::instances);
+TEST(RefPtr, CopyFromNull)
+{
+    RefPtr<RefCounted1> p1, p2;
+    p1 = p2;
+    // Shouldn't crash.
 }
 
-TEST(RefPtr, ImplicitlyCast) {
-  {
-    RefPtr<RefCounted3> ptr = MakeRefCounted<RefCounted3>();
-    ASSERT_EQ(1, RefCounted3::instances);
-    ASSERT_EQ(1, RefCountedVirtual::instances);
-    RefPtr<RefCountedVirtual> p1(ptr);
-    ASSERT_EQ(1, RefCounted3::instances);
-    ASSERT_EQ(1, RefCountedVirtual::instances);
-    RefPtr<RefCountedVirtual> p2(std::move(ptr));
-    ASSERT_EQ(1, RefCounted3::instances);
-    ASSERT_EQ(1, RefCountedVirtual::instances);
-  }
-  ASSERT_EQ(0, RefCounted3::instances);
-  ASSERT_EQ(0, RefCountedVirtual::instances);
-}
-
-TEST(RefPtr, CopyFromNull) {
-  RefPtr<RefCounted1> p1, p2;
-  p1 = p2;
-  // Shouldn't crash.
-}
-
-TEST(RefPtr, MoveFromNull) {
-  RefPtr<RefCounted1> p1, p2;
-  p1 = std::move(p2);
-  // Shouldn't crash.
+TEST(RefPtr, MoveFromNull)
+{
+    RefPtr<RefCounted1> p1, p2;
+    p1 = std::move(p2);
+    // Shouldn't crash.
 }
 
 struct Deleter;
+
 struct RefCounted4 : RefCounted<RefCounted4, Deleter> {
-  RefCounted4() { ++instances; }
-  ~RefCounted4() { --instances; }
-  static int instances;
+    RefCounted4() { ++instances; }
+
+    ~RefCounted4() { --instances; }
+
+    static int instances;
 };
+
 int RefCounted4::instances = 0;
 
 struct Deleter {
-  void operator()(RefCounted4 *p) { delete p; }
+    void operator()(RefCounted4 *p) { delete p; }
 };
 
-TEST(RefPtr, CustomDeleter) {
-  RefPtr<RefCounted4> p1 = MakeRefCounted<RefCounted4>();
-  ASSERT_EQ(1, RefCounted4::instances);
-  p1.Reset();
-  ASSERT_EQ(0, RefCounted4::instances);
+TEST(RefPtr, CustomDeleter)
+{
+    RefPtr<RefCounted4> p1 = MakeRefCounted<RefCounted4>();
+    ASSERT_EQ(1, RefCounted4::instances);
+    p1.Reset();
+    ASSERT_EQ(0, RefCounted4::instances);
 }
 
 /*
@@ -253,4 +274,4 @@ TEST(RefPtr, AtomicDontLeak) {
 }
 */
 
-} // namespace tile
+}// namespace tile
diff --git a/tile/base/slice.cc b/tile/base/slice.cc
index 62bcc45..8865138 100644
--- a/tile/base/slice.cc
+++ b/tile/base/slice.cc
@@ -2,16 +2,15 @@
 #include "tile/base/internal/logging.h"
 
 namespace tile {
-std::size_t Slice::find(Slice s, std::size_t pos) const {
-  TILE_CHECK(pos <= len_);
+std::size_t
+Slice::find(Slice s, std::size_t pos) const
+{
+    TILE_CHECK(pos <= len_);
 
-  if (s.empty()) {
-    return npos;
-  }
+    if (s.empty()) { return npos; }
 
-  auto iter =
-      std::search(data_ + pos, data_ + len_, s.data(), s.data() + s.size());
-  return iter == data_ + len_ ? npos : iter - data_;
+    auto iter = std::search(data_ + pos, data_ + len_, s.data(), s.data() + s.size());
+    return iter == data_ + len_ ? npos : iter - data_;
 }
 
-} // namespace tile
+}// namespace tile
diff --git a/tile/base/slice.h b/tile/base/slice.h
index 8af5c35..f17ceec 100644
--- a/tile/base/slice.h
+++ b/tile/base/slice.h
@@ -16,206 +16,220 @@
 namespace tile {
 namespace detail {
 static constexpr char kChars[] = {
-    char(-128), char(-127), char(-126), char(-125), char(-124), char(-123),
-    char(-122), char(-121), char(-120), char(-119), char(-118), char(-117),
-    char(-116), char(-115), char(-114), char(-113), char(-112), char(-111),
-    char(-110), char(-109), char(-108), char(-107), char(-106), char(-105),
-    char(-104), char(-103), char(-102), char(-101), char(-100), char(-99),
-    char(-98),  char(-97),  char(-96),  char(-95),  char(-94),  char(-93),
-    char(-92),  char(-91),  char(-90),  char(-89),  char(-88),  char(-87),
-    char(-86),  char(-85),  char(-84),  char(-83),  char(-82),  char(-81),
-    char(-80),  char(-79),  char(-78),  char(-77),  char(-76),  char(-75),
-    char(-74),  char(-73),  char(-72),  char(-71),  char(-70),  char(-69),
-    char(-68),  char(-67),  char(-66),  char(-65),  char(-64),  char(-63),
-    char(-62),  char(-61),  char(-60),  char(-59),  char(-58),  char(-57),
-    char(-56),  char(-55),  char(-54),  char(-53),  char(-52),  char(-51),
-    char(-50),  char(-49),  char(-48),  char(-47),  char(-46),  char(-45),
-    char(-44),  char(-43),  char(-42),  char(-41),  char(-40),  char(-39),
-    char(-38),  char(-37),  char(-36),  char(-35),  char(-34),  char(-33),
-    char(-32),  char(-31),  char(-30),  char(-29),  char(-28),  char(-27),
-    char(-26),  char(-25),  char(-24),  char(-23),  char(-22),  char(-21),
-    char(-20),  char(-19),  char(-18),  char(-17),  char(-16),  char(-15),
-    char(-14),  char(-13),  char(-12),  char(-11),  char(-10),  char(-9),
-    char(-8),   char(-7),   char(-6),   char(-5),   char(-4),   char(-3),
-    char(-2),   char(-1),   char(0),    char(1),    char(2),    char(3),
-    char(4),    char(5),    char(6),    char(7),    char(8),    char(9),
-    char(10),   char(11),   char(12),   char(13),   char(14),   char(15),
-    char(16),   char(17),   char(18),   char(19),   char(20),   char(21),
-    char(22),   char(23),   char(24),   char(25),   char(26),   char(27),
-    char(28),   char(29),   char(30),   char(31),   char(32),   char(33),
-    char(34),   char(35),   char(36),   char(37),   char(38),   char(39),
-    char(40),   char(41),   char(42),   char(43),   char(44),   char(45),
-    char(46),   char(47),   char(48),   char(49),   char(50),   char(51),
-    char(52),   char(53),   char(54),   char(55),   char(56),   char(57),
-    char(58),   char(59),   char(60),   char(61),   char(62),   char(63),
-    char(64),   char(65),   char(66),   char(67),   char(68),   char(69),
-    char(70),   char(71),   char(72),   char(73),   char(74),   char(75),
-    char(76),   char(77),   char(78),   char(79),   char(80),   char(81),
-    char(82),   char(83),   char(84),   char(85),   char(86),   char(87),
-    char(88),   char(89),   char(90),   char(91),   char(92),   char(93),
-    char(94),   char(95),   char(96),   char(97),   char(98),   char(99),
-    char(100),  char(101),  char(102),  char(103),  char(104),  char(105),
-    char(106),  char(107),  char(108),  char(109),  char(110),  char(111),
-    char(112),  char(113),  char(114),  char(115),  char(116),  char(117),
-    char(118),  char(119),  char(120),  char(121),  char(122),  char(123),
+    char(-128), char(-127), char(-126), char(-125), char(-124), char(-123), char(-122), char(-121), char(-120),
+    char(-119), char(-118), char(-117), char(-116), char(-115), char(-114), char(-113), char(-112), char(-111),
+    char(-110), char(-109), char(-108), char(-107), char(-106), char(-105), char(-104), char(-103), char(-102),
+    char(-101), char(-100), char(-99),  char(-98),  char(-97),  char(-96),  char(-95),  char(-94),  char(-93),
+    char(-92),  char(-91),  char(-90),  char(-89),  char(-88),  char(-87),  char(-86),  char(-85),  char(-84),
+    char(-83),  char(-82),  char(-81),  char(-80),  char(-79),  char(-78),  char(-77),  char(-76),  char(-75),
+    char(-74),  char(-73),  char(-72),  char(-71),  char(-70),  char(-69),  char(-68),  char(-67),  char(-66),
+    char(-65),  char(-64),  char(-63),  char(-62),  char(-61),  char(-60),  char(-59),  char(-58),  char(-57),
+    char(-56),  char(-55),  char(-54),  char(-53),  char(-52),  char(-51),  char(-50),  char(-49),  char(-48),
+    char(-47),  char(-46),  char(-45),  char(-44),  char(-43),  char(-42),  char(-41),  char(-40),  char(-39),
+    char(-38),  char(-37),  char(-36),  char(-35),  char(-34),  char(-33),  char(-32),  char(-31),  char(-30),
+    char(-29),  char(-28),  char(-27),  char(-26),  char(-25),  char(-24),  char(-23),  char(-22),  char(-21),
+    char(-20),  char(-19),  char(-18),  char(-17),  char(-16),  char(-15),  char(-14),  char(-13),  char(-12),
+    char(-11),  char(-10),  char(-9),   char(-8),   char(-7),   char(-6),   char(-5),   char(-4),   char(-3),
+    char(-2),   char(-1),   char(0),    char(1),    char(2),    char(3),    char(4),    char(5),    char(6),
+    char(7),    char(8),    char(9),    char(10),   char(11),   char(12),   char(13),   char(14),   char(15),
+    char(16),   char(17),   char(18),   char(19),   char(20),   char(21),   char(22),   char(23),   char(24),
+    char(25),   char(26),   char(27),   char(28),   char(29),   char(30),   char(31),   char(32),   char(33),
+    char(34),   char(35),   char(36),   char(37),   char(38),   char(39),   char(40),   char(41),   char(42),
+    char(43),   char(44),   char(45),   char(46),   char(47),   char(48),   char(49),   char(50),   char(51),
+    char(52),   char(53),   char(54),   char(55),   char(56),   char(57),   char(58),   char(59),   char(60),
+    char(61),   char(62),   char(63),   char(64),   char(65),   char(66),   char(67),   char(68),   char(69),
+    char(70),   char(71),   char(72),   char(73),   char(74),   char(75),   char(76),   char(77),   char(78),
+    char(79),   char(80),   char(81),   char(82),   char(83),   char(84),   char(85),   char(86),   char(87),
+    char(88),   char(89),   char(90),   char(91),   char(92),   char(93),   char(94),   char(95),   char(96),
+    char(97),   char(98),   char(99),   char(100),  char(101),  char(102),  char(103),  char(104),  char(105),
+    char(106),  char(107),  char(108),  char(109),  char(110),  char(111),  char(112),  char(113),  char(114),
+    char(115),  char(116),  char(117),  char(118),  char(119),  char(120),  char(121),  char(122),  char(123),
     char(124),  char(125),  char(126),  char(127)};
 
 // char [-128, 127]
-static std::array<char, 256> &GetChars() {
-  static std::array<char, 256> chars;
-  static std::once_flag flag;
-  std::call_once(flag, [] {
-    for (int i = 0; i < 256; i++) {
-      chars[i] = static_cast<char>(i - 128);
-    }
-  });
-  return chars;
+static std::array<char, 256> &
+GetChars()
+{
+    static std::array<char, 256> chars;
+    static std::once_flag flag;
+    std::call_once(flag, [] {
+        for (int i = 0; i < 256; i++) { chars[i] = static_cast<char>(i - 128); }
+    });
+    return chars;
 }
-} // namespace detail
+}// namespace detail
 
 class Slice {
 public:
-  using string_t = ::std::string;
-  static constexpr std::size_t npos = std::string::npos;
+    using string_t                    = ::std::string;
+    static constexpr std::size_t npos = std::string::npos;
 
-  constexpr Slice() : data_(""), len_(0) {}
-  // char
-  constexpr Slice(const char &ch) : data_(&detail::kChars[128 + ch]), len_(1) {}
-  // std::string
-  Slice(const std::string &str) : data_(str.data()), len_(str.size()) {}
-  // const char*
-  Slice(const char *c_str) : data_(c_str), len_(strlen(c_str)) {}
-  constexpr Slice(const char *begin, const char *end)
-      : data_(begin), len_(end - begin) {}
-  constexpr Slice(const char *data, size_t len) : data_(data), len_(len) {}
+    constexpr Slice() : data_(""), len_(0) {}
 
-  constexpr Slice(const Slice &other) : data_(other.data_), len_(other.len_) {}
+    // char
+    constexpr Slice(const char &ch) : data_(&detail::kChars[128 + ch]), len_(1) {}
 
-  char front() const {
-    assert(len_ > 0);
-    return *data_;
-  }
+    // std::string
+    Slice(const std::string &str) : data_(str.data()), len_(str.size()) {}
 
-  char back() const {
-    assert(len_ > 0);
-    return data_[len_ - 1];
-  }
+    // const char*
+    Slice(const char *c_str) : data_(c_str), len_(strlen(c_str)) {}
 
-  Slice &operator=(const Slice &other) {
-    data_ = other.data_;
-    len_ = other.len_;
-    return *this;
-  }
+    constexpr Slice(const char *begin, const char *end) : data_(begin), len_(end - begin) {}
 
-  void RemovePrefix(size_t n) {
-    assert(len_ >= n && n >= 0);
-    data_ += n;
-    len_ -= n;
-  }
+    constexpr Slice(const char *data, size_t len) : data_(data), len_(len) {}
 
-  void RemoveSuffix(size_t n) {
-    assert(len_ >= n && n >= 0);
-    len_ -= n;
-  }
+    constexpr Slice(const Slice &other) : data_(other.data_), len_(other.len_) {}
 
-  Slice substr(size_t pos, size_t n) const {
-    if (n == npos) {
-      return substr(pos, len_ - pos);
+    char front() const
+    {
+        assert(len_ > 0);
+        return *data_;
     }
 
-    assert(pos <= len_ && n <= len_ - pos);
-    return Slice(data_ + pos, n);
-  }
-
-  Slice substr(size_t pos) const {
-    assert(pos <= len_);
-    return Slice(data_ + pos, len_ - pos);
-  }
-
-  std::string ToString() const { return std::string(data_, len_); }
-
-  void clear() {
-    data_ = "";
-    len_ = 0;
-  }
-
-  std::size_t find(Slice s, std::size_t pos = 0) const;
-
-  std::size_t find_first_of(Slice s) const { return find(s); }
-
-  // TODO: Optimize it
-  std::size_t find_last_of(Slice s) const {
-    if (s.empty() || s.size() > size()) {
-      return npos;
+    char back() const
+    {
+        assert(len_ > 0);
+        return data_[len_ - 1];
     }
 
-    auto ptr = data_ + len_ - s.size();
-    for (; ptr >= data_; --ptr) {
-      if (std::find(s.begin(), s.end(), *ptr) != s.end()) {
-        return ptr - data_;
-      }
+    Slice &operator=(const Slice &other)
+    {
+        data_ = other.data_;
+        len_  = other.len_;
+        return *this;
     }
 
-    return npos;
-  }
+    void RemovePrefix(size_t n)
+    {
+        assert(len_ >= n && n >= 0);
+        data_ += n;
+        len_ -= n;
+    }
 
-  const char *cbegin() const { return data_; }
-  const char *cend() const { return data_ + len_; }
+    void RemoveSuffix(size_t n)
+    {
+        assert(len_ >= n && n >= 0);
+        len_ -= n;
+    }
 
-  const char *begin() const { return data_; }
-  const char *end() const { return data_ + len_; }
+    Slice substr(size_t pos, size_t n) const
+    {
+        if (n == npos) { return substr(pos, len_ - pos); }
 
-  const char *data() const { return data_; }
-  size_t size() const { return len_; }
-  bool empty() const { return len_ == 0; }
+        assert(pos <= len_ && n <= len_ - pos);
+        return Slice(data_ + pos, n);
+    }
 
-  const char &operator[](size_t pos) const {
-    assert(pos < len_ && pos >= 0);
-    return data_[pos];
-  }
+    Slice substr(size_t pos) const
+    {
+        assert(pos <= len_);
+        return Slice(data_ + pos, len_ - pos);
+    }
 
-  inline operator string_t() const { return ToString(); }
+    std::string ToString() const { return std::string(data_, len_); }
+
+    void clear()
+    {
+        data_ = "";
+        len_  = 0;
+    }
+
+    std::size_t find(Slice s, std::size_t pos = 0) const;
+
+    std::size_t find_first_of(Slice s) const { return find(s); }
+
+    // TODO: Optimize it
+    std::size_t find_last_of(Slice s) const
+    {
+        if (s.empty() || s.size() > size()) { return npos; }
+
+        auto ptr = data_ + len_ - s.size();
+        for (; ptr >= data_; --ptr) {
+            if (std::find(s.begin(), s.end(), *ptr) != s.end()) { return ptr - data_; }
+        }
+
+        return npos;
+    }
+
+    const char *cbegin() const { return data_; }
+
+    const char *cend() const { return data_ + len_; }
+
+    const char *begin() const { return data_; }
+
+    const char *end() const { return data_ + len_; }
+
+    const char *data() const { return data_; }
+
+    size_t size() const { return len_; }
+
+    bool empty() const { return len_ == 0; }
+
+    const char &operator[](size_t pos) const
+    {
+        assert(pos < len_ && pos >= 0);
+        return data_[pos];
+    }
+
+    inline operator string_t() const { return ToString(); }
 
 private:
-  const char *data_;
-  size_t len_;
+    const char *data_;
+    size_t len_;
 };
 
-inline bool operator==(const Slice &lhs, const Slice &rhs) {
-  return lhs.size() == rhs.size() &&
-         memcmp(lhs.data(), rhs.data(), lhs.size()) == 0;
+inline bool
+operator==(const Slice &lhs, const Slice &rhs)
+{
+    return lhs.size() == rhs.size() && memcmp(lhs.data(), rhs.data(), lhs.size()) == 0;
 }
 
-inline bool operator!=(const Slice &lhs, const Slice &rhs) {
-  return !(lhs == rhs);
+inline bool
+operator!=(const Slice &lhs, const Slice &rhs)
+{
+    return !(lhs == rhs);
 }
 
-inline bool operator<(const Slice &lhs, const Slice &rhs) {
-  const size_t min_len = std::min(lhs.size(), rhs.size());
-  const int r = memcmp(lhs.data(), rhs.data(), min_len);
-  return r < 0 || (r == 0 && lhs.size() < rhs.size());
+inline bool
+operator<(const Slice &lhs, const Slice &rhs)
+{
+    const size_t min_len = std::min(lhs.size(), rhs.size());
+    const int r          = memcmp(lhs.data(), rhs.data(), min_len);
+    return r < 0 || (r == 0 && lhs.size() < rhs.size());
 }
 
-inline bool operator==(const char *lhs, const Slice &rhs) {
-  return Slice(lhs) == rhs;
-}
-inline bool operator!=(const char *lhs, const Slice &rhs) {
-  return Slice(lhs) != rhs;
+inline bool
+operator==(const char *lhs, const Slice &rhs)
+{
+    return Slice(lhs) == rhs;
 }
 
-inline std::ostream &operator<<(std::ostream &os, const Slice &s) {
-  return os << s.ToString();
+inline bool
+operator!=(const char *lhs, const Slice &rhs)
+{
+    return Slice(lhs) != rhs;
 }
 
-inline std::string operator+(const Slice &lhs, const Slice &rhs) {
-  return lhs.ToString() + rhs.ToString();
+inline std::ostream &
+operator<<(std::ostream &os, const Slice &s)
+{
+    return os << s.ToString();
 }
 
-} // namespace tile
+inline std::string
+operator+(const Slice &lhs, const Slice &rhs)
+{
+    return lhs.ToString() + rhs.ToString();
+}
+
+}// namespace tile
+
 namespace std {
-template <> struct hash<::tile::Slice> {
-  std::size_t operator()(const ::tile::Slice &s) const noexcept { return 0; }
+template<>
+struct hash<::tile::Slice> {
+    std::size_t operator()(const ::tile::Slice &s) const noexcept { return 0; }
 };
-} // namespace std
+}// namespace std
 
-#endif // _TILE_BASE_SLICE_H
+#endif// _TILE_BASE_SLICE_H
diff --git a/tile/base/status.cc b/tile/base/status.cc
index a36c2c9..10f3917 100644
--- a/tile/base/status.cc
+++ b/tile/base/status.cc
@@ -2,30 +2,34 @@
 #include "tile/base/internal/logging.h"
 
 namespace tile {
-Status::Status(int status, const std::string &desc) {
-  if (status == 0) {
-    std::atomic<bool> flag{false};
-    TILE_LOG_ERROR_IF_ONCE(
-        !desc.empty(),
-        "Status `SUCCESS` may not carry description but [{}] is given", desc);
-  } else {
-    state_ = MakeRefCounted<State>();
-    state_->status = status;
-    state_->desc = desc;
-  }
+Status::Status(int status, const std::string &desc)
+{
+    if (status == 0) {
+        std::atomic<bool> flag{false};
+        TILE_LOG_ERROR_IF_ONCE(!desc.empty(), "Status `SUCCESS` may not carry description but [{}] is given", desc);
+    } else {
+        state_         = MakeRefCounted<State>();
+        state_->status = status;
+        state_->desc   = desc;
+    }
 }
 
-const std::string &Status::message() const noexcept {
-  return state_ ? state_->desc : internal::EarlyInitConstant<std::string>();
+const std::string &
+Status::message() const noexcept
+{
+    return state_ ? state_->desc : internal::EarlyInitConstant<std::string>();
 }
 
-std::string Status::ToString() const {
-  return fmt::format("[{}] {}", code(),
-                     !ok() ? message()
-                           : "The operation completed successfully");
-}
-std::ostream &operator<<(std::ostream &os, const Status &status) {
-  return os << status.ToString();
+std::string
+Status::ToString() const
+{
+    return fmt::format("[{}] {}", code(), !ok() ? message() : "The operation completed successfully");
 }
 
-} // namespace tile
+std::ostream &
+operator<<(std::ostream &os, const Status &status)
+{
+    return os << status.ToString();
+}
+
+}// namespace tile
diff --git a/tile/base/status.h b/tile/base/status.h
index f5f7039..0c341a8 100644
--- a/tile/base/status.h
+++ b/tile/base/status.h
@@ -14,31 +14,32 @@
 namespace tile {
 class Status {
 public:
-  Status() noexcept = default;
-  explicit Status(int status, const std::string &desc =
-                                  internal::EarlyInitConstant<std::string>());
-  template <typename T, typename = enable_if_t<
-                            std::is_same<underlying_type_t<T>, int>::value>>
-  explicit Status(T status, const std::string &desc =
-                                internal::EarlyInitConstant<std::string>())
-      : Status(static_cast<int>(status), desc) {}
+    Status() noexcept = default;
+    explicit Status(int status, const std::string &desc = internal::EarlyInitConstant<std::string>());
 
-  bool ok() const noexcept { return !state_; };
-  int code() const noexcept { return !state_ ? 0 : state_->status; };
+    template<typename T, typename = enable_if_t<std::is_same<underlying_type_t<T>, int>::value>>
+    explicit Status(T status, const std::string &desc = internal::EarlyInitConstant<std::string>())
+        : Status(static_cast<int>(status), desc)
+    {}
 
-  const std::string &message() const noexcept;
+    bool ok() const noexcept { return !state_; };
 
-  std::string ToString() const;
+    int code() const noexcept { return !state_ ? 0 : state_->status; };
+
+    const std::string &message() const noexcept;
+
+    std::string ToString() const;
 
 private:
-  struct State : RefCounted<State> {
-    int status;
-    std::string desc;
-  };
-  RefPtr<State> state_;
+    struct State : RefCounted<State> {
+        int status;
+        std::string desc;
+    };
+
+    RefPtr<State> state_;
 };
 
 std::ostream &operator<<(std::ostream &os, const Status &status);
-} // namespace tile
+}// namespace tile
 
-#endif // TILE_BASE_STATUS_H
+#endif// TILE_BASE_STATUS_H
diff --git a/tile/base/status_test.cc b/tile/base/status_test.cc
index c67497d..846911e 100644
--- a/tile/base/status_test.cc
+++ b/tile/base/status_test.cc
@@ -5,33 +5,36 @@
 
 namespace tile {
 
-TEST(Status, Success) {
-  Status st;
-  ASSERT_TRUE(st.ok());
-  ASSERT_EQ(0, st.code());
-  ASSERT_EQ("", st.message());
-  Status st2 = st;
-  ASSERT_TRUE(st2.ok());
-  ASSERT_EQ(0, st2.code());
-  ASSERT_EQ("", st2.message());
+TEST(Status, Success)
+{
+    Status st;
+    ASSERT_TRUE(st.ok());
+    ASSERT_EQ(0, st.code());
+    ASSERT_EQ("", st.message());
+    Status st2 = st;
+    ASSERT_TRUE(st2.ok());
+    ASSERT_EQ(0, st2.code());
+    ASSERT_EQ("", st2.message());
 }
 
-TEST(Status, Failure) {
-  Status st(1, "err");
-  ASSERT_FALSE(st.ok());
-  ASSERT_EQ(1, st.code());
-  ASSERT_EQ("err", st.message());
-  Status st2 = st;
-  ASSERT_FALSE(st2.ok());
-  ASSERT_EQ(1, st2.code());
-  ASSERT_EQ("err", st2.message());
+TEST(Status, Failure)
+{
+    Status st(1, "err");
+    ASSERT_FALSE(st.ok());
+    ASSERT_EQ(1, st.code());
+    ASSERT_EQ("err", st.message());
+    Status st2 = st;
+    ASSERT_FALSE(st2.ok());
+    ASSERT_EQ(1, st2.code());
+    ASSERT_EQ("err", st2.message());
 }
 
 enum class SomeEnum { Enum1 = 2 };
 
-TEST(Status, FromEnum) {
-  Status st(SomeEnum::Enum1);
-  EXPECT_EQ(2, st.code());
+TEST(Status, FromEnum)
+{
+    Status st(SomeEnum::Enum1);
+    EXPECT_EQ(2, st.code());
 }
 
-} // namespace tile
+}// namespace tile
diff --git a/tile/base/string.cc b/tile/base/string.cc
index fce7e6e..82c3b15 100644
--- a/tile/base/string.cc
+++ b/tile/base/string.cc
@@ -12,346 +12,357 @@ namespace tile {
 
 namespace {
 struct LastErrorStasher {
-  LastErrorStasher() : last_errno(errno) { errno = 0; }
-  ~LastErrorStasher() { errno = last_errno; }
-  int last_errno;
+    LastErrorStasher() : last_errno(errno) { errno = 0; }
+
+    ~LastErrorStasher() { errno = last_errno; }
+
+    int last_errno;
 };
-} // namespace
-template <typename T, typename F, typename... Args>
-std::optional<T> TryParseImpl(F fptr, const char *s,
-                              std::initializer_list<T> invs, Args &&...args) {
-  if (s[0] == 0) {
-    return std::nullopt;
-  }
+}// namespace
 
-  LastErrorStasher _;
-  char *end;
-  auto result = fptr(s, &end, args...);
-  if (end != s + strlen(s)) {
-    return std::nullopt;
-  }
+template<typename T, typename F, typename... Args>
+std::optional<T>
+TryParseImpl(F fptr, const char *s, std::initializer_list<T> invs, Args &&...args)
+{
+    if (s[0] == 0) { return std::nullopt; }
 
-  for (auto &&e : invs) {
-    if (result == e && errno == ERANGE) {
-      return std::nullopt;
+    LastErrorStasher _;
+    char *end;
+    auto result = fptr(s, &end, args...);
+    if (end != s + strlen(s)) { return std::nullopt; }
+
+    for (auto &&e : invs) {
+        if (result == e && errno == ERANGE) { return std::nullopt; }
     }
-  }
 
-  return result;
+    return result;
 }
 
-bool StartsWith(Slice s, Slice prefix) {
-  return s.size() >= prefix.size() && s.substr(0, prefix.size()) == prefix;
+bool
+StartsWith(Slice s, Slice prefix)
+{
+    return s.size() >= prefix.size() && s.substr(0, prefix.size()) == prefix;
 }
 
-bool EndsWith(Slice s, Slice suffix) {
-  return s.size() >= suffix.size() &&
-         s.substr(s.size() - suffix.size()) == suffix;
-}
-bool StartsWithIgnoreCase(Slice s, Slice prefix) {
-  return s.size() >= prefix.size() &&
-         EqualsIgnoreCase(s.substr(0, prefix.size()), prefix);
-}
-bool EndsWithIgnoreCase(Slice s, Slice suffix) {
-  return s.size() >= suffix.size() &&
-         EqualsIgnoreCase(s.substr(s.size() - suffix.size()), suffix);
+bool
+EndsWith(Slice s, Slice suffix)
+{
+    return s.size() >= suffix.size() && s.substr(s.size() - suffix.size()) == suffix;
 }
 
-void Replace(Slice from, Slice to, std::string *str, std::size_t count) {
-  TILE_CHECK(!from.empty(), "`from` may not be empty");
-  const std::string from_str = from.ToString();
-  const std::string to_str = to.ToString();
-  auto pos = str->find(from_str);
-  while (pos != std::string::npos && count--) {
-    str->replace(pos, from.size(), to_str);
-    pos = str->find(from_str, pos + to.size());
-  }
+bool
+StartsWithIgnoreCase(Slice s, Slice prefix)
+{
+    return s.size() >= prefix.size() && EqualsIgnoreCase(s.substr(0, prefix.size()), prefix);
 }
 
-std::string Replace(Slice str, Slice from, Slice to, std::size_t count) {
-  std::string result = str.ToString();
-  Replace(from, to, &result, count);
-  return result;
+bool
+EndsWithIgnoreCase(Slice s, Slice suffix)
+{
+    return s.size() >= suffix.size() && EqualsIgnoreCase(s.substr(s.size() - suffix.size()), suffix);
 }
 
-std::vector<Slice> Split(Slice s, char delim, bool keep_empty,
-                         std::size_t max_split_parts) {
-  return Split(s, Slice(delim), keep_empty, max_split_parts);
+void
+Replace(Slice from, Slice to, std::string *str, std::size_t count)
+{
+    TILE_CHECK(!from.empty(), "`from` may not be empty");
+    const std::string from_str = from.ToString();
+    const std::string to_str   = to.ToString();
+    auto pos                   = str->find(from_str);
+    while (pos != std::string::npos && count--) {
+        str->replace(pos, from.size(), to_str);
+        pos = str->find(from_str, pos + to.size());
+    }
 }
-std::vector<Slice> Split(Slice s, Slice delim, bool keep_empty,
-                         std::size_t max_split_parts) {
 
-  TILE_CHECK_GE(max_split_parts, 0, "`max_split_parts` must be greater than 0");
+std::string
+Replace(Slice str, Slice from, Slice to, std::size_t count)
+{
+    std::string result = str.ToString();
+    Replace(from, to, &result, count);
+    return result;
+}
+
+std::vector<Slice>
+Split(Slice s, char delim, bool keep_empty, std::size_t max_split_parts)
+{
+    return Split(s, Slice(delim), keep_empty, max_split_parts);
+}
+
+std::vector<Slice>
+Split(Slice s, Slice delim, bool keep_empty, std::size_t max_split_parts)
+{
+
+    TILE_CHECK_GE(max_split_parts, 0, "`max_split_parts` must be greater than 0");
+
+    constexpr std::size_t kMaxSplit = std::numeric_limits<std::size_t>::max();
+    std::vector<Slice> splited;
+    if (s.empty() || max_split_parts == 1) { return splited; }
+    auto current = s;
+    assert(!delim.empty());
+    int split_count = 0;
+    while (max_split_parts == kMaxSplit || split_count < max_split_parts) {
+        auto next_pos = current.find(delim);
+        auto part     = current.substr(0, next_pos);
+        if (!part.empty() || keep_empty) { splited.push_back(part); }
+
+        ++split_count;
+
+        if (next_pos == Slice::npos) {
+            break;
+        } else if (split_count + 1 >= max_split_parts) {
+            splited.push_back(current.substr(next_pos + delim.size()));
+            break;
+        } else {
+            current = current.substr(next_pos + delim.size());
+        }
+    }
 
-  constexpr std::size_t kMaxSplit = std::numeric_limits<std::size_t>::max();
-  std::vector<Slice> splited;
-  if (s.empty() || max_split_parts == 1) {
     return splited;
-  }
-  auto current = s;
-  assert(!delim.empty());
-  int split_count = 0;
-  while (max_split_parts == kMaxSplit || split_count < max_split_parts) {
-    auto next_pos = current.find(delim);
-    auto part = current.substr(0, next_pos);
-    if (!part.empty() || keep_empty) {
-      splited.push_back(part);
+}
+
+Slice
+TrimLeft(Slice s, Slice cutset)
+{
+    return TrimLeft(s, [&cutset](char c) { return cutset.find(Slice(&c, 1)) != Slice::npos; });
+}
+
+Slice
+TrimRight(Slice s, Slice cutset)
+{
+    return TrimRight(s, [&cutset](char c) { return cutset.find(Slice(&c, 1)) != Slice::npos; });
+}
+
+Slice
+Trim(Slice s, Slice cutset)
+{
+    return Trim(s, [&cutset](char c) { return cutset.find(Slice(&c, 1)) != Slice::npos; });
+}
+
+Slice
+TrimLeft(Slice s, std::function<bool(char)> pred)
+{
+    while (!s.empty() && pred(s[0])) { s.RemovePrefix(1); }
+    return s;
+}
+
+Slice
+TrimRight(Slice s, std::function<bool(char)> pred)
+{
+    while (!s.empty() && pred(s[s.size() - 1])) { s.RemoveSuffix(1); }
+    return s;
+}
+
+Slice
+Trim(Slice s, std::function<bool(char)> pred)
+{
+    return TrimRight(TrimLeft(s, pred), pred);
+}
+
+template<typename T>
+void
+JoinImpl(const T &parts, Slice delim, std::string *result)
+{
+    auto size = 0;
+    for (auto &&e : parts) { size += e.size() + delim.size(); }
+    result->clear();
+    if (!size) { return; }
+
+    size -= delim.size();
+    result->reserve(size);
+    for (auto iter = parts.begin(); iter != parts.end(); ++iter) {
+        if (iter != parts.begin()) { result->append(delim.begin(), delim.end()); }
+        result->append(iter->begin(), iter->end());
     }
-
-    ++split_count;
-
-    if (next_pos == Slice::npos) {
-      break;
-    } else if (split_count + 1 >= max_split_parts) {
-      splited.push_back(current.substr(next_pos + delim.size()));
-      break;
-    } else {
-      current = current.substr(next_pos + delim.size());
-    }
-  }
-
-  return splited;
 }
 
-Slice TrimLeft(Slice s, Slice cutset) {
-  return TrimLeft(s, [&cutset](char c) {
-    return cutset.find(Slice(&c, 1)) != Slice::npos;
-  });
+std::string
+Join(const std::vector<std::string> &parts, Slice delim)
+{
+    std::string result;
+    JoinImpl(parts, delim, &result);
+    return result;
 }
 
-Slice TrimRight(Slice s, Slice cutset) {
-  return TrimRight(s, [&cutset](char c) {
-    return cutset.find(Slice(&c, 1)) != Slice::npos;
-  });
+std::string
+Join(const std::vector<Slice> &parts, Slice delim)
+{
+    std::string result;
+    JoinImpl(parts, delim, &result);
+    return result;
 }
 
-Slice Trim(Slice s, Slice cutset) {
-  return Trim(s, [&cutset](char c) {
-    return cutset.find(Slice(&c, 1)) != Slice::npos;
-  });
-}
-Slice TrimLeft(Slice s, std::function<bool(char)> pred) {
-  while (!s.empty() && pred(s[0])) {
-    s.RemovePrefix(1);
-  }
-  return s;
-}
-Slice TrimRight(Slice s, std::function<bool(char)> pred) {
-  while (!s.empty() && pred(s[s.size() - 1])) {
-    s.RemoveSuffix(1);
-  }
-  return s;
-}
-Slice Trim(Slice s, std::function<bool(char)> pred) {
-  return TrimRight(TrimLeft(s, pred), pred);
+std::string
+Join(const std::initializer_list<Slice> &parts, Slice delim)
+{
+    std::string result;
+    JoinImpl(parts, delim, &result);
+    return result;
 }
 
-template <typename T>
-void JoinImpl(const T &parts, Slice delim, std::string *result) {
-  auto size = 0;
-  for (auto &&e : parts) {
-    size += e.size() + delim.size();
-  }
-  result->clear();
-  if (!size) {
-    return;
-  }
-
-  size -= delim.size();
-  result->reserve(size);
-  for (auto iter = parts.begin(); iter != parts.end(); ++iter) {
-    if (iter != parts.begin()) {
-      result->append(delim.begin(), delim.end());
-    }
-    result->append(iter->begin(), iter->end());
-  }
-}
-std::string Join(const std::vector<std::string> &parts, Slice delim) {
-  std::string result;
-  JoinImpl(parts, delim, &result);
-  return result;
-}
-std::string Join(const std::vector<Slice> &parts, Slice delim) {
-  std::string result;
-  JoinImpl(parts, delim, &result);
-  return result;
-}
-std::string Join(const std::initializer_list<Slice> &parts, Slice delim) {
-  std::string result;
-  JoinImpl(parts, delim, &result);
-  return result;
+char
+ToUpper(char c)
+{
+    return std::toupper(c);
 }
 
-char ToUpper(char c) { return std::toupper(c); }
-char ToLower(char c) { return std::tolower(c); }
-void ToUpper(std::string *str) {
-  std::for_each(str->begin(), str->end(), [](char &c) { c = ToUpper(c); });
-}
-void ToLower(std::string *str) {
-  std::for_each(str->begin(), str->end(), [](char &c) { c = ToLower(c); });
-}
-std::string ToUpper(Slice s) {
-  std::string result;
-  result.reserve(s.size());
-  for (auto &&c : s) {
-    result.push_back(ToUpper(c));
-  }
-  return result;
-}
-std::string ToLower(Slice s) {
-  std::string result;
-  result.reserve(s.size());
-  for (auto &&c : s) {
-    result.push_back(ToLower(c));
-  }
-  return result;
+char
+ToLower(char c)
+{
+    return std::tolower(c);
 }
 
-bool Equals(Slice a, Slice b, std::size_t len) {
-  if (a.size() > len) {
-    a.RemoveSuffix(a.size() - len);
-  }
-  if (b.size() > len) {
-    b.RemoveSuffix(b.size() - len);
-  }
-  return a.size() == b.size() && std::equal(a.begin(), a.end(), b.begin());
+void
+ToUpper(std::string *str)
+{
+    std::for_each(str->begin(), str->end(), [](char &c) { c = ToUpper(c); });
 }
 
-bool EqualsIgnoreCase(Slice a, Slice b, std::size_t len) {
-  if (a.size() > len) {
-    a.RemoveSuffix(a.size() - len);
-  }
-  if (b.size() > len) {
-    b.RemoveSuffix(b.size() - len);
-  }
-  return a.size() == b.size() &&
-         std::equal(a.begin(), a.end(), b.begin(),
-                    [](char a, char b) { return ToLower(a) == ToLower(b); });
+void
+ToLower(std::string *str)
+{
+    std::for_each(str->begin(), str->end(), [](char &c) { c = ToLower(c); });
+}
+
+std::string
+ToUpper(Slice s)
+{
+    std::string result;
+    result.reserve(s.size());
+    for (auto &&c : s) { result.push_back(ToUpper(c)); }
+    return result;
+}
+
+std::string
+ToLower(Slice s)
+{
+    std::string result;
+    result.reserve(s.size());
+    for (auto &&c : s) { result.push_back(ToLower(c)); }
+    return result;
+}
+
+bool
+Equals(Slice a, Slice b, std::size_t len)
+{
+    if (a.size() > len) { a.RemoveSuffix(a.size() - len); }
+    if (b.size() > len) { b.RemoveSuffix(b.size() - len); }
+    return a.size() == b.size() && std::equal(a.begin(), a.end(), b.begin());
+}
+
+bool
+EqualsIgnoreCase(Slice a, Slice b, std::size_t len)
+{
+    if (a.size() > len) { a.RemoveSuffix(a.size() - len); }
+    if (b.size() > len) { b.RemoveSuffix(b.size() - len); }
+    return a.size() == b.size()
+        && std::equal(a.begin(), a.end(), b.begin(), [](char a, char b) { return ToLower(a) == ToLower(b); });
 }
 
 std::optional<bool>
-TryParseTraits<bool>::TryParse(Slice s, bool recognizes_alpbabet_symbol,
-                               bool ignore_case) {
-  auto num_opt = tile::TryParse<int>(s);
-  if (num_opt) {
-    return *num_opt != 0;
-  } else {
-    const std::vector<std::string> true_arr{"true", "yes", "on", "y"};
-    const std::vector<std::string> false_arr{"false", "no", "off", "n"};
-    if (s.size() > 5) {
-      return false;
-    }
+TryParseTraits<bool>::TryParse(Slice s, bool recognizes_alpbabet_symbol, bool ignore_case)
+{
+    auto num_opt = tile::TryParse<int>(s);
+    if (num_opt) {
+        return *num_opt != 0;
+    } else {
+        const std::vector<std::string> true_arr{"true", "yes", "on", "y"};
+        const std::vector<std::string> false_arr{"false", "no", "off", "n"};
+        if (s.size() > 5) { return false; }
 
-    auto InArray = [](const std::vector<std::string> &arr, Slice s) {
-      for (auto &&e : arr) {
-        if (EqualsIgnoreCase(e, s)) {
-          return true;
+        auto InArray = [](const std::vector<std::string> &arr, Slice s) {
+            for (auto &&e : arr) {
+                if (EqualsIgnoreCase(e, s)) { return true; }
+            }
+            return false;
+        };
+        if (InArray(true_arr, s)) {
+            return true;
+        } else if (InArray(false_arr, s)) {
+            return false;
         }
-      }
-      return false;
-    };
-    if (InArray(true_arr, s)) {
-      return true;
-    } else if (InArray(false_arr, s)) {
-      return false;
     }
-  }
 
-  return std::nullopt;
-}
-
-template <typename T> bool TryParseIngegralImpl(T &value, Slice s) {
-  s = Trim(s);
-  if (s.empty()) {
-    return false;
-  }
-
-  T sign = 1;
-  if (s[0] == '+' || s[0] == '-') {
-    if (s[0] == '-') {
-      sign = -1;
-    }
-    s.RemovePrefix(1);
-    s = TrimLeft(s);
-
-    if (s.empty()) {
-      return false;
-    }
-  }
-}
-
-template <typename T>
-std::optional<T>
-TryParseTraits<T, typename std::enable_if<std::is_integral<T>::value>::type>::
-    TryParse(Slice s, int base) {
-  assert(base >= 2 && base <= 36);
-
-  if (s.empty()) {
     return std::nullopt;
-  }
-
-  const std::string str = s.ToString();
-  char *endptr = nullptr;
-  T value;
-
-  LastErrorStasher _;
-  if (std::is_same<T, unsigned long long>::value ||
-      std::is_same<T, std::uint64_t>::value) {
-    unsigned long long temp_value = std::strtoull(str.data(), &endptr, base);
-    if (endptr != str.data() + str.size()) {
-      return std::nullopt;
-    }
-
-    if (errno == ERANGE || errno == EINVAL) {
-      return std::nullopt;
-    }
-    value = temp_value;
-  } else {
-    long long temp_value = std::strtoll(str.data(), &endptr, base);
-    if (endptr != str.data() + str.size()) {
-      return std::nullopt;
-    }
-
-    if (errno == ERANGE || errno == EINVAL) {
-      return std::nullopt;
-    }
-    if (temp_value < std::numeric_limits<T>::min() ||
-        temp_value > std::numeric_limits<T>::max()) {
-      return std::nullopt;
-    }
-
-    value = temp_value;
-  }
-
-  return value;
 }
 
-template <typename T>
+template<typename T>
+bool
+TryParseIngegralImpl(T &value, Slice s)
+{
+    s = Trim(s);
+    if (s.empty()) { return false; }
+
+    T sign = 1;
+    if (s[0] == '+' || s[0] == '-') {
+        if (s[0] == '-') { sign = -1; }
+        s.RemovePrefix(1);
+        s = TrimLeft(s);
+
+        if (s.empty()) { return false; }
+    }
+}
+
+template<typename T>
 std::optional<T>
-TryParseTraits<T, typename std::enable_if<std::is_floating_point<T>::value>::
-                      type>::TryParse(Slice s) {
-  char temp_buffer[129];
-  std::string heap_buffer;
-  const char *ptr;
-  if (TILE_LIKELY(s.size() < 128)) {
-    ptr = temp_buffer;
-    memcpy(temp_buffer, s.data(), s.size());
-    temp_buffer[s.size()] = 0;
-  } else {
-    heap_buffer.assign(s.data(), s.size());
-    ptr = heap_buffer.data();
-  }
+TryParseTraits<T, typename std::enable_if<std::is_integral<T>::value>::type>::TryParse(Slice s, int base)
+{
+    assert(base >= 2 && base <= 36);
 
-  if (std::is_same<T, float>::value) {
-    return TryParseImpl<float>(&strtof, ptr, {-HUGE_VALF, HUGE_VALF});
-  } else if (std::is_same<T, double>::value) {
-    return TryParseImpl<double>(&strtod, ptr, {-HUGE_VAL, HUGE_VAL});
-  } else if (std::is_same<T, long double>::value) {
-    return TryParseImpl<long double>(&strtold, ptr, {-HUGE_VALL, HUGE_VALL});
-  }
+    if (s.empty()) { return std::nullopt; }
 
-  TILE_UNREACHABLE("unknown floating point type, {}", GetTypeName<T>());
-  return std::nullopt;
+    const std::string str = s.ToString();
+    char *endptr          = nullptr;
+    T value;
+
+    LastErrorStasher _;
+    if (std::is_same<T, unsigned long long>::value || std::is_same<T, std::uint64_t>::value) {
+        unsigned long long temp_value = std::strtoull(str.data(), &endptr, base);
+        if (endptr != str.data() + str.size()) { return std::nullopt; }
+
+        if (errno == ERANGE || errno == EINVAL) { return std::nullopt; }
+        value = temp_value;
+    } else {
+        long long temp_value = std::strtoll(str.data(), &endptr, base);
+        if (endptr != str.data() + str.size()) { return std::nullopt; }
+
+        if (errno == ERANGE || errno == EINVAL) { return std::nullopt; }
+        if (temp_value < std::numeric_limits<T>::min() || temp_value > std::numeric_limits<T>::max()) {
+            return std::nullopt;
+        }
+
+        value = temp_value;
+    }
+
+    return value;
+}
+
+template<typename T>
+std::optional<T>
+TryParseTraits<T, typename std::enable_if<std::is_floating_point<T>::value>::type>::TryParse(Slice s)
+{
+    char temp_buffer[129];
+    std::string heap_buffer;
+    const char *ptr;
+    if (TILE_LIKELY(s.size() < 128)) {
+        ptr = temp_buffer;
+        memcpy(temp_buffer, s.data(), s.size());
+        temp_buffer[s.size()] = 0;
+    } else {
+        heap_buffer.assign(s.data(), s.size());
+        ptr = heap_buffer.data();
+    }
+
+    if (std::is_same<T, float>::value) {
+        return TryParseImpl<float>(&strtof, ptr, {-HUGE_VALF, HUGE_VALF});
+    } else if (std::is_same<T, double>::value) {
+        return TryParseImpl<double>(&strtod, ptr, {-HUGE_VAL, HUGE_VAL});
+    } else if (std::is_same<T, long double>::value) {
+        return TryParseImpl<long double>(&strtold, ptr, {-HUGE_VALL, HUGE_VALL});
+    }
+
+    TILE_UNREACHABLE("unknown floating point type, {}", GetTypeName<T>());
+    return std::nullopt;
 }
 
 #define INSTANIATE_TRY_PARSE_TRAITS(type) template struct TryParseTraits<type>;
@@ -370,4 +381,4 @@ INSTANIATE_TRY_PARSE_TRAITS(float);
 INSTANIATE_TRY_PARSE_TRAITS(double);
 INSTANIATE_TRY_PARSE_TRAITS(long double);
 
-} // namespace tile
+}// namespace tile
diff --git a/tile/base/string.h b/tile/base/string.h
index 46b5143..267ed5d 100644
--- a/tile/base/string.h
+++ b/tile/base/string.h
@@ -11,14 +11,21 @@
 #include <limits>
 #include <string>
 #include <vector>
+
 namespace tile {
 
-template <typename... Args> std::string Format(Slice fmt, Args &&...args) {
-  return fmt::format(fmt.ToString(), std::forward<Args>(args)...);
+template<typename... Args>
+std::string
+Format(Slice fmt, Args &&...args)
+{
+    return fmt::format(fmt.ToString(), std::forward<Args>(args)...);
 }
-template <typename OutputIt, typename... Args>
-OutputIt FormatTo(OutputIt out, Slice fmt, Args &&...args) {
-  return fmt::format_to(out, fmt.ToString(), std::forward<Args>(args)...);
+
+template<typename OutputIt, typename... Args>
+OutputIt
+FormatTo(OutputIt out, Slice fmt, Args &&...args)
+{
+    return fmt::format_to(out, fmt.ToString(), std::forward<Args>(args)...);
 }
 
 // 一些基本函数
@@ -28,11 +35,8 @@ bool EndsWith(Slice s, Slice prefix);
 bool StartsWithIgnoreCase(Slice s, Slice prefix);
 bool EndsWithIgnoreCase(Slice s, Slice prefix);
 
-void Replace(Slice from, Slice to, std::string *str,
-             std::size_t count = std::numeric_limits<std::size_t>::max());
-std::string
-Replace(Slice str, Slice from, Slice to,
-        std::size_t count = std::numeric_limits<std::size_t>::max());
+void Replace(Slice from, Slice to, std::string *str, std::size_t count = std::numeric_limits<std::size_t>::max());
+std::string Replace(Slice str, Slice from, Slice to, std::size_t count = std::numeric_limits<std::size_t>::max());
 
 Slice TrimLeft(Slice s, Slice cutset);
 Slice TrimRight(Slice s, Slice cutset);
@@ -41,12 +45,14 @@ Slice TrimLeft(Slice s, std::function<bool(char)> pred = isspace);
 Slice TrimRight(Slice s, std::function<bool(char)> pred = isspace);
 Slice Trim(Slice s, std::function<bool(char)> pred = isspace);
 
-std::vector<Slice>
-Split(Slice s, char delim, bool keep_empty = false,
-      std::size_t max_split_parts = std::numeric_limits<std::size_t>::max());
-std::vector<Slice>
-Split(Slice s, Slice delim, bool keep_empty = false,
-      std::size_t max_split_parts = std::numeric_limits<std::size_t>::max());
+std::vector<Slice> Split(Slice s,
+                         char delim,
+                         bool keep_empty             = false,
+                         std::size_t max_split_parts = std::numeric_limits<std::size_t>::max());
+std::vector<Slice> Split(Slice s,
+                         Slice delim,
+                         bool keep_empty             = false,
+                         std::size_t max_split_parts = std::numeric_limits<std::size_t>::max());
 
 std::string Join(const std::vector<std::string> &parts, Slice delim);
 std::string Join(const std::vector<Slice> &parts, Slice delim);
@@ -59,25 +65,27 @@ void ToLower(std::string *str);
 std::string ToUpper(Slice s);
 std::string ToLower(Slice s);
 
-bool Equals(Slice a, Slice b,
-            std::size_t len = std::numeric_limits<std::size_t>::max());
-bool EqualsIgnoreCase(
-    Slice a, Slice b,
-    std::size_t len = std::numeric_limits<std::size_t>::max());
+bool Equals(Slice a, Slice b, std::size_t len = std::numeric_limits<std::size_t>::max());
+bool EqualsIgnoreCase(Slice a, Slice b, std::size_t len = std::numeric_limits<std::size_t>::max());
 
 // TryParse
-template <typename T, typename = void> struct TryParseTraits;
+template<typename T, typename = void>
+struct TryParseTraits;
 
-template <typename T, typename... Args>
-std::optional<T> TryParse(Slice s, const Args &...args) {
-  return TryParseTraits<T>::TryParse(s, args...);
+template<typename T, typename... Args>
+std::optional<T>
+TryParse(Slice s, const Args &...args)
+{
+    return TryParseTraits<T>::TryParse(s, args...);
 }
 
-template <typename T, typename> struct TryParseTraits {
-  template <typename... Args>
-  static std::optional<T> TryParse(Slice s, const Args &...args) {
-    return TryParse(std::common_type<T>(), s, args...);
-  }
+template<typename T, typename>
+struct TryParseTraits {
+    template<typename... Args>
+    static std::optional<T> TryParse(Slice s, const Args &...args)
+    {
+        return TryParse(std::common_type<T>(), s, args...);
+    }
 };
 
 // String to bool
@@ -85,26 +93,23 @@ template <typename T, typename> struct TryParseTraits {
 // 2. "yes" or "no"
 // 3. "on" or "off"
 // 4. non-zero or zero
-template <> struct TryParseTraits<bool> {
-  static std::optional<bool> TryParse(Slice s,
-                                      bool recognizes_alpbabet_symbol = true,
-                                      bool ignore_case = true);
+template<>
+struct TryParseTraits<bool> {
+    static std::optional<bool> TryParse(Slice s, bool recognizes_alpbabet_symbol = true, bool ignore_case = true);
 };
 
 // string to number
-template <typename T>
-struct TryParseTraits<
-    T, typename std::enable_if<std::is_integral<T>::value>::type> {
-  static std::optional<T> TryParse(Slice s, int base = 10);
+template<typename T>
+struct TryParseTraits<T, typename std::enable_if<std::is_integral<T>::value>::type> {
+    static std::optional<T> TryParse(Slice s, int base = 10);
 };
 
 // string to decimal
-template <typename T>
-struct TryParseTraits<
-    T, typename std::enable_if<std::is_floating_point<T>::value>::type> {
-  static std::optional<T> TryParse(Slice s);
+template<typename T>
+struct TryParseTraits<T, typename std::enable_if<std::is_floating_point<T>::value>::type> {
+    static std::optional<T> TryParse(Slice s);
 };
 
-} // namespace tile
+}// namespace tile
 
-#endif // _TILE_BASE_STRING_H
+#endif// _TILE_BASE_STRING_H
diff --git a/tile/base/string_test.cc b/tile/base/string_test.cc
index 19cdca7..79697a9 100644
--- a/tile/base/string_test.cc
+++ b/tile/base/string_test.cc
@@ -8,296 +8,319 @@
 #include <cmath>
 
 namespace tile {
-TEST(String, TryParseIntegral) {
-  ASSERT_FALSE(TryParse<int>(std::string(123456, 'a')));
-  ASSERT_FALSE(TryParse<int>(""));
-  ASSERT_FALSE(TryParse<int>("a"));
-  ASSERT_FALSE(TryParse<int>("1-2"));
+TEST(String, TryParseIntegral)
+{
+    ASSERT_FALSE(TryParse<int>(std::string(123456, 'a')));
+    ASSERT_FALSE(TryParse<int>(""));
+    ASSERT_FALSE(TryParse<int>("a"));
+    ASSERT_FALSE(TryParse<int>("1-2"));
 
-  ASSERT_FALSE(TryParse<std::int8_t>(std::to_string(INT8_MAX + 1LL)));
-  ASSERT_FALSE(TryParse<std::int8_t>(std::to_string(INT8_MIN - 1LL)));
-  ASSERT_FALSE(TryParse<std::uint8_t>(std::to_string(UINT8_MAX + 1LL)));
-  ASSERT_FALSE(TryParse<std::uint8_t>("-1"));
+    ASSERT_FALSE(TryParse<std::int8_t>(std::to_string(INT8_MAX + 1LL)));
+    ASSERT_FALSE(TryParse<std::int8_t>(std::to_string(INT8_MIN - 1LL)));
+    ASSERT_FALSE(TryParse<std::uint8_t>(std::to_string(UINT8_MAX + 1LL)));
+    ASSERT_FALSE(TryParse<std::uint8_t>("-1"));
 
-  ASSERT_FALSE(TryParse<std::int16_t>(std::to_string(INT16_MAX + 1LL)));
-  ASSERT_FALSE(TryParse<std::int16_t>(std::to_string(INT16_MIN - 1LL)));
-  ASSERT_FALSE(TryParse<std::uint16_t>(std::to_string(UINT16_MAX + 1LL)));
-  ASSERT_FALSE(TryParse<std::uint16_t>("-1"));
+    ASSERT_FALSE(TryParse<std::int16_t>(std::to_string(INT16_MAX + 1LL)));
+    ASSERT_FALSE(TryParse<std::int16_t>(std::to_string(INT16_MIN - 1LL)));
+    ASSERT_FALSE(TryParse<std::uint16_t>(std::to_string(UINT16_MAX + 1LL)));
+    ASSERT_FALSE(TryParse<std::uint16_t>("-1"));
 
-  ASSERT_FALSE(TryParse<std::int32_t>(std::to_string(INT32_MAX + 1LL)));
-  ASSERT_FALSE(TryParse<std::int32_t>(std::to_string(INT32_MIN - 1LL)));
-  ASSERT_FALSE(TryParse<std::uint32_t>(std::to_string(UINT32_MAX + 1LL)));
-  ASSERT_FALSE(TryParse<std::uint32_t>("-1"));
+    ASSERT_FALSE(TryParse<std::int32_t>(std::to_string(INT32_MAX + 1LL)));
+    ASSERT_FALSE(TryParse<std::int32_t>(std::to_string(INT32_MIN - 1LL)));
+    ASSERT_FALSE(TryParse<std::uint32_t>(std::to_string(UINT32_MAX + 1LL)));
+    ASSERT_FALSE(TryParse<std::uint32_t>("-1"));
 
-  ASSERT_FALSE(TryParse<std::int64_t>(std::to_string(INT64_MAX + 1ULL)));
-  ASSERT_FALSE(TryParse<std::int64_t>(std::to_string(INT64_MIN) + "0"));
-  ASSERT_FALSE(TryParse<std::uint64_t>(std::to_string(UINT64_MAX) + "0"));
-  // FIXME: TryParse<std::uint64_t>("-1") should return false.
-  // ASSERT_FALSE(TryParse<std::uint64_t>("-1"));
+    ASSERT_FALSE(TryParse<std::int64_t>(std::to_string(INT64_MAX + 1ULL)));
+    ASSERT_FALSE(TryParse<std::int64_t>(std::to_string(INT64_MIN) + "0"));
+    ASSERT_FALSE(TryParse<std::uint64_t>(std::to_string(UINT64_MAX) + "0"));
+    // FIXME: TryParse<std::uint64_t>("-1") should return false.
+    // ASSERT_FALSE(TryParse<std::uint64_t>("-1"));
 
-  ASSERT_TRUE(TryParse<int>("0"));
-  ASSERT_TRUE(TryParse<std::int64_t>(std::to_string(INT64_MAX)));
-  ASSERT_TRUE(TryParse<std::int8_t>("0"));
-  ASSERT_TRUE(TryParse<std::uint8_t>("0"));
-  ASSERT_TRUE(TryParse<std::int16_t>("0"));
-  ASSERT_TRUE(TryParse<std::uint16_t>("0"));
-  ASSERT_TRUE(TryParse<std::int32_t>("0"));
-  ASSERT_TRUE(TryParse<std::uint32_t>("0"));
-  ASSERT_TRUE(TryParse<std::int64_t>("0"));
-  ASSERT_TRUE(TryParse<std::uint64_t>("0"));
+    ASSERT_TRUE(TryParse<int>("0"));
+    ASSERT_TRUE(TryParse<std::int64_t>(std::to_string(INT64_MAX)));
+    ASSERT_TRUE(TryParse<std::int8_t>("0"));
+    ASSERT_TRUE(TryParse<std::uint8_t>("0"));
+    ASSERT_TRUE(TryParse<std::int16_t>("0"));
+    ASSERT_TRUE(TryParse<std::uint16_t>("0"));
+    ASSERT_TRUE(TryParse<std::int32_t>("0"));
+    ASSERT_TRUE(TryParse<std::uint32_t>("0"));
+    ASSERT_TRUE(TryParse<std::int64_t>("0"));
+    ASSERT_TRUE(TryParse<std::uint64_t>("0"));
 
-  for (int i = -100; i != 100; ++i) {
-    auto rc = TryParse<int>(std::to_string(i));
-    ASSERT_TRUE(rc);
-    ASSERT_EQ(*rc, i);
-  }
-  for (int i = 0; i != 100000; ++i) {
-    auto x = Random<std::int64_t>();
-    auto rc = TryParse<std::int64_t>(std::to_string(x));
-    ASSERT_TRUE(rc);
-    ASSERT_EQ(x, *rc);
-  }
-  for (int i = 0; i != 100000; ++i) {
-    auto x = Random<std::uint64_t>();
-    auto rc = TryParse<std::uint64_t>(std::to_string(x));
-    ASSERT_TRUE(rc);
-    ASSERT_EQ(x, *rc);
-  }
-}
-
-TEST(String, TryParseFloatingPoint) {
-  ASSERT_FALSE(TryParse<float>(""));
-  ASSERT_FALSE(TryParse<double>(""));
-  ASSERT_FALSE(TryParse<long double>(""));
-  ASSERT_FALSE(TryParse<double>("a"));
-  ASSERT_FALSE(TryParse<long double>("a"));
-
-  ASSERT_TRUE(TryParse<float>(std::to_string(HUGE_VALF)));
-  ASSERT_TRUE(TryParse<float>(std::to_string(-HUGE_VALF)));
-  ASSERT_TRUE(TryParse<double>(std::to_string(HUGE_VAL)));
-  ASSERT_TRUE(TryParse<double>(std::to_string(-HUGE_VAL)));
-  ASSERT_TRUE(TryParse<long double>(std::to_string(HUGE_VALL)));
-  ASSERT_TRUE(TryParse<long double>(std::to_string(-HUGE_VALL)));
-
-  for (int i = 0; i != 100000; ++i) {
-    auto x = 1.0 * Random() * Random();
-    {
-      auto rc = TryParse<float>(std::to_string(x));
-      ASSERT_TRUE(rc);
-      ASSERT_NEAR(x, *rc, fabs(x + *rc) / 2 * 1e-5);
+    for (int i = -100; i != 100; ++i) {
+        auto rc = TryParse<int>(std::to_string(i));
+        ASSERT_TRUE(rc);
+        ASSERT_EQ(*rc, i);
     }
-    {
-      auto rc = TryParse<double>(std::to_string(x));
-      ASSERT_TRUE(rc);
-      ASSERT_NEAR(x, *rc, fabs(x + *rc) / 2 * 1e-5);
+    for (int i = 0; i != 100000; ++i) {
+        auto x  = Random<std::int64_t>();
+        auto rc = TryParse<std::int64_t>(std::to_string(x));
+        ASSERT_TRUE(rc);
+        ASSERT_EQ(x, *rc);
     }
-    {
-      auto rc = TryParse<long double>(std::to_string(x));
-      ASSERT_TRUE(rc);
-      ASSERT_NEAR(x, *rc, fabsl(x + *rc) / 2 * 1e-5);
+    for (int i = 0; i != 100000; ++i) {
+        auto x  = Random<std::uint64_t>();
+        auto rc = TryParse<std::uint64_t>(std::to_string(x));
+        ASSERT_TRUE(rc);
+        ASSERT_EQ(x, *rc);
     }
-  }
 }
 
-TEST(String, TryParseBool) {
-  ASSERT_FALSE(TryParse<bool>(""));
-  ASSERT_FALSE(TryParse<bool>(".."));
-  ASSERT_TRUE(TryParse<bool>("2"));
+TEST(String, TryParseFloatingPoint)
+{
+    ASSERT_FALSE(TryParse<float>(""));
+    ASSERT_FALSE(TryParse<double>(""));
+    ASSERT_FALSE(TryParse<long double>(""));
+    ASSERT_FALSE(TryParse<double>("a"));
+    ASSERT_FALSE(TryParse<long double>("a"));
 
-  ASSERT_TRUE(TryParse<bool>("1"));
-  ASSERT_TRUE(TryParse<bool>("0"));
-  ASSERT_TRUE(TryParse<bool>("y"));
-  ASSERT_TRUE(TryParse<bool>("n"));
-  ASSERT_TRUE(TryParse<bool>("Y"));
-  ASSERT_TRUE(TryParse<bool>("N"));
-  ASSERT_TRUE(TryParse<bool>("Yes"));
-  ASSERT_TRUE(TryParse<bool>("nO"));
-  ASSERT_TRUE(TryParse<bool>("TRue"));
-  ASSERT_TRUE(TryParse<bool>("faLse"));
+    ASSERT_TRUE(TryParse<float>(std::to_string(HUGE_VALF)));
+    ASSERT_TRUE(TryParse<float>(std::to_string(-HUGE_VALF)));
+    ASSERT_TRUE(TryParse<double>(std::to_string(HUGE_VAL)));
+    ASSERT_TRUE(TryParse<double>(std::to_string(-HUGE_VAL)));
+    ASSERT_TRUE(TryParse<long double>(std::to_string(HUGE_VALL)));
+    ASSERT_TRUE(TryParse<long double>(std::to_string(-HUGE_VALL)));
 
-  ASSERT_TRUE(*TryParse<bool>("1"));
-  ASSERT_FALSE(*TryParse<bool>("0"));
-  ASSERT_TRUE(*TryParse<bool>("y"));
-  ASSERT_FALSE(*TryParse<bool>("n"));
-  ASSERT_TRUE(*TryParse<bool>("Y"));
-  ASSERT_FALSE(*TryParse<bool>("N"));
-  ASSERT_TRUE(*TryParse<bool>("yeS"));
-  ASSERT_FALSE(*TryParse<bool>("No"));
-  ASSERT_TRUE(*TryParse<bool>("tRUe"));
-  ASSERT_FALSE(*TryParse<bool>("falsE"));
+    for (int i = 0; i != 100000; ++i) {
+        auto x = 1.0 * Random() * Random();
+        {
+            auto rc = TryParse<float>(std::to_string(x));
+            ASSERT_TRUE(rc);
+            ASSERT_NEAR(x, *rc, fabs(x + *rc) / 2 * 1e-5);
+        }
+        {
+            auto rc = TryParse<double>(std::to_string(x));
+            ASSERT_TRUE(rc);
+            ASSERT_NEAR(x, *rc, fabs(x + *rc) / 2 * 1e-5);
+        }
+        {
+            auto rc = TryParse<long double>(std::to_string(x));
+            ASSERT_TRUE(rc);
+            ASSERT_NEAR(x, *rc, fabsl(x + *rc) / 2 * 1e-5);
+        }
+    }
 }
 
-TEST(String, StartsWith) {
-  ASSERT_TRUE(StartsWith("asdf", "asdf"));
-  ASSERT_TRUE(StartsWith("asdf", "asd"));
-  ASSERT_TRUE(StartsWith("asdf", "as"));
-  ASSERT_TRUE(StartsWith("asdf", "a"));
-  ASSERT_TRUE(StartsWith("asdf", ""));
-  ASSERT_TRUE(StartsWith("", ""));
-  ASSERT_TRUE(!StartsWith("asdf", "b"));
-  ASSERT_TRUE(!StartsWith("", "b"));
+TEST(String, TryParseBool)
+{
+    ASSERT_FALSE(TryParse<bool>(""));
+    ASSERT_FALSE(TryParse<bool>(".."));
+    ASSERT_TRUE(TryParse<bool>("2"));
+
+    ASSERT_TRUE(TryParse<bool>("1"));
+    ASSERT_TRUE(TryParse<bool>("0"));
+    ASSERT_TRUE(TryParse<bool>("y"));
+    ASSERT_TRUE(TryParse<bool>("n"));
+    ASSERT_TRUE(TryParse<bool>("Y"));
+    ASSERT_TRUE(TryParse<bool>("N"));
+    ASSERT_TRUE(TryParse<bool>("Yes"));
+    ASSERT_TRUE(TryParse<bool>("nO"));
+    ASSERT_TRUE(TryParse<bool>("TRue"));
+    ASSERT_TRUE(TryParse<bool>("faLse"));
+
+    ASSERT_TRUE(*TryParse<bool>("1"));
+    ASSERT_FALSE(*TryParse<bool>("0"));
+    ASSERT_TRUE(*TryParse<bool>("y"));
+    ASSERT_FALSE(*TryParse<bool>("n"));
+    ASSERT_TRUE(*TryParse<bool>("Y"));
+    ASSERT_FALSE(*TryParse<bool>("N"));
+    ASSERT_TRUE(*TryParse<bool>("yeS"));
+    ASSERT_FALSE(*TryParse<bool>("No"));
+    ASSERT_TRUE(*TryParse<bool>("tRUe"));
+    ASSERT_FALSE(*TryParse<bool>("falsE"));
 }
 
-TEST(String, EndsWith) {
-  ASSERT_TRUE(EndsWith("asdf", "asdf"));
-  ASSERT_TRUE(EndsWith("asdf", "sdf"));
-  ASSERT_TRUE(EndsWith("asdf", "df"));
-  ASSERT_TRUE(EndsWith("asdf", "f"));
-  ASSERT_TRUE(EndsWith("asdf", ""));
-  ASSERT_TRUE(EndsWith("", ""));
-  ASSERT_TRUE(!EndsWith("asdf", "b"));
-  ASSERT_TRUE(!EndsWith("", "b"));
+TEST(String, StartsWith)
+{
+    ASSERT_TRUE(StartsWith("asdf", "asdf"));
+    ASSERT_TRUE(StartsWith("asdf", "asd"));
+    ASSERT_TRUE(StartsWith("asdf", "as"));
+    ASSERT_TRUE(StartsWith("asdf", "a"));
+    ASSERT_TRUE(StartsWith("asdf", ""));
+    ASSERT_TRUE(StartsWith("", ""));
+    ASSERT_TRUE(!StartsWith("asdf", "b"));
+    ASSERT_TRUE(!StartsWith("", "b"));
 }
 
-TEST(String, Replace) {
-  ASSERT_EQ("//////", Replace("////////////", "//", "/"));
-  ASSERT_EQ("aabb", Replace("bbbb", "b", "a", 2));
-  ASSERT_EQ("/././././", Replace("/.//.//.//./", "//", "/"));
-  ASSERT_EQ("/.//./././", Replace("/.///.//.//./", "//", "/"));
-  ASSERT_EQ("abbb", Replace("bbbb", "b", "a", 1));
-  ASSERT_EQ("//", Replace("//", "/", "/"));
-  ASSERT_EQ("", Replace("//", "/", ""));
-  ASSERT_EQ("//", Replace("///", "//", "/"));
+TEST(String, EndsWith)
+{
+    ASSERT_TRUE(EndsWith("asdf", "asdf"));
+    ASSERT_TRUE(EndsWith("asdf", "sdf"));
+    ASSERT_TRUE(EndsWith("asdf", "df"));
+    ASSERT_TRUE(EndsWith("asdf", "f"));
+    ASSERT_TRUE(EndsWith("asdf", ""));
+    ASSERT_TRUE(EndsWith("", ""));
+    ASSERT_TRUE(!EndsWith("asdf", "b"));
+    ASSERT_TRUE(!EndsWith("", "b"));
 }
 
-TEST(String, Trim) {
-  ASSERT_EQ("", Trim(""));
-  ASSERT_EQ("", Trim(" "));
-  ASSERT_EQ("", Trim("  "));
-  ASSERT_EQ("", Trim("   "));
-  ASSERT_EQ("aa", Trim("aa"));
-  ASSERT_EQ("aa", Trim(" aa"));
-  ASSERT_EQ("aa", Trim("  aa"));
-  ASSERT_EQ("aa", Trim("aa "));
-  ASSERT_EQ("aa", Trim("aa  "));
-  ASSERT_EQ("aa", Trim(" aa "));
-  ASSERT_EQ("aa", Trim("  aa "));
-  ASSERT_EQ("aa", Trim(" aa  "));
-  ASSERT_EQ("aa", Trim("  aa  "));
-  ASSERT_EQ("a a", Trim("  a a  "));
+TEST(String, Replace)
+{
+    ASSERT_EQ("//////", Replace("////////////", "//", "/"));
+    ASSERT_EQ("aabb", Replace("bbbb", "b", "a", 2));
+    ASSERT_EQ("/././././", Replace("/.//.//.//./", "//", "/"));
+    ASSERT_EQ("/.//./././", Replace("/.///.//.//./", "//", "/"));
+    ASSERT_EQ("abbb", Replace("bbbb", "b", "a", 1));
+    ASSERT_EQ("//", Replace("//", "/", "/"));
+    ASSERT_EQ("", Replace("//", "/", ""));
+    ASSERT_EQ("//", Replace("///", "//", "/"));
 }
 
-TEST(String, Split1) {
-  auto splited = Split("/a/b/c/d/e/f///g", '/');
-  ASSERT_EQ(7, splited.size());
-  ASSERT_EQ("a", splited[0]);
-  ASSERT_EQ("b", splited[1]);
-  ASSERT_EQ("c", splited[2]);
-  ASSERT_EQ("d", splited[3]);
-  ASSERT_EQ("e", splited[4]);
-  ASSERT_EQ("f", splited[5]);
-  ASSERT_EQ("g", splited[6]);
+TEST(String, Trim)
+{
+    ASSERT_EQ("", Trim(""));
+    ASSERT_EQ("", Trim(" "));
+    ASSERT_EQ("", Trim("  "));
+    ASSERT_EQ("", Trim("   "));
+    ASSERT_EQ("aa", Trim("aa"));
+    ASSERT_EQ("aa", Trim(" aa"));
+    ASSERT_EQ("aa", Trim("  aa"));
+    ASSERT_EQ("aa", Trim("aa "));
+    ASSERT_EQ("aa", Trim("aa  "));
+    ASSERT_EQ("aa", Trim(" aa "));
+    ASSERT_EQ("aa", Trim("  aa "));
+    ASSERT_EQ("aa", Trim(" aa  "));
+    ASSERT_EQ("aa", Trim("  aa  "));
+    ASSERT_EQ("a a", Trim("  a a  "));
 }
 
-TEST(String, Split2) {
-  auto splited = Split("a///g/", '/');
-  ASSERT_EQ(2, splited.size());
-  ASSERT_EQ(splited[0], "a");
-  ASSERT_EQ(splited[1], "g");
+TEST(String, Split1)
+{
+    auto splited = Split("/a/b/c/d/e/f///g", '/');
+    ASSERT_EQ(7, splited.size());
+    ASSERT_EQ("a", splited[0]);
+    ASSERT_EQ("b", splited[1]);
+    ASSERT_EQ("c", splited[2]);
+    ASSERT_EQ("d", splited[3]);
+    ASSERT_EQ("e", splited[4]);
+    ASSERT_EQ("f", splited[5]);
+    ASSERT_EQ("g", splited[6]);
 }
 
-TEST(String, Split3) {
-  auto splited = Split("/////a/g", '/');
-  ASSERT_EQ(2, splited.size());
-  ASSERT_EQ("a", splited[0]);
-  ASSERT_EQ("g", splited[1]);
+TEST(String, Split2)
+{
+    auto splited = Split("a///g/", '/');
+    ASSERT_EQ(2, splited.size());
+    ASSERT_EQ(splited[0], "a");
+    ASSERT_EQ(splited[1], "g");
 }
 
-TEST(String, Split4) {
-  auto splited = Split("/////a/g///", '/');
-  ASSERT_EQ(2, splited.size());
-  ASSERT_EQ("a", splited[0]);
-  ASSERT_EQ("g", splited[1]);
+TEST(String, Split3)
+{
+    auto splited = Split("/////a/g", '/');
+    ASSERT_EQ(2, splited.size());
+    ASSERT_EQ("a", splited[0]);
+    ASSERT_EQ("g", splited[1]);
 }
 
-TEST(String, Split5) {
-  auto splited = Split("////a//g//", "//");
-  ASSERT_EQ(2, splited.size());
-  ASSERT_EQ("a", splited[0]);
-  ASSERT_EQ("g", splited[1]);
+TEST(String, Split4)
+{
+    auto splited = Split("/////a/g///", '/');
+    ASSERT_EQ(2, splited.size());
+    ASSERT_EQ("a", splited[0]);
+    ASSERT_EQ("g", splited[1]);
 }
 
-TEST(String, Split6) {
-  auto splited = Split("//a//g", "//");
-  ASSERT_EQ(2, splited.size());
-  ASSERT_EQ("a", splited[0]);
-  ASSERT_EQ("g", splited[1]);
+TEST(String, Split5)
+{
+    auto splited = Split("////a//g//", "//");
+    ASSERT_EQ(2, splited.size());
+    ASSERT_EQ("a", splited[0]);
+    ASSERT_EQ("g", splited[1]);
 }
 
-TEST(String, Split7) {
-  auto splited = Split("a//g", "//");
-  ASSERT_EQ(2, splited.size());
-  ASSERT_EQ("a", splited[0]);
-  ASSERT_EQ("g", splited[1]);
+TEST(String, Split6)
+{
+    auto splited = Split("//a//g", "//");
+    ASSERT_EQ(2, splited.size());
+    ASSERT_EQ("a", splited[0]);
+    ASSERT_EQ("g", splited[1]);
 }
 
-TEST(String, Split8) {
-  auto splited = Split("//", "//");
-  ASSERT_EQ(0, splited.size());
+TEST(String, Split7)
+{
+    auto splited = Split("a//g", "//");
+    ASSERT_EQ(2, splited.size());
+    ASSERT_EQ("a", splited[0]);
+    ASSERT_EQ("g", splited[1]);
 }
 
-TEST(String, Split9) {
-  auto splited = Split("", '/');
-  ASSERT_EQ(0, splited.size());
+TEST(String, Split8)
+{
+    auto splited = Split("//", "//");
+    ASSERT_EQ(0, splited.size());
 }
 
-TEST(String, SplitWithLimit) {
-  auto splited = Split("a/b/c/d/e/f/g", '/', false, 3);
-  ASSERT_EQ(3, splited.size());
-  ASSERT_EQ(splited[0], "a");
-  ASSERT_EQ(splited[1], "b");
-  ASSERT_EQ(splited[2], "c/d/e/f/g");
+TEST(String, Split9)
+{
+    auto splited = Split("", '/');
+    ASSERT_EQ(0, splited.size());
 }
 
-TEST(String, SplitKeepEmpty1) {
-  auto splited = Split("///a//g///", '/', true);
-  ASSERT_EQ(9, splited.size());
-  ASSERT_EQ("", splited[0]);
-  ASSERT_EQ("", splited[1]);
-  ASSERT_EQ("", splited[2]);
-  ASSERT_EQ("a", splited[3]);
-  ASSERT_EQ("", splited[4]);
-  ASSERT_EQ("g", splited[5]);
-  ASSERT_EQ("", splited[6]);
-  ASSERT_EQ("", splited[7]);
-  ASSERT_EQ("", splited[8]);
+TEST(String, SplitWithLimit)
+{
+    auto splited = Split("a/b/c/d/e/f/g", '/', false, 3);
+    ASSERT_EQ(3, splited.size());
+    ASSERT_EQ(splited[0], "a");
+    ASSERT_EQ(splited[1], "b");
+    ASSERT_EQ(splited[2], "c/d/e/f/g");
 }
 
-TEST(String, SplitKeepEmpty2) {
-  auto splited = Split("//", "//", true);
-  ASSERT_EQ(2, splited.size());
-  ASSERT_EQ("", splited[0]);
-  ASSERT_EQ("", splited[1]);
+TEST(String, SplitKeepEmpty1)
+{
+    auto splited = Split("///a//g///", '/', true);
+    ASSERT_EQ(9, splited.size());
+    ASSERT_EQ("", splited[0]);
+    ASSERT_EQ("", splited[1]);
+    ASSERT_EQ("", splited[2]);
+    ASSERT_EQ("a", splited[3]);
+    ASSERT_EQ("", splited[4]);
+    ASSERT_EQ("g", splited[5]);
+    ASSERT_EQ("", splited[6]);
+    ASSERT_EQ("", splited[7]);
+    ASSERT_EQ("", splited[8]);
 }
 
-TEST(String, Join) {
-  ASSERT_EQ("a\nbb\nccc", Join({"a", "bb", "ccc"}, "\n"));
-  ASSERT_EQ("a\n\nbb\nccc", Join({"a", "", "bb", "ccc"}, "\n"));
-  ASSERT_EQ("a\n\nbb\nccc", Join({"a", "", "bb", "ccc"}, "\n"));
-  std::vector<Slice> s = {"a", "", "bb", "ccc"};
-  ASSERT_EQ("a\n\nbb\nccc", Join(s, "\n"));
+TEST(String, SplitKeepEmpty2)
+{
+    auto splited = Split("//", "//", true);
+    ASSERT_EQ(2, splited.size());
+    ASSERT_EQ("", splited[0]);
+    ASSERT_EQ("", splited[1]);
 }
 
-TEST(String, EqualsIgnoreCase) {
-  ASSERT_TRUE(EqualsIgnoreCase("abc", "abc"));
-  ASSERT_TRUE(EqualsIgnoreCase("abc", "aBc"));
-  ASSERT_TRUE(EqualsIgnoreCase("abc", "ABC"));
-  ASSERT_FALSE(EqualsIgnoreCase("abc", "ab"));
-  ASSERT_FALSE(EqualsIgnoreCase("abc", "abcd"));
-  ASSERT_FALSE(EqualsIgnoreCase("abc", "d"));
+TEST(String, Join)
+{
+    ASSERT_EQ("a\nbb\nccc", Join({"a", "bb", "ccc"}, "\n"));
+    ASSERT_EQ("a\n\nbb\nccc", Join({"a", "", "bb", "ccc"}, "\n"));
+    ASSERT_EQ("a\n\nbb\nccc", Join({"a", "", "bb", "ccc"}, "\n"));
+    std::vector<Slice> s = {"a", "", "bb", "ccc"};
+    ASSERT_EQ("a\n\nbb\nccc", Join(s, "\n"));
 }
 
-TEST(String, ToUpper) {
-  std::string s = "abCD";
-  ToUpper(&s);
-  ASSERT_EQ("ABCD", s);
-  ASSERT_EQ("ABCD", ToUpper("aBCd"));
+TEST(String, EqualsIgnoreCase)
+{
+    ASSERT_TRUE(EqualsIgnoreCase("abc", "abc"));
+    ASSERT_TRUE(EqualsIgnoreCase("abc", "aBc"));
+    ASSERT_TRUE(EqualsIgnoreCase("abc", "ABC"));
+    ASSERT_FALSE(EqualsIgnoreCase("abc", "ab"));
+    ASSERT_FALSE(EqualsIgnoreCase("abc", "abcd"));
+    ASSERT_FALSE(EqualsIgnoreCase("abc", "d"));
 }
 
-TEST(String, ToLower) {
-  std::string s = "abCD";
-  ToLower(&s);
-  ASSERT_EQ("abcd", s);
-  ASSERT_EQ("abcd", ToLower("aBCd"));
+TEST(String, ToUpper)
+{
+    std::string s = "abCD";
+    ToUpper(&s);
+    ASSERT_EQ("ABCD", s);
+    ASSERT_EQ("ABCD", ToUpper("aBCd"));
 }
-} // namespace tile
+
+TEST(String, ToLower)
+{
+    std::string s = "abCD";
+    ToLower(&s);
+    ASSERT_EQ("abcd", s);
+    ASSERT_EQ("abcd", ToLower("aBCd"));
+}
+}// namespace tile
diff --git a/tile/base/thread/cond_var.cc b/tile/base/thread/cond_var.cc
index 7e5dd8c..11f8eea 100644
--- a/tile/base/thread/cond_var.cc
+++ b/tile/base/thread/cond_var.cc
@@ -13,44 +13,66 @@ namespace cond_var {
 
 class CondVarProxy::Impl {
 public:
-  Impl() {}
-  ~Impl() {}
-  void NotifyOne() { cv_.notify_one(); }
-  void NotifyAll() { cv_.notify_all(); }
+    Impl() {}
 
-  void Wait(Mutex *m) {
-    std::mutex *p = reinterpret_cast<std::mutex *>(m->GetNativeHandle());
-    TILE_CHECK(p);
-    std::unique_lock<std::mutex> std_lock(*p, std::adopt_lock);
-    cv_.wait(std_lock);
-    std_lock.release();
-  }
+    ~Impl() {}
 
-  bool WaitFor(Mutex *m, std::size_t nanoseconds) {
-    std::mutex *p = static_cast<std::mutex *>(m->GetNativeHandle());
-    TILE_CHECK(p);
+    void NotifyOne() { cv_.notify_one(); }
 
-    std::unique_lock<std::mutex> std_lock(*p, std::adopt_lock);
-    bool res = cv_.wait_for(std_lock, std::chrono::nanoseconds(nanoseconds)) ==
-               std::cv_status::no_timeout;
-    std_lock.release();
-    return res;
-  }
+    void NotifyAll() { cv_.notify_all(); }
+
+    void Wait(Mutex *m)
+    {
+        std::mutex *p = reinterpret_cast<std::mutex *>(m->GetNativeHandle());
+        TILE_CHECK(p);
+        std::unique_lock<std::mutex> std_lock(*p, std::adopt_lock);
+        cv_.wait(std_lock);
+        std_lock.release();
+    }
+
+    bool WaitFor(Mutex *m, std::size_t nanoseconds)
+    {
+        std::mutex *p = static_cast<std::mutex *>(m->GetNativeHandle());
+        TILE_CHECK(p);
+
+        std::unique_lock<std::mutex> std_lock(*p, std::adopt_lock);
+        bool res = cv_.wait_for(std_lock, std::chrono::nanoseconds(nanoseconds)) == std::cv_status::no_timeout;
+        std_lock.release();
+        return res;
+    }
 
 private:
-  std::condition_variable cv_;
+    std::condition_variable cv_;
 };
 
 CondVarProxy::CondVarProxy() : impl_(make_unique<Impl>()) {}
+
 CondVarProxy::~CondVarProxy() {}
 
-void CondVarProxy::Wait(Mutex *mutex) { impl_->Wait(mutex); }
-bool CondVarProxy::WaitFor(Mutex *mutex, std::size_t nanoseconds) {
-  return impl_->WaitFor(mutex, nanoseconds);
+void
+CondVarProxy::Wait(Mutex *mutex)
+{
+    impl_->Wait(mutex);
 }
-void CondVarProxy::NotifyAll() { impl_->NotifyAll(); }
-void CondVarProxy::NotifyOne() { impl_->NotifyOne(); }
 
-} // namespace cond_var
-} // namespace detail
-} // namespace tile
+bool
+CondVarProxy::WaitFor(Mutex *mutex, std::size_t nanoseconds)
+{
+    return impl_->WaitFor(mutex, nanoseconds);
+}
+
+void
+CondVarProxy::NotifyAll()
+{
+    impl_->NotifyAll();
+}
+
+void
+CondVarProxy::NotifyOne()
+{
+    impl_->NotifyOne();
+}
+
+}// namespace cond_var
+}// namespace detail
+}// namespace tile
diff --git a/tile/base/thread/cond_var.h b/tile/base/thread/cond_var.h
index dd4b22c..9118a03 100644
--- a/tile/base/thread/cond_var.h
+++ b/tile/base/thread/cond_var.h
@@ -11,116 +11,114 @@
 namespace tile {
 class Mutex;
 class ScopedLock;
-template <typename M, typename... Args> class UniqueLock;
+template<typename M, typename... Args>
+class UniqueLock;
 
 namespace detail {
 namespace cond_var {
 
 class CondVarProxy {
 public:
-  CondVarProxy();
-  ~CondVarProxy();
-  void Wait(Mutex *mutex);
-  bool WaitFor(Mutex *mutex, std::size_t nanoseconds);
-  void NotifyAll();
-  void NotifyOne();
+    CondVarProxy();
+    ~CondVarProxy();
+    void Wait(Mutex *mutex);
+    bool WaitFor(Mutex *mutex, std::size_t nanoseconds);
+    void NotifyAll();
+    void NotifyOne();
 
 private:
-  class Impl;
-  std::unique_ptr<Impl> impl_;
+    class Impl;
+    std::unique_ptr<Impl> impl_;
 };
 
 class CondVar {
 public:
-  CondVar() = default;
-  ~CondVar() = default;
+    CondVar()  = default;
+    ~CondVar() = default;
 
-  template <typename LockType> void Wait(LockType &lock) {
-    proxy_.Wait(GetMutex(&lock));
-  }
-  template <typename LockType, typename Predicate>
-  void Wait(LockType &lock, Predicate pred) {
-    while (!pred()) {
-      Wait(lock);
-    }
-  }
-
-  template <typename LockType, typename Rep, typename Period>
-  bool WaitFor(LockType &lock,
-               const std::chrono::duration<Rep, Period> &timeout_duration) {
-    return proxy_.WaitFor(
-        GetMutex(&lock),
-        std::chrono::duration_cast<std::chrono::nanoseconds>(timeout_duration)
-            .count());
-  }
-
-  template <typename LockType, typename Rep, typename Period,
-            typename Predicate>
-  bool WaitFor(LockType &lock,
-               const std::chrono::duration<Rep, Period> &timeout_duration,
-               Predicate pred) {
-    if (!pred()) {
-      WaitFor(lock, timeout_duration);
-    }
-    return pred();
-  }
-
-  template <typename LockType, typename Clock, typename Duration>
-  bool WaitUntil(LockType &lock,
-                 const std::chrono::time_point<Clock, Duration> &abs_time) {
-    // TODO: use Clock
-    auto duration = abs_time - Clock::now();
-    if (duration.count() <= 0) {
-      // timeout
-      return false;
+    template<typename LockType>
+    void Wait(LockType &lock)
+    {
+        proxy_.Wait(GetMutex(&lock));
     }
 
-    return WaitFor(lock, duration);
-  }
-
-  template <typename LockType, typename Clock, typename Duration,
-            typename Predicate>
-  bool WaitUntil(LockType &lock,
-                 const std::chrono::time_point<Clock, Duration> &abs_time,
-                 Predicate pred) {
-    if (!pred()) {
-      WaitUntil(lock, abs_time);
+    template<typename LockType, typename Predicate>
+    void Wait(LockType &lock, Predicate pred)
+    {
+        while (!pred()) { Wait(lock); }
     }
-    return pred();
-  }
 
-  void NotifyOne() { proxy_.NotifyOne(); }
-  void NotifyAll() { proxy_.NotifyAll(); }
+    template<typename LockType, typename Rep, typename Period>
+    bool WaitFor(LockType &lock, const std::chrono::duration<Rep, Period> &timeout_duration)
+    {
+        return proxy_.WaitFor(GetMutex(&lock),
+                              std::chrono::duration_cast<std::chrono::nanoseconds>(timeout_duration).count());
+    }
+
+    template<typename LockType, typename Rep, typename Period, typename Predicate>
+    bool WaitFor(LockType &lock, const std::chrono::duration<Rep, Period> &timeout_duration, Predicate pred)
+    {
+        if (!pred()) { WaitFor(lock, timeout_duration); }
+        return pred();
+    }
+
+    template<typename LockType, typename Clock, typename Duration>
+    bool WaitUntil(LockType &lock, const std::chrono::time_point<Clock, Duration> &abs_time)
+    {
+        // TODO: use Clock
+        auto duration = abs_time - Clock::now();
+        if (duration.count() <= 0) {
+            // timeout
+            return false;
+        }
+
+        return WaitFor(lock, duration);
+    }
+
+    template<typename LockType, typename Clock, typename Duration, typename Predicate>
+    bool WaitUntil(LockType &lock, const std::chrono::time_point<Clock, Duration> &abs_time, Predicate pred)
+    {
+        if (!pred()) { WaitUntil(lock, abs_time); }
+        return pred();
+    }
+
+    void NotifyOne() { proxy_.NotifyOne(); }
+
+    void NotifyAll() { proxy_.NotifyAll(); }
 
 private:
-  template <typename C> struct has_get_mutex_fn {
-    template <typename U = C,
-              typename = enable_if_t<std::is_same<
-                  decltype(std::declval<U>().GetMutex()), Mutex *>::value>>
-    static int Test(int);
+    template<typename C>
+    struct has_get_mutex_fn {
+        template<typename U = C,
+                 typename   = enable_if_t<std::is_same<decltype(std::declval<U>().GetMutex()), Mutex *>::value>>
+        static int Test(int);
 
-    template <typename> static char Test(...);
+        template<typename>
+        static char Test(...);
 
-    static constexpr bool value =
-        std::is_same<decltype(Test<C>(0)), int>::value;
-  };
+        static constexpr bool value = std::is_same<decltype(Test<C>(0)), int>::value;
+    };
 
-  template <typename C>
-  enable_if_t<has_get_mutex_fn<C>::value, Mutex *> GetMutex(C *c) {
-    return c->GetMutex();
-  }
-  template <typename C>
-  enable_if_t<!has_get_mutex_fn<C>::value, Mutex *> GetMutex(C *c) {
-    static_assert(sizeof(C) == 0, "C does not have `Mutex* GetMutex()` method");
-    return nullptr;
-  }
+    template<typename C>
+    enable_if_t<has_get_mutex_fn<C>::value, Mutex *> GetMutex(C *c)
+    {
+        return c->GetMutex();
+    }
+
+    template<typename C>
+    enable_if_t<!has_get_mutex_fn<C>::value, Mutex *> GetMutex(C *c)
+    {
+        static_assert(sizeof(C) == 0, "C does not have `Mutex* GetMutex()` method");
+        return nullptr;
+    }
 
 private:
-  CondVarProxy proxy_;
+    CondVarProxy proxy_;
 };
-} // namespace cond_var
-} // namespace detail
-using CondVar = ::tile::detail::cond_var::CondVar;
-} // namespace tile
+}// namespace cond_var
+}// namespace detail
 
-#endif // TILE_BASE_THREAD_COND_VAR_H
+using CondVar = ::tile::detail::cond_var::CondVar;
+}// namespace tile
+
+#endif// TILE_BASE_THREAD_COND_VAR_H
diff --git a/tile/base/thread/cond_var_test.cc b/tile/base/thread/cond_var_test.cc
index 85ff911..25997db 100644
--- a/tile/base/thread/cond_var_test.cc
+++ b/tile/base/thread/cond_var_test.cc
@@ -11,122 +11,125 @@ namespace tile {
 
 class CondVarTest : public ::testing::Test {
 protected:
-  void SetUp() override {
-    m = new Mutex();
-    cv = new CondVar();
-    worker = nullptr;
-    ResetEnv();
-  }
-
-  void TearDown() override {
-    SetWorker(nullptr);
-    delete m;
-    delete cv;
-  }
-
-  void SetWorker(std::thread *new_worker) {
-    if (worker) {
-      if (worker->joinable()) {
-        worker->join();
-      }
-      delete worker;
+    void SetUp() override
+    {
+        m      = new Mutex();
+        cv     = new CondVar();
+        worker = nullptr;
+        ResetEnv();
     }
-    worker = new_worker;
-  }
 
-  void ResetEnv() {
-    is_started = false;
-    is_set = false;
-    is_timeout = false;
-  }
-
-  void SetStarted() { is_started = true; }
-
-  void WaitStarted() {
-    while (!is_started) {
-      std::this_thread::sleep_for(std::chrono::milliseconds(1));
+    void TearDown() override
+    {
+        SetWorker(nullptr);
+        delete m;
+        delete cv;
+    }
+
+    void SetWorker(std::thread *new_worker)
+    {
+        if (worker) {
+            if (worker->joinable()) { worker->join(); }
+            delete worker;
+        }
+        worker = new_worker;
+    }
+
+    void ResetEnv()
+    {
+        is_started = false;
+        is_set     = false;
+        is_timeout = false;
+    }
+
+    void SetStarted() { is_started = true; }
+
+    void WaitStarted()
+    {
+        while (!is_started) { std::this_thread::sleep_for(std::chrono::milliseconds(1)); }
     }
-  }
 
 protected:
-  Mutex *m;
-  CondVar *cv;
-  std::atomic<bool> is_started;
-  bool is_set;
-  bool is_timeout;
-  std::thread *worker;
+    Mutex *m;
+    CondVar *cv;
+    std::atomic<bool> is_started;
+    bool is_set;
+    bool is_timeout;
+    std::thread *worker;
 };
 
-TEST_F(CondVarTest, NotifyOne_Wait) {
-  // Wait
-  {
-    std::thread t1([&] {
-      // UniqueLock<Mutex> inner_locker(*m);
-      // cv->Wait(inner_locker);
-      ScopedLock inner_locker(*m);
-      SetStarted();
-      cv->Wait(inner_locker);
-      is_set = true;
-      cv->NotifyOne();
-    });
-
-    WaitStarted();
-    std::this_thread::sleep_for(std::chrono::milliseconds(50));
-    ASSERT_FALSE(is_set);
-
+TEST_F(CondVarTest, NotifyOne_Wait)
+{
+    // Wait
     {
-      UniqueLock<Mutex> locker(*m);
-      cv->NotifyOne();
+        std::thread t1([&] {
+            // UniqueLock<Mutex> inner_locker(*m);
+            // cv->Wait(inner_locker);
+            ScopedLock inner_locker(*m);
+            SetStarted();
+            cv->Wait(inner_locker);
+            is_set = true;
+            cv->NotifyOne();
+        });
+
+        WaitStarted();
+        std::this_thread::sleep_for(std::chrono::milliseconds(50));
+        ASSERT_FALSE(is_set);
+
+        {
+            UniqueLock<Mutex> locker(*m);
+            cv->NotifyOne();
+        }
+        TILE_LOG_INFO("yield the lock");
+        t1.join();
+        ASSERT_TRUE(is_set);
     }
-    TILE_LOG_INFO("yield the lock");
-    t1.join();
-    ASSERT_TRUE(is_set);
-  }
 }
 
-TEST_F(CondVarTest, NotifyOne_WaitFor) {
-  // Wait
-  // constexpr auto kWaitTimeoutMs = 100;
-  constexpr auto kWaitTimeout = std::chrono::milliseconds(100);
-  auto WaitFor = [&] {
-    UniqueLock<Mutex> inner_locker(*m);
-    SetStarted();
-    if (cv->WaitFor(inner_locker, kWaitTimeout)) {
-      is_set = true;
-      cv->NotifyOne();
-    } else {
-      is_timeout = true;
-    }
-  };
-
-  {
-
-    SetWorker(new std::thread(WaitFor));
-    WaitStarted();
-    ASSERT_FALSE(is_set);
+TEST_F(CondVarTest, NotifyOne_WaitFor)
+{
+    // Wait
+    // constexpr auto kWaitTimeoutMs = 100;
+    constexpr auto kWaitTimeout = std::chrono::milliseconds(100);
+    auto WaitFor                = [&] {
+        UniqueLock<Mutex> inner_locker(*m);
+        SetStarted();
+        if (cv->WaitFor(inner_locker, kWaitTimeout)) {
+            is_set = true;
+            cv->NotifyOne();
+        } else {
+            is_timeout = true;
+        }
+    };
 
     {
-      UniqueLock<Mutex> locker(*m);
-      cv->NotifyOne();
+
+        SetWorker(new std::thread(WaitFor));
+        WaitStarted();
+        ASSERT_FALSE(is_set);
+
+        {
+            UniqueLock<Mutex> locker(*m);
+            cv->NotifyOne();
+        }
+
+        worker->join();
+        ASSERT_FALSE(is_timeout);
+        ASSERT_TRUE(is_set);
     }
 
-    worker->join();
-    ASSERT_FALSE(is_timeout);
-    ASSERT_TRUE(is_set);
-  }
-
-  // timeout
-  {
-    ResetEnv();
-    SetWorker(new std::thread(WaitFor));
+    // timeout
     {
-      UniqueLock<Mutex> locker(*m);
-      ASSERT_FALSE(is_timeout);
+        ResetEnv();
+        SetWorker(new std::thread(WaitFor));
+        {
+            UniqueLock<Mutex> locker(*m);
+            ASSERT_FALSE(is_timeout);
+        }
+        worker->join();
+        ASSERT_TRUE(is_timeout);
+        ASSERT_FALSE(is_set);
     }
-    worker->join();
-    ASSERT_TRUE(is_timeout);
-    ASSERT_FALSE(is_set);
-  }
 }
 
-} // namespace tile
+}// namespace tile
diff --git a/tile/base/thread/event.h b/tile/base/thread/event.h
index 12747f4..61f9c2b 100644
--- a/tile/base/thread/event.h
+++ b/tile/base/thread/event.h
@@ -10,56 +10,63 @@
 namespace tile {
 class Event {
 public:
-  enum Mode { ManualReset, AutoReset };
-  explicit Event(Mode mode = ManualReset) : mode_(mode), signaled_(false) {}
+    enum Mode { ManualReset, AutoReset };
 
-  inline void Set() {
-    ScopedLock _(m_);
-    signaled_ = true;
-    cv_.NotifyAll();
-  }
-  inline void Reset() {
-    ScopedLock _(m_);
-    signaled_ = false;
-  }
-  inline void Wait() {
-    ScopedLock _(m_);
-    cv_.Wait(m_, [this] { return signaled_; });
-    ResetIfNeeded();
-  }
+    explicit Event(Mode mode = ManualReset) : mode_(mode), signaled_(false) {}
 
-  template <typename Rep, typename Period>
-  bool WaitFor(const std::chrono::duration<Rep, Period> &timeout) {
-    ScopedLock _(m_);
-    if (cv_.WaitFor(m_, timeout, [this] { return signaled_; })) {
-      ResetIfNeeded();
-      return true;
+    inline void Set()
+    {
+        ScopedLock _(m_);
+        signaled_ = true;
+        cv_.NotifyAll();
     }
-    return false;
-  }
 
-  template <typename Clock, typename Duration>
-  bool WaitUntil(const std::chrono::time_point<Clock, Duration> &timeout_time) {
-    ScopedLock _(m_);
-    if (cv_.WaitUntil(m_, timeout_time, [this] { return signaled_; })) {
-      ResetIfNeeded();
-      return true;
+    inline void Reset()
+    {
+        ScopedLock _(m_);
+        signaled_ = false;
+    }
+
+    inline void Wait()
+    {
+        ScopedLock _(m_);
+        cv_.Wait(m_, [this] { return signaled_; });
+        ResetIfNeeded();
+    }
+
+    template<typename Rep, typename Period>
+    bool WaitFor(const std::chrono::duration<Rep, Period> &timeout)
+    {
+        ScopedLock _(m_);
+        if (cv_.WaitFor(m_, timeout, [this] { return signaled_; })) {
+            ResetIfNeeded();
+            return true;
+        }
+        return false;
+    }
+
+    template<typename Clock, typename Duration>
+    bool WaitUntil(const std::chrono::time_point<Clock, Duration> &timeout_time)
+    {
+        ScopedLock _(m_);
+        if (cv_.WaitUntil(m_, timeout_time, [this] { return signaled_; })) {
+            ResetIfNeeded();
+            return true;
+        }
+        return false;
     }
-    return false;
-  }
 
 private:
-  inline void ResetIfNeeded() {
-    if (mode_ == AutoReset) {
-      signaled_ = false;
+    inline void ResetIfNeeded()
+    {
+        if (mode_ == AutoReset) { signaled_ = false; }
     }
-  }
 
-  const Mode mode_;
-  bool signaled_;
-  Mutex m_;
-  CondVar cv_;
+    const Mode mode_;
+    bool signaled_;
+    Mutex m_;
+    CondVar cv_;
 };
-} // namespace tile
+}// namespace tile
 
-#endif // TILE_BASE_THREAD_EVENT_H
+#endif// TILE_BASE_THREAD_EVENT_H
diff --git a/tile/base/thread/latch.cc b/tile/base/thread/latch.cc
index 583ae39..087e10a 100644
--- a/tile/base/thread/latch.cc
+++ b/tile/base/thread/latch.cc
@@ -1,36 +1,43 @@
 #include "tile/base/thread/latch.h"
+
 namespace tile {
 Latch::Latch(std::ptrdiff_t count) : count_(count) {}
 
-void Latch::CountDown(std::ptrdiff_t update) {
-  TILE_DCHECK_GT(update, 0);
+void
+Latch::CountDown(std::ptrdiff_t update)
+{
+    TILE_DCHECK_GT(update, 0);
 
-  {
-    UniqueLock<Mutex> _(m_);
-    TILE_CHECK_GE(count_, update);
-    count_ -= update;
+    {
+        UniqueLock<Mutex> _(m_);
+        TILE_CHECK_GE(count_, update);
+        count_ -= update;
 
-    if (count_ == 0) {
-      cv_.NotifyAll();
+        if (count_ == 0) { cv_.NotifyAll(); }
     }
-  }
 }
 
-bool Latch::TryWait() const noexcept {
-  UniqueLock<Mutex> _(m_);
-  TILE_CHECK_GE(count_, 0);
-  return !count_;
+bool
+Latch::TryWait() const noexcept
+{
+    UniqueLock<Mutex> _(m_);
+    TILE_CHECK_GE(count_, 0);
+    return !count_;
 }
 
-void Latch::Wait() const {
-  UniqueLock<Mutex> _(m_);
-  TILE_CHECK_GE(count_, 0);
-  cv_.Wait(_, [&] { return count_ == 0; });
+void
+Latch::Wait() const
+{
+    UniqueLock<Mutex> _(m_);
+    TILE_CHECK_GE(count_, 0);
+    cv_.Wait(_, [&] { return count_ == 0; });
 }
 
-void Latch::ArriveAndWait(std::ptrdiff_t update) {
-  CountDown(update);
-  Wait();
+void
+Latch::ArriveAndWait(std::ptrdiff_t update)
+{
+    CountDown(update);
+    Wait();
 }
 
-} // namespace tile
+}// namespace tile
diff --git a/tile/base/thread/latch.h b/tile/base/thread/latch.h
index 4d34575..3c239e8 100644
--- a/tile/base/thread/latch.h
+++ b/tile/base/thread/latch.h
@@ -10,33 +10,34 @@
 namespace tile {
 class Latch {
 public:
-  explicit Latch(std::ptrdiff_t count);
-  void CountDown(std::ptrdiff_t update = 1);
-  bool TryWait() const noexcept;
-  void Wait() const;
+    explicit Latch(std::ptrdiff_t count);
+    void CountDown(std::ptrdiff_t update = 1);
+    bool TryWait() const noexcept;
+    void Wait() const;
 
-  template <typename Rep, typename Period>
-  bool WaitFor(const std::chrono::duration<Rep, Period> &timeout) const {
-    UniqueLock<Mutex> lk(m_);
-    TILE_CHECK_GE(count_, 0);
-    return cv_.WaitFor(lk, timeout, [this] { return count_ == 0; });
-  }
+    template<typename Rep, typename Period>
+    bool WaitFor(const std::chrono::duration<Rep, Period> &timeout) const
+    {
+        UniqueLock<Mutex> lk(m_);
+        TILE_CHECK_GE(count_, 0);
+        return cv_.WaitFor(lk, timeout, [this] { return count_ == 0; });
+    }
 
-  template <typename Clock, typename Duration>
-  bool
-  WaitUntil(const std::chrono::time_point<Clock, Duration> &abs_time) const {
-    UniqueLock<Mutex> lk(m_);
-    TILE_CHECK_GE(count_, 0);
-    return cv_.WaitUntil(lk, abs_time, [this] { return count_ == 0; });
-  }
+    template<typename Clock, typename Duration>
+    bool WaitUntil(const std::chrono::time_point<Clock, Duration> &abs_time) const
+    {
+        UniqueLock<Mutex> lk(m_);
+        TILE_CHECK_GE(count_, 0);
+        return cv_.WaitUntil(lk, abs_time, [this] { return count_ == 0; });
+    }
 
-  void ArriveAndWait(std::ptrdiff_t update = 1);
+    void ArriveAndWait(std::ptrdiff_t update = 1);
 
 private:
-  mutable Mutex m_;
-  mutable CondVar cv_;
-  std::ptrdiff_t count_;
+    mutable Mutex m_;
+    mutable CondVar cv_;
+    std::ptrdiff_t count_;
 };
-} // namespace tile
+}// namespace tile
 
-#endif // TILE_BASE_THREAD_LATCH_H
+#endif// TILE_BASE_THREAD_LATCH_H
diff --git a/tile/base/thread/latch_test.cc b/tile/base/thread/latch_test.cc
index 0d2a1f8..34e3c5f 100644
--- a/tile/base/thread/latch_test.cc
+++ b/tile/base/thread/latch_test.cc
@@ -13,60 +13,62 @@ namespace tile {
 
 std::atomic<bool> exiting{false};
 
-void RunTest() {
-  std::size_t local_count = 0, remote_count = 0;
-  while (!exiting) {
-    auto called = std::make_shared<std::atomic<bool>>(false);
-    std::this_thread::yield(); // Wait for thread pool to start.
-    Latch l(1);
-    auto t = std::thread([&] {
-      if (!called->exchange(true)) {
-        std::this_thread::yield(); // Something costly.
-        l.CountDown();
-        ++remote_count;
-      }
-    });
-    std::this_thread::yield(); // Something costly.
-    if (!called->exchange(true)) {
-      l.CountDown();
-      ++local_count;
+void
+RunTest()
+{
+    std::size_t local_count = 0, remote_count = 0;
+    while (!exiting) {
+        auto called = std::make_shared<std::atomic<bool>>(false);
+        std::this_thread::yield();// Wait for thread pool to start.
+        Latch l(1);
+        auto t = std::thread([&] {
+            if (!called->exchange(true)) {
+                std::this_thread::yield();// Something costly.
+                l.CountDown();
+                ++remote_count;
+            }
+        });
+        std::this_thread::yield();// Something costly.
+        if (!called->exchange(true)) {
+            l.CountDown();
+            ++local_count;
+        }
+        l.Wait();
+        t.join();
     }
-    l.Wait();
-    t.join();
-  }
-  std::cout << local_count << " " << remote_count << std::endl;
+    std::cout << local_count << " " << remote_count << std::endl;
 }
 
-TEST(Latch, Torture) {
-  std::thread ts[10];
-  for (auto &&t : ts) {
-    t = std::thread(RunTest);
-  }
-  std::this_thread::sleep_for(std::chrono::seconds(1));
-  exiting = true;
-  for (auto &&t : ts) {
-    t.join();
-  }
+TEST(Latch, Torture)
+{
+    std::thread ts[10];
+    for (auto &&t : ts) { t = std::thread(RunTest); }
+    std::this_thread::sleep_for(std::chrono::seconds(1));
+    exiting = true;
+    for (auto &&t : ts) { t.join(); }
 }
 
-TEST(Latch, CountDownTwo) {
-  Latch l(2);
-  l.ArriveAndWait(2);
-  ASSERT_TRUE(1);
+TEST(Latch, CountDownTwo)
+{
+    Latch l(2);
+    l.ArriveAndWait(2);
+    ASSERT_TRUE(1);
 }
 
-TEST(Latch, WaitFor) {
-  Latch l(1);
-  ASSERT_FALSE(l.WaitFor(std::chrono::milliseconds(100)));
-  l.CountDown();
-  ASSERT_TRUE(l.WaitFor(std::chrono::seconds(0)));
+TEST(Latch, WaitFor)
+{
+    Latch l(1);
+    ASSERT_FALSE(l.WaitFor(std::chrono::milliseconds(100)));
+    l.CountDown();
+    ASSERT_TRUE(l.WaitFor(std::chrono::seconds(0)));
 }
 
-TEST(Latch, WaitUntil) {
-  Latch l(1);
-  ASSERT_FALSE(l.WaitUntil(ReadSteadyClock() + std::chrono::milliseconds(100)));
-  l.CountDown();
-  ASSERT_TRUE(l.WaitUntil(ReadSteadyClock()));
+TEST(Latch, WaitUntil)
+{
+    Latch l(1);
+    ASSERT_FALSE(l.WaitUntil(ReadSteadyClock() + std::chrono::milliseconds(100)));
+    l.CountDown();
+    ASSERT_TRUE(l.WaitUntil(ReadSteadyClock()));
 }
 
-} // namespace tile
+}// namespace tile
diff --git a/tile/base/thread/mutex.cc b/tile/base/thread/mutex.cc
index 841e89c..c57584c 100644
--- a/tile/base/thread/mutex.cc
+++ b/tile/base/thread/mutex.cc
@@ -8,39 +8,78 @@ namespace tile {
 
 class Mutex::Impl {
 public:
-  inline void Lock() { m_.lock(); }
-  inline bool TryLock() { return m_.try_lock(); }
-  inline void Unlock() { m_.unlock(); }
+    inline void Lock() { m_.lock(); }
 
-  inline void *GetNativeHandle() { return reinterpret_cast<void *>(&m_); };
+    inline bool TryLock() { return m_.try_lock(); }
+
+    inline void Unlock() { m_.unlock(); }
+
+    inline void *GetNativeHandle() { return reinterpret_cast<void *>(&m_); };
 
 private:
-  std::mutex m_;
+    std::mutex m_;
 };
 
 class RecursiveMutex::Impl {
 public:
-  inline void Lock() { m_.lock(); }
-  inline bool TryLock() { return m_.try_lock(); }
-  inline void Unlock() { m_.unlock(); }
+    inline void Lock() { m_.lock(); }
+
+    inline bool TryLock() { return m_.try_lock(); }
+
+    inline void Unlock() { m_.unlock(); }
 
 private:
-  std::recursive_mutex m_;
+    std::recursive_mutex m_;
 };
 
 Mutex::Mutex() : impl_(make_unique<Impl>()) {}
 
 Mutex::~Mutex() {}
 
-void Mutex::Lock() { impl_->Lock(); }
-bool Mutex::TryLock() { return impl_->TryLock(); }
-void Mutex::Unlock() { impl_->Unlock(); }
-void *Mutex::GetNativeHandle() { return impl_->GetNativeHandle(); }
+void
+Mutex::Lock()
+{
+    impl_->Lock();
+}
+
+bool
+Mutex::TryLock()
+{
+    return impl_->TryLock();
+}
+
+void
+Mutex::Unlock()
+{
+    impl_->Unlock();
+}
+
+void *
+Mutex::GetNativeHandle()
+{
+    return impl_->GetNativeHandle();
+}
 
 RecursiveMutex::RecursiveMutex() : impl_(make_unique<Impl>()) {}
-RecursiveMutex::~RecursiveMutex() {}
-void RecursiveMutex::Lock() { impl_->Lock(); }
-bool RecursiveMutex::TryLock() { return impl_->TryLock(); }
-void RecursiveMutex::Unlock() { impl_->Unlock(); }
 
-} // namespace tile
+RecursiveMutex::~RecursiveMutex() {}
+
+void
+RecursiveMutex::Lock()
+{
+    impl_->Lock();
+}
+
+bool
+RecursiveMutex::TryLock()
+{
+    return impl_->TryLock();
+}
+
+void
+RecursiveMutex::Unlock()
+{
+    impl_->Unlock();
+}
+
+}// namespace tile
diff --git a/tile/base/thread/mutex.h b/tile/base/thread/mutex.h
index f5aa42e..258e4b5 100644
--- a/tile/base/thread/mutex.h
+++ b/tile/base/thread/mutex.h
@@ -10,43 +10,43 @@ namespace tile {
 
 class Mutex final {
 public:
-  Mutex();
-  ~Mutex();
+    Mutex();
+    ~Mutex();
 
-  Mutex(const Mutex &) = delete;
-  Mutex &operator=(const Mutex &) = delete;
+    Mutex(const Mutex &)            = delete;
+    Mutex &operator=(const Mutex &) = delete;
 
-  void Lock();
-  bool TryLock();
-  void Unlock();
+    void Lock();
+    bool TryLock();
+    void Unlock();
 
 private:
-  // for CondVar
-  void *GetNativeHandle();
+    // for CondVar
+    void *GetNativeHandle();
 
 private:
-  friend class ::tile::detail::cond_var::CondVarProxy;
-  class Impl;
-  std::unique_ptr<Impl> impl_;
+    friend class ::tile::detail::cond_var::CondVarProxy;
+    class Impl;
+    std::unique_ptr<Impl> impl_;
 };
 
 class RecursiveMutex final {
 public:
-  RecursiveMutex();
-  ~RecursiveMutex();
+    RecursiveMutex();
+    ~RecursiveMutex();
 
-  RecursiveMutex(const RecursiveMutex &) = delete;
-  RecursiveMutex &operator=(const RecursiveMutex &) = delete;
+    RecursiveMutex(const RecursiveMutex &)            = delete;
+    RecursiveMutex &operator=(const RecursiveMutex &) = delete;
 
-  void Lock();
-  bool TryLock();
-  void Unlock();
+    void Lock();
+    bool TryLock();
+    void Unlock();
 
 private:
-  class Impl;
-  std::unique_ptr<Impl> impl_;
+    class Impl;
+    std::unique_ptr<Impl> impl_;
 };
 
-} // namespace tile
+}// namespace tile
 
-#endif // TILE_BASE_THREAD_MUTEX_H
+#endif// TILE_BASE_THREAD_MUTEX_H
diff --git a/tile/base/thread/mutex_benchmark.cc b/tile/base/thread/mutex_benchmark.cc
index c56ebdc..a1513b9 100644
--- a/tile/base/thread/mutex_benchmark.cc
+++ b/tile/base/thread/mutex_benchmark.cc
@@ -3,53 +3,64 @@
 #include "benchmark/benchmark.h"
 
 namespace tile {
-void Benchmark_MutexLock(benchmark::State &state) {
-  Mutex m;
-  while (state.KeepRunning()) {
-    (void)m.Lock();
-    (void)m.Unlock();
-  }
+void
+Benchmark_MutexLock(benchmark::State &state)
+{
+    Mutex m;
+    while (state.KeepRunning()) {
+        (void) m.Lock();
+        (void) m.Unlock();
+    }
 }
-void Benchmark_MutexTryLock(benchmark::State &state) {
-  Mutex m;
-  while (state.KeepRunning()) {
-    (void)m.TryLock();
-    (void)m.Unlock();
-  }
+
+void
+Benchmark_MutexTryLock(benchmark::State &state)
+{
+    Mutex m;
+    while (state.KeepRunning()) {
+        (void) m.TryLock();
+        (void) m.Unlock();
+    }
 }
+
 constexpr auto kRecursiveMutexMaxLockCount = 10000;
 
-void Benchmark_RecursiveMutexLock(benchmark::State &state) {
-  RecursiveMutex m;
-  int count = 0;
-  bool should_lock = true;
-  while (state.KeepRunning()) {
-    if (should_lock) {
-      (void)m.Lock();
-      should_lock = ++count < kRecursiveMutexMaxLockCount;
-    } else {
-      (void)m.Unlock();
-      should_lock = --count == 0;
+void
+Benchmark_RecursiveMutexLock(benchmark::State &state)
+{
+    RecursiveMutex m;
+    int count        = 0;
+    bool should_lock = true;
+    while (state.KeepRunning()) {
+        if (should_lock) {
+            (void) m.Lock();
+            should_lock = ++count < kRecursiveMutexMaxLockCount;
+        } else {
+            (void) m.Unlock();
+            should_lock = --count == 0;
+        }
     }
-  }
 }
-void Benchmark_RecursiveMutexTryLock(benchmark::State &state) {
-  RecursiveMutex m;
-  int count = 0;
-  bool should_lock = true;
-  while (state.KeepRunning()) {
-    if (should_lock) {
-      (void)m.TryLock();
-      should_lock = ++count < kRecursiveMutexMaxLockCount;
-    } else {
-      (void)m.Unlock();
-      should_lock = --count == 0;
+
+void
+Benchmark_RecursiveMutexTryLock(benchmark::State &state)
+{
+    RecursiveMutex m;
+    int count        = 0;
+    bool should_lock = true;
+    while (state.KeepRunning()) {
+        if (should_lock) {
+            (void) m.TryLock();
+            should_lock = ++count < kRecursiveMutexMaxLockCount;
+        } else {
+            (void) m.Unlock();
+            should_lock = --count == 0;
+        }
     }
-  }
 }
 
 BENCHMARK(Benchmark_MutexLock);
 BENCHMARK(Benchmark_MutexTryLock);
 BENCHMARK(Benchmark_RecursiveMutexLock);
 BENCHMARK(Benchmark_RecursiveMutexTryLock);
-} // namespace tile
+}// namespace tile
diff --git a/tile/base/thread/rw_mutex.cc b/tile/base/thread/rw_mutex.cc
index 662aa38..1362072 100644
--- a/tile/base/thread/rw_mutex.cc
+++ b/tile/base/thread/rw_mutex.cc
@@ -4,133 +4,151 @@
 #include "tile/base/thread/cond_var.h"
 #include "tile/base/thread/mutex.h"
 #include "tile/base/thread/scoped_lock.h"
+
 namespace tile {
 
 class RWMutex::Impl {
 public:
-  Impl(PriorityPolicy policy) : policy_(policy) {}
+    Impl(PriorityPolicy policy) : policy_(policy) {}
 
-  void WriteLock() {
-    ScopedLock lock(m_);
-    if (IsWriteMode() || IsReadMode()) {
-      waiting_writers_++;
+    void WriteLock()
+    {
+        ScopedLock lock(m_);
+        if (IsWriteMode() || IsReadMode()) { waiting_writers_++; }
+        cv_.Wait(lock, [&] {
+            if (IsWriteMode() || IsReadMode()) { return false; }
+
+            if (policy_ == PriorityPolicy::ReadPreferring) { return waiting_readers_ == 0; }
+
+            return true;
+        });
+        --waiting_writers_;
+        SetWriteMode();
     }
-    cv_.Wait(lock, [&] {
-      if (IsWriteMode() || IsReadMode()) {
+
+    bool WriteTryLock()
+    {
+        ScopedLock lock(m_);
+        if (IsWriteMode() || waiting_writers_ > 0) { return false; }
+        if (policy_ == PriorityPolicy::ReadPreferring && waiting_readers_ > 0) { return false; }
+
+        SetWriteMode();
+
+        return true;
+    }
+
+    void WriteUnlock()
+    {
+        ScopedLock lock(m_);
+        state_ = kNoLocked;
+        cv_.NotifyAll();
+    }
+
+    void ReadLock()
+    {
+        ScopedLock lock(m_);
+        AddReader();
+        cv_.Wait(lock, [&] { return CanSwitchToReadMode(); });
+
+        if (!IsReadMode()) {
+            SetReadMode();
+            cv_.NotifyAll();
+        }
+    }
+
+    bool ReadTryLock()
+    {
+        ScopedLock lock(m_);
+        if (!IsReadMode()) { return false; }
+
+        if (policy_ == PriorityPolicy::WritePreferring && waiting_writers_ > 0) { return false; }
+
+        return true;
+    }
+
+    void ReadUnlock() {}
+
+private:
+    bool CanSwitchToWriteMode() const
+    {
+        if (IsReadMode()) { return false; }
         return false;
-      }
-
-      if (policy_ == PriorityPolicy::ReadPreferring) {
-        return waiting_readers_ == 0;
-      }
-
-      return true;
-    });
-    --waiting_writers_;
-    SetWriteMode();
-  }
-
-  bool WriteTryLock() {
-    ScopedLock lock(m_);
-    if (IsWriteMode() || waiting_writers_ > 0) {
-      return false;
-    }
-    if (policy_ == PriorityPolicy::ReadPreferring && waiting_readers_ > 0) {
-      return false;
     }
 
-    SetWriteMode();
+    bool CanSwitchToReadMode() const
+    {
+        if (IsWriteMode()) { return false; }
 
-    return true;
-  }
-  void WriteUnlock() {
-    ScopedLock lock(m_);
-    state_ = kNoLocked;
-    cv_.NotifyAll();
-  }
+        if (policy_ == PriorityPolicy::WritePreferring && waiting_writers_ > 0) { return false; }
 
-  void ReadLock() {
-    ScopedLock lock(m_);
-    AddReader();
-    cv_.Wait(lock, [&] { return CanSwitchToReadMode(); });
-
-    if (!IsReadMode()) {
-      SetReadMode();
-      cv_.NotifyAll();
-    }
-  }
-
-  bool ReadTryLock() {
-    ScopedLock lock(m_);
-    if (!IsReadMode()) {
-      return false;
+        return true;
     }
 
-    if (policy_ == PriorityPolicy::WritePreferring && waiting_writers_ > 0) {
-      return false;
-    }
+    bool IsWriteMode() const { return state_ == kLockedByWriter; }
 
-    return true;
-  }
-  void ReadUnlock() {}
+    bool IsReadMode() const { return state_ == kLockedByReader; }
+
+    void SetWriteMode() { state_ = kLockedByWriter; }
+
+    void SetReadMode() { state_ = kLockedByReader; }
+
+    void AddReader() { waiting_readers_++; }
+
+    enum State {
+        kNoLocked,
+        kLockedByWriter,// 1 writer
+        kLockedByReader,// waiting_readers_ readers
+    };
 
 private:
-  bool CanSwitchToWriteMode() const {
-    if (IsReadMode()) {
-      return false;
-    }
-    return false;
-  }
+    Mutex m_;
+    CondVar cv_;
 
-  bool CanSwitchToReadMode() const {
-    if (IsWriteMode()) {
-      return false;
-    }
+    const PriorityPolicy policy_;
+    State state_         = kNoLocked;
+    int waiting_readers_ = 0;
+    int waiting_writers_ = 0;
 
-    if (policy_ == PriorityPolicy::WritePreferring && waiting_writers_ > 0) {
-      return false;
-    }
-
-    return true;
-  }
-
-  bool IsWriteMode() const { return state_ == kLockedByWriter; }
-  bool IsReadMode() const { return state_ == kLockedByReader; }
-  void SetWriteMode() { state_ = kLockedByWriter; }
-  void SetReadMode() { state_ = kLockedByReader; }
-  void AddReader() { waiting_readers_++; }
-
-  enum State {
-    kNoLocked,
-    kLockedByWriter, // 1 writer
-    kLockedByReader, // waiting_readers_ readers
-  };
-
-private:
-  Mutex m_;
-  CondVar cv_;
-
-  const PriorityPolicy policy_;
-  State state_ = kNoLocked;
-  int waiting_readers_ = 0;
-  int waiting_writers_ = 0;
-
-  std::unique_ptr<detail::mutex::RWMutexReadRefWrapper> read_mutex_;
-  std::unique_ptr<detail::mutex::RWMutexWriteRefWrapper> write_mutex_;
+    std::unique_ptr<detail::mutex::RWMutexReadRefWrapper> read_mutex_;
+    std::unique_ptr<detail::mutex::RWMutexWriteRefWrapper> write_mutex_;
 };
 
 RWMutex::RWMutex(PriorityPolicy policy) : impl_(make_unique<Impl>(policy)) {}
 
-void RWMutex::WriteLock() { impl_->WriteLock(); }
+void
+RWMutex::WriteLock()
+{
+    impl_->WriteLock();
+}
 
-bool RWMutex::WriteTryLock() { return impl_->WriteTryLock(); }
+bool
+RWMutex::WriteTryLock()
+{
+    return impl_->WriteTryLock();
+}
 
-void RWMutex::WriteUnlock() { impl_->WriteUnlock(); }
+void
+RWMutex::WriteUnlock()
+{
+    impl_->WriteUnlock();
+}
 
-void RWMutex::ReadLock() { impl_->ReadUnlock(); }
+void
+RWMutex::ReadLock()
+{
+    impl_->ReadUnlock();
+}
 
-bool RWMutex::ReadTryLock() { return impl_->ReadTryLock(); }
+bool
+RWMutex::ReadTryLock()
+{
+    return impl_->ReadTryLock();
+}
 
-void RWMutex::ReadUnlock() { impl_->ReadUnlock(); }
+void
+RWMutex::ReadUnlock()
+{
+    impl_->ReadUnlock();
+}
 
-} // namespace tile
+}// namespace tile
diff --git a/tile/base/thread/rw_mutex.h b/tile/base/thread/rw_mutex.h
index 4b69398..5a0ef1a 100644
--- a/tile/base/thread/rw_mutex.h
+++ b/tile/base/thread/rw_mutex.h
@@ -4,6 +4,7 @@
 #include <memory>
 
 #pragma once
+
 namespace tile {
 namespace detail {
 namespace mutex {
@@ -11,31 +12,32 @@ namespace mutex {
 class RWMutexReadRefWrapper;
 class RWMutexWriteRefWrapper;
 
-} // namespace mutex
-} // namespace detail
+}// namespace mutex
+}// namespace detail
 
 class RWMutex final {
 public:
-  enum PriorityPolicy { Unspecified, ReadPreferring, WritePreferring };
-  RWMutex(PriorityPolicy policy = Unspecified);
+    enum PriorityPolicy { Unspecified, ReadPreferring, WritePreferring };
 
-  RWMutex(const RWMutex &) = delete;
-  RWMutex(RWMutex &&) = delete;
+    RWMutex(PriorityPolicy policy = Unspecified);
 
-  void WriteLock();
-  bool WriteTryLock();
-  void WriteUnlock();
+    RWMutex(const RWMutex &) = delete;
+    RWMutex(RWMutex &&)      = delete;
 
-  void ReadLock();
-  bool ReadTryLock();
-  void ReadUnlock();
+    void WriteLock();
+    bool WriteTryLock();
+    void WriteUnlock();
 
-  detail::mutex::RWMutexReadRefWrapper &ReadMutex() const;
-  detail::mutex::RWMutexWriteRefWrapper &WriteMutex() const;
+    void ReadLock();
+    bool ReadTryLock();
+    void ReadUnlock();
+
+    detail::mutex::RWMutexReadRefWrapper &ReadMutex() const;
+    detail::mutex::RWMutexWriteRefWrapper &WriteMutex() const;
 
 private:
-  class Impl;
-  std::unique_ptr<Impl> impl_;
+    class Impl;
+    std::unique_ptr<Impl> impl_;
 };
 
 namespace detail {
@@ -43,28 +45,35 @@ namespace mutex {
 
 class RWMutexReadRefWrapper {
 public:
-  inline constexpr RWMutexReadRefWrapper(RWMutex &m) : m_(m) {}
-  inline void Lock() { m_.ReadLock(); }
-  inline bool TryLock() { return m_.ReadTryLock(); }
-  inline void Unlock() { m_.ReadUnlock(); }
+    inline constexpr RWMutexReadRefWrapper(RWMutex &m) : m_(m) {}
+
+    inline void Lock() { m_.ReadLock(); }
+
+    inline bool TryLock() { return m_.ReadTryLock(); }
+
+    inline void Unlock() { m_.ReadUnlock(); }
 
 private:
-  RWMutex &m_;
+    RWMutex &m_;
 };
+
 class RWMutexWriteRefWrapper {
 public:
-  inline constexpr RWMutexWriteRefWrapper(RWMutex &m) : m_(m) {}
-  inline void Lock() { m_.WriteLock(); }
-  inline bool TryLock() { return m_.WriteTryLock(); }
-  inline void Unlock() { m_.WriteUnlock(); }
+    inline constexpr RWMutexWriteRefWrapper(RWMutex &m) : m_(m) {}
+
+    inline void Lock() { m_.WriteLock(); }
+
+    inline bool TryLock() { return m_.WriteTryLock(); }
+
+    inline void Unlock() { m_.WriteUnlock(); }
 
 private:
-  RWMutex &m_;
+    RWMutex &m_;
 };
 
-} // namespace mutex
-} // namespace detail
+}// namespace mutex
+}// namespace detail
 
-} // namespace tile
+}// namespace tile
 
-#endif // TILE_BASE_THREAD_RW_MUTEX_H
+#endif// TILE_BASE_THREAD_RW_MUTEX_H
diff --git a/tile/base/thread/scoped_lock.cc b/tile/base/thread/scoped_lock.cc
index f72c0a2..f6da7fb 100644
--- a/tile/base/thread/scoped_lock.cc
+++ b/tile/base/thread/scoped_lock.cc
@@ -12,95 +12,87 @@ namespace detail {
 namespace scoped_lock {
 
 namespace {
-constexpr int kWarningTryCount = 15;
+constexpr int kWarningTryCount  = 15;
 constexpr auto kTryLockTimeCost = std::chrono::nanoseconds(20);
 
-void Lock(std::vector<std::function<void()>> &lockers) {
-  // use lockers_
-  TILE_LOG_WARNING_IF(lockers.size() > 1,
-                      "some mutex can't be `try_lock()`/`TryLock()`, use "
-                      "`lock()`/`Lock()` instead of try_lockers_");
+void
+Lock(std::vector<std::function<void()>> &lockers)
+{
+    // use lockers_
+    TILE_LOG_WARNING_IF(lockers.size() > 1,
+                        "some mutex can't be `try_lock()`/`TryLock()`, use "
+                        "`lock()`/`Lock()` instead of try_lockers_");
 
-  for (auto &locker : lockers) {
-    locker();
-  }
+    for (auto &locker : lockers) { locker(); }
 }
 
-void TryLock(std::vector<std::function<bool()>> &try_lockers,
-             std::vector<std::function<void()>> &unlockers) {
-  TILE_CHECK(try_lockers.size() == unlockers.size(),
-             "ensure try_lockers and unlockers have same size");
-  std::vector<int> idxs(try_lockers.size(), 0);
-  for (int i = 0; i < idxs.size(); i++) {
-    idxs[i] = i;
-  }
+void
+TryLock(std::vector<std::function<bool()>> &try_lockers, std::vector<std::function<void()>> &unlockers)
+{
+    TILE_CHECK(try_lockers.size() == unlockers.size(), "ensure try_lockers and unlockers have same size");
+    std::vector<int> idxs(try_lockers.size(), 0);
+    for (int i = 0; i < idxs.size(); i++) { idxs[i] = i; }
 
-  int try_count = 0;
-  while (true) {
-    int i = 0;
-    for (; i < idxs.size(); ++i) {
-      if (!try_lockers[idxs[i]]()) {
-        break;
-      }
-    }
+    int try_count = 0;
+    while (true) {
+        int i = 0;
+        for (; i < idxs.size(); ++i) {
+            if (!try_lockers[idxs[i]]()) { break; }
+        }
 
-    if (i == idxs.size()) {
-      // all mutex are locked, exit.
-      break;
-    } else {
-      ++try_count;
-      TILE_LOG_WARNING_IF_EVERY_SECOND(
-          try_count > kWarningTryCount,
-          "try lock failed. try_count={}, locked_mutex={} times", try_count, i);
-      while (--i >= 0) {
-        unlockers[idxs[i]]();
-      }
+        if (i == idxs.size()) {
+            // all mutex are locked, exit.
+            break;
+        } else {
+            ++try_count;
+            TILE_LOG_WARNING_IF_EVERY_SECOND(
+                try_count > kWarningTryCount, "try lock failed. try_count={}, locked_mutex={} times", try_count, i);
+            while (--i >= 0) { unlockers[idxs[i]](); }
+        }
+        std::next_permutation(idxs.begin(), idxs.end());
+        if (try_count > kWarningTryCount) {
+            std::this_thread::sleep_for(Random(0, 5) * try_lockers.size() * kTryLockTimeCost);
+        }
     }
-    std::next_permutation(idxs.begin(), idxs.end());
-    if (try_count > kWarningTryCount) {
-      std::this_thread::sleep_for(Random(0, 5) * try_lockers.size() *
-                                  kTryLockTimeCost);
-    }
-  }
 }
 
-} // namespace
-} // namespace scoped_lock
-} // namespace detail
+}// namespace
+}// namespace scoped_lock
+}// namespace detail
 
 namespace detail {
 namespace scoped_lock {
 
-void LockMultipleMutexByNextPermutation(
-    std::vector<std::function<void()>> &lockers,
-    std::vector<std::function<bool()>> &try_lockers,
-    std::vector<std::function<void()>> &unlockers) {
-  TILE_DCHECK(lockers.size() == unlockers.size());
-  TILE_DCHECK_LE(try_lockers.size(), lockers.size());
+void
+LockMultipleMutexByNextPermutation(std::vector<std::function<void()>> &lockers,
+                                   std::vector<std::function<bool()>> &try_lockers,
+                                   std::vector<std::function<void()>> &unlockers)
+{
+    TILE_DCHECK(lockers.size() == unlockers.size());
+    TILE_DCHECK_LE(try_lockers.size(), lockers.size());
 
-  if (lockers.size() > 1 && try_lockers.size() == lockers.size()) {
-    TryLock(try_lockers, unlockers);
-  } else {
-    Lock(lockers);
-  }
+    if (lockers.size() > 1 && try_lockers.size() == lockers.size()) {
+        TryLock(try_lockers, unlockers);
+    } else {
+        Lock(lockers);
+    }
 }
 
-void UnlockMultipleMutex(std::vector<std::function<void()>> &unlockers) {
-  for (auto &unlocker : unlockers) {
-    unlocker();
-  }
+void
+UnlockMultipleMutex(std::vector<std::function<void()>> &unlockers)
+{
+    for (auto &unlocker : unlockers) { unlocker(); }
 }
 
-} // namespace scoped_lock
+}// namespace scoped_lock
 
-} // namespace detail
-ScopedLock::ScopedLock(Mutex &m) : ScopedBase(m), mutex_ptr_(&m) {
-  detail::scoped_lock::LockMultipleMutexByNextPermutation(
-      lockers_, try_lockers_, unlockers_);
+}// namespace detail
+
+ScopedLock::ScopedLock(Mutex &m) : ScopedBase(m), mutex_ptr_(&m)
+{
+    detail::scoped_lock::LockMultipleMutexByNextPermutation(lockers_, try_lockers_, unlockers_);
 }
 
-ScopedLock::~ScopedLock() {
-  detail::scoped_lock::UnlockMultipleMutex(unlockers_);
-}
+ScopedLock::~ScopedLock() { detail::scoped_lock::UnlockMultipleMutex(unlockers_); }
 
-} // namespace tile
+}// namespace tile
diff --git a/tile/base/thread/scoped_lock.h b/tile/base/thread/scoped_lock.h
index ee95db4..62db445 100644
--- a/tile/base/thread/scoped_lock.h
+++ b/tile/base/thread/scoped_lock.h
@@ -15,49 +15,46 @@ class Mutex;
 
 namespace detail {
 namespace scoped_lock {
-template <typename... MutexType>
-void AssertNoDuplicateMutex(MutexType &...mutex) {
-  // [{lock1_ptr, idx1}, {lock2_ptr, idx2}, {lock3_ptr, idx3}...]
-  std::vector<::std::pair<void *, int>> mutex_ptrs =
-      detail::thread::GetMutexPtrs(1, mutex...);
+template<typename... MutexType>
+void
+AssertNoDuplicateMutex(MutexType &...mutex)
+{
+    // [{lock1_ptr, idx1}, {lock2_ptr, idx2}, {lock3_ptr, idx3}...]
+    std::vector<::std::pair<void *, int>> mutex_ptrs = detail::thread::GetMutexPtrs(1, mutex...);
 
-  std::sort(mutex_ptrs.begin(), mutex_ptrs.end());
-  auto iter = std::adjacent_find(mutex_ptrs.begin(), mutex_ptrs.end(),
-                                 [](const ::std::pair<void *, int> &lhs,
-                                    const ::std::pair<void *, int> &rhs) {
-                                   return lhs.first == rhs.first;
-                                 });
-  TILE_CHECK(iter == mutex_ptrs.end(),
-             "You should not lock a lock twice idx1 [{}], idx2 [{}]",
-             iter->second, (iter + 1)->second);
+    std::sort(mutex_ptrs.begin(), mutex_ptrs.end());
+    auto iter = std::adjacent_find(mutex_ptrs.begin(), mutex_ptrs.end(),
+                                   [](const ::std::pair<void *, int> &lhs, const ::std::pair<void *, int> &rhs) {
+                                       return lhs.first == rhs.first;
+                                   });
+    TILE_CHECK(iter == mutex_ptrs.end(), "You should not lock a lock twice idx1 [{}], idx2 [{}]", iter->second,
+               (iter + 1)->second);
 }
 
 class ScopedBase {
 public:
-  template <typename... MutexType>
-  ScopedBase(MutexType &...mutex)
-      : lockers_(detail::thread::GetLockers(mutex...)),
-        try_lockers_(detail::thread::GetTryLockers(mutex...)),
-        unlockers_(detail::thread::GetUnlockers(mutex...)) {
-    detail::scoped_lock::AssertNoDuplicateMutex(mutex...);
+    template<typename... MutexType>
+    ScopedBase(MutexType &...mutex)
+        : lockers_(detail::thread::GetLockers(mutex...)),
+          try_lockers_(detail::thread::GetTryLockers(mutex...)),
+          unlockers_(detail::thread::GetUnlockers(mutex...))
+    {
+        detail::scoped_lock::AssertNoDuplicateMutex(mutex...);
 
-    constexpr auto count = detail::thread::mutex_count<MutexType...>::value;
-    TILE_CHECK(lockers_.size() == count,
-               "You should not lock a unlockable object");
-    TILE_CHECK(unlockers_.size() == count,
-               "You should not unlock a unlockable object");
-  }
+        constexpr auto count = detail::thread::mutex_count<MutexType...>::value;
+        TILE_CHECK(lockers_.size() == count, "You should not lock a unlockable object");
+        TILE_CHECK(unlockers_.size() == count, "You should not unlock a unlockable object");
+    }
 
 protected:
-  std::vector<std::function<void()>> lockers_;
-  std::vector<std::function<bool()>> try_lockers_;
-  std::vector<std::function<void()>> unlockers_;
+    std::vector<std::function<void()>> lockers_;
+    std::vector<std::function<bool()>> try_lockers_;
+    std::vector<std::function<void()>> unlockers_;
 };
 
-void LockMultipleMutexByNextPermutation(
-    std::vector<std::function<void()>> &lockers,
-    std::vector<std::function<bool()>> &try_lockers,
-    std::vector<std::function<void()>> &unlockers);
+void LockMultipleMutexByNextPermutation(std::vector<std::function<void()>> &lockers,
+                                        std::vector<std::function<bool()>> &try_lockers,
+                                        std::vector<std::function<void()>> &unlockers);
 void UnlockMultipleMutex(std::vector<std::function<void()>> &unlockers);
 
 // template <typename M, typename... MutexType>
@@ -71,56 +68,61 @@ void UnlockMultipleMutex(std::vector<std::function<void()>> &unlockers);
 //   return nullptr;
 // }
 
-} // namespace scoped_lock
+}// namespace scoped_lock
 
-} // namespace detail
+}// namespace detail
 
 class ScopedLock : private detail::scoped_lock::ScopedBase {
 public:
-  template <typename... MutexType>
-  ScopedLock(MutexType &...mutex) : ScopedBase(mutex...), mutex_ptr_(nullptr) {
-    detail::scoped_lock::LockMultipleMutexByNextPermutation(
-        lockers_, try_lockers_, unlockers_);
-  }
+    template<typename... MutexType>
+    ScopedLock(MutexType &...mutex)
+        : ScopedBase(mutex...),
+          mutex_ptr_(nullptr)
+    {
+        detail::scoped_lock::LockMultipleMutexByNextPermutation(lockers_, try_lockers_, unlockers_);
+    }
 
-  explicit ScopedLock(Mutex &m);
+    explicit ScopedLock(Mutex &m);
 
-  ~ScopedLock();
+    ~ScopedLock();
 
-  ScopedLock(const ScopedLock &) = delete;
-  ScopedLock(ScopedLock &&) = delete;
-  ScopedLock &operator=(const ScopedLock &) = delete;
-  ScopedLock &operator=(ScopedLock &&) = delete;
+    ScopedLock(const ScopedLock &)            = delete;
+    ScopedLock(ScopedLock &&)                 = delete;
+    ScopedLock &operator=(const ScopedLock &) = delete;
+    ScopedLock &operator=(ScopedLock &&)      = delete;
 
 private:
-  friend class ::tile::detail::cond_var::CondVar;
-  Mutex *GetMutex() {
-    TILE_CHECK(mutex_ptr_, "mutex_ptr_ is nullptr");
-    return mutex_ptr_;
-  }
+    friend class ::tile::detail::cond_var::CondVar;
+
+    Mutex *GetMutex()
+    {
+        TILE_CHECK(mutex_ptr_, "mutex_ptr_ is nullptr");
+        return mutex_ptr_;
+    }
 
 private:
-  // if first element is not a ::tile::Mutex, mutex_ptr_ is nullptr.
-  Mutex *mutex_ptr_;
+    // if first element is not a ::tile::Mutex, mutex_ptr_ is nullptr.
+    Mutex *mutex_ptr_;
 };
 
 class ScopedUnlock : private detail::scoped_lock::ScopedBase {
 public:
-  template <typename... MutexType>
-  ScopedUnlock(MutexType &...mutex) : ScopedBase(mutex...) {
-    detail::scoped_lock::UnlockMultipleMutex(unlockers_);
-  }
+    template<typename... MutexType>
+    ScopedUnlock(MutexType &...mutex) : ScopedBase(mutex...)
+    {
+        detail::scoped_lock::UnlockMultipleMutex(unlockers_);
+    }
 
-  inline ~ScopedUnlock() {
-    detail::scoped_lock::LockMultipleMutexByNextPermutation(
-        lockers_, try_lockers_, unlockers_);
-  }
+    inline ~ScopedUnlock()
+    {
+        detail::scoped_lock::LockMultipleMutexByNextPermutation(lockers_, try_lockers_, unlockers_);
+    }
 
-  ScopedUnlock(const ScopedUnlock &) = delete;
-  ScopedUnlock(ScopedUnlock &&) = delete;
-  ScopedUnlock &operator=(const ScopedUnlock &) = delete;
-  ScopedUnlock &operator=(ScopedUnlock &&) = delete;
+    ScopedUnlock(const ScopedUnlock &)            = delete;
+    ScopedUnlock(ScopedUnlock &&)                 = delete;
+    ScopedUnlock &operator=(const ScopedUnlock &) = delete;
+    ScopedUnlock &operator=(ScopedUnlock &&)      = delete;
 };
 
-} // namespace tile
-#endif // TILE_BASE_THREAD_SCOPED_LOCK_H
+}// namespace tile
+#endif// TILE_BASE_THREAD_SCOPED_LOCK_H
diff --git a/tile/base/thread/scoped_lock_test.cc b/tile/base/thread/scoped_lock_test.cc
index 6d661f4..a92c0b0 100644
--- a/tile/base/thread/scoped_lock_test.cc
+++ b/tile/base/thread/scoped_lock_test.cc
@@ -5,349 +5,398 @@
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 #include <thread>
+
 namespace tile {
 
-int lock_count = 0;
+int lock_count     = 0;
 int try_lock_count = 0;
-int unlock_count = 0;
+int unlock_count   = 0;
 
-#define RESET_ENV()                                                            \
-  lock_count = 0;                                                              \
-  unlock_count = 0;
+#define RESET_ENV()                                                                                                    \
+    lock_count   = 0;                                                                                                  \
+    unlock_count = 0;
 
 struct MockMutex {
-  void Lock() { ++lock_count; }
-  void Unlock() { ++unlock_count; }
+    void Lock() { ++lock_count; }
+
+    void Unlock() { ++unlock_count; }
 };
 
 struct MockTryLockMutex {
-  void Lock() { ++lock_count; }
-  bool TryLock() {
-    ++try_lock_count;
-    return true;
-  }
-  void Unlock() { ++unlock_count; }
+    void Lock() { ++lock_count; }
+
+    bool TryLock()
+    {
+        ++try_lock_count;
+        return true;
+    }
+
+    void Unlock() { ++unlock_count; }
 };
 
-TEST(Mutex, MutexTraits) {
-  {
-    struct Lockable1 {
-      void Lock() {}
-      void lock() {}
-    };
-    struct Lockable2 {
-      bool Lock() { return false; }
-      bool lock() { return false; }
-    };
-    struct Lockable3 {
-      void Lock(int) {}
-      void lock(int) {}
-    };
-    ASSERT_TRUE(tile::detail::thread::Lockable<Lockable1>::value);
-    ASSERT_TRUE(tile::detail::thread::lockable<Lockable1>::value);
-    ASSERT_FALSE(tile::detail::thread::Lockable<Lockable2>::value);
-    ASSERT_FALSE(tile::detail::thread::lockable<Lockable2>::value);
-    ASSERT_FALSE(tile::detail::thread::Lockable<Lockable3>::value);
-    ASSERT_FALSE(tile::detail::thread::lockable<Lockable3>::value);
-  }
+TEST(Mutex, MutexTraits)
+{
+    {
+        struct Lockable1 {
+            void Lock() {}
 
-  {
-    struct TryLockable1 {
-      bool TryLock() { return false; }
-      bool try_lock() { return false; }
-    };
-    struct TryLockable2 {
-      void TryLock() {}
-      void try_lock() {}
-    };
-    struct TryLockable3 {
-      bool TryLock(int) { return false; }
-      bool try_lock(int) { return false; }
-    };
-    ASSERT_TRUE(tile::detail::thread::TryLockable<TryLockable1>::value);
-    ASSERT_TRUE(tile::detail::thread::try_lockable<TryLockable1>::value);
-    ASSERT_FALSE(tile::detail::thread::TryLockable<TryLockable2>::value);
-    ASSERT_FALSE(tile::detail::thread::try_lockable<TryLockable2>::value);
-    ASSERT_FALSE(tile::detail::thread::TryLockable<TryLockable3>::value);
-    ASSERT_FALSE(tile::detail::thread::try_lockable<TryLockable3>::value);
-  }
+            void lock() {}
+        };
+
+        struct Lockable2 {
+            bool Lock() { return false; }
+
+            bool lock() { return false; }
+        };
+
+        struct Lockable3 {
+            void Lock(int) {}
+
+            void lock(int) {}
+        };
+
+        ASSERT_TRUE(tile::detail::thread::Lockable<Lockable1>::value);
+        ASSERT_TRUE(tile::detail::thread::lockable<Lockable1>::value);
+        ASSERT_FALSE(tile::detail::thread::Lockable<Lockable2>::value);
+        ASSERT_FALSE(tile::detail::thread::lockable<Lockable2>::value);
+        ASSERT_FALSE(tile::detail::thread::Lockable<Lockable3>::value);
+        ASSERT_FALSE(tile::detail::thread::lockable<Lockable3>::value);
+    }
+
+    {
+        struct TryLockable1 {
+            bool TryLock() { return false; }
+
+            bool try_lock() { return false; }
+        };
+
+        struct TryLockable2 {
+            void TryLock() {}
+
+            void try_lock() {}
+        };
+
+        struct TryLockable3 {
+            bool TryLock(int) { return false; }
+
+            bool try_lock(int) { return false; }
+        };
+
+        ASSERT_TRUE(tile::detail::thread::TryLockable<TryLockable1>::value);
+        ASSERT_TRUE(tile::detail::thread::try_lockable<TryLockable1>::value);
+        ASSERT_FALSE(tile::detail::thread::TryLockable<TryLockable2>::value);
+        ASSERT_FALSE(tile::detail::thread::try_lockable<TryLockable2>::value);
+        ASSERT_FALSE(tile::detail::thread::TryLockable<TryLockable3>::value);
+        ASSERT_FALSE(tile::detail::thread::try_lockable<TryLockable3>::value);
+    }
 }
 
-TEST(Mutex, LockableAndUnlockable) {
-  RESET_ENV();
+TEST(Mutex, LockableAndUnlockable)
+{
+    RESET_ENV();
 
-  MockMutex m;
-  tile::MutexTraits<MockMutex>::Lock(&m);
-  ASSERT_EQ(1, lock_count);
-  ASSERT_EQ(0, unlock_count);
-
-  tile::MutexTraits<MockMutex>::Unlock(&m);
-  ASSERT_EQ(1, lock_count);
-  ASSERT_EQ(1, unlock_count);
-
-  ASSERT_TRUE(tile::detail::thread::Lockable<MockMutex>::value);
-  ASSERT_FALSE(tile::detail::thread::lockable<MockMutex>::value);
-  ASSERT_TRUE(tile::detail::thread::Unlockable<MockMutex>::value);
-  ASSERT_FALSE(tile::detail::thread::unlockable<MockMutex>::value);
-  ASSERT_FALSE(tile::detail::thread::TryLockable<MockMutex>::value);
-  ASSERT_FALSE(tile::detail::thread::try_lockable<MockMutex>::value);
-}
-
-TEST(Mutex, Lock_And_lock) {
-  RESET_ENV();
-  // 1. Lock + lock, use Lock
-  // 2. lock       , use lock
-  // 3. Lock       , use Lock
-  {
-    struct M1 {
-      void Lock() { lock_count++; }
-      void lock() { lock_count--; }
-      void unlock() { /* do nothing */ }
-    } m1;
-    ASSERT_TRUE(tile::detail::thread::Lockable<M1>::value);
-    ASSERT_TRUE(tile::detail::thread::lockable<M1>::value);
-
-    tile::MutexOperator<M1>::Lock(&m1);
-    ASSERT_EQ(1, lock_count);
-
-    struct M2 {
-      void lock() { lock_count--; }
-      void unlock() { /* do nothing */ }
-    } m2;
-    ASSERT_FALSE(tile::detail::thread::Lockable<M2>::value);
-    ASSERT_TRUE(tile::detail::thread::lockable<M2>::value);
-
-    tile::MutexOperator<M2>::Lock(&m2);
-    ASSERT_EQ(0, lock_count);
-
-    struct M3 {
-      void Lock() { lock_count++; }
-      void unlock() { /* do nothing */ }
-    } m3;
-    ASSERT_TRUE(tile::detail::thread::Lockable<M3>::value);
-    ASSERT_FALSE(tile::detail::thread::lockable<M3>::value);
-
-    tile::MutexOperator<M3>::Lock(&m3);
-    ASSERT_EQ(1, lock_count);
-  }
-}
-
-TEST(Mutex, Unlock_And_unlock) {
-  RESET_ENV();
-  // 1. Unlock + unlock, use Unlock
-  // 2. unlock       , use unlock
-  // 3. Unlock       , use Unlock
-  {
-    struct M1 {
-      void Unlock() { unlock_count++; }
-      void unlock() { unlock_count--; }
-      void lock() { /* do nothing */ }
-    } m1;
-    ASSERT_TRUE(tile::detail::thread::Unlockable<M1>::value);
-    ASSERT_TRUE(tile::detail::thread::unlockable<M1>::value);
-
-    tile::MutexOperator<M1>::Unlock(&m1);
-    ASSERT_EQ(1, unlock_count);
-
-    struct M2 {
-      void unlock() { unlock_count--; }
-      void lock() { /* do nothing */ }
-    } m2;
-    ASSERT_FALSE(tile::detail::thread::Unlockable<M2>::value);
-    ASSERT_TRUE(tile::detail::thread::unlockable<M2>::value);
-
-    tile::MutexOperator<M2>::Unlock(&m2);
-    ASSERT_EQ(0, unlock_count);
-
-    struct M3 {
-      void Unlock() { unlock_count++; }
-      void lock() { /* do nothing */ }
-    } m3;
-    ASSERT_TRUE(tile::detail::thread::Unlockable<M3>::value);
-    ASSERT_FALSE(tile::detail::thread::unlockable<M3>::value);
-
-    tile::MutexOperator<M3>::Unlock(&m3);
-    ASSERT_EQ(1, unlock_count);
-  }
-}
-
-TEST(Mutex, TryLock_And_try_lock) {
-  RESET_ENV();
-  // 1. TryLock + try_lock, use TryLock
-  // 2. try_lock       , use try_lock
-  // 3. TryLock       , use TryLock
-  {
-    struct M1 {
-      bool TryLock() {
-        lock_count++;
-        return true;
-      }
-      bool try_lock() {
-        lock_count--;
-        return true;
-      }
-      void lock() { /* do nothing */ }
-      void unlock() { /* do nothing */ }
-    } m1;
-    ASSERT_TRUE(tile::detail::thread::TryLockable<M1>::value);
-    ASSERT_TRUE(tile::detail::thread::try_lockable<M1>::value);
-    ASSERT_TRUE(tile::MutexOperator<M1>::TryLock(&m1));
-    ASSERT_EQ(1, lock_count);
-    struct M2 {
-      bool try_lock() {
-        lock_count--;
-        return true;
-      }
-      void lock() { /* do nothing */ }
-      void unlock() { /* do nothing */ }
-    } m2;
-    ASSERT_FALSE(tile::detail::thread::TryLockable<M2>::value);
-    ASSERT_TRUE(tile::detail::thread::try_lockable<M2>::value);
-    ASSERT_TRUE(tile::MutexOperator<M2>::TryLock(&m2));
-    ASSERT_EQ(0, lock_count);
-    struct M3 {
-      bool TryLock() {
-        lock_count++;
-        return true;
-      }
-      void lock() { /* do nothing */ }
-      void unlock() { /* do nothing */ }
-    } m3;
-    ASSERT_TRUE(tile::detail::thread::TryLockable<M3>::value);
-    ASSERT_FALSE(tile::detail::thread::try_lockable<M3>::value);
-    ASSERT_TRUE(tile::MutexOperator<M3>::TryLock(&m3));
-    ASSERT_EQ(1, lock_count);
-  }
-}
-
-TEST(ScopedLock, SingleMutex) {
-  RESET_ENV();
-  MockMutex m;
-  {
-    tile::ScopedLock lock(m);
+    MockMutex m;
+    tile::MutexTraits<MockMutex>::Lock(&m);
     ASSERT_EQ(1, lock_count);
     ASSERT_EQ(0, unlock_count);
-  }
-  ASSERT_EQ(1, lock_count);
-  ASSERT_EQ(1, unlock_count);
+
+    tile::MutexTraits<MockMutex>::Unlock(&m);
+    ASSERT_EQ(1, lock_count);
+    ASSERT_EQ(1, unlock_count);
+
+    ASSERT_TRUE(tile::detail::thread::Lockable<MockMutex>::value);
+    ASSERT_FALSE(tile::detail::thread::lockable<MockMutex>::value);
+    ASSERT_TRUE(tile::detail::thread::Unlockable<MockMutex>::value);
+    ASSERT_FALSE(tile::detail::thread::unlockable<MockMutex>::value);
+    ASSERT_FALSE(tile::detail::thread::TryLockable<MockMutex>::value);
+    ASSERT_FALSE(tile::detail::thread::try_lockable<MockMutex>::value);
 }
 
-TEST(ScopedLock, TryLock) {
-  RESET_ENV();
-  MockTryLockMutex m1;
-  MockTryLockMutex m2;
-  {
-    tile::ScopedLock lock(m1, m2);
+TEST(Mutex, Lock_And_lock)
+{
+    RESET_ENV();
+    // 1. Lock + lock, use Lock
+    // 2. lock       , use lock
+    // 3. Lock       , use Lock
+    {
+        struct M1 {
+            void Lock() { lock_count++; }
+
+            void lock() { lock_count--; }
+
+            void unlock() { /* do nothing */ }
+        } m1;
+
+        ASSERT_TRUE(tile::detail::thread::Lockable<M1>::value);
+        ASSERT_TRUE(tile::detail::thread::lockable<M1>::value);
+
+        tile::MutexOperator<M1>::Lock(&m1);
+        ASSERT_EQ(1, lock_count);
+
+        struct M2 {
+            void lock() { lock_count--; }
+
+            void unlock() { /* do nothing */ }
+        } m2;
+
+        ASSERT_FALSE(tile::detail::thread::Lockable<M2>::value);
+        ASSERT_TRUE(tile::detail::thread::lockable<M2>::value);
+
+        tile::MutexOperator<M2>::Lock(&m2);
+        ASSERT_EQ(0, lock_count);
+
+        struct M3 {
+            void Lock() { lock_count++; }
+
+            void unlock() { /* do nothing */ }
+        } m3;
+
+        ASSERT_TRUE(tile::detail::thread::Lockable<M3>::value);
+        ASSERT_FALSE(tile::detail::thread::lockable<M3>::value);
+
+        tile::MutexOperator<M3>::Lock(&m3);
+        ASSERT_EQ(1, lock_count);
+    }
+}
+
+TEST(Mutex, Unlock_And_unlock)
+{
+    RESET_ENV();
+    // 1. Unlock + unlock, use Unlock
+    // 2. unlock       , use unlock
+    // 3. Unlock       , use Unlock
+    {
+        struct M1 {
+            void Unlock() { unlock_count++; }
+
+            void unlock() { unlock_count--; }
+
+            void lock() { /* do nothing */ }
+        } m1;
+
+        ASSERT_TRUE(tile::detail::thread::Unlockable<M1>::value);
+        ASSERT_TRUE(tile::detail::thread::unlockable<M1>::value);
+
+        tile::MutexOperator<M1>::Unlock(&m1);
+        ASSERT_EQ(1, unlock_count);
+
+        struct M2 {
+            void unlock() { unlock_count--; }
+
+            void lock() { /* do nothing */ }
+        } m2;
+
+        ASSERT_FALSE(tile::detail::thread::Unlockable<M2>::value);
+        ASSERT_TRUE(tile::detail::thread::unlockable<M2>::value);
+
+        tile::MutexOperator<M2>::Unlock(&m2);
+        ASSERT_EQ(0, unlock_count);
+
+        struct M3 {
+            void Unlock() { unlock_count++; }
+
+            void lock() { /* do nothing */ }
+        } m3;
+
+        ASSERT_TRUE(tile::detail::thread::Unlockable<M3>::value);
+        ASSERT_FALSE(tile::detail::thread::unlockable<M3>::value);
+
+        tile::MutexOperator<M3>::Unlock(&m3);
+        ASSERT_EQ(1, unlock_count);
+    }
+}
+
+TEST(Mutex, TryLock_And_try_lock)
+{
+    RESET_ENV();
+    // 1. TryLock + try_lock, use TryLock
+    // 2. try_lock       , use try_lock
+    // 3. TryLock       , use TryLock
+    {
+        struct M1 {
+            bool TryLock()
+            {
+                lock_count++;
+                return true;
+            }
+
+            bool try_lock()
+            {
+                lock_count--;
+                return true;
+            }
+
+            void lock() { /* do nothing */ }
+
+            void unlock() { /* do nothing */ }
+        } m1;
+
+        ASSERT_TRUE(tile::detail::thread::TryLockable<M1>::value);
+        ASSERT_TRUE(tile::detail::thread::try_lockable<M1>::value);
+        ASSERT_TRUE(tile::MutexOperator<M1>::TryLock(&m1));
+        ASSERT_EQ(1, lock_count);
+
+        struct M2 {
+            bool try_lock()
+            {
+                lock_count--;
+                return true;
+            }
+
+            void lock() { /* do nothing */ }
+
+            void unlock() { /* do nothing */ }
+        } m2;
+
+        ASSERT_FALSE(tile::detail::thread::TryLockable<M2>::value);
+        ASSERT_TRUE(tile::detail::thread::try_lockable<M2>::value);
+        ASSERT_TRUE(tile::MutexOperator<M2>::TryLock(&m2));
+        ASSERT_EQ(0, lock_count);
+
+        struct M3 {
+            bool TryLock()
+            {
+                lock_count++;
+                return true;
+            }
+
+            void lock() { /* do nothing */ }
+
+            void unlock() { /* do nothing */ }
+        } m3;
+
+        ASSERT_TRUE(tile::detail::thread::TryLockable<M3>::value);
+        ASSERT_FALSE(tile::detail::thread::try_lockable<M3>::value);
+        ASSERT_TRUE(tile::MutexOperator<M3>::TryLock(&m3));
+        ASSERT_EQ(1, lock_count);
+    }
+}
+
+TEST(ScopedLock, SingleMutex)
+{
+    RESET_ENV();
+    MockMutex m;
+    {
+        tile::ScopedLock lock(m);
+        ASSERT_EQ(1, lock_count);
+        ASSERT_EQ(0, unlock_count);
+    }
+    ASSERT_EQ(1, lock_count);
+    ASSERT_EQ(1, unlock_count);
+}
+
+TEST(ScopedLock, TryLock)
+{
+    RESET_ENV();
+    MockTryLockMutex m1;
+    MockTryLockMutex m2;
+    {
+        tile::ScopedLock lock(m1, m2);
+        ASSERT_EQ(0, lock_count);
+        ASSERT_EQ(2, try_lock_count);
+        ASSERT_EQ(0, unlock_count);
+    }
+    // tile::MutexOperator<MockTryLockMutex>::Unlock(&m);
     ASSERT_EQ(0, lock_count);
     ASSERT_EQ(2, try_lock_count);
-    ASSERT_EQ(0, unlock_count);
-  }
-  // tile::MutexOperator<MockTryLockMutex>::Unlock(&m);
-  ASSERT_EQ(0, lock_count);
-  ASSERT_EQ(2, try_lock_count);
-  ASSERT_EQ(2, unlock_count);
+    ASSERT_EQ(2, unlock_count);
 }
 
-TEST(ScopedLock, MultiThread) {
-  constexpr std::size_t kThreadCount = 5;
-  constexpr std::size_t kLoopCount = 10000;
+TEST(ScopedLock, MultiThread)
+{
+    constexpr std::size_t kThreadCount = 5;
+    constexpr std::size_t kLoopCount   = 10000;
 
-  int x = 0;
-  Mutex m;
-  auto AddOne([&] {
-    tile::ScopedLock lock(m);
-    int old = x++;
-    ASSERT_EQ(old + 1, x);
-  });
-
-  std::vector<std::thread> threads;
-  threads.resize(kThreadCount);
-  for (int i = 0; i < kThreadCount; i++) {
-    threads[i] = std::thread([&] {
-      for (int i = 0; i < kLoopCount; i++) {
-        AddOne();
-      }
+    int x                              = 0;
+    Mutex m;
+    auto AddOne([&] {
+        tile::ScopedLock lock(m);
+        int old = x++;
+        ASSERT_EQ(old + 1, x);
     });
-  }
-  while (x != kThreadCount * kLoopCount) {
-    std::this_thread::yield();
-  }
-  for (auto &&t : threads) {
-    t.join();
-  }
+
+    std::vector<std::thread> threads;
+    threads.resize(kThreadCount);
+    for (int i = 0; i < kThreadCount; i++) {
+        threads[i] = std::thread([&] {
+            for (int i = 0; i < kLoopCount; i++) { AddOne(); }
+        });
+    }
+    while (x != kThreadCount * kLoopCount) { std::this_thread::yield(); }
+    for (auto &&t : threads) { t.join(); }
 }
 
-TEST(ScopedLock, MultiThread_4Mutex) {
-  std::mutex m1;
-  std::mutex m2;
-  std::mutex m3;
-  std::mutex m4;
-  constexpr int kLockTestNum = 1000;
-  constexpr int kThreadNum = 24;
-  std::atomic<int> test_success_count{0};
+TEST(ScopedLock, MultiThread_4Mutex)
+{
+    std::mutex m1;
+    std::mutex m2;
+    std::mutex m3;
+    std::mutex m4;
+    constexpr int kLockTestNum = 1000;
+    constexpr int kThreadNum   = 24;
+    std::atomic<int> test_success_count{0};
 
-#define LOCK_ORDER_IMPL(prefix, id1, id2, id3, id4)                            \
-  std::thread TILE_INTERNAL_PP_CAT(thread_, __LINE__)([&] {                    \
-    for (int i = 0; i < kLockTestNum; i++) {                                   \
-      tile::ScopedLock lock(prefix##id1, prefix##id2, prefix##id3,             \
-                            prefix##id4);                                      \
-      int progress = test_success_count.fetch_add(1);                          \
-      TILE_LOG_INFO_IF_EVERY_SECOND(                                           \
-          progress % (kThreadNum * kLockTestNum / 100) == 0, "progress: {}%",  \
-          100.0 * progress / (kThreadNum * kLockTestNum));                     \
-    }                                                                          \
-  });                                                                          \
-  tile::ScopedDeferred TILE_INTERNAL_PP_CAT(defer_, __LINE__)(                 \
-      [&] { TILE_INTERNAL_PP_CAT(thread_, __LINE__).join(); });
+#define LOCK_ORDER_IMPL(prefix, id1, id2, id3, id4)                                                                    \
+    std::thread TILE_INTERNAL_PP_CAT(thread_, __LINE__)([&] {                                                          \
+        for (int i = 0; i < kLockTestNum; i++) {                                                                       \
+            tile::ScopedLock lock(prefix##id1, prefix##id2, prefix##id3, prefix##id4);                                 \
+            int progress = test_success_count.fetch_add(1);                                                            \
+            TILE_LOG_INFO_IF_EVERY_SECOND(progress % (kThreadNum * kLockTestNum / 100) == 0, "progress: {}%",          \
+                                          100.0 * progress / (kThreadNum * kLockTestNum));                             \
+        }                                                                                                              \
+    });                                                                                                                \
+    tile::ScopedDeferred TILE_INTERNAL_PP_CAT(defer_, __LINE__)([&] {                                                  \
+        TILE_INTERNAL_PP_CAT(thread_, __LINE__).join();                                                                \
+    });
 
 #define LOCK_ORDER(x, y, z, w) LOCK_ORDER_IMPL(m, x, y, z, w)
 
-  {
-    //
-    LOCK_ORDER(1, 2, 3, 4);
-    LOCK_ORDER(1, 2, 4, 3);
-    LOCK_ORDER(1, 3, 2, 4);
-    LOCK_ORDER(1, 3, 4, 2);
-    LOCK_ORDER(1, 4, 2, 3);
-    LOCK_ORDER(1, 4, 3, 2);
-    //
-    LOCK_ORDER(2, 1, 3, 4);
-    LOCK_ORDER(2, 1, 4, 3);
-    LOCK_ORDER(2, 3, 1, 4);
-    LOCK_ORDER(2, 3, 4, 1);
-    LOCK_ORDER(2, 4, 1, 3);
-    LOCK_ORDER(2, 4, 3, 1);
-    //
-    LOCK_ORDER(3, 1, 2, 4);
-    LOCK_ORDER(3, 1, 4, 2);
-    LOCK_ORDER(3, 2, 1, 4);
-    LOCK_ORDER(3, 2, 4, 1);
-    LOCK_ORDER(3, 4, 1, 2);
-    LOCK_ORDER(3, 4, 2, 1);
-    //
-    LOCK_ORDER(4, 1, 2, 3);
-    LOCK_ORDER(4, 1, 3, 2);
-    LOCK_ORDER(4, 2, 1, 3);
-    LOCK_ORDER(4, 2, 3, 1);
-    LOCK_ORDER(4, 3, 1, 2);
-    LOCK_ORDER(4, 3, 2, 1);
-  }
-  TILE_LOG_INFO("progress {}%", 100.0 * test_success_count.load() /
-                                    (kThreadNum * kLockTestNum));
+    {
+        //
+        LOCK_ORDER(1, 2, 3, 4);
+        LOCK_ORDER(1, 2, 4, 3);
+        LOCK_ORDER(1, 3, 2, 4);
+        LOCK_ORDER(1, 3, 4, 2);
+        LOCK_ORDER(1, 4, 2, 3);
+        LOCK_ORDER(1, 4, 3, 2);
+        //
+        LOCK_ORDER(2, 1, 3, 4);
+        LOCK_ORDER(2, 1, 4, 3);
+        LOCK_ORDER(2, 3, 1, 4);
+        LOCK_ORDER(2, 3, 4, 1);
+        LOCK_ORDER(2, 4, 1, 3);
+        LOCK_ORDER(2, 4, 3, 1);
+        //
+        LOCK_ORDER(3, 1, 2, 4);
+        LOCK_ORDER(3, 1, 4, 2);
+        LOCK_ORDER(3, 2, 1, 4);
+        LOCK_ORDER(3, 2, 4, 1);
+        LOCK_ORDER(3, 4, 1, 2);
+        LOCK_ORDER(3, 4, 2, 1);
+        //
+        LOCK_ORDER(4, 1, 2, 3);
+        LOCK_ORDER(4, 1, 3, 2);
+        LOCK_ORDER(4, 2, 1, 3);
+        LOCK_ORDER(4, 2, 3, 1);
+        LOCK_ORDER(4, 3, 1, 2);
+        LOCK_ORDER(4, 3, 2, 1);
+    }
+    TILE_LOG_INFO("progress {}%", 100.0 * test_success_count.load() / (kThreadNum * kLockTestNum));
 
 #undef LOCK_ORDER_IMPL
 #undef LOCK_ORDER
-  ASSERT_EQ(kThreadNum * kLockTestNum, test_success_count.load());
+    ASSERT_EQ(kThreadNum * kLockTestNum, test_success_count.load());
 }
 
-TEST(ScopedLock, DuplicateLockCheck) {
-  TILE_LOG_INFO("log before InitGoogleLogging");
-  ASSERT_DEATH(
-      [] {
-        std::mutex m;
-        tile::ScopedLock lock(m, m);
-      }(),
-      ::testing::HasSubstr("You should not lock a lock twice"));
+TEST(ScopedLock, DuplicateLockCheck)
+{
+    TILE_LOG_INFO("log before InitGoogleLogging");
+    ASSERT_DEATH(
+        [] {
+            std::mutex m;
+            tile::ScopedLock lock(m, m);
+        }(),
+        ::testing::HasSubstr("You should not lock a lock twice"));
 }
 
-} // namespace tile
+}// namespace tile
diff --git a/tile/base/thread/spinlock.cc b/tile/base/thread/spinlock.cc
index 45985f9..7db532d 100644
--- a/tile/base/thread/spinlock.cc
+++ b/tile/base/thread/spinlock.cc
@@ -21,14 +21,18 @@
 
 namespace tile {
 
-void Spinlock::LockSlow() noexcept {
-  auto start_tp = ReadCoarseSteadyClock();
-  do {
-    while (locked_.load(std::memory_order_relaxed)) {
-      TILE_CPU_RELAX();
-    }
-  } while (locked_.exchange(true, std::memory_order_acquire));
+void
+Spinlock::LockSlow() noexcept
+{
+    auto start_tp = ReadCoarseSteadyClock();
+    do {
+        while (locked_.load(std::memory_order_relaxed)) { TILE_CPU_RELAX(); }
+    } while (locked_.exchange(true, std::memory_order_acquire));
 }
 
-void RelaxCpu() noexcept { TILE_CPU_RELAX(); }
-} // namespace tile
+void
+RelaxCpu() noexcept
+{
+    TILE_CPU_RELAX();
+}
+}// namespace tile
diff --git a/tile/base/thread/spinlock.h b/tile/base/thread/spinlock.h
index 2d84d42..88a212a 100644
--- a/tile/base/thread/spinlock.h
+++ b/tile/base/thread/spinlock.h
@@ -11,26 +11,25 @@ namespace tile {
 
 class Spinlock {
 public:
-  void Lock() noexcept {
-    if (TILE_LIKELY(TryLock())) {
-      return;
+    void Lock() noexcept
+    {
+        if (TILE_LIKELY(TryLock())) { return; }
+
+        LockSlow();
     }
 
-    LockSlow();
-  }
-  bool TryLock() noexcept {
-    return !locked_.exchange(true, std::memory_order_acquire);
-  }
-  void Unlock() noexcept { locked_.store(false, std::memory_order_release); }
+    bool TryLock() noexcept { return !locked_.exchange(true, std::memory_order_acquire); }
+
+    void Unlock() noexcept { locked_.store(false, std::memory_order_release); }
 
 private:
-  void LockSlow() noexcept;
+    void LockSlow() noexcept;
 
 private:
-  std::atomic<bool> locked_{false};
+    std::atomic<bool> locked_{false};
 };
 
 void RelaxCpu() noexcept;
-} // namespace tile
+}// namespace tile
 
-#endif // TILE_BASE_THREAD_SPINLOCK_H
+#endif// TILE_BASE_THREAD_SPINLOCK_H
diff --git a/tile/base/thread/spinlock_test.cc b/tile/base/thread/spinlock_test.cc
index a703daf..6034a3e 100644
--- a/tile/base/thread/spinlock_test.cc
+++ b/tile/base/thread/spinlock_test.cc
@@ -11,27 +11,26 @@ namespace tile {
 
 std::uint64_t counter{};
 
-TEST(Spinlock, All) {
-  constexpr auto T = 10;
-  constexpr auto N = 100000;
-  std::thread ts[T];
-  Latch latch(1);
-  Spinlock splk;
+TEST(Spinlock, All)
+{
+    constexpr auto T = 10;
+    constexpr auto N = 100000;
+    std::thread ts[T];
+    Latch latch(1);
+    Spinlock splk;
 
-  for (auto &&t : ts) {
-    t = std::thread([&] {
-      latch.Wait();
-      for (int i = 0; i != N; ++i) {
-        ScopedLock lk(splk);
-        ++counter;
-      }
-    });
-  }
-  latch.ArriveAndWait();
-  for (auto &&t : ts) {
-    t.join();
-  }
-  ASSERT_EQ(T * N, counter);
+    for (auto &&t : ts) {
+        t = std::thread([&] {
+            latch.Wait();
+            for (int i = 0; i != N; ++i) {
+                ScopedLock lk(splk);
+                ++counter;
+            }
+        });
+    }
+    latch.ArriveAndWait();
+    for (auto &&t : ts) { t.join(); }
+    ASSERT_EQ(T * N, counter);
 }
 
-} // namespace tile
+}// namespace tile
diff --git a/tile/base/thread/thread_local.h b/tile/base/thread/thread_local.h
index c36d320..161f34c 100644
--- a/tile/base/thread/thread_local.h
+++ b/tile/base/thread/thread_local.h
@@ -39,7 +39,7 @@ public:
         ScopedLock _(init_lock_);
     }
 
-    ThreadLocal(const ThreadLocal &) = delete;
+    ThreadLocal(const ThreadLocal &)            = delete;
     ThreadLocal &operator=(const ThreadLocal &) = delete;
 
 private:
diff --git a/tile/base/thread/thread_local/object_array.h b/tile/base/thread/thread_local/object_array.h
index e8ede26..2625b55 100644
--- a/tile/base/thread/thread_local/object_array.h
+++ b/tile/base/thread/thread_local/object_array.h
@@ -44,7 +44,7 @@ public:
         }
     }
 
-    LazyInitObjectArray(LazyInitObjectArray &&) = default;
+    LazyInitObjectArray(LazyInitObjectArray &&)            = default;
     LazyInitObjectArray &operator=(LazyInitObjectArray &&) = default;
 
     template<typename F>
diff --git a/tile/base/thread/unique_lock.h b/tile/base/thread/unique_lock.h
index 3039175..066eb66 100644
--- a/tile/base/thread/unique_lock.h
+++ b/tile/base/thread/unique_lock.h
@@ -10,48 +10,48 @@
 #include <atomic>
 
 namespace tile {
-template <typename M, typename... Args> class UniqueLock;
+template<typename M, typename... Args>
+class UniqueLock;
 
-template <typename M> class UniqueLock<M> final {
-  static_assert((detail::thread::Lockable<M>::value ||
-                 detail::thread::lockable<M>::value) &&
-                    (detail::thread::Unlockable<M>::value ||
-                     detail::thread::unlockable<M>::value),
-                "M is not lockable, unlockable");
+template<typename M>
+class UniqueLock<M> final {
+    static_assert((detail::thread::Lockable<M>::value || detail::thread::lockable<M>::value)
+                      && (detail::thread::Unlockable<M>::value || detail::thread::unlockable<M>::value),
+                  "M is not lockable, unlockable");
 
 public:
-  inline explicit UniqueLock(M &m) : m_(m), locked_(true) {
-    MutexOperator<M>::Lock(&m_);
-  }
-  inline ~UniqueLock() {
-    if (locked_.load(std::memory_order_acquire)) {
-      MutexOperator<M>::Unlock(&m_);
-    }
-  }
+    inline explicit UniqueLock(M &m) : m_(m), locked_(true) { MutexOperator<M>::Lock(&m_); }
 
-  UniqueLock(const UniqueLock &) = delete;
-  UniqueLock(UniqueLock &&) = delete;
-  UniqueLock &operator=(const UniqueLock &) = delete;
-  UniqueLock &operator=(UniqueLock &&) = delete;
-
-  inline void Unlock() {
-    bool expected = true;
-    if (locked_.compare_exchange_strong(expected, false)) {
-      MutexOperator<M>::Unlock(&m_);
-    } else {
-      TILE_CHECK(false, "You can't unlock a unlocked lock");
+    inline ~UniqueLock()
+    {
+        if (locked_.load(std::memory_order_acquire)) { MutexOperator<M>::Unlock(&m_); }
+    }
+
+    UniqueLock(const UniqueLock &)            = delete;
+    UniqueLock(UniqueLock &&)                 = delete;
+    UniqueLock &operator=(const UniqueLock &) = delete;
+    UniqueLock &operator=(UniqueLock &&)      = delete;
+
+    inline void Unlock()
+    {
+        bool expected = true;
+        if (locked_.compare_exchange_strong(expected, false)) {
+            MutexOperator<M>::Unlock(&m_);
+        } else {
+            TILE_CHECK(false, "You can't unlock a unlocked lock");
+        }
     }
-  }
 
 private:
-  friend class ::tile::detail::cond_var::CondVar;
-  M *GetMutex() { return &m_; }
+    friend class ::tile::detail::cond_var::CondVar;
+
+    M *GetMutex() { return &m_; }
 
 private:
-  M &m_;
-  std::atomic<bool> locked_;
+    M &m_;
+    std::atomic<bool> locked_;
 };
 
-} // namespace tile
+}// namespace tile
 
-#endif // TILE_BASE_THREAD_UNIQUE_LOCK_H
+#endif// TILE_BASE_THREAD_UNIQUE_LOCK_H
diff --git a/tile/base/thread/unique_lock_test.cc b/tile/base/thread/unique_lock_test.cc
index 4f29002..400effe 100644
--- a/tile/base/thread/unique_lock_test.cc
+++ b/tile/base/thread/unique_lock_test.cc
@@ -5,57 +5,54 @@
 #include <thread>
 
 namespace tile {
-TEST(UniqueLock, Lock) {
-  Mutex m;
-  bool is_set = false;
-
-  {
-    UniqueLock<Mutex> lock(m);
+TEST(UniqueLock, Lock)
+{
+    Mutex m;
+    bool is_set = false;
 
     {
-      std::thread t1([&] {
         UniqueLock<Mutex> lock(m);
-        is_set = true;
-      });
 
-      ASSERT_FALSE(is_set);
-      std::this_thread::sleep_for(std::chrono::milliseconds(10));
-      ASSERT_FALSE(is_set);
-      m.Unlock();
-      t1.join();
-      ASSERT_TRUE(is_set);
-      m.Lock();
+        {
+            std::thread t1([&] {
+                UniqueLock<Mutex> lock(m);
+                is_set = true;
+            });
+
+            ASSERT_FALSE(is_set);
+            std::this_thread::sleep_for(std::chrono::milliseconds(10));
+            ASSERT_FALSE(is_set);
+            m.Unlock();
+            t1.join();
+            ASSERT_TRUE(is_set);
+            m.Lock();
+        }
     }
-  }
-  ASSERT_TRUE(m.TryLock());
-  m.Unlock();
+    ASSERT_TRUE(m.TryLock());
+    m.Unlock();
 }
-TEST(UniqueLock, MultiThread) {
-  constexpr std::size_t kThreadCount = 5;
-  constexpr std::size_t kLoopCount = 10000;
 
-  int x = 0;
-  Mutex m;
-  auto AddOne([&] {
-    tile::UniqueLock<Mutex> lock(m);
-    int old = x++;
-    ASSERT_EQ(old + 1, x);
-  });
+TEST(UniqueLock, MultiThread)
+{
+    constexpr std::size_t kThreadCount = 5;
+    constexpr std::size_t kLoopCount   = 10000;
 
-  std::vector<std::thread> threads;
-  threads.resize(kThreadCount);
-  for (int i = 0; i < kThreadCount; i++) {
-    threads[i] = std::thread([&] {
-      for (int i = 0; i < kLoopCount; i++) {
-        AddOne();
-      }
+    int x                              = 0;
+    Mutex m;
+    auto AddOne([&] {
+        tile::UniqueLock<Mutex> lock(m);
+        int old = x++;
+        ASSERT_EQ(old + 1, x);
     });
-  }
-  while (x != kThreadCount * kLoopCount) {
-    std::this_thread::yield();
-  }
-  for (auto &&t : threads) {
-    t.join();
-  }
+
+    std::vector<std::thread> threads;
+    threads.resize(kThreadCount);
+    for (int i = 0; i < kThreadCount; i++) {
+        threads[i] = std::thread([&] {
+            for (int i = 0; i < kLoopCount; i++) { AddOne(); }
+        });
+    }
+    while (x != kThreadCount * kLoopCount) { std::this_thread::yield(); }
+    for (auto &&t : threads) { t.join(); }
 }
-} // namespace tile
+}// namespace tile
diff --git a/tile/base/type_index.h b/tile/base/type_index.h
index c2c33b7..87626cf 100644
--- a/tile/base/type_index.h
+++ b/tile/base/type_index.h
@@ -10,51 +10,51 @@
 namespace tile {
 namespace detail {
 struct TypeIndexEntity {
-  std::type_index runtime_type_index;
+    std::type_index runtime_type_index;
 };
 
-} // namespace detail
+}// namespace detail
 
 class TypeIndex {
 public:
-  TypeIndex() noexcept : entity_(nullptr) {}
-  std::type_index GetRuntimeTypeIndex() const {
-    return entity_->runtime_type_index;
-  }
+    TypeIndex() noexcept : entity_(nullptr) {}
 
-  constexpr bool operator==(TypeIndex other) const {
-    return entity_ == other.entity_;
-  }
-  constexpr bool operator!=(TypeIndex other) const {
-    return entity_ != other.entity_;
-  }
-  constexpr bool operator<(TypeIndex other) const {
-    return entity_ < other.entity_;
-  }
+    std::type_index GetRuntimeTypeIndex() const { return entity_->runtime_type_index; }
+
+    constexpr bool operator==(TypeIndex other) const { return entity_ == other.entity_; }
+
+    constexpr bool operator!=(TypeIndex other) const { return entity_ != other.entity_; }
+
+    constexpr bool operator<(TypeIndex other) const { return entity_ < other.entity_; }
 
 private:
-  template <typename T> friend TypeIndex GetTypeIndex();
-  friend struct std::hash<TypeIndex>;
+    template<typename T>
+    friend TypeIndex GetTypeIndex();
+    friend struct std::hash<TypeIndex>;
 
-  constexpr explicit TypeIndex(const detail::TypeIndexEntity *entity)
-      : entity_(entity) {}
+    constexpr explicit TypeIndex(const detail::TypeIndexEntity *entity) : entity_(entity) {}
 
 private:
-  const detail::TypeIndexEntity *entity_;
+    const detail::TypeIndexEntity *entity_;
 };
 
-template <typename T> TypeIndex GetTypeIndex() {
-  static detail::TypeIndexEntity entity{std::type_index(typeid(T))};
-  return TypeIndex(&entity);
+template<typename T>
+TypeIndex
+GetTypeIndex()
+{
+    static detail::TypeIndexEntity entity{std::type_index(typeid(T))};
+    return TypeIndex(&entity);
 }
-} // namespace tile
+}// namespace tile
 
 namespace std {
-template <> struct hash<tile::TypeIndex> {
-  size_t operator()(const tile::TypeIndex &type_index) const noexcept {
-    return std::hash<const void *>{}(type_index.entity_);
-  }
+template<>
+struct hash<tile::TypeIndex> {
+    size_t operator()(const tile::TypeIndex &type_index) const noexcept
+    {
+        return std::hash<const void *>{}(type_index.entity_);
+    }
 };
-} // namespace std
+}// namespace std
 
-#endif // _TILE_BASE_TYPE_INDEX_H
+#endif// _TILE_BASE_TYPE_INDEX_H
diff --git a/tile/base/variant.h b/tile/base/variant.h
index bd9cd7f..a764f46 100644
--- a/tile/base/variant.h
+++ b/tile/base/variant.h
@@ -7,9 +7,10 @@
 #include <variant>
 #else
 #include "tile/base/internal/variant.h"
+
 namespace std {
 using namespace mpark;
 }
 #endif
 
-#endif // TILE_BASE_VARIANT_H
+#endif// TILE_BASE_VARIANT_H
diff --git a/tile/base/write_mostly/metrics.h b/tile/base/write_mostly/metrics.h
index e702109..27c814a 100644
--- a/tile/base/write_mostly/metrics.h
+++ b/tile/base/write_mostly/metrics.h
@@ -13,24 +13,25 @@ namespace tile {
 
 namespace write_mostly {
 namespace detail {
-template <typename T> struct MetricsStats;
+template<typename T>
+struct MetricsStats;
 }
-} // namespace write_mostly
+}// namespace write_mostly
 
-template <typename T> struct MetricsStats {
-  using SumType = internal::conditional_t<
-      std::is_integral<T>::value,
-      internal::conditional_t<std::is_signed<T>::value, std::int64_t,
-                              std::uint64_t>,
-      long double>;
+template<typename T>
+struct MetricsStats {
+    using SumType =
+        internal::conditional_t<std::is_integral<T>::value,
+                                internal::conditional_t<std::is_signed<T>::value, std::int64_t, std::uint64_t>,
+                                long double>;
 
-  SumType sum;
-  std::size_t cnt;
-  T max;
-  T min;
-  T average;
+    SumType sum;
+    std::size_t cnt;
+    T max;
+    T min;
+    T average;
 };
 
-} // namespace tile
+}// namespace tile
 
-#endif // TILE_BASE_WRITE_MOSTLY_METRICS_H
+#endif// TILE_BASE_WRITE_MOSTLY_METRICS_H
diff --git a/tile/base/write_mostly/write_mostly.h b/tile/base/write_mostly/write_mostly.h
index f17ee86..5cf3916 100644
--- a/tile/base/write_mostly/write_mostly.h
+++ b/tile/base/write_mostly/write_mostly.h
@@ -8,11 +8,12 @@
 #include <mutex>
 
 namespace tile {
-template <typename Traits> class WriteMostly {
-  using T = typename Traits::Type;
+template<typename Traits>
+class WriteMostly {
+    using T = typename Traits::Type;
 
 public:
 };
-} // namespace tile
+}// namespace tile
 
-#endif // TILE_BASE_WRITE_MOSTLY_WRITE_MOSTLY_H
+#endif// TILE_BASE_WRITE_MOSTLY_WRITE_MOSTLY_H
diff --git a/tile/init.cc b/tile/init.cc
index bcde904..e96c10b 100644
--- a/tile/init.cc
+++ b/tile/init.cc
@@ -20,7 +20,8 @@
 #include <mutex>
 #include <sys/signal.h>
 
-DEFINE_bool(tile_abort_on_double_quit_signal, true,
+DEFINE_bool(tile_abort_on_double_quit_signal,
+            true,
             "If set, flare aborts the whole program when a second SIGQUIT (or "
             "SIGINT) is received. This helps when the program cannot exit "
             "cleanly on the first signal.");
@@ -30,90 +31,97 @@ namespace {
 
 std::atomic<bool> g_quit_siganl{false};
 
-void QuitSignalHandler(int sig) {
-  auto old = g_quit_siganl.exchange(true, std::memory_order_relaxed);
-  if (old && FLAGS_tile_abort_on_double_quit_signal) {
-    RAW_LOG(FATAL, "Double quit signal received. Crashing the program");
-  }
+void
+QuitSignalHandler(int sig)
+{
+    auto old = g_quit_siganl.exchange(true, std::memory_order_relaxed);
+    if (old && FLAGS_tile_abort_on_double_quit_signal) {
+        RAW_LOG(FATAL, "Double quit signal received. Crashing the program");
+    }
 }
 
-void InstallQuitSignalHandler() {
-  static std::once_flag flag;
-  std::call_once(flag, [&] {
-    TILE_PCHECK(signal(SIGINT, QuitSignalHandler) != SIG_ERR);
-    TILE_PCHECK(signal(SIGQUIT, QuitSignalHandler) != SIG_ERR);
-    TILE_PCHECK(signal(SIGTERM, QuitSignalHandler) != SIG_ERR);
-  });
+void
+InstallQuitSignalHandler()
+{
+    static std::once_flag flag;
+    std::call_once(flag, [&] {
+        TILE_PCHECK(signal(SIGINT, QuitSignalHandler) != SIG_ERR);
+        TILE_PCHECK(signal(SIGQUIT, QuitSignalHandler) != SIG_ERR);
+        TILE_PCHECK(signal(SIGTERM, QuitSignalHandler) != SIG_ERR);
+    });
 }
-} // namespace
+}// namespace
 
-int Start(int argc, char **argv, std::function<int(int, char **)> cb,
-          bool single_thread, bool enable_crash_catch) {
-  // glog
-  if (enable_crash_catch) {
-    google::InstallFailureSignalHandler();
-  }
+int
+Start(int argc, char **argv, std::function<int(int, char **)> cb, bool single_thread, bool enable_crash_catch)
+{
+    // glog
+    if (enable_crash_catch) { google::InstallFailureSignalHandler(); }
 
-  // Init gflags
-  gflags::SetVersionString(TILE_VERSION);
-  gflags::ParseCommandLineFlags(&argc, &argv, true);
-  detail::ApplyFlagOverrider();
+    // Init gflags
+    gflags::SetVersionString(TILE_VERSION);
+    gflags::ParseCommandLineFlags(&argc, &argv, true);
+    detail::ApplyFlagOverrider();
 
-  // Init Glog
-  google::InitGoogleLogging(argv[0]);
+    // Init Glog
+    google::InitGoogleLogging(argv[0]);
 
-  TILE_LOG_INFO("Tile started. version: {}", TILE_VERSION);
+    TILE_LOG_INFO("Tile started. version: {}", TILE_VERSION);
 
-  TILE_PCHECK(signal(SIGPIPE, SIG_IGN) != SIG_ERR);
+    TILE_PCHECK(signal(SIGPIPE, SIG_IGN) != SIG_ERR);
 
-  // Init BasicRuntime
-  InitializeBasicRuntime();
+    // Init BasicRuntime
+    InitializeBasicRuntime();
 
-  // Run all initializers
-  detail::RunAllInitializers();
+    // Run all initializers
+    detail::RunAllInitializers();
 
-  int rc = 0;
+    int rc = 0;
 
-  Latch latch(1);
-  auto runner = [&] {
-    option::InitializeOptions();
-    rc = cb(argc, argv);
-    internal::HttpEngine::Stop();
-    internal::HttpEngine::Join();
-    option::ShutdownOptions();
+    Latch latch(1);
+    auto runner = [&] {
+        option::InitializeOptions();
+        rc = cb(argc, argv);
+        internal::HttpEngine::Stop();
+        internal::HttpEngine::Join();
+        option::ShutdownOptions();
 
-    latch.CountDown();
-  };
+        latch.CountDown();
+    };
 
-  if (single_thread) {
-    runner();
-  } else {
-    std::thread worker(runner);
-    latch.Wait();
-    worker.join();
-  }
+    if (single_thread) {
+        runner();
+    } else {
+        std::thread worker(runner);
+        latch.Wait();
+        worker.join();
+    }
 
-  detail::RunAllFinalizers();
-  TerminateBasicRuntime();
-  gflags::ShutDownCommandLineFlags();
-  TILE_LOG_INFO("Exited");
+    detail::RunAllFinalizers();
+    TerminateBasicRuntime();
+    gflags::ShutDownCommandLineFlags();
+    TILE_LOG_INFO("Exited");
 
-  return rc;
+    return rc;
 }
 
-void InitializeBasicRuntime() {
-  detail::chrono::CoarseClockInitializer::Instance()->Start();
-  internal::BackgroundTaskHost::Instance()->Start();
-  internal::TimeKeeper::Instance()->Start();
+void
+InitializeBasicRuntime()
+{
+    detail::chrono::CoarseClockInitializer::Instance()->Start();
+    internal::BackgroundTaskHost::Instance()->Start();
+    internal::TimeKeeper::Instance()->Start();
 }
 
-void TerminateBasicRuntime() {
-  internal::TimeKeeper::Instance()->Stop();
-  internal::TimeKeeper::Instance()->Join();
-  internal::BackgroundTaskHost::Instance()->Stop();
-  internal::BackgroundTaskHost::Instance()->Join();
-  detail::chrono::CoarseClockInitializer::Instance()->Stop();
-  detail::chrono::CoarseClockInitializer::Instance()->Join();
+void
+TerminateBasicRuntime()
+{
+    internal::TimeKeeper::Instance()->Stop();
+    internal::TimeKeeper::Instance()->Join();
+    internal::BackgroundTaskHost::Instance()->Stop();
+    internal::BackgroundTaskHost::Instance()->Join();
+    detail::chrono::CoarseClockInitializer::Instance()->Stop();
+    detail::chrono::CoarseClockInitializer::Instance()->Join();
 }
 
-} // namespace tile
+}// namespace tile
diff --git a/tile/init.h b/tile/init.h
index 0350f76..f81d892 100644
--- a/tile/init.h
+++ b/tile/init.h
@@ -6,8 +6,11 @@
 #include <functional>
 
 namespace tile {
-int Start(int argc, char **argv, std::function<int(int, char **)> cb,
-          bool single_thread = false, bool enable_crash_catch = true);
+int Start(int argc,
+          char **argv,
+          std::function<int(int, char **)> cb,
+          bool single_thread      = false,
+          bool enable_crash_catch = true);
 
 void WaitForQuitSignal();
 bool CheckForQuitSignal();
@@ -15,6 +18,6 @@ bool CheckForQuitSignal();
 void InitializeBasicRuntime();
 void TerminateBasicRuntime();
 
-} // namespace tile
+}// namespace tile
 
-#endif // TILE_INIT_H
+#endif// TILE_INIT_H
diff --git a/tile/init/on_init.cc b/tile/init/on_init.cc
index 3ad04b0..f411db9 100644
--- a/tile/init/on_init.cc
+++ b/tile/init/on_init.cc
@@ -17,96 +17,100 @@ std::vector<std::function<void()>> initializer_registry;
 std::vector<std::function<void()>> finalizer_registry;
 
 struct AtExitCallbackRegistry {
-  Mutex mutex;
-  std::vector<std::function<void()>> registry;
+    Mutex mutex;
+    std::vector<std::function<void()>> registry;
 };
 
-AtExitCallbackRegistry *GetAtExitCallbackRegistry() {
-  static NeverDestroyed<AtExitCallbackRegistry> registry;
-  return registry.Get();
+AtExitCallbackRegistry *
+GetAtExitCallbackRegistry()
+{
+    static NeverDestroyed<AtExitCallbackRegistry> registry;
+    return registry.Get();
 }
 
-} // namespace
-} // namespace tile
+}// namespace
+}// namespace tile
 
 namespace tile {
 namespace internal {
 
-void SetAtExitCallback(std::function<void()> callback) {
-  auto &&registry = GetAtExitCallbackRegistry();
-  ScopedLock _(registry->mutex);
-  registry->registry.push_back(callback);
+void
+SetAtExitCallback(std::function<void()> callback)
+{
+    auto &&registry = GetAtExitCallbackRegistry();
+    ScopedLock _(registry->mutex);
+    registry->registry.push_back(callback);
 }
 
-} // namespace internal
-} // namespace tile
+}// namespace internal
+}// namespace tile
 
 namespace tile {
 namespace detail {
 
 struct Bean {
-  std::function<void()> initializer;
-  std::function<void()> finalizer;
+    std::function<void()> initializer;
+    std::function<void()> finalizer;
 };
 
 std::atomic<bool> registry_prepared{false};
 
-std::map<std::int32_t, std::vector<Bean>> *GetStagingRegistry() {
-  static std::map<std::int32_t, std::vector<Bean>> registry;
-  return &registry;
+std::map<std::int32_t, std::vector<Bean>> *
+GetStagingRegistry()
+{
+    static std::map<std::int32_t, std::vector<Bean>> registry;
+    return &registry;
 }
 
-void PrepareForRunningCallbacks() {
-  auto &&temp_registry = *GetStagingRegistry();
-  auto &&init_registry = initializer_registry;
-  auto &&fini_registry = finalizer_registry;
+void
+PrepareForRunningCallbacks()
+{
+    auto &&temp_registry = *GetStagingRegistry();
+    auto &&init_registry = initializer_registry;
+    auto &&fini_registry = finalizer_registry;
 
-  for (auto &&item : temp_registry) {
-    auto &&k = item.first;
-    auto &&v = item.second;
-    std::shuffle(v.begin(), v.end(), random::Engine());
-    for (auto &&f : v) {
-      init_registry.push_back(std::move(f.initializer));
-      if (f.finalizer) {
-        fini_registry.push_back(std::move(f.finalizer));
-      }
+    for (auto &&item : temp_registry) {
+        auto &&k = item.first;
+        auto &&v = item.second;
+        std::shuffle(v.begin(), v.end(), random::Engine());
+        for (auto &&f : v) {
+            init_registry.push_back(std::move(f.initializer));
+            if (f.finalizer) { fini_registry.push_back(std::move(f.finalizer)); }
+        }
     }
-  }
 
-  std::reverse(fini_registry.begin(), fini_registry.end());
-  registry_prepared.store(true, std::memory_order_relaxed);
+    std::reverse(fini_registry.begin(), fini_registry.end());
+    registry_prepared.store(true, std::memory_order_relaxed);
 }
 
-void RegisterOnInitCallback(std::int32_t priority, std::function<void()> init,
-                            std::function<void()> fini) {
-  TILE_CHECK(
-      !registry_prepared.load(std::memory_order_relaxed),
-      "Callbacks may only be registered before `tile::Start()` is called");
-  auto &&registry = *GetStagingRegistry();
-  TILE_CHECK(init != nullptr, "Initializer must be provided");
-  registry[priority].push_back({std::move(init), std::move(fini)});
+void
+RegisterOnInitCallback(std::int32_t priority, std::function<void()> init, std::function<void()> fini)
+{
+    TILE_CHECK(!registry_prepared.load(std::memory_order_relaxed),
+               "Callbacks may only be registered before `tile::Start()` is called");
+    auto &&registry = *GetStagingRegistry();
+    TILE_CHECK(init != nullptr, "Initializer must be provided");
+    registry[priority].push_back({std::move(init), std::move(fini)});
 }
 
-void RunAllInitializers() {
-  PrepareForRunningCallbacks();
-  auto &&registry = initializer_registry;
+void
+RunAllInitializers()
+{
+    PrepareForRunningCallbacks();
+    auto &&registry = initializer_registry;
 
-  for (auto &&c : registry) {
-    c();
-  }
-  registry.clear();
+    for (auto &&c : registry) { c(); }
+    registry.clear();
 }
 
-void RunAllFinalizers() {
-  auto &&registry = finalizer_registry;
-  for (auto &&c : registry) {
-    c();
-  }
-  registry.clear();
-  for (auto &&e : GetAtExitCallbackRegistry()->registry) {
-    e();
-  }
+void
+RunAllFinalizers()
+{
+    auto &&registry = finalizer_registry;
+    for (auto &&c : registry) { c(); }
+    registry.clear();
+    for (auto &&e : GetAtExitCallbackRegistry()->registry) { e(); }
 }
 
-} // namespace detail
-} // namespace tile
+}// namespace detail
+}// namespace tile
diff --git a/tile/init/on_init.h b/tile/init/on_init.h
index 8b385a0..7be5d39 100644
--- a/tile/init/on_init.h
+++ b/tile/init/on_init.h
@@ -9,40 +9,44 @@
 #include <functional>
 #include <utility>
 
-#define TILE_ON_INIT(...)                                                      \
-  static ::tile::detail::OnInitRegistration TILE_INTERNAL_PP_CAT(              \
-      tile_on_init_registration_object_, __COUNTER__)(__FILE__, __LINE__,      \
-                                                      __VA_ARGS__);
+#define TILE_ON_INIT(...)                                                                                              \
+    static ::tile::detail::OnInitRegistration TILE_INTERNAL_PP_CAT(tile_on_init_registration_object_, __COUNTER__)(    \
+        __FILE__, __LINE__, __VA_ARGS__);
 
 namespace tile {
 namespace internal {
 void SetAtExitCallback(std::function<void()> callback);
 
 }
-} // namespace tile
+}// namespace tile
 
 namespace tile {
 namespace detail {
 
-void RegisterOnInitCallback(std::int32_t priority, std::function<void()> init,
-                            std::function<void()> fini);
+void RegisterOnInitCallback(std::int32_t priority, std::function<void()> init, std::function<void()> fini);
 
 void RunAllInitializers();
 void RunAllFinalizers();
 
 class OnInitRegistration {
 public:
-  inline OnInitRegistration(const char *file, std::uint32_t line,
-                            std::function<void()> init,
-                            std::function<void()> fini = nullptr)
-      : OnInitRegistration(file, line, 0, init, fini) {}
-  inline OnInitRegistration(const char *file, std::uint32_t line,
-                            std::int32_t priority, std::function<void()> init,
-                            std::function<void()> fini = nullptr) {
-    RegisterOnInitCallback(priority, std::move(init), std::move(fini));
-  }
-};
-} // namespace detail
-} // namespace tile
+    inline OnInitRegistration(const char *file,
+                              std::uint32_t line,
+                              std::function<void()> init,
+                              std::function<void()> fini = nullptr)
+        : OnInitRegistration(file, line, 0, init, fini)
+    {}
 
-#endif // TILE_INIT_ON_INIT_H
+    inline OnInitRegistration(const char *file,
+                              std::uint32_t line,
+                              std::int32_t priority,
+                              std::function<void()> init,
+                              std::function<void()> fini = nullptr)
+    {
+        RegisterOnInitCallback(priority, std::move(init), std::move(fini));
+    }
+};
+}// namespace detail
+}// namespace tile
+
+#endif// TILE_INIT_ON_INIT_H
diff --git a/tile/init/on_init_test.cc b/tile/init/on_init_test.cc
index 0964332..bc5f47a 100644
--- a/tile/init/on_init_test.cc
+++ b/tile/init/on_init_test.cc
@@ -6,12 +6,12 @@
 
 static int v = 0;
 TILE_ON_INIT(0, [] {
-  TILE_LOG_INFO("OnInit");
-  v = 1;
+    TILE_LOG_INFO("OnInit");
+    v = 1;
 })
 
 namespace tile {
 namespace init {
 TEST(OnInit, All) { EXPECT_EQ(1, v); }
-} // namespace init
-} // namespace tile
+}// namespace init
+}// namespace tile
diff --git a/tile/init/override_flag.cc b/tile/init/override_flag.cc
index 14b3786..2866d06 100644
--- a/tile/init/override_flag.cc
+++ b/tile/init/override_flag.cc
@@ -11,35 +11,39 @@ namespace detail {
 namespace {
 using Registry = std::unordered_map<std::string, std::pair<std::string, bool>>;
 
-Registry *GetRegistry() {
-  static Registry registry;
-  return &registry;
+Registry *
+GetRegistry()
+{
+    static Registry registry;
+    return &registry;
 }
-} // namespace
+}// namespace
 
-void RegisterFlagOverrider(const std::string &name, const std::string &to,
-                           bool forcibly) {
-  auto &&value = (*GetRegistry())[name];
-  if (!value.first.empty()) {
-    TILE_LOG_FATAL("Duplicate override for flag {}, was [{}], now [{}]", name,
-                   value.first, to);
-  }
-
-  value = std::make_pair(to, forcibly);
-}
-
-void ApplyFlagOverrider() {
-  for (auto &&item : *GetRegistry()) {
-    auto &k = item.first;
-    auto &v = item.second;
-
-    auto current = gflags::GetCommandLineFlagInfoOrDie(k.c_str());
-    if (current.is_default || v.second) {
-      gflags::SetCommandLineOption(k.c_str(), v.first.c_str());
-      TILE_VLOG(10, "Overriding flag [{}] with [{}]", k, v.first);
+void
+RegisterFlagOverrider(const std::string &name, const std::string &to, bool forcibly)
+{
+    auto &&value = (*GetRegistry())[name];
+    if (!value.first.empty()) {
+        TILE_LOG_FATAL("Duplicate override for flag {}, was [{}], now [{}]", name, value.first, to);
     }
-  }
+
+    value = std::make_pair(to, forcibly);
 }
 
-} // namespace detail
-} // namespace tile
+void
+ApplyFlagOverrider()
+{
+    for (auto &&item : *GetRegistry()) {
+        auto &k      = item.first;
+        auto &v      = item.second;
+
+        auto current = gflags::GetCommandLineFlagInfoOrDie(k.c_str());
+        if (current.is_default || v.second) {
+            gflags::SetCommandLineOption(k.c_str(), v.first.c_str());
+            TILE_VLOG(10, "Overriding flag [{}] with [{}]", k, v.first);
+        }
+    }
+}
+
+}// namespace detail
+}// namespace tile
diff --git a/tile/init/override_flag.h b/tile/init/override_flag.h
index bde9b17..a08c01d 100644
--- a/tile/init/override_flag.h
+++ b/tile/init/override_flag.h
@@ -6,36 +6,35 @@
 #include "tile/base/internal/macro.h"
 #include <string>
 
-#define TILE_OVERRIDE_FLAG(Name, NewValue)                                     \
-  static ::tile::detail::FlagOverriderRegistration TILE_INTERNAL_PP_CAT(       \
-      tile_anonymous_flag_overrider_, __COUNTER__)(#Name, NewValue, false);
-#define TILE_FORCE_OVERRIDE_FLAG(Name, NewValue)                               \
-  static ::tile::detail::FlagOverriderRegistration TILE_INTERNAL_PP_CAT(       \
-      tile_anonymous_flag_overrider_, __COUNTER__)(#Name, NewValue, true);
+#define TILE_OVERRIDE_FLAG(Name, NewValue)                                                                             \
+    static ::tile::detail::FlagOverriderRegistration TILE_INTERNAL_PP_CAT(                                             \
+        tile_anonymous_flag_overrider_, __COUNTER__)(#Name, NewValue, false);
+#define TILE_FORCE_OVERRIDE_FLAG(Name, NewValue)                                                                       \
+    static ::tile::detail::FlagOverriderRegistration TILE_INTERNAL_PP_CAT(                                             \
+        tile_anonymous_flag_overrider_, __COUNTER__)(#Name, NewValue, true);
 
 namespace tile {
 namespace detail {
-void RegisterFlagOverrider(const std::string &name, const std::string &value,
-                           bool forcibly);
+void RegisterFlagOverrider(const std::string &name, const std::string &value, bool forcibly);
 // Called by `tile::Start`
 void ApplyFlagOverrider();
 
 class FlagOverriderRegistration {
 public:
-  template <typename T,
-            typename std::enable_if<std::is_trivial<T>::value &&
-                                    !std::is_same<T, const char *>::value>::type
-                * = nullptr>
-  FlagOverriderRegistration(const std::string &name, T value, bool forcibly) {
-    RegisterFlagOverrider(name, std::to_string(value), forcibly);
-  }
+    template<
+        typename T,
+        typename std::enable_if<std::is_trivial<T>::value && !std::is_same<T, const char *>::value>::type * = nullptr>
+    FlagOverriderRegistration(const std::string &name, T value, bool forcibly)
+    {
+        RegisterFlagOverrider(name, std::to_string(value), forcibly);
+    }
 
-  FlagOverriderRegistration(const std::string &name, const std::string &value,
-                            bool forcibly) {
-    RegisterFlagOverrider(name, value, forcibly);
-  }
+    FlagOverriderRegistration(const std::string &name, const std::string &value, bool forcibly)
+    {
+        RegisterFlagOverrider(name, value, forcibly);
+    }
 };
-} // namespace detail
-} // namespace tile
+}// namespace detail
+}// namespace tile
 
-#endif // _TILE_INIT_OVERRIDE_FLAG_H
+#endif// _TILE_INIT_OVERRIDE_FLAG_H
diff --git a/tile/init/override_flag_test.cc b/tile/init/override_flag_test.cc
index 7460b5e..7bcbda5 100644
--- a/tile/init/override_flag_test.cc
+++ b/tile/init/override_flag_test.cc
@@ -10,5 +10,5 @@ TILE_OVERRIDE_FLAG(test, false)
 namespace tile {
 namespace init {
 TEST(OverrideFlag, All) { EXPECT_FALSE(FLAGS_test); }
-} // namespace init
-} // namespace tile
+}// namespace init
+}// namespace tile
diff --git a/tile/io/acceptor.h b/tile/io/acceptor.h
index 9d03fcb..3bcae6f 100644
--- a/tile/io/acceptor.h
+++ b/tile/io/acceptor.h
@@ -9,10 +9,10 @@
 namespace tile {
 class Acceptor {
 public:
-  ~Acceptor() = default;
-  virtual void Stop() = 0;
-  virtual void Join() = 0;
+    ~Acceptor()         = default;
+    virtual void Stop() = 0;
+    virtual void Join() = 0;
 };
-} // namespace tile
+}// namespace tile
 
-#endif // TILE_IO_ACCEPTOR_H
+#endif// TILE_IO_ACCEPTOR_H
diff --git a/tile/io/descriptor.cc b/tile/io/descriptor.cc
index 8d9aaca..eab9fec 100644
--- a/tile/io/descriptor.cc
+++ b/tile/io/descriptor.cc
@@ -13,284 +13,295 @@
 namespace tile {
 
 namespace {
-void CreateOneTimeTimer(std::function<void()> callback,
-                        std::chrono::nanoseconds ns) {
-  if (ns.count() != 0) {
-    auto moved_callback = MakeMoveOnCopy(callback);
-    internal::TimeKeeper::Instance()->AddTimer(
-        ReadSteadyClock() + ns, ns,
-        [moved_callback] { moved_callback.Ref()(); }, true);
-  } else {
-    callback();
-  }
+void
+CreateOneTimeTimer(std::function<void()> callback, std::chrono::nanoseconds ns)
+{
+    if (ns.count() != 0) {
+        auto moved_callback = MakeMoveOnCopy(callback);
+        internal::TimeKeeper::Instance()->AddTimer(
+            ReadSteadyClock() + ns, ns, [moved_callback] { moved_callback.Ref()(); }, true);
+    } else {
+        callback();
+    }
 }
 
-} // namespace
+}// namespace
 
 struct Descriptor::SeldomlyUsed {
-  std::string name;
-  std::atomic<bool> cleanup_queued{false};
-  std::atomic<std::size_t> error_events{};
-  std::atomic<bool> error_seen{};
-  std::atomic<CleanupReason> cleanup_reason{CleanupReason::None};
+    std::string name;
+    std::atomic<bool> cleanup_queued{false};
+    std::atomic<std::size_t> error_events{};
+    std::atomic<bool> error_seen{};
+    std::atomic<CleanupReason> cleanup_reason{CleanupReason::None};
 
-  Mutex cleanup_lock;
-  CondVar cleanup_cv;
-  bool cleanup_completed{false};
+    Mutex cleanup_lock;
+    CondVar cleanup_cv;
+    bool cleanup_completed{false};
 };
 
-Descriptor::Descriptor(Handle fd, Event events, const std::string &name) {
-  // static_assert(offsetof(Descriptor, read_mostly_) ==
-  //                   hardware_destructive_interference_size,
-  //               "");
+Descriptor::Descriptor(Handle fd, Event events, const std::string &name)
+{
+    // static_assert(offsetof(Descriptor, read_mostly_) ==
+    //                   hardware_destructive_interference_size,
+    //               "");
 
-  // init read_mostly_
-  read_mostly_.fd = std::move(fd);
-  read_mostly_.event_mask = static_cast<int>(events);
-  read_mostly_.seldomly_used = make_unique<SeldomlyUsed>();
+    // init read_mostly_
+    read_mostly_.fd            = std::move(fd);
+    read_mostly_.event_mask    = static_cast<int>(events);
+    read_mostly_.seldomly_used = make_unique<SeldomlyUsed>();
 
-  restart_read_count_ = HasEventMask(Event::Write) ? 1 : 0;
-  restart_read_count_ = HasEventMask(Event::Write) ? 1 : 0;
+    restart_read_count_        = HasEventMask(Event::Write) ? 1 : 0;
+    restart_read_count_        = HasEventMask(Event::Write) ? 1 : 0;
 
-  if (name.empty()) {
-    read_mostly_.seldomly_used->name = Format("{}", fmt::ptr(this));
-  } else {
-    read_mostly_.seldomly_used->name = Format("{} @ {}", name, fmt::ptr(this));
-  }
+    if (name.empty()) {
+        read_mostly_.seldomly_used->name = Format("{}", fmt::ptr(this));
+    } else {
+        read_mostly_.seldomly_used->name = Format("{} @ {}", name, fmt::ptr(this));
+    }
 }
 
-Descriptor::~Descriptor() {
-  TILE_CHECK(!Enabled(),
-             "Descriptor {} is still associated with event loop {} when it's "
-             "destructed.",
-             fmt::ptr(this), fmt::ptr(GetEventLoop()));
+Descriptor::~Descriptor()
+{
+    TILE_CHECK(!Enabled(),
+               "Descriptor {} is still associated with event loop {} when it's "
+               "destructed.",
+               fmt::ptr(this), fmt::ptr(GetEventLoop()));
 }
 
-void Descriptor::RestartReadIn(std::chrono::nanoseconds after) {
-  auto ref = RefPtr<Descriptor>(ref_ptr, this);
-  CreateOneTimeTimer([this, ref] { RestartReadNow(); }, after);
-}
-
-void Descriptor::RestartWriteIn(std::chrono::nanoseconds after) {
-  auto ref = RefPtr<Descriptor>(ref_ptr, this);
-  CreateOneTimeTimer([this, ref] { RestartWriteNow(); }, after);
-}
-
-void Descriptor::Kill(CleanupReason reason) {
-  TILE_CHECK(reason != CleanupReason::None);
-  auto expected = CleanupReason::None;
-  if (read_mostly_.seldomly_used->cleanup_reason.compare_exchange_strong(
-          expected, reason, std::memory_order_relaxed)) {
+void
+Descriptor::RestartReadIn(std::chrono::nanoseconds after)
+{
     auto ref = RefPtr<Descriptor>(ref_ptr, this);
+    CreateOneTimeTimer([this, ref] { RestartReadNow(); }, after);
+}
+
+void
+Descriptor::RestartWriteIn(std::chrono::nanoseconds after)
+{
+    auto ref = RefPtr<Descriptor>(ref_ptr, this);
+    CreateOneTimeTimer([this, ref] { RestartWriteNow(); }, after);
+}
+
+void
+Descriptor::Kill(CleanupReason reason)
+{
+    TILE_CHECK(reason != CleanupReason::None);
+    auto expected = CleanupReason::None;
+    if (read_mostly_.seldomly_used->cleanup_reason.compare_exchange_strong(
+            expected, reason, std::memory_order_relaxed)) {
+        auto ref = RefPtr<Descriptor>(ref_ptr, this);
+        GetEventLoop()->AddTask([this, ref] {
+            GetEventLoop()->DisabledDescriptor(this);
+            cleanup_pending_.store(true, std::memory_order_relaxed);
+
+            QueueCleanupCallbackCheck();
+        });
+    }
+}
+
+void
+Descriptor::WaitForCleanup()
+{
+    ScopedLock lock(read_mostly_.seldomly_used->cleanup_lock);
+    read_mostly_.seldomly_used->cleanup_cv.Wait(lock, [this] { return read_mostly_.seldomly_used->cleanup_completed; });
+}
+
+const std::string &
+Descriptor::GetName() const
+{
+    return read_mostly_.seldomly_used->name;
+}
+
+void
+Descriptor::FireEvents(int mask, std::uint64_t polled_at)
+{
+    if (TILE_UNLIKELY(mask & static_cast<int>(Event::Read))) {
+        FireErrorEvent(polled_at);
+        return;
+    }
+
+    if (mask & static_cast<int>(Event::Write)) { FireWriteEvent(polled_at); }
+
+    if (mask & static_cast<int>(Event::Read)) { FireReadEvent(polled_at); }
+}
+
+void
+Descriptor::FireReadEvent(std::uint64_t fired_at)
+{
+    if (read_events_.fetch_add(1, std::memory_order_acquire) == 0) {
+        RefPtr<Descriptor> ref(ref_ptr, this);
+        do {
+            auto rc = OnReadable();
+
+            if (TILE_LIKELY(rc == EventAction::Ready)) {
+                continue;
+            } else if (TILE_UNLIKELY(rc == EventAction::Leaving)) {
+                TILE_CHECK(
+                    read_mostly_.seldomly_used->cleanup_reason.load(std::memory_order_relaxed) != CleanupReason::None,
+                    "Did you forget to call `Kill()`");
+
+                GetEventLoop()->AddTask([this, ref] {
+                    read_events_.store(0, std::memory_order_relaxed);
+                    QueueCleanupCallbackCheck();
+                });
+                break;
+            } else if (rc == EventAction::Suppress) {
+                SuppressReadAndClearReadEventCount();
+                break;
+            }
+        } while (read_events_.fetch_sub(1, std::memory_order_release) != 1);
+
+        QueueCleanupCallbackCheck();
+    }
+}
+
+void
+Descriptor::FireWriteEvent(std::uint64_t fired_at)
+{
+    if (write_events_.fetch_add(1, std::memory_order_acquire) == 0) {
+        RefPtr<Descriptor> ref(ref_ptr, this);
+        do {
+            auto rc = OnWritable();
+            if (TILE_LIKELY(rc == EventAction::Ready)) {
+                continue;
+            } else if (TILE_UNLIKELY(rc == EventAction::Leaving)) {
+                TILE_CHECK(
+                    read_mostly_.seldomly_used->cleanup_reason.load(std::memory_order_relaxed) != CleanupReason::None,
+                    "Did you forget to call `Kill()`");
+                GetEventLoop()->AddTask([this, ref] {
+                    write_events_.store(0, std::memory_order_relaxed);
+                    QueueCleanupCallbackCheck();
+                });
+                break;
+            } else {
+                TILE_UNREACHABLE("Unexpected EventAction");
+            }
+        } while (write_events_.fetch_sub(1, std::memory_order_release) != 1);
+        QueueCleanupCallbackCheck();
+    }
+}
+
+void
+Descriptor::FireErrorEvent(std::uint64_t fired_at)
+{
+    if (read_mostly_.seldomly_used->error_seen.exchange(true, std::memory_order_relaxed)) {
+        TILE_VLOG(10, "Unexpected: Multiple `Event::Error` received.");
+        return;
+    }
+
+    if (read_mostly_.seldomly_used->error_events.fetch_add(1, std::memory_order_relaxed) == 0) {
+        TILE_CHECK_EQ(read_mostly_.seldomly_used->error_events.fetch_sub(1, std::memory_order_release), 1);
+        QueueCleanupCallbackCheck();
+    } else {
+        TILE_UNEXPECTED("Don't Allow Multi Error");
+    }
+}
+
+void
+Descriptor::RestartReadNow()
+{
+    RefPtr<Descriptor> ref(ref_ptr, this);
     GetEventLoop()->AddTask([this, ref] {
-      GetEventLoop()->DisabledDescriptor(this);
-      cleanup_pending_.store(true, std::memory_order_relaxed);
+        if (Enabled()) {
+            auto count = restart_read_count_.fetch_add(1, std::memory_order_relaxed);
 
-      QueueCleanupCallbackCheck();
+            if (count == 0) {
+                TILE_CHECK(!HasEventMask(Event::Read));
+                SetEventMask(GetEventMask() | static_cast<int>(Event::Read));
+                GetEventLoop()->RearmDescriptor(this);
+            }
+        }
     });
-  }
 }
 
-void Descriptor::WaitForCleanup() {
-  ScopedLock lock(read_mostly_.seldomly_used->cleanup_lock);
-  read_mostly_.seldomly_used->cleanup_cv.Wait(
-      lock, [this] { return read_mostly_.seldomly_used->cleanup_completed; });
-}
-
-const std::string &Descriptor::GetName() const {
-  return read_mostly_.seldomly_used->name;
-}
-
-void Descriptor::FireEvents(int mask, std::uint64_t polled_at) {
-  if (TILE_UNLIKELY(mask & static_cast<int>(Event::Read))) {
-    FireErrorEvent(polled_at);
-    return;
-  }
-
-  if (mask & static_cast<int>(Event::Write)) {
-    FireWriteEvent(polled_at);
-  }
-
-  if (mask & static_cast<int>(Event::Read)) {
-    FireReadEvent(polled_at);
-  }
-}
-
-void Descriptor::FireReadEvent(std::uint64_t fired_at) {
-  if (read_events_.fetch_add(1, std::memory_order_acquire) == 0) {
+void
+Descriptor::SuppressReadAndClearReadEventCount()
+{
     RefPtr<Descriptor> ref(ref_ptr, this);
-    do {
-      auto rc = OnReadable();
+    GetEventLoop()->AddTask([this, ref] {
+        read_events_.store(0, std::memory_order_relaxed);
+        QueueCleanupCallbackCheck();
 
-      if (TILE_LIKELY(rc == EventAction::Ready)) {
-        continue;
-      } else if (TILE_UNLIKELY(rc == EventAction::Leaving)) {
-        TILE_CHECK(read_mostly_.seldomly_used->cleanup_reason.load(
-                       std::memory_order_relaxed) != CleanupReason::None,
-                   "Did you forget to call `Kill()`");
+        if (Enabled()) {
+            auto reached = restart_read_count_.fetch_sub(1, std::memory_order_relaxed) - 1;
+            TILE_CHECK_NE(reached, -1, "Must call by `RestartReadNow`");
+            TILE_CHECK(GetEventMask() & static_cast<int>(Event::Read));
 
-        GetEventLoop()->AddTask([this, ref] {
-          read_events_.store(0, std::memory_order_relaxed);
-          QueueCleanupCallbackCheck();
-        });
-        break;
-      } else if (rc == EventAction::Suppress) {
-        SuppressReadAndClearReadEventCount();
-        break;
-      }
-    } while (read_events_.fetch_sub(1, std::memory_order_release) != 1);
-
-    QueueCleanupCallbackCheck();
-  }
+            if (reached == 0) {
+                SetEventMask(GetEventMask() & ~static_cast<int>(Event::Read));
+                GetEventLoop()->RearmDescriptor(this);
+            } else {
+                FireEvents(static_cast<int>(Event::Read), 0);
+            }
+        }
+    });
 }
 
-void Descriptor::FireWriteEvent(std::uint64_t fired_at) {
-  if (write_events_.fetch_add(1, std::memory_order_acquire) == 0) {
+void
+Descriptor::SuppressWriteAndClearWriteEventCount()
+{
     RefPtr<Descriptor> ref(ref_ptr, this);
-    do {
-      auto rc = OnWritable();
-      if (TILE_LIKELY(rc == EventAction::Ready)) {
-        continue;
-      } else if (TILE_UNLIKELY(rc == EventAction::Leaving)) {
-        TILE_CHECK(read_mostly_.seldomly_used->cleanup_reason.load(
-                       std::memory_order_relaxed) != CleanupReason::None,
-                   "Did you forget to call `Kill()`");
-        GetEventLoop()->AddTask([this, ref] {
-          write_events_.store(0, std::memory_order_relaxed);
-          QueueCleanupCallbackCheck();
-        });
-        break;
-      } else {
-        TILE_UNREACHABLE("Unexpected EventAction");
-      }
-    } while (write_events_.fetch_sub(1, std::memory_order_release) != 1);
-    QueueCleanupCallbackCheck();
-  }
+
+    GetEventLoop()->AddTask([this, ref] {
+        write_events_.store(0, std::memory_order_relaxed);
+        QueueCleanupCallbackCheck();
+
+        if (Enabled()) {
+            auto reached = restart_write_count_.fetch_sub(1, std::memory_order_relaxed) - 1;
+            TILE_CHECK(reached == 0 || reached == 1, "Unexpected restart-write count: {}");
+            TILE_CHECK(GetEventMask() & static_cast<int>(Event::Write));
+
+            if (reached == 0) {
+                SetEventMask(GetEventMask() & ~static_cast<int>(Event::Write));
+                GetEventLoop()->RearmDescriptor(this);
+            } else {
+                FireEvents(static_cast<int>(Event::Write), 0);
+            }
+        }
+    });
 }
 
-void Descriptor::FireErrorEvent(std::uint64_t fired_at) {
-  if (read_mostly_.seldomly_used->error_seen.exchange(
-          true, std::memory_order_relaxed)) {
-    TILE_VLOG(10, "Unexpected: Multiple `Event::Error` received.");
-    return;
-  }
-
-  if (read_mostly_.seldomly_used->error_events.fetch_add(
-          1, std::memory_order_relaxed) == 0) {
-    TILE_CHECK_EQ(read_mostly_.seldomly_used->error_events.fetch_sub(
-                      1, std::memory_order_release),
-                  1);
-    QueueCleanupCallbackCheck();
-  } else {
-    TILE_UNEXPECTED("Don't Allow Multi Error");
-  }
+void
+Descriptor::RestartWriteNow()
+{
+    RefPtr<Descriptor> ref(ref_ptr, this);
+    GetEventLoop()->AddTask([this, ref] {
+        if (Enabled()) {
+            auto count = restart_write_count_.fetch_add(1, std::memory_order_relaxed);
+            if (count == 0) {
+                TILE_CHECK(!HasEventMask(Event::Write));
+                SetEventMask(GetEventMask() | static_cast<int>(Event::Write));
+                GetEventLoop()->RearmDescriptor(this);
+            }
+        }
+    });
 }
 
-void Descriptor::RestartReadNow() {
-  RefPtr<Descriptor> ref(ref_ptr, this);
-  GetEventLoop()->AddTask([this, ref] {
-    if (Enabled()) {
-      auto count = restart_read_count_.fetch_add(1, std::memory_order_relaxed);
+void
+Descriptor::QueueCleanupCallbackCheck()
+{
+    if (TILE_LIKELY(!cleanup_pending_.load(std::memory_order_relaxed))) { return; }
 
-      if (count == 0) {
-        TILE_CHECK(!HasEventMask(Event::Read));
-        SetEventMask(GetEventMask() | static_cast<int>(Event::Read));
-        GetEventLoop()->RearmDescriptor(this);
-      }
+    bool no_event = read_events_.load(std::memory_order_relaxed) == 0
+        && write_events_.load(std::memory_order_relaxed) == 0
+        && read_mostly_.seldomly_used->error_events.load(std::memory_order_relaxed) == 0;
+    if (no_event) {
+        if (!read_mostly_.seldomly_used->cleanup_queued.exchange(true, std::memory_order_relaxed)) {
+            RefPtr<Descriptor> ref(ref_ptr, this);
+            GetEventLoop()->AddTask([this, ref] {
+                TILE_CHECK_EQ(read_events_.load(std::memory_order_relaxed), 0);
+                TILE_CHECK_EQ(write_events_.load(std::memory_order_relaxed), 0);
+                TILE_CHECK_EQ(read_mostly_.seldomly_used->error_events.load(std::memory_order_relaxed), 0);
+
+                GetEventLoop()->DetachDescriptor(this);
+                OnCleanup(read_mostly_.seldomly_used->cleanup_reason.load(std::memory_order_relaxed));
+
+                ScopedLock _(read_mostly_.seldomly_used->cleanup_lock);
+                read_mostly_.seldomly_used->cleanup_completed = true;
+                read_mostly_.seldomly_used->cleanup_cv.NotifyOne();
+            });
+        }
     }
-  });
 }
 
-void Descriptor::SuppressReadAndClearReadEventCount() {
-  RefPtr<Descriptor> ref(ref_ptr, this);
-  GetEventLoop()->AddTask([this, ref] {
-    read_events_.store(0, std::memory_order_relaxed);
-    QueueCleanupCallbackCheck();
-
-    if (Enabled()) {
-      auto reached =
-          restart_read_count_.fetch_sub(1, std::memory_order_relaxed) - 1;
-      TILE_CHECK_NE(reached, -1, "Must call by `RestartReadNow`");
-      TILE_CHECK(GetEventMask() & static_cast<int>(Event::Read));
-
-      if (reached == 0) {
-        SetEventMask(GetEventMask() & ~static_cast<int>(Event::Read));
-        GetEventLoop()->RearmDescriptor(this);
-      } else {
-        FireEvents(static_cast<int>(Event::Read), 0);
-      }
-    }
-  });
-}
-
-void Descriptor::SuppressWriteAndClearWriteEventCount() {
-  RefPtr<Descriptor> ref(ref_ptr, this);
-
-  GetEventLoop()->AddTask([this, ref] {
-    write_events_.store(0, std::memory_order_relaxed);
-    QueueCleanupCallbackCheck();
-
-    if (Enabled()) {
-      auto reached =
-          restart_write_count_.fetch_sub(1, std::memory_order_relaxed) - 1;
-      TILE_CHECK(reached == 0 || reached == 1,
-                 "Unexpected restart-write count: {}");
-      TILE_CHECK(GetEventMask() & static_cast<int>(Event::Write));
-
-      if (reached == 0) {
-        SetEventMask(GetEventMask() & ~static_cast<int>(Event::Write));
-        GetEventLoop()->RearmDescriptor(this);
-      } else {
-        FireEvents(static_cast<int>(Event::Write), 0);
-      }
-    }
-  });
-}
-
-void Descriptor::RestartWriteNow() {
-  RefPtr<Descriptor> ref(ref_ptr, this);
-  GetEventLoop()->AddTask([this, ref] {
-    if (Enabled()) {
-      auto count = restart_write_count_.fetch_add(1, std::memory_order_relaxed);
-      if (count == 0) {
-        TILE_CHECK(!HasEventMask(Event::Write));
-        SetEventMask(GetEventMask() | static_cast<int>(Event::Write));
-        GetEventLoop()->RearmDescriptor(this);
-      }
-    }
-  });
-}
-
-void Descriptor::QueueCleanupCallbackCheck() {
-  if (TILE_LIKELY(!cleanup_pending_.load(std::memory_order_relaxed))) {
-    return;
-  }
-
-  bool no_event = read_events_.load(std::memory_order_relaxed) == 0 &&
-                  write_events_.load(std::memory_order_relaxed) == 0 &&
-                  read_mostly_.seldomly_used->error_events.load(
-                      std::memory_order_relaxed) == 0;
-  if (no_event) {
-    if (!read_mostly_.seldomly_used->cleanup_queued.exchange(
-            true, std::memory_order_relaxed)) {
-      RefPtr<Descriptor> ref(ref_ptr, this);
-      GetEventLoop()->AddTask([this, ref] {
-        TILE_CHECK_EQ(read_events_.load(std::memory_order_relaxed), 0);
-        TILE_CHECK_EQ(write_events_.load(std::memory_order_relaxed), 0);
-        TILE_CHECK_EQ(read_mostly_.seldomly_used->error_events.load(
-                          std::memory_order_relaxed),
-                      0);
-
-        GetEventLoop()->DetachDescriptor(this);
-        OnCleanup(read_mostly_.seldomly_used->cleanup_reason.load(
-            std::memory_order_relaxed));
-
-        ScopedLock _(read_mostly_.seldomly_used->cleanup_lock);
-        read_mostly_.seldomly_used->cleanup_completed = true;
-        read_mostly_.seldomly_used->cleanup_cv.NotifyOne();
-      });
-    }
-  }
-}
-
-} // namespace tile
+}// namespace tile
diff --git a/tile/io/descriptor.h b/tile/io/descriptor.h
index d31af86..e50d8a3 100644
--- a/tile/io/descriptor.h
+++ b/tile/io/descriptor.h
@@ -12,97 +12,89 @@
 namespace tile {
 class EventLoop;
 
-class alignas(2 * hardware_constructive_interference_size) Descriptor
-    : public RefCounted<Descriptor> {
+class alignas(2 * hardware_constructive_interference_size) Descriptor : public RefCounted<Descriptor> {
 public:
-  enum class Event { Read = 1, Write = 1 << 1, Error = 1 << 2 };
+    enum class Event { Read = 1, Write = 1 << 1, Error = 1 << 2 };
 
-  explicit Descriptor(Handle fd, Event events, const std::string &name = "");
+    explicit Descriptor(Handle fd, Event events, const std::string &name = "");
 
-  virtual ~Descriptor();
+    virtual ~Descriptor();
 
-  int fd() const { return -1; }
+    int fd() const { return -1; }
 
-  EventLoop *GetEventLoop() const {
-    return read_mostly_.ev.load(std::memory_order_relaxed);
-  }
+    EventLoop *GetEventLoop() const { return read_mostly_.ev.load(std::memory_order_relaxed); }
 
 protected:
-  enum class EventAction {
-    Ready,
-    // `Kill()`
-    Leaving,
-    // `RestartReadIn`/`RestartWriteIn`
-    Suppress,
-  };
+    enum class EventAction {
+        Ready,
+        // `Kill()`
+        Leaving,
+        // `RestartReadIn`/`RestartWriteIn`
+        Suppress,
+    };
 
-  enum class CleanupReason {
-    None,
-    HandshakeFailed,
-    Disconnect,
-    UserInitiated,
-    Closing,
-    Error
-  };
+    enum class CleanupReason { None, HandshakeFailed, Disconnect, UserInitiated, Closing, Error };
 
-  virtual EventAction OnReadable() = 0;
-  virtual EventAction OnWritable() = 0;
-  virtual void OnError(int err) = 0;
-  virtual void OnCleanup(CleanupReason reason) = 0;
-  void RestartReadIn(std::chrono::nanoseconds after);
-  void RestartWriteIn(std::chrono::nanoseconds after);
-  void Kill(CleanupReason reason);
-  void WaitForCleanup();
+    virtual EventAction OnReadable()             = 0;
+    virtual EventAction OnWritable()             = 0;
+    virtual void OnError(int err)                = 0;
+    virtual void OnCleanup(CleanupReason reason) = 0;
+    void RestartReadIn(std::chrono::nanoseconds after);
+    void RestartWriteIn(std::chrono::nanoseconds after);
+    void Kill(CleanupReason reason);
+    void WaitForCleanup();
 
 private:
-  TILE_FRIEND_TEST(Descriptor, ConcurrentRestartRead);
-  friend class EventLoop;
-  struct SeldomlyUsed;
+    TILE_FRIEND_TEST(Descriptor, ConcurrentRestartRead);
+    friend class EventLoop;
+    struct SeldomlyUsed;
 
-  void SetEventLoop(EventLoop *ev) { read_mostly_.ev.store(ev); }
-  const std::string &GetName() const;
+    void SetEventLoop(EventLoop *ev) { read_mostly_.ev.store(ev); }
 
-  bool HasEventMask(Event mask) const {
-    return (read_mostly_.event_mask & static_cast<int>(mask)) != 0;
-  }
-  void SetEventMask(int mask) { read_mostly_.event_mask = mask; }
-  int GetEventMask() const { return read_mostly_.event_mask; }
+    const std::string &GetName() const;
 
-  void SetEnabled(bool enabled) { read_mostly_.enabled = enabled; }
-  bool Enabled() const { return read_mostly_.enabled; }
+    bool HasEventMask(Event mask) const { return (read_mostly_.event_mask & static_cast<int>(mask)) != 0; }
 
-  void FireEvents(int mas, std::uint64_t polled_at);
-  void FireReadEvent(std::uint64_t fired_at);
-  void FireWriteEvent(std::uint64_t fired_at);
-  void FireErrorEvent(std::uint64_t fired_at);
+    void SetEventMask(int mask) { read_mostly_.event_mask = mask; }
 
-  void SuppressReadAndClearReadEventCount();
-  void SuppressWriteAndClearWriteEventCount();
+    int GetEventMask() const { return read_mostly_.event_mask; }
 
-  void RestartReadNow();
-  void RestartWriteNow();
+    void SetEnabled(bool enabled) { read_mostly_.enabled = enabled; }
 
-  void QueueCleanupCallbackCheck();
+    bool Enabled() const { return read_mostly_.enabled; }
+
+    void FireEvents(int mas, std::uint64_t polled_at);
+    void FireReadEvent(std::uint64_t fired_at);
+    void FireWriteEvent(std::uint64_t fired_at);
+    void FireErrorEvent(std::uint64_t fired_at);
+
+    void SuppressReadAndClearReadEventCount();
+    void SuppressWriteAndClearWriteEventCount();
+
+    void RestartReadNow();
+    void RestartWriteNow();
+
+    void QueueCleanupCallbackCheck();
 
 private:
-  std::atomic<std::size_t> read_events_{}, write_events_{};
+    std::atomic<std::size_t> read_events_{}, write_events_{};
 
-  std::atomic<bool> cleanup_pending_{false};
+    std::atomic<bool> cleanup_pending_{false};
 
-  std::atomic<std::size_t> restart_read_count_, restart_write_count_;
+    std::atomic<std::size_t> restart_read_count_, restart_write_count_;
 
-  struct alignas(hardware_destructive_interference_size) {
-    Handle fd;
-    std::atomic<EventLoop *> ev{nullptr};
-    int event_mask;
-    bool enabled{false};
+    struct alignas(hardware_destructive_interference_size) {
+        Handle fd;
+        std::atomic<EventLoop *> ev{nullptr};
+        int event_mask;
+        bool enabled{false};
 
-    std::unique_ptr<SeldomlyUsed> seldomly_used;
+        std::unique_ptr<SeldomlyUsed> seldomly_used;
 
-  } read_mostly_;
+    } read_mostly_;
 };
 
 TILE_DEFINE_ENUM_BITMASK_OPS(Descriptor::Event);
 
-} // namespace tile
-#endif // TILE_IO_DESCRIPTOR_H
+}// namespace tile
+#endif// TILE_IO_DESCRIPTOR_H
diff --git a/tile/io/detail/eintr_safe.cc b/tile/io/detail/eintr_safe.cc
index 04802d6..500ac3d 100644
--- a/tile/io/detail/eintr_safe.cc
+++ b/tile/io/detail/eintr_safe.cc
@@ -5,8 +5,10 @@ namespace tile {
 namespace io {
 namespace detail {
 
-int EIntrSafeAccept(int sockfd, sockaddr *addr, socklen_t *addrlen) {
-  return EIntrSafeCall([&] { return accept(sockfd, addr, addrlen); });
+int
+EIntrSafeAccept(int sockfd, sockaddr *addr, socklen_t *addrlen)
+{
+    return EIntrSafeCall([&] { return accept(sockfd, addr, addrlen); });
 }
 
 // int EIntrSafeEpollWait(int epfd, epoll_event *events, int maxevents,
@@ -15,22 +17,24 @@ int EIntrSafeAccept(int sockfd, sockaddr *addr, socklen_t *addrlen) {
 //       [&] { return epoll_wait(epfd, events, maxevents, timeout); });
 // }
 
-ssize_t EIntrSafeRecvFrom(int sockfd, void *buf, size_t len, int flags,
-                          sockaddr *src_addr, socklen_t *addrlen) {
-  return EIntrSafeCall(
-      [&] { return recvfrom(sockfd, buf, len, flags, src_addr, addrlen); });
+ssize_t
+EIntrSafeRecvFrom(int sockfd, void *buf, size_t len, int flags, sockaddr *src_addr, socklen_t *addrlen)
+{
+    return EIntrSafeCall([&] { return recvfrom(sockfd, buf, len, flags, src_addr, addrlen); });
 }
 
-ssize_t EIntrSafeSendTo(int sockfd, const void *buf, size_t len, int flags,
-                        const sockaddr *dest_addr, socklen_t addrlen) {
-  return EIntrSafeCall(
-      [&] { return sendto(sockfd, buf, len, flags, dest_addr, addrlen); });
+ssize_t
+EIntrSafeSendTo(int sockfd, const void *buf, size_t len, int flags, const sockaddr *dest_addr, socklen_t addrlen)
+{
+    return EIntrSafeCall([&] { return sendto(sockfd, buf, len, flags, dest_addr, addrlen); });
 }
 
-ssize_t EIntrSafeSendMsg(int sockfd, const msghdr *msg, int flags) {
-  return EIntrSafeCall([&] { return sendmsg(sockfd, msg, flags); });
+ssize_t
+EIntrSafeSendMsg(int sockfd, const msghdr *msg, int flags)
+{
+    return EIntrSafeCall([&] { return sendmsg(sockfd, msg, flags); });
 }
-} // namespace detail
+}// namespace detail
 
-} // namespace io
-} // namespace tile
+}// namespace io
+}// namespace tile
diff --git a/tile/io/detail/eintr_safe.h b/tile/io/detail/eintr_safe.h
index 340cc12..601c036 100644
--- a/tile/io/detail/eintr_safe.h
+++ b/tile/io/detail/eintr_safe.h
@@ -16,53 +16,62 @@ namespace tile {
 namespace io {
 namespace detail {
 
-template <typename F> auto EIntrSafeCallSlow(F &&f) -> invoke_result_t<F> {
-  while (true) {
-    auto rc = std::forward<F>(f)();
-    if (TILE_LIKELY(rc >= 0 || errno != EINTR)) {
-      return rc;
+template<typename F>
+auto
+EIntrSafeCallSlow(F &&f) -> invoke_result_t<F>
+{
+    while (true) {
+        auto rc = std::forward<F>(f)();
+        if (TILE_LIKELY(rc >= 0 || errno != EINTR)) { return rc; }
     }
-  }
 }
 
-template <class F> inline auto EIntrSafeCall(F &&f) -> invoke_result_t<F> {
-  auto rc = std::forward<F>(f)();
-  if (TILE_LIKELY(rc >= 0 || errno != EINTR)) {
-    return rc;
-  }
+template<class F>
+inline auto
+EIntrSafeCall(F &&f) -> invoke_result_t<F>
+{
+    auto rc = std::forward<F>(f)();
+    if (TILE_LIKELY(rc >= 0 || errno != EINTR)) { return rc; }
 
-  return EIntrSafeCallSlow(std::forward<F>(f));
+    return EIntrSafeCallSlow(std::forward<F>(f));
 }
 
-inline ssize_t EIntrSafeRead(int fd, void *buf, size_t count) {
-  return EIntrSafeCall([&] { return read(fd, buf, count); });
+inline ssize_t
+EIntrSafeRead(int fd, void *buf, size_t count)
+{
+    return EIntrSafeCall([&] { return read(fd, buf, count); });
 }
 
-inline ssize_t EIntrSafeWrite(int fd, const void *buf, size_t count) {
-  return EIntrSafeCall([&] { return write(fd, buf, count); });
+inline ssize_t
+EIntrSafeWrite(int fd, const void *buf, size_t count)
+{
+    return EIntrSafeCall([&] { return write(fd, buf, count); });
 }
 
-inline ssize_t EIntrSafeReadV(int fd, const iovec *iov, int iovcnt) {
-  // FIXME: Does `readv` really return `EINTR`?
-  return EIntrSafeCall([&] { return readv(fd, iov, iovcnt); });
+inline ssize_t
+EIntrSafeReadV(int fd, const iovec *iov, int iovcnt)
+{
+    // FIXME: Does `readv` really return `EINTR`?
+    return EIntrSafeCall([&] { return readv(fd, iov, iovcnt); });
 }
 
-inline ssize_t EIntrSafeWriteV(int fd, const iovec *iov, int iovcnt) {
-  // FIXME: Does `writev` really return `EINTR`?
-  return EIntrSafeCall([&] { return writev(fd, iov, iovcnt); });
+inline ssize_t
+EIntrSafeWriteV(int fd, const iovec *iov, int iovcnt)
+{
+    // FIXME: Does `writev` really return `EINTR`?
+    return EIntrSafeCall([&] { return writev(fd, iov, iovcnt); });
 }
 
 int EIntrSafeAccept(int sockfd, sockaddr *addr, socklen_t *addrlen);
 // int EIntrSafeEpollWait(int epfd, epoll_event *events, int maxevents,
 //                        int timeout);
-ssize_t EIntrSafeRecvFrom(int sockfd, void *buf, size_t len, int flags,
-                          sockaddr *src_addr, socklen_t *addrlen);
-ssize_t EIntrSafeSendTo(int sockfd, const void *buf, size_t len, int flags,
-                        const sockaddr *dest_addr, socklen_t addrlen);
+ssize_t EIntrSafeRecvFrom(int sockfd, void *buf, size_t len, int flags, sockaddr *src_addr, socklen_t *addrlen);
+ssize_t
+EIntrSafeSendTo(int sockfd, const void *buf, size_t len, int flags, const sockaddr *dest_addr, socklen_t addrlen);
 ssize_t EIntrSafeSendMsg(int sockfd, const struct msghdr *msg, int flags);
 
-} // namespace detail
-} // namespace io
-} // namespace tile
+}// namespace detail
+}// namespace io
+}// namespace tile
 
-#endif // TILE_IO_DETAIL_EINTR_SAFE_H
+#endif// TILE_IO_DETAIL_EINTR_SAFE_H
diff --git a/tile/io/event_loop.cc b/tile/io/event_loop.cc
index 159bb1c..0efb08d 100644
--- a/tile/io/event_loop.cc
+++ b/tile/io/event_loop.cc
@@ -9,22 +9,64 @@ namespace tile {
 
 namespace {}
 
-} // namespace tile
+}// namespace tile
+
 namespace tile {
 EventLoop::EventLoop() {}
+
 EventLoop::~EventLoop() {}
 
-void EventLoop::AttachDescriptor(Descriptor *desc, bool enabled) {}
-void EventLoop::EnableDescriptor(Descriptor *desc) {}
-void EventLoop::RearmDescriptor(Descriptor *desc) {}
-void EventLoop::DisabledDescriptor(Descriptor *desc) {}
-void EventLoop::DetachDescriptor(Descriptor *desc) {}
-void EventLoop::AddTask(std::function<void()> &&cb) {}
-void EventLoop::Barrier() {}
-void EventLoop::Run() {}
-void EventLoop::Stop() {}
-void EventLoop::Join() {}
-EventLoop *EventLoop::Current() { return nullptr; }
-void EventLoop::WaitAndRunEvents(std::chrono::milliseconds wait_for) {}
-void EventLoop::RunUserTasks() {}
-} // namespace tile
+void
+EventLoop::AttachDescriptor(Descriptor *desc, bool enabled)
+{}
+
+void
+EventLoop::EnableDescriptor(Descriptor *desc)
+{}
+
+void
+EventLoop::RearmDescriptor(Descriptor *desc)
+{}
+
+void
+EventLoop::DisabledDescriptor(Descriptor *desc)
+{}
+
+void
+EventLoop::DetachDescriptor(Descriptor *desc)
+{}
+
+void
+EventLoop::AddTask(std::function<void()> &&cb)
+{}
+
+void
+EventLoop::Barrier()
+{}
+
+void
+EventLoop::Run()
+{}
+
+void
+EventLoop::Stop()
+{}
+
+void
+EventLoop::Join()
+{}
+
+EventLoop *
+EventLoop::Current()
+{
+    return nullptr;
+}
+
+void
+EventLoop::WaitAndRunEvents(std::chrono::milliseconds wait_for)
+{}
+
+void
+EventLoop::RunUserTasks()
+{}
+}// namespace tile
diff --git a/tile/io/event_loop.h b/tile/io/event_loop.h
index bd2ba10..761fcbd 100644
--- a/tile/io/event_loop.h
+++ b/tile/io/event_loop.h
@@ -12,41 +12,41 @@
 namespace tile {
 class EventLoop {
 public:
-  EventLoop();
-  ~EventLoop();
+    EventLoop();
+    ~EventLoop();
 
-  void AttachDescriptor(Descriptor *desc, bool enabled = true);
-  void EnableDescriptor(Descriptor *desc);
+    void AttachDescriptor(Descriptor *desc, bool enabled = true);
+    void EnableDescriptor(Descriptor *desc);
 
-  void RearmDescriptor(Descriptor *desc);
+    void RearmDescriptor(Descriptor *desc);
 
-  void DisabledDescriptor(Descriptor *desc);
+    void DisabledDescriptor(Descriptor *desc);
 
-  void DetachDescriptor(Descriptor *desc);
+    void DetachDescriptor(Descriptor *desc);
 
-  void AddTask(std::function<void()> &&cb);
+    void AddTask(std::function<void()> &&cb);
 
-  void Barrier();
+    void Barrier();
 
-  // Won't return until `Stop()` is called.
-  void Run();
+    // Won't return until `Stop()` is called.
+    void Run();
 
-  void Stop();
-  void Join();
+    void Stop();
+    void Join();
 
-  static EventLoop *Current();
+    static EventLoop *Current();
 
 private:
-  void WaitAndRunEvents(std::chrono::milliseconds wait_for);
-  void RunUserTasks();
+    void WaitAndRunEvents(std::chrono::milliseconds wait_for);
+    void RunUserTasks();
 
 private:
-  std::atomic<bool> exiting_{false};
+    std::atomic<bool> exiting_{false};
 
-  Mutex tasks_lock_;
-  std::list<std::function<void()>> tasks_;
+    Mutex tasks_lock_;
+    std::list<std::function<void()>> tasks_;
 };
 
-} // namespace tile
+}// namespace tile
 
-#endif // TILE_IO_EVENT_LOOP_H
+#endif// TILE_IO_EVENT_LOOP_H
diff --git a/tile/io/native/acceptor.cc b/tile/io/native/acceptor.cc
index b434762..49c38a1 100644
--- a/tile/io/native/acceptor.cc
+++ b/tile/io/native/acceptor.cc
@@ -6,53 +6,68 @@
 namespace tile {
 NativeAcceptor::NativeAcceptor(Handle fd, Options options)
     : Descriptor(std::move(fd), Event::Read, "NativeAcceptor"),
-      options_(std::move(options)) {}
+      options_(std::move(options))
+{}
 
-void NativeAcceptor::Stop() { Kill(CleanupReason::UserInitiated); }
-void NativeAcceptor::Join() { WaitForCleanup(); }
+void
+NativeAcceptor::Stop()
+{
+    Kill(CleanupReason::UserInitiated);
+}
 
-Descriptor::EventAction NativeAcceptor::OnReadable() {
-  while (true) {
-    EndpointRetriever er;
-    Handle new_fd(io::detail::EIntrSafeAccept(fd(), er.RetrieveAddr(),
-                                              er.RetrieveLength()));
-    if (new_fd.Get() > 0) {
-      auto ep = er.Build();
-      TILE_VLOG(10, "Accepted connection from [{}]", ep.ToString());
-      options_.connection_handler(std::move(new_fd), std::move(ep));
-    } else {
-      const auto err = errno;
+void
+NativeAcceptor::Join()
+{
+    WaitForCleanup();
+}
 
-      if (err == ECONNABORTED || err == EPERM || err == EMFILE ||
-          err == ENFILE || err == ENOBUFS || err == ENOMEM) {
-        TILE_LOG_WARNING_EVERY_SECOND(
-            "Failed in accepting connection (fd #{}): [{}] {}", fd(), err,
-            strerror(err));
-        continue;
-      } else if (err == EAGAIN || err == EWOULDBLOCK) {
-        return EventAction::Ready;
-      } else {
-        TILE_LOG_FATAL(
-            "Unexpected error when accepting connection (fd #{}): [{}] {}",
-            fd(), err, strerror(err));
-      }
+Descriptor::EventAction
+NativeAcceptor::OnReadable()
+{
+    while (true) {
+        EndpointRetriever er;
+        Handle new_fd(io::detail::EIntrSafeAccept(fd(), er.RetrieveAddr(), er.RetrieveLength()));
+        if (new_fd.Get() > 0) {
+            auto ep = er.Build();
+            TILE_VLOG(10, "Accepted connection from [{}]", ep.ToString());
+            options_.connection_handler(std::move(new_fd), std::move(ep));
+        } else {
+            const auto err = errno;
+
+            if (err == ECONNABORTED || err == EPERM || err == EMFILE || err == ENFILE || err == ENOBUFS
+                || err == ENOMEM) {
+                TILE_LOG_WARNING_EVERY_SECOND(
+                    "Failed in accepting connection (fd #{}): [{}] {}", fd(), err, strerror(err));
+                continue;
+            } else if (err == EAGAIN || err == EWOULDBLOCK) {
+                return EventAction::Ready;
+            } else {
+                TILE_LOG_FATAL("Unexpected error when accepting connection (fd #{}): [{}] {}", fd(), err,
+                               strerror(err));
+            }
+        }
     }
-  }
 }
 
-Descriptor::EventAction NativeAcceptor::OnWritable() {
-  TILE_UNREACHABLE("NativeAcceptor::OnWritable.");
-  // NOLINTS
+Descriptor::EventAction
+NativeAcceptor::OnWritable()
+{
+    TILE_UNREACHABLE("NativeAcceptor::OnWritable.");
+    // NOLINTS
 }
 
-void NativeAcceptor::OnCleanup(CleanupReason reason) {
-  // NOTHING
+void
+NativeAcceptor::OnCleanup(CleanupReason reason)
+{
+    // NOTHING
 }
 
-void NativeAcceptor::OnError(int err) {
-  TILE_LOG_FATAL("Error occurred on acceptor {}, no more connection can be "
-                 "accepted; {}",
-                 fmt::ptr(this), strerror(err));
+void
+NativeAcceptor::OnError(int err)
+{
+    TILE_LOG_FATAL("Error occurred on acceptor {}, no more connection can be "
+                   "accepted; {}",
+                   fmt::ptr(this), strerror(err));
 }
 
-} // namespace tile
+}// namespace tile
diff --git a/tile/io/native/acceptor.h b/tile/io/native/acceptor.h
index 1745a8d..620b8c3 100644
--- a/tile/io/native/acceptor.h
+++ b/tile/io/native/acceptor.h
@@ -9,23 +9,23 @@
 namespace tile {
 class NativeAcceptor final : public Descriptor, public Acceptor {
 public:
-  struct Options {
-    std::function<void(Handle fd, Endpoint peer)> connection_handler;
-  };
+    struct Options {
+        std::function<void(Handle fd, Endpoint peer)> connection_handler;
+    };
 
-  explicit NativeAcceptor(Handle fd, Options options);
-  void Stop() override;
-  void Join() override;
+    explicit NativeAcceptor(Handle fd, Options options);
+    void Stop() override;
+    void Join() override;
 
 private:
-  EventAction OnReadable() override;
-  EventAction OnWritable() override; // Abort on call.
-  void OnError(int err) override;
-  void OnCleanup(CleanupReason reason) override;
+    EventAction OnReadable() override;
+    EventAction OnWritable() override;// Abort on call.
+    void OnError(int err) override;
+    void OnCleanup(CleanupReason reason) override;
 
 private:
-  Options options_;
+    Options options_;
 };
-} // namespace tile
+}// namespace tile
 
-#endif // TILE_IO_NATIVE_ACCEPTOR_H
+#endif// TILE_IO_NATIVE_ACCEPTOR_H
diff --git a/tile/io/util/rate_limiter.cc b/tile/io/util/rate_limiter.cc
index ff2569b..6f42e9f 100644
--- a/tile/io/util/rate_limiter.cc
+++ b/tile/io/util/rate_limiter.cc
@@ -8,77 +8,100 @@ namespace tile {
 namespace {
 class NullLimiter : public RateLimiter {
 public:
-  std::size_t GetQuota() override { return 0; }
-  void ConsumeBytes(std::size_t consumed) override {}
-};
-} // namespace
+    std::size_t GetQuota() override { return 0; }
 
-RateLimiter *RateLimiter::GetDefaultRxRateLimiter() {
-  static NullLimiter null_limiter;
-  return &null_limiter;
+    void ConsumeBytes(std::size_t consumed) override {}
+};
+}// namespace
+
+RateLimiter *
+RateLimiter::GetDefaultRxRateLimiter()
+{
+    static NullLimiter null_limiter;
+    return &null_limiter;
 }
 
-RateLimiter *RateLimiter::GetDefaultTxRateLimiter() {
-  static NullLimiter null_limiter;
-  return &null_limiter;
+RateLimiter *
+RateLimiter::GetDefaultTxRateLimiter()
+{
+    static NullLimiter null_limiter;
+    return &null_limiter;
 }
 
 TokenBucketRateLimiter::TokenBucketRateLimiter(std::size_t bucket_quota,
                                                std::size_t quota_per_tick,
                                                std::chrono::nanoseconds tick,
                                                bool over_consumption_allowed)
-    : max_quota_(bucket_quota), quota_per_tick_(quota_per_tick), tick_(tick),
-      over_consumption_allowed_(over_consumption_allowed) {
-  TILE_CHECK_GT(bucket_quota, 0);
-  TILE_CHECK_GT(quota_per_tick, 0);
-  last_refill_ = ReadSteadyClock().time_since_epoch() / tick_;
-  curr_quota_ = max_quota_;
+    : max_quota_(bucket_quota),
+      quota_per_tick_(quota_per_tick),
+      tick_(tick),
+      over_consumption_allowed_(over_consumption_allowed)
+{
+    TILE_CHECK_GT(bucket_quota, 0);
+    TILE_CHECK_GT(quota_per_tick, 0);
+    last_refill_ = ReadSteadyClock().time_since_epoch() / tick_;
+    curr_quota_  = max_quota_;
 }
 
-std::size_t TokenBucketRateLimiter::GetQuota() {
-  auto now = ReadSteadyClock().time_since_epoch() / tick_;
-  std::uint64_t last_refill = internal::Exchange(last_refill_, now);
+std::size_t
+TokenBucketRateLimiter::GetQuota()
+{
+    auto now                  = ReadSteadyClock().time_since_epoch() / tick_;
+    std::uint64_t last_refill = internal::Exchange(last_refill_, now);
 
-  curr_quota_ += quota_per_tick_ * (now - last_refill);
+    curr_quota_ += quota_per_tick_ * (now - last_refill);
 
-  if (curr_quota_ > 0) {
-    curr_quota_ = std::min<std::size_t>(curr_quota_, max_quota_);
-    return curr_quota_;
-  } else {
-    return 0;
-  }
+    if (curr_quota_ > 0) {
+        curr_quota_ = std::min<std::size_t>(curr_quota_, max_quota_);
+        return curr_quota_;
+    } else {
+        return 0;
+    }
 }
 
-void TokenBucketRateLimiter::ConsumeBytes(std::size_t consumed) {
-  TILE_CHECK(over_consumption_allowed_ || consumed <= curr_quota_);
-  curr_quota_ -= consumed;
+void
+TokenBucketRateLimiter::ConsumeBytes(std::size_t consumed)
+{
+    TILE_CHECK(over_consumption_allowed_ || consumed <= curr_quota_);
+    curr_quota_ -= consumed;
 }
 
-ThreadSafeRateLimiter::ThreadSafeRateLimiter(MaybeOwning<RateLimiter> limiter,
-                                             std::size_t burst_limit)
-    : burst_limit_(burst_limit), impl_(std::move(limiter)) {
-  TILE_CHECK_GT(burst_limit_, 0);
+ThreadSafeRateLimiter::ThreadSafeRateLimiter(MaybeOwning<RateLimiter> limiter, std::size_t burst_limit)
+    : burst_limit_(burst_limit),
+      impl_(std::move(limiter))
+{
+    TILE_CHECK_GT(burst_limit_, 0);
 }
 
-std::size_t ThreadSafeRateLimiter::GetQuota() {
-  std::lock_guard<std::mutex> lock(lock_);
-  return impl_->GetQuota();
-}
-void ThreadSafeRateLimiter::ConsumeBytes(std::size_t consumed) {
-  std::lock_guard<std::mutex> lock(lock_);
-  impl_->ConsumeBytes(consumed);
+std::size_t
+ThreadSafeRateLimiter::GetQuota()
+{
+    std::lock_guard<std::mutex> lock(lock_);
+    return impl_->GetQuota();
 }
 
-LayeredRateLimiter::LayeredRateLimiter(RateLimiter *upper,
-                                       MaybeOwning<RateLimiter> ours)
-    : upper_(upper), ours_(std::move(ours)) {}
-
-std::size_t LayeredRateLimiter::GetQuota() {
-  return std::min(upper_->GetQuota(), ours_->GetQuota());
+void
+ThreadSafeRateLimiter::ConsumeBytes(std::size_t consumed)
+{
+    std::lock_guard<std::mutex> lock(lock_);
+    impl_->ConsumeBytes(consumed);
 }
 
-void LayeredRateLimiter::ConsumeBytes(std::size_t consumed) {
-  upper_->ConsumeBytes(consumed);
-  ours_->ConsumeBytes(consumed);
+LayeredRateLimiter::LayeredRateLimiter(RateLimiter *upper, MaybeOwning<RateLimiter> ours)
+    : upper_(upper),
+      ours_(std::move(ours))
+{}
+
+std::size_t
+LayeredRateLimiter::GetQuota()
+{
+    return std::min(upper_->GetQuota(), ours_->GetQuota());
 }
-} // namespace tile
+
+void
+LayeredRateLimiter::ConsumeBytes(std::size_t consumed)
+{
+    upper_->ConsumeBytes(consumed);
+    ours_->ConsumeBytes(consumed);
+}
+}// namespace tile
diff --git a/tile/io/util/rate_limiter.h b/tile/io/util/rate_limiter.h
index 8ed24c6..2d58b2f 100644
--- a/tile/io/util/rate_limiter.h
+++ b/tile/io/util/rate_limiter.h
@@ -11,60 +11,59 @@
 namespace tile {
 class RateLimiter {
 public:
-  virtual ~RateLimiter() = default;
+    virtual ~RateLimiter()                          = default;
 
-  virtual std::size_t GetQuota() = 0;
-  virtual void ConsumeBytes(std::size_t consumed) = 0;
-  static RateLimiter *GetDefaultRxRateLimiter();
-  static RateLimiter *GetDefaultTxRateLimiter();
+    virtual std::size_t GetQuota()                  = 0;
+    virtual void ConsumeBytes(std::size_t consumed) = 0;
+    static RateLimiter *GetDefaultRxRateLimiter();
+    static RateLimiter *GetDefaultTxRateLimiter();
 };
 
 class TokenBucketRateLimiter : public RateLimiter {
 public:
-  TokenBucketRateLimiter(
-      std::size_t bucket_quota, std::size_t quota_per_tick,
-      std::chrono::nanoseconds tick = std::chrono::milliseconds(1),
-      bool over_consumption_allowed = true);
+    TokenBucketRateLimiter(std::size_t bucket_quota,
+                           std::size_t quota_per_tick,
+                           std::chrono::nanoseconds tick = std::chrono::milliseconds(1),
+                           bool over_consumption_allowed = true);
 
-  std::size_t GetQuota() override;
-  void ConsumeBytes(std::size_t consumed) override;
+    std::size_t GetQuota() override;
+    void ConsumeBytes(std::size_t consumed) override;
 
 private:
-  std::size_t max_quota_;
-  std::size_t quota_per_tick_;
-  std::chrono::nanoseconds tick_;
-  bool over_consumption_allowed_;
+    std::size_t max_quota_;
+    std::size_t quota_per_tick_;
+    std::chrono::nanoseconds tick_;
+    bool over_consumption_allowed_;
 
-  std::uint64_t last_refill_;
-  std::int64_t curr_quota_{0};
+    std::uint64_t last_refill_;
+    std::int64_t curr_quota_{0};
 };
 
 class ThreadSafeRateLimiter : public RateLimiter {
 public:
-  explicit ThreadSafeRateLimiter(
-      MaybeOwning<RateLimiter> limiter,
-      std::size_t burst_limit = std::numeric_limits<std::size_t>::max());
-  std::size_t GetQuota() override;
-  void ConsumeBytes(std::size_t consumed) override;
+    explicit ThreadSafeRateLimiter(MaybeOwning<RateLimiter> limiter,
+                                   std::size_t burst_limit = std::numeric_limits<std::size_t>::max());
+    std::size_t GetQuota() override;
+    void ConsumeBytes(std::size_t consumed) override;
 
 private:
-  std::size_t burst_limit_;
-  std::mutex lock_;
-  MaybeOwning<RateLimiter> impl_;
+    std::size_t burst_limit_;
+    std::mutex lock_;
+    MaybeOwning<RateLimiter> impl_;
 };
 
 class LayeredRateLimiter : public RateLimiter {
 public:
-  LayeredRateLimiter(RateLimiter *upper, MaybeOwning<RateLimiter> ours);
+    LayeredRateLimiter(RateLimiter *upper, MaybeOwning<RateLimiter> ours);
 
-  std::size_t GetQuota() override;
-  void ConsumeBytes(std::size_t consumed) override;
+    std::size_t GetQuota() override;
+    void ConsumeBytes(std::size_t consumed) override;
 
 private:
-  RateLimiter *upper_;
-  MaybeOwning<RateLimiter> ours_;
+    RateLimiter *upper_;
+    MaybeOwning<RateLimiter> ours_;
 };
 
-} // namespace tile
+}// namespace tile
 
-#endif // TILE_IO_UTIL_RATE_LIMITER_H
+#endif// TILE_IO_UTIL_RATE_LIMITER_H
diff --git a/tile/io/util/rate_limiter_test.cc b/tile/io/util/rate_limiter_test.cc
index 753e8f1..4d5742a 100644
--- a/tile/io/util/rate_limiter_test.cc
+++ b/tile/io/util/rate_limiter_test.cc
@@ -8,181 +8,172 @@
 
 namespace tile {
 
-TEST(RateLimiter, TokenBucketRateLimiter) {
-  TokenBucketRateLimiter limiter(1000, 1);
-  std::size_t total = 0;
-  auto start = ReadSteadyClock();
-  while (ReadSteadyClock() - start < std::chrono::seconds(5)) {
-    auto current = limiter.GetQuota();
-    total += current;
-    limiter.ConsumeBytes(current);
-
-    // with sleep
-    std::this_thread::sleep_for(std::chrono::milliseconds(1) * Random(100));
-  }
-  ASSERT_NEAR(6000, total, 200);
-}
-
-TEST(RateLimiter, TokenBucketRateLimiter2) {
-  TokenBucketRateLimiter limiter(1000, 1);
-  std::size_t total = 0;
-  auto start = ReadSteadyClock();
-  while (ReadSteadyClock() - start < std::chrono::seconds(5)) {
-    auto current = limiter.GetQuota();
-    total += current;
-    limiter.ConsumeBytes(current);
-  }
-  ASSERT_NEAR(6000, total, 200);
-}
-
-TEST(RateLimiter, TokenBucketRateLimiterCapBurst) {
-  TokenBucketRateLimiter limiter(25, 500);
-  for (int i = 0; i != 10; ++i) {
-    ASSERT_EQ(25, limiter.GetQuota());
-    std::this_thread::sleep_for(std::chrono::milliseconds(10));
-  }
-}
-
-TEST(RateLimiter, TokenBucketRateLimiterCapBurst2) {
-  TokenBucketRateLimiter limiter(1000, 500);
-  for (int i = 0; i != 10; ++i) {
-    ASSERT_EQ(1000, limiter.GetQuota());
-    std::this_thread::sleep_for(
-        std::chrono::milliseconds(10)); // Enough to fully fill the bucket.
-  }
-}
-
-TEST(RateLimiter, MultithreadedRateLimiter) {
-  ThreadSafeRateLimiter limiter(make_unique<TokenBucketRateLimiter>(1000, 1));
-  std::atomic<std::size_t> total{0};
-  std::vector<std::thread> ts;
-
-  for (int i = 0; i != 10; ++i) {
-    ts.emplace_back(std::thread([&] {
-      auto start = ReadSteadyClock();
-      while (ReadSteadyClock() - start < std::chrono::seconds(5)) {
+TEST(RateLimiter, TokenBucketRateLimiter)
+{
+    TokenBucketRateLimiter limiter(1000, 1);
+    std::size_t total = 0;
+    auto start        = ReadSteadyClock();
+    while (ReadSteadyClock() - start < std::chrono::seconds(5)) {
         auto current = limiter.GetQuota();
         total += current;
         limiter.ConsumeBytes(current);
-        std::this_thread::sleep_for(std::chrono::milliseconds(10) * Random(10));
-      }
-    }));
-  }
 
-  for (auto &&t : ts) {
-    t.join();
-  }
-
-  ASSERT_NEAR(6000, total.load(), 500);
+        // with sleep
+        std::this_thread::sleep_for(std::chrono::milliseconds(1) * Random(100));
+    }
+    ASSERT_NEAR(6000, total, 200);
 }
 
-TEST(RateLimiter, LayeredRateLimiter) {
-  ThreadSafeRateLimiter base_limiter(
-      make_unique<TokenBucketRateLimiter>(1000, 1));
-  auto our_limiter = make_unique<ThreadSafeRateLimiter>(
-      make_unique<TokenBucketRateLimiter>(1000, 100));
-  LayeredRateLimiter layered_limiter(&base_limiter, std::move(our_limiter));
-  std::atomic<std::size_t> total{0};
-  std::vector<std::thread> ts;
-
-  for (int i = 0; i != 10; ++i) {
-    ts.emplace_back(std::thread([&] {
-      auto start = ReadSteadyClock();
-      while (ReadSteadyClock() - start < std::chrono::seconds(5)) {
-        auto current = layered_limiter.GetQuota();
+TEST(RateLimiter, TokenBucketRateLimiter2)
+{
+    TokenBucketRateLimiter limiter(1000, 1);
+    std::size_t total = 0;
+    auto start        = ReadSteadyClock();
+    while (ReadSteadyClock() - start < std::chrono::seconds(5)) {
+        auto current = limiter.GetQuota();
         total += current;
-        layered_limiter.ConsumeBytes(current);
-        std::this_thread::sleep_for(std::chrono::milliseconds(10) * Random(10));
-      }
-    }));
-  }
-
-  for (auto &&t : ts) {
-    t.join();
-  }
-
-  ASSERT_NEAR(6000, total.load(), 500); // `msrl` takes effect.
+        limiter.ConsumeBytes(current);
+    }
+    ASSERT_NEAR(6000, total, 200);
 }
 
-TEST(RateLimiter, LayeredRateLimiter2) {
-  ThreadSafeRateLimiter base_limiter(
-      make_unique<TokenBucketRateLimiter>(1000, 100));
-  auto our_limiter = make_unique<ThreadSafeRateLimiter>(
-      make_unique<TokenBucketRateLimiter>(1000, 1));
-  LayeredRateLimiter layered_limiter(&base_limiter, std::move(our_limiter));
-  std::atomic<std::size_t> total{0};
-  std::vector<std::thread> ts;
-
-  for (int i = 0; i != 10; ++i) {
-    ts.emplace_back(std::thread([&] {
-      auto start = ReadSteadyClock();
-      while (ReadSteadyClock() - start < std::chrono::seconds(5)) {
-        auto current = layered_limiter.GetQuota();
-        total += current;
-        layered_limiter.ConsumeBytes(current);
-        std::this_thread::sleep_for(std::chrono::milliseconds(1) * Random(10));
-      }
-    }));
-  }
-
-  for (auto &&t : ts) {
-    t.join();
-  }
-
-  ASSERT_NEAR(6000, total.load(), 500); // `tbsrl` takes effect.
+TEST(RateLimiter, TokenBucketRateLimiterCapBurst)
+{
+    TokenBucketRateLimiter limiter(25, 500);
+    for (int i = 0; i != 10; ++i) {
+        ASSERT_EQ(25, limiter.GetQuota());
+        std::this_thread::sleep_for(std::chrono::milliseconds(10));
+    }
 }
 
-TEST(RateLimiter, LayeredRateLimiter3) {
-  ThreadSafeRateLimiter base_limiter(
-      make_unique<TokenBucketRateLimiter>(1000, 1));
-  std::atomic<std::size_t> total{0};
-  std::vector<std::thread> ts;
-
-  for (int i = 0; i != 10; ++i) {
-    ts.emplace_back(std::thread([&] {
-      auto our_limiter = make_unique<TokenBucketRateLimiter>(1000, 100);
-      LayeredRateLimiter layered_limiter(&base_limiter, std::move(our_limiter));
-      auto start = ReadSteadyClock();
-      while (ReadSteadyClock() - start < std::chrono::seconds(5)) {
-        auto current = layered_limiter.GetQuota();
-        total += current;
-        layered_limiter.ConsumeBytes(current);
-      }
-    }));
-  }
-
-  for (auto &&t : ts) {
-    t.join();
-  }
-
-  ASSERT_NEAR(6000, total.load(), 500); // `msrl` takes effect.
+TEST(RateLimiter, TokenBucketRateLimiterCapBurst2)
+{
+    TokenBucketRateLimiter limiter(1000, 500);
+    for (int i = 0; i != 10; ++i) {
+        ASSERT_EQ(1000, limiter.GetQuota());
+        std::this_thread::sleep_for(std::chrono::milliseconds(10));// Enough to fully fill the bucket.
+    }
 }
 
-TEST(RateLimiter, LayeredRateLimiter4) {
-  ThreadSafeRateLimiter base_limiter(
-      make_unique<TokenBucketRateLimiter>(1000, 100));
-  std::atomic<std::size_t> total{0};
-  std::vector<std::thread> ts;
+TEST(RateLimiter, MultithreadedRateLimiter)
+{
+    ThreadSafeRateLimiter limiter(make_unique<TokenBucketRateLimiter>(1000, 1));
+    std::atomic<std::size_t> total{0};
+    std::vector<std::thread> ts;
 
-  for (int i = 0; i != 10; ++i) {
-    ts.emplace_back(std::thread([&] {
-      auto our_limiter = make_unique<ThreadSafeRateLimiter>(
-          make_unique<TokenBucketRateLimiter>(1000, 1));
-      LayeredRateLimiter layered_limiter(&base_limiter, std::move(our_limiter));
-      auto start = ReadSteadyClock();
-      while (ReadSteadyClock() - start < std::chrono::seconds(5)) {
-        auto current = layered_limiter.GetQuota();
-        total += current;
-        layered_limiter.ConsumeBytes(current);
-      }
-    }));
-  }
+    for (int i = 0; i != 10; ++i) {
+        ts.emplace_back(std::thread([&] {
+            auto start = ReadSteadyClock();
+            while (ReadSteadyClock() - start < std::chrono::seconds(5)) {
+                auto current = limiter.GetQuota();
+                total += current;
+                limiter.ConsumeBytes(current);
+                std::this_thread::sleep_for(std::chrono::milliseconds(10) * Random(10));
+            }
+        }));
+    }
 
-  for (auto &&t : ts) {
-    t.join();
-  }
+    for (auto &&t : ts) { t.join(); }
 
-  ASSERT_NEAR(60000, total.load(), 5000); // `tbsrl` takes effect.
+    ASSERT_NEAR(6000, total.load(), 500);
 }
 
-} // namespace tile
+TEST(RateLimiter, LayeredRateLimiter)
+{
+    ThreadSafeRateLimiter base_limiter(make_unique<TokenBucketRateLimiter>(1000, 1));
+    auto our_limiter = make_unique<ThreadSafeRateLimiter>(make_unique<TokenBucketRateLimiter>(1000, 100));
+    LayeredRateLimiter layered_limiter(&base_limiter, std::move(our_limiter));
+    std::atomic<std::size_t> total{0};
+    std::vector<std::thread> ts;
+
+    for (int i = 0; i != 10; ++i) {
+        ts.emplace_back(std::thread([&] {
+            auto start = ReadSteadyClock();
+            while (ReadSteadyClock() - start < std::chrono::seconds(5)) {
+                auto current = layered_limiter.GetQuota();
+                total += current;
+                layered_limiter.ConsumeBytes(current);
+                std::this_thread::sleep_for(std::chrono::milliseconds(10) * Random(10));
+            }
+        }));
+    }
+
+    for (auto &&t : ts) { t.join(); }
+
+    ASSERT_NEAR(6000, total.load(), 500);// `msrl` takes effect.
+}
+
+TEST(RateLimiter, LayeredRateLimiter2)
+{
+    ThreadSafeRateLimiter base_limiter(make_unique<TokenBucketRateLimiter>(1000, 100));
+    auto our_limiter = make_unique<ThreadSafeRateLimiter>(make_unique<TokenBucketRateLimiter>(1000, 1));
+    LayeredRateLimiter layered_limiter(&base_limiter, std::move(our_limiter));
+    std::atomic<std::size_t> total{0};
+    std::vector<std::thread> ts;
+
+    for (int i = 0; i != 10; ++i) {
+        ts.emplace_back(std::thread([&] {
+            auto start = ReadSteadyClock();
+            while (ReadSteadyClock() - start < std::chrono::seconds(5)) {
+                auto current = layered_limiter.GetQuota();
+                total += current;
+                layered_limiter.ConsumeBytes(current);
+                std::this_thread::sleep_for(std::chrono::milliseconds(1) * Random(10));
+            }
+        }));
+    }
+
+    for (auto &&t : ts) { t.join(); }
+
+    ASSERT_NEAR(6000, total.load(), 500);// `tbsrl` takes effect.
+}
+
+TEST(RateLimiter, LayeredRateLimiter3)
+{
+    ThreadSafeRateLimiter base_limiter(make_unique<TokenBucketRateLimiter>(1000, 1));
+    std::atomic<std::size_t> total{0};
+    std::vector<std::thread> ts;
+
+    for (int i = 0; i != 10; ++i) {
+        ts.emplace_back(std::thread([&] {
+            auto our_limiter = make_unique<TokenBucketRateLimiter>(1000, 100);
+            LayeredRateLimiter layered_limiter(&base_limiter, std::move(our_limiter));
+            auto start = ReadSteadyClock();
+            while (ReadSteadyClock() - start < std::chrono::seconds(5)) {
+                auto current = layered_limiter.GetQuota();
+                total += current;
+                layered_limiter.ConsumeBytes(current);
+            }
+        }));
+    }
+
+    for (auto &&t : ts) { t.join(); }
+
+    ASSERT_NEAR(6000, total.load(), 500);// `msrl` takes effect.
+}
+
+TEST(RateLimiter, LayeredRateLimiter4)
+{
+    ThreadSafeRateLimiter base_limiter(make_unique<TokenBucketRateLimiter>(1000, 100));
+    std::atomic<std::size_t> total{0};
+    std::vector<std::thread> ts;
+
+    for (int i = 0; i != 10; ++i) {
+        ts.emplace_back(std::thread([&] {
+            auto our_limiter = make_unique<ThreadSafeRateLimiter>(make_unique<TokenBucketRateLimiter>(1000, 1));
+            LayeredRateLimiter layered_limiter(&base_limiter, std::move(our_limiter));
+            auto start = ReadSteadyClock();
+            while (ReadSteadyClock() - start < std::chrono::seconds(5)) {
+                auto current = layered_limiter.GetQuota();
+                total += current;
+                layered_limiter.ConsumeBytes(current);
+            }
+        }));
+    }
+
+    for (auto &&t : ts) { t.join(); }
+
+    ASSERT_NEAR(60000, total.load(), 5000);// `tbsrl` takes effect.
+}
+
+}// namespace tile
diff --git a/tile/net/http/http_client.cc b/tile/net/http/http_client.cc
index ade386f..7430161 100644
--- a/tile/net/http/http_client.cc
+++ b/tile/net/http/http_client.cc
@@ -10,547 +10,523 @@
 #include "curl/curl.h"
 #include "gflags/gflags.h"
 
-DEFINE_int32(tile_http_client_default_timeout_ms, 1000,
-             "Default timeout of tile::HttpClient.");
+DEFINE_int32(tile_http_client_default_timeout_ms, 1000, "Default timeout of tile::HttpClient.");
 
 namespace tile {
 namespace {
-HttpClient::ErrorCode GetErrorCodeFromCurlCode(int c) {
-  switch (c) {
-  case CURLE_UNSUPPORTED_PROTOCOL:
-    return HttpClient::ERROR_PROTOCOL_NOT_SUPPORTED;
-  case CURLE_URL_MALFORMAT:
-    return HttpClient::ERROR_INVALID_URI_ADDRESS;
-  case CURLE_COULDNT_RESOLVE_PROXY:
-    return HttpClient::ERROR_PROXY;
-  case CURLE_COULDNT_RESOLVE_HOST:
-    return HttpClient::ERROR_FAIL_TO_RESOLVE_ADDRESS;
-  case CURLE_COULDNT_CONNECT:
-    return HttpClient::ERROR_CONNECTION;
-  case CURLE_HTTP2:
-  case CURLE_HTTP2_STREAM:
-    return HttpClient::ERROR_HTTP2;
-  case CURLE_HTTP_RETURNED_ERROR:
-  case CURLE_HTTP_POST_ERROR:
-    TILE_LOG_WARNING_EVERY_SECOND("ERROR_CURL_HTTP_ERROR CURLcode {}", c);
-    return HttpClient::ERROR_INTERNAL_ERROR;
-  case CURLE_OPERATION_TIMEDOUT:
-    return HttpClient::ERROR_TIMEOUT;
-  case CURLE_SSL_CONNECT_ERROR:
-  case CURLE_SSL_ENGINE_NOTFOUND:
-  case CURLE_SSL_ENGINE_SETFAILED:
-  case CURLE_SSL_CERTPROBLEM:
-  case CURLE_SSL_CIPHER:
-  case CURLE_PEER_FAILED_VERIFICATION:
-    TILE_LOG_WARNING_EVERY_SECOND("ERROR_SSL CURLcode {}", c);
-    return HttpClient::ERROR_SSL;
-  case CURLE_SEND_ERROR:
-  case CURLE_RECV_ERROR:
-    return HttpClient::ERROR_IO;
-  case CURLE_TOO_MANY_REDIRECTS:
-    return HttpClient::ERROR_TOO_MANY_REDIRECTS;
-  case CURLE_GOT_NOTHING:
-    return HttpClient::ERROR_GET_NOTHING;
+HttpClient::ErrorCode
+GetErrorCodeFromCurlCode(int c)
+{
+    switch (c) {
+    case CURLE_UNSUPPORTED_PROTOCOL:
+        return HttpClient::ERROR_PROTOCOL_NOT_SUPPORTED;
+    case CURLE_URL_MALFORMAT:
+        return HttpClient::ERROR_INVALID_URI_ADDRESS;
+    case CURLE_COULDNT_RESOLVE_PROXY:
+        return HttpClient::ERROR_PROXY;
+    case CURLE_COULDNT_RESOLVE_HOST:
+        return HttpClient::ERROR_FAIL_TO_RESOLVE_ADDRESS;
+    case CURLE_COULDNT_CONNECT:
+        return HttpClient::ERROR_CONNECTION;
+    case CURLE_HTTP2:
+    case CURLE_HTTP2_STREAM:
+        return HttpClient::ERROR_HTTP2;
+    case CURLE_HTTP_RETURNED_ERROR:
+    case CURLE_HTTP_POST_ERROR:
+        TILE_LOG_WARNING_EVERY_SECOND("ERROR_CURL_HTTP_ERROR CURLcode {}", c);
+        return HttpClient::ERROR_INTERNAL_ERROR;
+    case CURLE_OPERATION_TIMEDOUT:
+        return HttpClient::ERROR_TIMEOUT;
+    case CURLE_SSL_CONNECT_ERROR:
+    case CURLE_SSL_ENGINE_NOTFOUND:
+    case CURLE_SSL_ENGINE_SETFAILED:
+    case CURLE_SSL_CERTPROBLEM:
+    case CURLE_SSL_CIPHER:
+    case CURLE_PEER_FAILED_VERIFICATION:
+        TILE_LOG_WARNING_EVERY_SECOND("ERROR_SSL CURLcode {}", c);
+        return HttpClient::ERROR_SSL;
+    case CURLE_SEND_ERROR:
+    case CURLE_RECV_ERROR:
+        return HttpClient::ERROR_IO;
+    case CURLE_TOO_MANY_REDIRECTS:
+        return HttpClient::ERROR_TOO_MANY_REDIRECTS;
+    case CURLE_GOT_NOTHING:
+        return HttpClient::ERROR_GET_NOTHING;
 
-  default: {
-    TILE_LOG_WARNING_EVERY_SECOND("ERROR_UNKNOWN CURLcode {}, curl msg: ", c,
-                                  curl_easy_strerror(static_cast<CURLcode>(c)));
-    return HttpClient::ERROR_UNKNOWN;
-  }
-  }
-}
-
-long TileHttpVersionToCurlHttpVersion(HttpVersion v,
-                                      bool no_automatic_upgrade) {
-  if (no_automatic_upgrade) {
-    return CURL_HTTP_VERSION_2_PRIOR_KNOWLEDGE;
-  }
-  switch (v) {
-  case HttpVersion::Unspecified:
-    return CURL_HTTP_VERSION_NONE;
-  case HttpVersion::V_1_0:
-    return CURL_HTTP_VERSION_1_0;
-  case HttpVersion::V_1_1:
-    return CURL_HTTP_VERSION_1_1;
-  case HttpVersion::V_2:
-    return CURL_HTTP_VERSION_2_0;
-  case HttpVersion::V_3:
-    return CURL_HTTP_VERSION_3;
-  default:
-    TILE_CHECK(0, "Unknown flare http version");
-  }
-  return CURL_HTTP_VERSION_NONE;
-}
-
-HttpVersion CurlHttpVersionToHttpVersion(long v) {
-  switch (v) {
-  case CURL_HTTP_VERSION_NONE:
-    return HttpVersion::Unspecified;
-  case CURL_HTTP_VERSION_1_0:
-    return HttpVersion::V_1_0;
-  case CURL_HTTP_VERSION_1_1:
-    return HttpVersion::V_1_1;
-  case CURL_HTTP_VERSION_2_0:
-    return HttpVersion::V_2;
-  case CURL_HTTP_VERSION_3:
-    return HttpVersion::V_3;
-  default:
-    TILE_CHECK(0, "Unknown flare http version {}", v);
-  }
-  return HttpVersion::Unspecified;
-}
-
-void FillResponseInfo(CURL *easy_handler,
-                      HttpClient::ResponseInfo *response_info) {
-  TILE_CHECK(response_info);
-  TILE_CHECK(easy_handler);
-
-  {
-    char *effective_url = nullptr;
-    curl_easy_getinfo(easy_handler, CURLINFO_EFFECTIVE_URL, &effective_url);
-    response_info->effective_url = effective_url;
-  }
-
-  {
-    double transfer_time_in_seconds = 0;
-    curl_easy_getinfo(easy_handler, CURLINFO_TOTAL_TIME,
-                      &transfer_time_in_seconds);
-    response_info->total_time_transfer =
-        std::chrono::duration_cast<std::chrono::nanoseconds>(
-            std::chrono::duration<double>(transfer_time_in_seconds));
-  }
-
-  {
-    long http_version;
-    curl_easy_getinfo(easy_handler, CURLINFO_HTTP_VERSION, &http_version);
-    response_info->http_version = CurlHttpVersionToHttpVersion(http_version);
-  }
-}
-
-std::optional<std::string> GetHttpRequestUriFromUrl(const std::string &url) {
-  // http://example.com/xxx
-  // http://example.com
-
-  auto start_pos = url.find("://");
-  if (start_pos != std::string::npos) {
-    start_pos += 3;
-
-    auto end_pos = url.find("/", start_pos);
-    if (end_pos != std::string::npos) {
-      return url.substr(end_pos);
+    default: {
+        TILE_LOG_WARNING_EVERY_SECOND(
+            "ERROR_UNKNOWN CURLcode {}, curl msg: ", c, curl_easy_strerror(static_cast<CURLcode>(c)));
+        return HttpClient::ERROR_UNKNOWN;
     }
-  }
+    }
+}
 
-  return std::nullopt;
+long
+TileHttpVersionToCurlHttpVersion(HttpVersion v, bool no_automatic_upgrade)
+{
+    if (no_automatic_upgrade) { return CURL_HTTP_VERSION_2_PRIOR_KNOWLEDGE; }
+    switch (v) {
+    case HttpVersion::Unspecified:
+        return CURL_HTTP_VERSION_NONE;
+    case HttpVersion::V_1_0:
+        return CURL_HTTP_VERSION_1_0;
+    case HttpVersion::V_1_1:
+        return CURL_HTTP_VERSION_1_1;
+    case HttpVersion::V_2:
+        return CURL_HTTP_VERSION_2_0;
+    case HttpVersion::V_3:
+        return CURL_HTTP_VERSION_3;
+    default:
+        TILE_CHECK(0, "Unknown flare http version");
+    }
+    return CURL_HTTP_VERSION_NONE;
+}
+
+HttpVersion
+CurlHttpVersionToHttpVersion(long v)
+{
+    switch (v) {
+    case CURL_HTTP_VERSION_NONE:
+        return HttpVersion::Unspecified;
+    case CURL_HTTP_VERSION_1_0:
+        return HttpVersion::V_1_0;
+    case CURL_HTTP_VERSION_1_1:
+        return HttpVersion::V_1_1;
+    case CURL_HTTP_VERSION_2_0:
+        return HttpVersion::V_2;
+    case CURL_HTTP_VERSION_3:
+        return HttpVersion::V_3;
+    default:
+        TILE_CHECK(0, "Unknown flare http version {}", v);
+    }
+    return HttpVersion::Unspecified;
+}
+
+void
+FillResponseInfo(CURL *easy_handler, HttpClient::ResponseInfo *response_info)
+{
+    TILE_CHECK(response_info);
+    TILE_CHECK(easy_handler);
+
+    {
+        char *effective_url = nullptr;
+        curl_easy_getinfo(easy_handler, CURLINFO_EFFECTIVE_URL, &effective_url);
+        response_info->effective_url = effective_url;
+    }
+
+    {
+        double transfer_time_in_seconds = 0;
+        curl_easy_getinfo(easy_handler, CURLINFO_TOTAL_TIME, &transfer_time_in_seconds);
+        response_info->total_time_transfer = std::chrono::duration_cast<std::chrono::nanoseconds>(
+            std::chrono::duration<double>(transfer_time_in_seconds));
+    }
+
+    {
+        long http_version;
+        curl_easy_getinfo(easy_handler, CURLINFO_HTTP_VERSION, &http_version);
+        response_info->http_version = CurlHttpVersionToHttpVersion(http_version);
+    }
+}
+
+std::optional<std::string>
+GetHttpRequestUriFromUrl(const std::string &url)
+{
+    // http://example.com/xxx
+    // http://example.com
+
+    auto start_pos = url.find("://");
+    if (start_pos != std::string::npos) {
+        start_pos += 3;
+
+        auto end_pos = url.find("/", start_pos);
+        if (end_pos != std::string::npos) { return url.substr(end_pos); }
+    }
+
+    return std::nullopt;
 }
 
 std::optional<std::pair<std::string, std::function<void(bool)>>>
-OverrideHost(const std::string &url, const std::string &override_host_nslb) {
-  return std::make_pair(url, nullptr);
+OverrideHost(const std::string &url, const std::string &override_host_nslb)
+{
+    return std::make_pair(url, nullptr);
 }
 
 class HttpEngineWrapper : public detail::HttpChannel {
 public:
-  static HttpEngineWrapper *Instance() {
-    static NeverDestroyedSingleton<HttpEngineWrapper> engine;
-    return engine.Get();
-  }
-
-  internal::HttpTask
-  GetHttpTask(const std::string &url, const HttpClient::Options opts,
-              const HttpClient::RequestOptions &request_options) {
-    internal::HttpTask task;
-    task.SetUrl(url);
-    task.SetTimeout(request_options.timeout);
-    CURL *h = task.GetNativeHandle();
-    if (opts.follow_redirects) {
-      TILE_CHECK_EQ(CURLE_OK, curl_easy_setopt(h, CURLOPT_FOLLOWLOCATION, 1L));
-      TILE_CHECK_EQ(CURLE_OK,
-                    curl_easy_setopt(h, CURLOPT_MAXREDIRS,
-                                     request_options.max_redirection_count));
+    static HttpEngineWrapper *Instance()
+    {
+        static NeverDestroyedSingleton<HttpEngineWrapper> engine;
+        return engine.Get();
     }
 
-    if (request_options.verbose) {
-      TILE_CHECK_EQ(CURLE_OK, curl_easy_setopt(h, CURLOPT_VERBOSE, 1L));
-    }
-
-    if (opts.use_bintin_compression) {
-      TILE_CHECK_EQ(CURLE_OK, curl_easy_setopt(h, CURLOPT_ACCEPT_ENCODING,
-                                               "identity, gzip, deflate"));
-    }
-
-    TILE_CHECK_EQ(CURLE_OK,
-                  curl_easy_setopt(h, CURLOPT_HTTP_VERSION,
-                                   TileHttpVersionToCurlHttpVersion(
-                                       request_options.http_version,
-                                       request_options.no_automatic_upgrade)));
-
-    for (auto &&s : request_options.headers) {
-      task.AddHeader(s);
-    }
-
-    if (!request_options.content_type.empty()) {
-      task.AddHeader("Content-Type: " + request_options.content_type);
-    }
-
-    if (!opts.verify_server_certificate) {
-      TILE_CHECK_EQ(CURLE_OK, curl_easy_setopt(h, CURLOPT_SSL_VERIFYPEER, 0));
-      TILE_CHECK_EQ(CURLE_OK, curl_easy_setopt(h, CURLOPT_SSL_VERIFYHOST, 0));
-    }
-
-    if (!opts.proxy_from_env) {
-      TILE_CHECK_EQ(CURLE_OK,
-                    curl_easy_setopt(h, CURLOPT_PROXY, opts.proxy.c_str()));
-    }
-
-    return task;
-  }
-
-  void AsyncCallCallback(
-      std::function<void(std::expected<HttpResponse, HttpClient::ErrorCode>)>
-          done,
-      std::function<void(bool)> report_function,
-      std::expected<internal::HttpTaskCompletion, Status> completion,
-      HttpClient::ResponseInfo *response_info) {
-    auto moved_report_function = MakeMoveOnCopy(report_function);
-    auto moved_done = MakeMoveOnCopy(done);
-    auto moved_completion = MakeMoveOnCopy(completion);
-
-    internal::BackgroundTaskHost::Instance()->Queue(
-        [moved_report_function, moved_completion, moved_done, response_info] {
-          auto &&report_function = moved_report_function.Ref();
-          auto &&completion = moved_completion.Ref();
-          auto &&done = moved_done.Ref();
-          if (report_function) {
-            report_function(!!completion);
-          }
-
-          std::optional<HttpResponse> opt_response;
-          if (completion) {
-            HttpResponse response;
-            response.set_version(completion->version());
-            response.set_status(completion->status());
-            response.set_body(std::move(*completion->body()));
-            CopyHeaders(*completion->headers(), response.headers());
-            opt_response = std::move(response);
-          }
-
-          if (completion && response_info) {
-            FillResponseInfo(completion->GetNativeHandle(), response_info);
-          }
-
-          if (!completion) {
-            done(std::make_unexpected(
-                GetErrorCodeFromCurlCode(completion.error().code())));
-          } else {
-            TILE_CHECK(opt_response.has_value());
-            done(std::move(*opt_response));
-          }
-        });
-  }
-
-  template <class F>
-  void AsyncCall(
-      HttpMethod method, const std::string &url,
-      const HttpClient::Options &opts,
-      const HttpClient::RequestOptions &request_options,
-      HttpClient::ResponseInfo *response_info,
-      std::function<void(std::expected<HttpResponse, HttpClient::ErrorCode>)>
-          &&done,
-      F &&callback) {
-    auto &&override_host =
-        OverrideHost(url, request_options.override_host_nslb);
-    if (!override_host) {
-      done(std::make_unexpected(HttpClient::ERROR_FAIL_TO_RESOLVE_ADDRESS));
-      return;
-    }
-
-    auto &&effective_url = override_host->first;
-    auto &&report_function = override_host->second;
-    auto task = GetHttpTask(effective_url, opts, request_options);
-    task.SetMethod(method);
-    std::unique_ptr<HttpRequest> request = make_unique<HttpRequest>();
-    request->set_version(request_options.http_version);
-    for (auto &&header : request_options.headers) {
-      auto pos = header.find(':');
-      if (pos != std::string::npos) {
-        request->headers()->Append(header.substr(0, pos),
-                                   Trim(header.substr(pos + 1)));
-      }
-    }
-
-    callback(&task, request.get());
-    auto moved_report_function = MakeMoveOnCopy(report_function);
-    auto moved_done = MakeMoveOnCopy(done);
-    internal::HttpEngine::Instance()->StartTask(
-        std::move(task),
-        [this, moved_report_function, moved_done,
-         response_info](std::expected<internal::HttpTaskCompletion, Status>
-                            &&completion) mutable {
-          AsyncCallCallback(moved_done.Move(), moved_report_function.Move(),
-                            std::move(completion), response_info);
-        });
-  }
-
-  void AsyncGet(
-      const std::string &url, const HttpClient::Options &opts,
-      const HttpClient::RequestOptions &request_options,
-      HttpClient::ResponseInfo *response_info,
-      std::function<void(std::expected<HttpResponse, HttpClient::ErrorCode>)>
-          &&done) override {
-
-    auto cb = [url](internal::HttpTask *, HttpRequest *p_request) {
-      if (p_request) {
-        p_request->set_method(HttpMethod::Get);
-        auto uri = GetHttpRequestUriFromUrl(url);
-        if (uri) {
-          p_request->set_uri(*uri);
+    internal::HttpTask GetHttpTask(const std::string &url,
+                                   const HttpClient::Options opts,
+                                   const HttpClient::RequestOptions &request_options)
+    {
+        internal::HttpTask task;
+        task.SetUrl(url);
+        task.SetTimeout(request_options.timeout);
+        CURL *h = task.GetNativeHandle();
+        if (opts.follow_redirects) {
+            TILE_CHECK_EQ(CURLE_OK, curl_easy_setopt(h, CURLOPT_FOLLOWLOCATION, 1L));
+            TILE_CHECK_EQ(CURLE_OK, curl_easy_setopt(h, CURLOPT_MAXREDIRS, request_options.max_redirection_count));
         }
-      }
-    };
-    return AsyncCall(HttpMethod::Get, url, opts, request_options, response_info,
-                     std::move(done), std::move(cb));
-  }
 
-  void AsyncPost(
-      const std::string &url, const HttpClient::Options &opts, std::string data,
-      const HttpClient::RequestOptions &request_options,
-      HttpClient::ResponseInfo *response_info,
-      std::function<void(std::expected<HttpResponse, HttpClient::ErrorCode>)>
-          &&done) override {
-    auto moved_data = MakeMoveOnCopy(data);
+        if (request_options.verbose) { TILE_CHECK_EQ(CURLE_OK, curl_easy_setopt(h, CURLOPT_VERBOSE, 1L)); }
 
-    auto cb = [url, moved_data](internal::HttpTask *p_task,
-                                HttpRequest *p_request) {
-      if (p_request) {
-        p_request->set_method(HttpMethod::Post);
-        auto uri = GetHttpRequestUriFromUrl(url);
-        if (uri) {
-          p_request->set_uri(*uri);
+        if (opts.use_bintin_compression) {
+            TILE_CHECK_EQ(CURLE_OK, curl_easy_setopt(h, CURLOPT_ACCEPT_ENCODING, "identity, gzip, deflate"));
         }
-        p_request->set_body(moved_data.Ref());
-      }
-      p_task->SetBody(moved_data.Move());
-    };
-    return AsyncCall(HttpMethod::Post, url, opts, request_options,
-                     response_info, std::move(done), std::move(cb));
-  }
 
-  void AsyncRequest(
-      const std::string &protocol, const std::string &host,
-      const HttpClient::Options &opts, const HttpRequest &request,
-      const HttpClient::RequestOptions &request_options,
-      HttpClient::ResponseInfo *response_info,
-      std::function<void(std::expected<HttpResponse, HttpClient::ErrorCode>)>
-          &&done) override {
-    auto url = protocol + "://" + host + request.uri();
-    auto cb = [request](internal::HttpTask *p_task, HttpRequest *p_request) {
-      if (p_request) {
-        *p_request = request;
-      }
+        TILE_CHECK_EQ(
+            CURLE_OK,
+            curl_easy_setopt(
+                h, CURLOPT_HTTP_VERSION,
+                TileHttpVersionToCurlHttpVersion(request_options.http_version, request_options.no_automatic_upgrade)));
 
-      if (request.body_size() > 0) {
-        if (request.noncontiguous_body()) {
-          p_task->SetBody(*request.noncontiguous_body());
-        } else {
-          p_task->SetBody(*request.body());
+        for (auto &&s : request_options.headers) { task.AddHeader(s); }
+
+        if (!request_options.content_type.empty()) { task.AddHeader("Content-Type: " + request_options.content_type); }
+
+        if (!opts.verify_server_certificate) {
+            TILE_CHECK_EQ(CURLE_OK, curl_easy_setopt(h, CURLOPT_SSL_VERIFYPEER, 0));
+            TILE_CHECK_EQ(CURLE_OK, curl_easy_setopt(h, CURLOPT_SSL_VERIFYHOST, 0));
         }
-      }
 
-      for (auto header : *request.headers()) {
-        p_task->AddHeader(header.first + ": " + header.second);
-      }
-      TILE_CHECK(request.method() != HttpMethod::Unspecified,
-                 "You should specify http method.");
-      TILE_CHECK_EQ(CURLE_OK,
-                    curl_easy_setopt(p_task->GetNativeHandle(),
-                                     CURLOPT_CUSTOMREQUEST,
-                                     ToSlice(request.method()).data()));
-    };
-    return AsyncCall(request.method(), url, opts, request_options,
-                     response_info, std::move(done), std::move(cb));
-  }
+        if (!opts.proxy_from_env) { TILE_CHECK_EQ(CURLE_OK, curl_easy_setopt(h, CURLOPT_PROXY, opts.proxy.c_str())); }
+
+        return task;
+    }
+
+    void AsyncCallCallback(std::function<void(std::expected<HttpResponse, HttpClient::ErrorCode>)> done,
+                           std::function<void(bool)> report_function,
+                           std::expected<internal::HttpTaskCompletion, Status> completion,
+                           HttpClient::ResponseInfo *response_info)
+    {
+        auto moved_report_function = MakeMoveOnCopy(report_function);
+        auto moved_done            = MakeMoveOnCopy(done);
+        auto moved_completion      = MakeMoveOnCopy(completion);
+
+        internal::BackgroundTaskHost::Instance()->Queue(
+            [moved_report_function, moved_completion, moved_done, response_info] {
+                auto &&report_function = moved_report_function.Ref();
+                auto &&completion      = moved_completion.Ref();
+                auto &&done            = moved_done.Ref();
+                if (report_function) { report_function(!!completion); }
+
+                std::optional<HttpResponse> opt_response;
+                if (completion) {
+                    HttpResponse response;
+                    response.set_version(completion->version());
+                    response.set_status(completion->status());
+                    response.set_body(std::move(*completion->body()));
+                    CopyHeaders(*completion->headers(), response.headers());
+                    opt_response = std::move(response);
+                }
+
+                if (completion && response_info) { FillResponseInfo(completion->GetNativeHandle(), response_info); }
+
+                if (!completion) {
+                    done(std::make_unexpected(GetErrorCodeFromCurlCode(completion.error().code())));
+                } else {
+                    TILE_CHECK(opt_response.has_value());
+                    done(std::move(*opt_response));
+                }
+            });
+    }
+
+    template<class F>
+    void AsyncCall(HttpMethod method,
+                   const std::string &url,
+                   const HttpClient::Options &opts,
+                   const HttpClient::RequestOptions &request_options,
+                   HttpClient::ResponseInfo *response_info,
+                   std::function<void(std::expected<HttpResponse, HttpClient::ErrorCode>)> &&done,
+                   F &&callback)
+    {
+        auto &&override_host = OverrideHost(url, request_options.override_host_nslb);
+        if (!override_host) {
+            done(std::make_unexpected(HttpClient::ERROR_FAIL_TO_RESOLVE_ADDRESS));
+            return;
+        }
+
+        auto &&effective_url   = override_host->first;
+        auto &&report_function = override_host->second;
+        auto task              = GetHttpTask(effective_url, opts, request_options);
+        task.SetMethod(method);
+        std::unique_ptr<HttpRequest> request = make_unique<HttpRequest>();
+        request->set_version(request_options.http_version);
+        for (auto &&header : request_options.headers) {
+            auto pos = header.find(':');
+            if (pos != std::string::npos) {
+                request->headers()->Append(header.substr(0, pos), Trim(header.substr(pos + 1)));
+            }
+        }
+
+        callback(&task, request.get());
+        auto moved_report_function = MakeMoveOnCopy(report_function);
+        auto moved_done            = MakeMoveOnCopy(done);
+        internal::HttpEngine::Instance()->StartTask(
+            std::move(task),
+            [this, moved_report_function, moved_done,
+             response_info](std::expected<internal::HttpTaskCompletion, Status> &&completion) mutable {
+                AsyncCallCallback(moved_done.Move(), moved_report_function.Move(), std::move(completion),
+                                  response_info);
+            });
+    }
+
+    void AsyncGet(const std::string &url,
+                  const HttpClient::Options &opts,
+                  const HttpClient::RequestOptions &request_options,
+                  HttpClient::ResponseInfo *response_info,
+                  std::function<void(std::expected<HttpResponse, HttpClient::ErrorCode>)> &&done) override
+    {
+
+        auto cb = [url](internal::HttpTask *, HttpRequest *p_request) {
+            if (p_request) {
+                p_request->set_method(HttpMethod::Get);
+                auto uri = GetHttpRequestUriFromUrl(url);
+                if (uri) { p_request->set_uri(*uri); }
+            }
+        };
+        return AsyncCall(HttpMethod::Get, url, opts, request_options, response_info, std::move(done), std::move(cb));
+    }
+
+    void AsyncPost(const std::string &url,
+                   const HttpClient::Options &opts,
+                   std::string data,
+                   const HttpClient::RequestOptions &request_options,
+                   HttpClient::ResponseInfo *response_info,
+                   std::function<void(std::expected<HttpResponse, HttpClient::ErrorCode>)> &&done) override
+    {
+        auto moved_data = MakeMoveOnCopy(data);
+
+        auto cb         = [url, moved_data](internal::HttpTask *p_task, HttpRequest *p_request) {
+            if (p_request) {
+                p_request->set_method(HttpMethod::Post);
+                auto uri = GetHttpRequestUriFromUrl(url);
+                if (uri) { p_request->set_uri(*uri); }
+                p_request->set_body(moved_data.Ref());
+            }
+            p_task->SetBody(moved_data.Move());
+        };
+        return AsyncCall(HttpMethod::Post, url, opts, request_options, response_info, std::move(done), std::move(cb));
+    }
+
+    void AsyncRequest(const std::string &protocol,
+                      const std::string &host,
+                      const HttpClient::Options &opts,
+                      const HttpRequest &request,
+                      const HttpClient::RequestOptions &request_options,
+                      HttpClient::ResponseInfo *response_info,
+                      std::function<void(std::expected<HttpResponse, HttpClient::ErrorCode>)> &&done) override
+    {
+        auto url = protocol + "://" + host + request.uri();
+        auto cb  = [request](internal::HttpTask *p_task, HttpRequest *p_request) {
+            if (p_request) { *p_request = request; }
+
+            if (request.body_size() > 0) {
+                if (request.noncontiguous_body()) {
+                    p_task->SetBody(*request.noncontiguous_body());
+                } else {
+                    p_task->SetBody(*request.body());
+                }
+            }
+
+            for (auto header : *request.headers()) { p_task->AddHeader(header.first + ": " + header.second); }
+            TILE_CHECK(request.method() != HttpMethod::Unspecified, "You should specify http method.");
+            TILE_CHECK_EQ(
+                CURLE_OK,
+                curl_easy_setopt(p_task->GetNativeHandle(), CURLOPT_CUSTOMREQUEST, ToSlice(request.method()).data()));
+        };
+        return AsyncCall(request.method(), url, opts, request_options, response_info, std::move(done), std::move(cb));
+    }
 
 private:
-  static void CopyHeaders(const std::vector<std::string> &from,
-                          HttpHeaders *to) {
-    for (auto &&s : from) {
-      auto pos = s.find(":");
-      if (pos != std::string::npos) {
-        auto name = s.substr(0, pos);
-        auto value = s.substr(pos + 1);
-        TILE_CHECK(!EndsWith(value, "\r\n"));
-        to->Append(std::string(name), std::string(Trim(value)));
-      }
+    static void CopyHeaders(const std::vector<std::string> &from, HttpHeaders *to)
+    {
+        for (auto &&s : from) {
+            auto pos = s.find(":");
+            if (pos != std::string::npos) {
+                auto name  = s.substr(0, pos);
+                auto value = s.substr(pos + 1);
+                TILE_CHECK(!EndsWith(value, "\r\n"));
+                to->Append(std::string(name), std::string(Trim(value)));
+            }
+        }
     }
-  }
 };
 
-detail::HttpChannel *mock_channel = nullptr;
+detail::HttpChannel *mock_channel    = nullptr;
 detail::HttpChannel *dry_run_channel = nullptr;
 
-bool IsMockAddress(const std::string &url_or_protocol, bool is_url) {
-  if (is_url) {
-    return StartsWith(url_or_protocol, "mock://");
-  }
-  return url_or_protocol == "mock";
+bool
+IsMockAddress(const std::string &url_or_protocol, bool is_url)
+{
+    if (is_url) { return StartsWith(url_or_protocol, "mock://"); }
+    return url_or_protocol == "mock";
 }
 
-detail::HttpChannel *GetHttpChannel(const std::string &url_or_protocol,
-                                    bool is_url = true) {
-  if (TILE_UNLIKELY(IsMockAddress(url_or_protocol, is_url))) {
-    TILE_CHECK(mock_channel, "Mock channel has not been registered yet.");
-    return mock_channel;
-  }
+detail::HttpChannel *
+GetHttpChannel(const std::string &url_or_protocol, bool is_url = true)
+{
+    if (TILE_UNLIKELY(IsMockAddress(url_or_protocol, is_url))) {
+        TILE_CHECK(mock_channel, "Mock channel has not been registered yet.");
+        return mock_channel;
+    }
 
-  return HttpEngineWrapper::Instance();
+    return HttpEngineWrapper::Instance();
 }
 
-} // namespace
+}// namespace
+
+namespace detail {}// namespace detail
 
-namespace detail {} // namespace detail
 HttpClient::HttpClient(const Options &options) : options_(options) {}
 
-const char *HttpClient::ErrorCodeToString(int error_code) {
-  switch (static_cast<ErrorCode>(error_code)) {
-  case ERROR_INVALID:
-    return "Invalid";
-  case ERROR_INVALID_URI_ADDRESS:
-    return "Invalid URI address";
-  case ERROR_FAIL_TO_RESOLVE_ADDRESS:
-    return "Failed to resolve address";
-  case ERROR_FAIL_TO_SEND_REQUEST:
-    return "Failed to send request";
-  case ERROR_FAIL_TO_GET_RESPONSE:
-    return "Failed to get response";
-  case ERROR_CONNECTION:
-    return "Connection io error";
-  case ERROR_TIMEOUT:
-    return "Response timeout";
-  case ERROR_PROXY:
-    return "ERROR_PROXY";
-  case ERROR_PARSE_RESPONSE:
-    return "Failed to parse response";
-  case ERROR_FAIL_TO_CONNECT_SERVER:
-    return "Failed to connect to server";
-  case ERROR_PROTOCOL_NOT_SUPPORTED:
-    return "Protocol is not supported";
-  case ERROR_TOO_MANY_REDIRECTS:
-    return "Too many redirections";
-  case ERROR_REDIRECT_LOCATION_NOT_FOUND:
-    return "redict location not found";
-  case ERROR_DECOMPRESS_RESPONSE:
-    return "Failed to decompress response";
-  case ERROR_HTTP2:
-    return "ERROR_HTTP2";
-  case ERROR_SSL:
-    return "ERROR_SSL";
-  case ERROR_IO:
-    return "ERROR_IO";
-  case ERROR_INTERNAL_ERROR:
-    return "ERROR_INTERNAL_ERROR";
-  case ERROR_DRY_RUN:
-    return "ERROR_DRY_RUN";
-  case ERROR_GET_NOTHING:
-    return "ERROR_GET_NOTHING";
-  case ERROR_UNKNOWN:
+const char *
+HttpClient::ErrorCodeToString(int error_code)
+{
+    switch (static_cast<ErrorCode>(error_code)) {
+    case ERROR_INVALID:
+        return "Invalid";
+    case ERROR_INVALID_URI_ADDRESS:
+        return "Invalid URI address";
+    case ERROR_FAIL_TO_RESOLVE_ADDRESS:
+        return "Failed to resolve address";
+    case ERROR_FAIL_TO_SEND_REQUEST:
+        return "Failed to send request";
+    case ERROR_FAIL_TO_GET_RESPONSE:
+        return "Failed to get response";
+    case ERROR_CONNECTION:
+        return "Connection io error";
+    case ERROR_TIMEOUT:
+        return "Response timeout";
+    case ERROR_PROXY:
+        return "ERROR_PROXY";
+    case ERROR_PARSE_RESPONSE:
+        return "Failed to parse response";
+    case ERROR_FAIL_TO_CONNECT_SERVER:
+        return "Failed to connect to server";
+    case ERROR_PROTOCOL_NOT_SUPPORTED:
+        return "Protocol is not supported";
+    case ERROR_TOO_MANY_REDIRECTS:
+        return "Too many redirections";
+    case ERROR_REDIRECT_LOCATION_NOT_FOUND:
+        return "redict location not found";
+    case ERROR_DECOMPRESS_RESPONSE:
+        return "Failed to decompress response";
+    case ERROR_HTTP2:
+        return "ERROR_HTTP2";
+    case ERROR_SSL:
+        return "ERROR_SSL";
+    case ERROR_IO:
+        return "ERROR_IO";
+    case ERROR_INTERNAL_ERROR:
+        return "ERROR_INTERNAL_ERROR";
+    case ERROR_DRY_RUN:
+        return "ERROR_DRY_RUN";
+    case ERROR_GET_NOTHING:
+        return "ERROR_GET_NOTHING";
+    case ERROR_UNKNOWN:
+        return "<Unknown>";
+    }
     return "<Unknown>";
-  }
-  return "<Unknown>";
 }
 
 std::expected<HttpResponse, HttpClient::ErrorCode>
-HttpClient::Get(const std::string &url, const RequestOptions &request_options,
-                ResponseInfo *response_info) {
-  Latch l(1);
-  std::expected<HttpResponse, HttpClient::ErrorCode> e;
-  GetHttpChannel(url)->AsyncGet(
-      url, options_, request_options, response_info,
-      [&](std::expected<HttpResponse, HttpClient::ErrorCode> res) mutable {
-        e = std::move(res);
-        l.CountDown();
-      });
-  l.Wait();
-  return e;
+HttpClient::Get(const std::string &url, const RequestOptions &request_options, ResponseInfo *response_info)
+{
+    Latch l(1);
+    std::expected<HttpResponse, HttpClient::ErrorCode> e;
+    GetHttpChannel(url)->AsyncGet(url, options_, request_options, response_info,
+                                  [&](std::expected<HttpResponse, HttpClient::ErrorCode> res) mutable {
+                                      e = std::move(res);
+                                      l.CountDown();
+                                  });
+    l.Wait();
+    return e;
 }
 
 std::expected<HttpResponse, HttpClient::ErrorCode>
-HttpClient::Post(const std::string &url, const std::string &data,
+HttpClient::Post(const std::string &url,
+                 const std::string &data,
                  const RequestOptions &request_options,
-                 ResponseInfo *response_info) {
-  Latch l(1);
-  std::expected<HttpResponse, HttpClient::ErrorCode> e;
-  GetHttpChannel(url)->AsyncPost(
-      url, options_, data, request_options, response_info,
-      [&](std::expected<HttpResponse, HttpClient::ErrorCode> res) mutable {
-        e = std::move(res);
-        l.CountDown();
-      });
-  l.Wait();
-  return e;
+                 ResponseInfo *response_info)
+{
+    Latch l(1);
+    std::expected<HttpResponse, HttpClient::ErrorCode> e;
+    GetHttpChannel(url)->AsyncPost(url, options_, data, request_options, response_info,
+                                   [&](std::expected<HttpResponse, HttpClient::ErrorCode> res) mutable {
+                                       e = std::move(res);
+                                       l.CountDown();
+                                   });
+    l.Wait();
+    return e;
 }
 
 std::expected<HttpResponse, HttpClient::ErrorCode>
-HttpClient::Request(const std::string &protocol, const std::string &host,
+HttpClient::Request(const std::string &protocol,
+                    const std::string &host,
                     const HttpRequest &request,
                     const RequestOptions &request_options,
-                    ResponseInfo *response_info) {
-  Latch l(1);
-  std::expected<HttpResponse, HttpClient::ErrorCode> e;
-  GetHttpChannel(protocol)->AsyncRequest(
-      protocol, host, options_, request, request_options, response_info,
-      [&](std::expected<HttpResponse, HttpClient::ErrorCode> res) mutable {
-        e = std::move(res);
-        l.CountDown();
-      });
-  l.Wait();
-  return e;
+                    ResponseInfo *response_info)
+{
+    Latch l(1);
+    std::expected<HttpResponse, HttpClient::ErrorCode> e;
+    GetHttpChannel(protocol)->AsyncRequest(protocol, host, options_, request, request_options, response_info,
+                                           [&](std::expected<HttpResponse, HttpClient::ErrorCode> res) mutable {
+                                               e = std::move(res);
+                                               l.CountDown();
+                                           });
+    l.Wait();
+    return e;
 }
 
 Future<std::expected<HttpResponse, HttpClient::ErrorCode>>
-HttpClient::AsyncGet(const std::string &url,
-                     const RequestOptions &request_options,
-                     ResponseInfo *response_info) {
-  Promise<std::expected<HttpResponse, ErrorCode>> promise;
-  auto future = promise.GetFuture();
-  auto moved_promise = MakeMoveOnCopy(promise);
-  GetHttpChannel(url)->AsyncGet(
-      url, options_, request_options, response_info,
-      [moved_promise](std::expected<HttpResponse, ErrorCode> res) mutable {
-        moved_promise->SetValue(std::move(res));
-      });
-  return future;
+HttpClient::AsyncGet(const std::string &url, const RequestOptions &request_options, ResponseInfo *response_info)
+{
+    Promise<std::expected<HttpResponse, ErrorCode>> promise;
+    auto future        = promise.GetFuture();
+    auto moved_promise = MakeMoveOnCopy(promise);
+    GetHttpChannel(url)->AsyncGet(url, options_, request_options, response_info,
+                                  [moved_promise](std::expected<HttpResponse, ErrorCode> res) mutable {
+                                      moved_promise->SetValue(std::move(res));
+                                  });
+    return future;
 }
 
 Future<std::expected<HttpResponse, HttpClient::ErrorCode>>
-HttpClient::AsyncPost(const std::string &url, const std::string &data,
+HttpClient::AsyncPost(const std::string &url,
+                      const std::string &data,
                       const RequestOptions &request_options,
-                      ResponseInfo *response_info) {
-  Promise<std::expected<HttpResponse, ErrorCode>> promise;
-  auto future = promise.GetFuture();
-  auto moved_promise = MakeMoveOnCopy(promise);
-  GetHttpChannel(url)->AsyncPost(
-      url, options_, data, request_options, response_info,
-      [moved_promise](std::expected<HttpResponse, ErrorCode> res) mutable {
-        moved_promise->SetValue(std::move(res));
-      });
-  return future;
+                      ResponseInfo *response_info)
+{
+    Promise<std::expected<HttpResponse, ErrorCode>> promise;
+    auto future        = promise.GetFuture();
+    auto moved_promise = MakeMoveOnCopy(promise);
+    GetHttpChannel(url)->AsyncPost(url, options_, data, request_options, response_info,
+                                   [moved_promise](std::expected<HttpResponse, ErrorCode> res) mutable {
+                                       moved_promise->SetValue(std::move(res));
+                                   });
+    return future;
 }
 
 Future<std::expected<HttpResponse, HttpClient::ErrorCode>>
-HttpClient::AsyncRequest(const std::string &protocol, const std::string &host,
+HttpClient::AsyncRequest(const std::string &protocol,
+                         const std::string &host,
                          const HttpRequest &request,
                          const RequestOptions &request_options,
-                         ResponseInfo *response_info) {
-  Promise<std::expected<HttpResponse, ErrorCode>> promise;
-  auto future = promise.GetFuture();
-  auto moved_promise = MakeMoveOnCopy(promise);
-  GetHttpChannel(protocol)->AsyncRequest(
-      protocol, host, options_, request, request_options, response_info,
-      [moved_promise](std::expected<HttpResponse, ErrorCode> res) mutable {
-        moved_promise->SetValue(std::move(res));
-      });
-  return future;
+                         ResponseInfo *response_info)
+{
+    Promise<std::expected<HttpResponse, ErrorCode>> promise;
+    auto future        = promise.GetFuture();
+    auto moved_promise = MakeMoveOnCopy(promise);
+    GetHttpChannel(protocol)->AsyncRequest(protocol, host, options_, request, request_options, response_info,
+                                           [moved_promise](std::expected<HttpResponse, ErrorCode> res) mutable {
+                                               moved_promise->SetValue(std::move(res));
+                                           });
+    return future;
 }
 
-} // namespace tile
+}// namespace tile
diff --git a/tile/net/http/http_client.h b/tile/net/http/http_client.h
index 77eea63..0697e26 100644
--- a/tile/net/http/http_client.h
+++ b/tile/net/http/http_client.h
@@ -18,140 +18,135 @@ DECLARE_int32(tile_http_client_default_timeout_ms);
 namespace tile {
 class HttpClient {
 public:
-  struct Options {
-    bool verify_server_certificate = true;
-    bool follow_redirects = true;
-    bool proxy_from_env = true;
+    struct Options {
+        bool verify_server_certificate = true;
+        bool follow_redirects          = true;
+        bool proxy_from_env            = true;
 
-    std::string proxy;
-    bool use_bintin_compression = false;
-  };
+        std::string proxy;
+        bool use_bintin_compression = false;
+    };
 
-  enum ErrorCode {
-    ERROR_INVALID = 0, // unused
-    ERROR_INVALID_URI_ADDRESS,
-    ERROR_FAIL_TO_RESOLVE_ADDRESS,
-    ERROR_FAIL_TO_SEND_REQUEST,
-    ERROR_FAIL_TO_GET_RESPONSE,
-    ERROR_CONNECTION,
-    ERROR_TIMEOUT,
-    ERROR_PARSE_RESPONSE,
-    ERROR_FAIL_TO_CONNECT_SERVER,
-    ERROR_PROTOCOL_NOT_SUPPORTED,
-    ERROR_TOO_MANY_REDIRECTS,
-    ERROR_REDIRECT_LOCATION_NOT_FOUND,
-    ERROR_DECOMPRESS_RESPONSE,
-    ERROR_PROXY,
-    ERROR_HTTP2,
-    ERROR_SSL,
-    ERROR_IO,
-    ERROR_INTERNAL_ERROR,
-    ERROR_DRY_RUN,
-    ERROR_GET_NOTHING,
-    ERROR_UNKNOWN = 100,
-  };
+    enum ErrorCode {
+        ERROR_INVALID = 0,// unused
+        ERROR_INVALID_URI_ADDRESS,
+        ERROR_FAIL_TO_RESOLVE_ADDRESS,
+        ERROR_FAIL_TO_SEND_REQUEST,
+        ERROR_FAIL_TO_GET_RESPONSE,
+        ERROR_CONNECTION,
+        ERROR_TIMEOUT,
+        ERROR_PARSE_RESPONSE,
+        ERROR_FAIL_TO_CONNECT_SERVER,
+        ERROR_PROTOCOL_NOT_SUPPORTED,
+        ERROR_TOO_MANY_REDIRECTS,
+        ERROR_REDIRECT_LOCATION_NOT_FOUND,
+        ERROR_DECOMPRESS_RESPONSE,
+        ERROR_PROXY,
+        ERROR_HTTP2,
+        ERROR_SSL,
+        ERROR_IO,
+        ERROR_INTERNAL_ERROR,
+        ERROR_DRY_RUN,
+        ERROR_GET_NOTHING,
+        ERROR_UNKNOWN = 100,
+    };
 
-  static const char *ErrorCodeToString(int error_code);
+    static const char *ErrorCodeToString(int error_code);
 
-  struct RequestOptions {
-    int max_redirection_count = 1;
-    std::chrono::nanoseconds timeout =
-        std::chrono::milliseconds(FLAGS_tile_http_client_default_timeout_ms);
-    std::string content_type;         // ex: text:html
-    std::vector<std::string> headers; // ex: "Content-Type: text/html"
-    bool verbose = false;
-    bool no_automatic_upgrade = false; // use http2 without 1.1  upgrade
-    HttpVersion http_version = HttpVersion::Unspecified;
-    std::string override_host_nslb;
+    struct RequestOptions {
+        int max_redirection_count        = 1;
+        std::chrono::nanoseconds timeout = std::chrono::milliseconds(FLAGS_tile_http_client_default_timeout_ms);
+        std::string content_type;        // ex: text:html
+        std::vector<std::string> headers;// ex: "Content-Type: text/html"
+        bool verbose              = false;
+        bool no_automatic_upgrade = false;// use http2 without 1.1  upgrade
+        HttpVersion http_version  = HttpVersion::Unspecified;
+        std::string override_host_nslb;
 
-    std::string binlog_correlation_id;
-  };
+        std::string binlog_correlation_id;
+    };
 
-  struct ResponseInfo {
-    std::string effective_url;                    // get the last used URL.
-    std::chrono::nanoseconds total_time_transfer; // transfer time
-    HttpVersion http_version;
-  };
+    struct ResponseInfo {
+        std::string effective_url;                   // get the last used URL.
+        std::chrono::nanoseconds total_time_transfer;// transfer time
+        HttpVersion http_version;
+    };
 
-  explicit HttpClient(
-      const Options &options = internal::LazyInitConstant<Options>());
+    explicit HttpClient(const Options &options = internal::LazyInitConstant<Options>());
 
-  Future<std::expected<HttpResponse, ErrorCode>>
-  AsyncGet(const std::string &url,
-           const RequestOptions &options =
-               internal::LazyInitConstant<RequestOptions>(),
-           ResponseInfo *response_detail = nullptr);
+    Future<std::expected<HttpResponse, ErrorCode>>
+    AsyncGet(const std::string &url,
+             const RequestOptions &options = internal::LazyInitConstant<RequestOptions>(),
+             ResponseInfo *response_detail = nullptr);
 
-  std::expected<HttpResponse, ErrorCode>
-  Get(const std::string &url,
-      const RequestOptions &options =
-          internal::LazyInitConstant<RequestOptions>(),
-      ResponseInfo *response_detail = nullptr);
+    std::expected<HttpResponse, ErrorCode>
+    Get(const std::string &url,
+        const RequestOptions &options = internal::LazyInitConstant<RequestOptions>(),
+        ResponseInfo *response_detail = nullptr);
 
-  Future<std::expected<HttpResponse, ErrorCode>>
-  AsyncPost(const std::string &url, const std::string &data,
-            const RequestOptions &options =
-                internal::LazyInitConstant<RequestOptions>(),
+    Future<std::expected<HttpResponse, ErrorCode>>
+    AsyncPost(const std::string &url,
+              const std::string &data,
+              const RequestOptions &options = internal::LazyInitConstant<RequestOptions>(),
+              ResponseInfo *response_detail = nullptr);
+
+    std::expected<HttpResponse, ErrorCode>
+    Post(const std::string &url,
+         const std::string &data,
+         const RequestOptions &options = internal::LazyInitConstant<RequestOptions>(),
+         ResponseInfo *response_detail = nullptr);
+
+    // Generic method
+    Future<std::expected<HttpResponse, ErrorCode>>
+    AsyncRequest(const std::string &protocol,
+                 const std::string &host,
+                 const HttpRequest &request,
+                 const RequestOptions &options = internal::LazyInitConstant<RequestOptions>(),
+                 ResponseInfo *response_detail = nullptr);
+
+    std::expected<HttpResponse, ErrorCode>
+    Request(const std::string &protocol,
+            const std::string &host,
+            const HttpRequest &request,
+            const RequestOptions &options = internal::LazyInitConstant<RequestOptions>(),
             ResponseInfo *response_detail = nullptr);
 
-  std::expected<HttpResponse, ErrorCode>
-  Post(const std::string &url, const std::string &data,
-       const RequestOptions &options =
-           internal::LazyInitConstant<RequestOptions>(),
-       ResponseInfo *response_detail = nullptr);
-
-  // Generic method
-  Future<std::expected<HttpResponse, ErrorCode>>
-  AsyncRequest(const std::string &protocol, const std::string &host,
-               const HttpRequest &request,
-               const RequestOptions &options =
-                   internal::LazyInitConstant<RequestOptions>(),
-               ResponseInfo *response_detail = nullptr);
-
-  std::expected<HttpResponse, ErrorCode>
-  Request(const std::string &protocol, const std::string &host,
-          const HttpRequest &request,
-          const RequestOptions &options =
-              internal::LazyInitConstant<RequestOptions>(),
-          ResponseInfo *response_detail = nullptr);
-
 private:
-  Options options_;
+    Options options_;
 };
 
 namespace detail {
 class HttpChannel {
 public:
-  HttpChannel() = default;
-  virtual ~HttpChannel() = default;
+    HttpChannel()                                                                                             = default;
+    virtual ~HttpChannel()                                                                                    = default;
 
-  virtual void AsyncGet(
-      const std::string &url, const HttpClient::Options &opts,
-      const HttpClient::RequestOptions &request_options,
-      HttpClient::ResponseInfo *response_info,
-      std::function<void(std::expected<HttpResponse, HttpClient::ErrorCode>)>
-          &&done) = 0;
+    virtual void AsyncGet(const std::string &url,
+                          const HttpClient::Options &opts,
+                          const HttpClient::RequestOptions &request_options,
+                          HttpClient::ResponseInfo *response_info,
+                          std::function<void(std::expected<HttpResponse, HttpClient::ErrorCode>)> &&done)     = 0;
 
-  virtual void AsyncPost(
-      const std::string &url, const HttpClient::Options &opts, std::string data,
-      const HttpClient::RequestOptions &request_options,
-      HttpClient::ResponseInfo *response_info,
-      std::function<void(std::expected<HttpResponse, HttpClient::ErrorCode>)>
-          &&done) = 0;
+    virtual void AsyncPost(const std::string &url,
+                           const HttpClient::Options &opts,
+                           std::string data,
+                           const HttpClient::RequestOptions &request_options,
+                           HttpClient::ResponseInfo *response_info,
+                           std::function<void(std::expected<HttpResponse, HttpClient::ErrorCode>)> &&done)    = 0;
 
-  virtual void AsyncRequest(
-      const std::string &protocol, const std::string &host,
-      const HttpClient::Options &opts, const HttpRequest &request,
-      const HttpClient::RequestOptions &request_options,
-      HttpClient::ResponseInfo *response_info,
-      std::function<void(std::expected<HttpResponse, HttpClient::ErrorCode>)>
-          &&done) = 0;
+    virtual void AsyncRequest(const std::string &protocol,
+                              const std::string &host,
+                              const HttpClient::Options &opts,
+                              const HttpRequest &request,
+                              const HttpClient::RequestOptions &request_options,
+                              HttpClient::ResponseInfo *response_info,
+                              std::function<void(std::expected<HttpResponse, HttpClient::ErrorCode>)> &&done) = 0;
 };
 
 void RegisterMockHttpChannel(HttpChannel *channel);
 void RegisterDryRunHttpChannel(HttpChannel *channel);
 
-} // namespace detail
-} // namespace tile
+}// namespace detail
+}// namespace tile
 
-#endif // TILE_NET_HTTP_HTTP_CLIENT_H
+#endif// TILE_NET_HTTP_HTTP_CLIENT_H
diff --git a/tile/net/http/http_client_test.cc b/tile/net/http/http_client_test.cc
index fa56d23..59e0574 100644
--- a/tile/net/http/http_client_test.cc
+++ b/tile/net/http/http_client_test.cc
@@ -9,59 +9,65 @@ TILE_OVERRIDE_FLAG(tile_http_client_default_timeout_ms, 10000);
 
 namespace tile {
 
-static constexpr auto one_s = std::chrono::seconds(1);
+static constexpr auto one_s  = std::chrono::seconds(1);
 static constexpr auto one_ms = std::chrono::milliseconds(1);
 
 static std::expected<HttpResponse, HttpClient::ErrorCode>
-Get(const std::string &url, std::chrono::nanoseconds timeout = 20 * one_s) {
-  HttpClient client;
-  HttpClient::RequestOptions opt;
-  opt.timeout = timeout;
+Get(const std::string &url, std::chrono::nanoseconds timeout = 20 * one_s)
+{
+    HttpClient client;
+    HttpClient::RequestOptions opt;
+    opt.timeout = timeout;
 
-  return client.Get(url, opt);
+    return client.Get(url, opt);
 }
 
-bool IsWanAccessible() {
-  static const auto kResult = /*!!Get("http://baidu.com") &&
+bool
+IsWanAccessible()
+{
+    static const auto kResult = /*!!Get("http://baidu.com") &&
                               !!Get("http://qq.com") &&*/
-      !!Get("http://www.baidu.com");
-  return kResult;
+        !!Get("http://www.baidu.com");
+    return kResult;
 }
 
 static std::expected<HttpResponse, HttpClient::ErrorCode>
-Post(const std::string &url, std::string data,
-     std::chrono::nanoseconds timeout = 20 * one_s) {
-  HttpClient client;
-  HttpClient::RequestOptions opt;
-  opt.timeout = timeout;
-  opt.content_type = "application/octet-stream";
-  return client.Post(url, std::move(data), opt);
+Post(const std::string &url, std::string data, std::chrono::nanoseconds timeout = 20 * one_s)
+{
+    HttpClient client;
+    HttpClient::RequestOptions opt;
+    opt.timeout      = timeout;
+    opt.content_type = "application/octet-stream";
+    return client.Post(url, std::move(data), opt);
 }
 
-TEST(HttpClient, TestDomain) {
-  if (!IsWanAccessible()) {
-    TILE_LOG_INFO("WAN is not accessible, skip this test");
-    return;
-  }
-  auto resp = Get("http://www.baidu.com");
-  ASSERT_TRUE(resp);
-  EXPECT_EQ(HttpStatus(200), resp->status());
+TEST(HttpClient, TestDomain)
+{
+    if (!IsWanAccessible()) {
+        TILE_LOG_INFO("WAN is not accessible, skip this test");
+        return;
+    }
+    auto resp = Get("http://www.baidu.com");
+    ASSERT_TRUE(resp);
+    EXPECT_EQ(HttpStatus(200), resp->status());
 }
 
-TEST(HttpClient, TestNotFound) {
-  if (!IsWanAccessible()) {
-    TILE_LOG_INFO("WAN is not accessible, skip this test");
-    return;
-  }
-  auto resp = Get("http://www.baidu.com/404");
-  ASSERT_TRUE(resp);
-  EXPECT_EQ(HttpStatus(404), resp->status());
+TEST(HttpClient, TestNotFound)
+{
+    if (!IsWanAccessible()) {
+        TILE_LOG_INFO("WAN is not accessible, skip this test");
+        return;
+    }
+    auto resp = Get("http://www.baidu.com/404");
+    ASSERT_TRUE(resp);
+    EXPECT_EQ(HttpStatus(404), resp->status());
 }
 
-TEST(HttpClient, TestTimeout) {
-  auto resp = Get("http://127.0.0.1:1/", one_ms * 50);
-  ASSERT_FALSE(resp);
-  EXPECT_EQ(HttpClient::ERROR_CONNECTION, resp.error());
+TEST(HttpClient, TestTimeout)
+{
+    auto resp = Get("http://127.0.0.1:1/", one_ms * 50);
+    ASSERT_FALSE(resp);
+    EXPECT_EQ(HttpClient::ERROR_CONNECTION, resp.error());
 }
 
-} // namespace tile
+}// namespace tile
diff --git a/tile/net/http/http_headers.cc b/tile/net/http/http_headers.cc
index b7478a0..96fd4ab 100644
--- a/tile/net/http/http_headers.cc
+++ b/tile/net/http/http_headers.cc
@@ -2,136 +2,139 @@
 #include "tile/base/logging.h"
 
 namespace tile {
-HttpHeaders::HttpHeaders(const HttpHeaders &other) : header_idx_() {
-  for (auto &&item : other) {
-    Append(item.first.ToString(), item.second.ToString());
-  }
+HttpHeaders::HttpHeaders(const HttpHeaders &other) : header_idx_()
+{
+    for (auto &&item : other) { Append(item.first.ToString(), item.second.ToString()); }
 }
 
-HttpHeaders &HttpHeaders::operator=(const HttpHeaders &other) {
-  if (&other == this) {
+HttpHeaders &
+HttpHeaders::operator=(const HttpHeaders &other)
+{
+    if (&other == this) { return *this; }
+    this->~HttpHeaders();
+    new (this) HttpHeaders(other);
     return *this;
-  }
-  this->~HttpHeaders();
-  new (this) HttpHeaders(other);
-  return *this;
 }
 
-void HttpHeaders::clear() noexcept {
-  header_block_.first.reset();
-  header_block_.second = 0;
-  owning_strs_2_.clear();
-  header_idx_.clear();
-  fields_.clear();
+void
+HttpHeaders::clear() noexcept
+{
+    header_block_.first.reset();
+    header_block_.second = 0;
+    owning_strs_2_.clear();
+    header_idx_.clear();
+    fields_.clear();
 }
-std::vector<Slice> HttpHeaders::TryGetMultiple(Slice key) const noexcept {
-  std::vector<Slice> values;
-  for (auto &&item : fields_) {
-    // I really shouldn't have done this.
-    if (EqualsIgnoreCase(item.first, key)) {
-      values.push_back(item.second);
+
+std::vector<Slice>
+HttpHeaders::TryGetMultiple(Slice key) const noexcept
+{
+    std::vector<Slice> values;
+    for (auto &&item : fields_) {
+        // I really shouldn't have done this.
+        if (EqualsIgnoreCase(item.first, key)) { values.push_back(item.second); }
     }
-  }
-  return values;
+    return values;
 }
 
-void HttpHeaders::Set(std::string key, std::string value) noexcept {
-  TILE_CHECK_EQ(Trim(key), key,
-                "Field key may not be surrounded by whitespaces.");
-  // To be precise, surrounding `value` with whitespace is not an error, it
-  // just does not make much sense.
-  //
-  // FIXME: Should we trim `value` automatically?
-  TILE_CHECK_EQ(Trim(value), value,
-                "There's hardly any point in surrounding field value with "
-                "whitespaces.");
+void
+HttpHeaders::Set(std::string key, std::string value) noexcept
+{
+    TILE_CHECK_EQ(Trim(key), key, "Field key may not be surrounded by whitespaces.");
+    // To be precise, surrounding `value` with whitespace is not an error, it
+    // just does not make much sense.
+    //
+    // FIXME: Should we trim `value` automatically?
+    TILE_CHECK_EQ(Trim(value), value,
+                  "There's hardly any point in surrounding field value with "
+                  "whitespaces.");
 
-  auto iter = header_idx_.find(key);
-  if (iter == header_idx_.end()) {
-    Append(std::move(key), std::move(value));
-  } else {
-    owning_strs_2_.emplace_back(std::move(value));
-    fields_[iter->second].second = owning_strs_2_.back();
-  }
-}
-
-void HttpHeaders::Append(std::string key, std::string value) noexcept {
-  TILE_CHECK_EQ(Trim(key), key,
-                "Field key may not be surrounded by whitespaces.");
-  // To be precise, surrounding `value` with whitespace is not an error, it
-  // just does not make much sense.
-  //
-  // FIXME: Should we trim `value` automatically?
-  TILE_CHECK_EQ(Trim(value), value,
-                "There's hardly any point in surrounding field value with "
-                "whitespaces.");
-  owning_strs_2_.emplace_back(std::move(key));
-  Slice k = owning_strs_2_.back();
-  owning_strs_2_.emplace_back(std::move(value));
-  Slice v = owning_strs_2_.back();
-
-  if (header_idx_.find(k) == header_idx_.end()) {
-    header_idx_[k] = fields_.size();
-  }
-  fields_.emplace_back(k, v);
-}
-
-void HttpHeaders::Append(
-    std::initializer_list<std::pair<Slice, Slice>> fields) noexcept {
-  for (auto &&item : fields) {
-    Append(item.first.ToString(), item.second.ToString());
-  }
-}
-
-bool HttpHeaders::Remove(Slice key) noexcept {
-  if (!TryGet(key)) {
-    return false;
-  }
-
-  header_idx_.clear();
-  std::size_t i = 0;
-  auto iter = fields_.begin();
-  while (iter != fields_.end()) {
-    if (internal::detail::CaseInsensitiveEqualTo()(iter->first, key)) {
-      iter = fields_.erase(iter);
+    auto iter = header_idx_.find(key);
+    if (iter == header_idx_.end()) {
+        Append(std::move(key), std::move(value));
     } else {
-      if (header_idx_.find(iter->first) == header_idx_.end()) {
-        header_idx_[iter->first] = i;
-      }
-      ++i;
-      ++iter;
+        owning_strs_2_.emplace_back(std::move(value));
+        fields_[iter->second].second = owning_strs_2_.back();
     }
-  }
-
-  return true;
 }
 
-std::string HttpHeaders::ToString() const {
-  std::string result;
-  for (auto &&item : fields_) {
-    result.append(item.first.data(), item.first.size());
-    result.append(": ");
-    result.append(item.second.data(), item.second.size());
-    result.append("\r\n");
-  }
-  return result;
+void
+HttpHeaders::Append(std::string key, std::string value) noexcept
+{
+    TILE_CHECK_EQ(Trim(key), key, "Field key may not be surrounded by whitespaces.");
+    // To be precise, surrounding `value` with whitespace is not an error, it
+    // just does not make much sense.
+    //
+    // FIXME: Should we trim `value` automatically?
+    TILE_CHECK_EQ(Trim(value), value,
+                  "There's hardly any point in surrounding field value with "
+                  "whitespaces.");
+    owning_strs_2_.emplace_back(std::move(key));
+    Slice k = owning_strs_2_.back();
+    owning_strs_2_.emplace_back(std::move(value));
+    Slice v = owning_strs_2_.back();
+
+    if (header_idx_.find(k) == header_idx_.end()) { header_idx_[k] = fields_.size(); }
+    fields_.emplace_back(k, v);
 }
 
-Slice HttpHeaders::RetrieveHeaderStorage(
-    std::pair<std::unique_ptr<char[]>, std::size_t> &&s) {
-  owning_strs_2_.clear();
-  header_idx_.clear();
-  header_block_ = std::move(s);
-  return Slice(header_block_.first.get(), header_block_.second);
+void
+HttpHeaders::Append(std::initializer_list<std::pair<Slice, Slice>> fields) noexcept
+{
+    for (auto &&item : fields) { Append(item.first.ToString(), item.second.ToString()); }
 }
-void HttpHeaders::RetrieveFields(NonowningFields &&fields) {
-  fields_ = std::move(fields);
-  for (std::size_t index = 0; index != fields_.size(); ++index) {
-    auto &&key = fields_[index].first;
 
-    if (header_idx_.find(key) == header_idx_.end()) {
-      header_idx_[key] = index;
+bool
+HttpHeaders::Remove(Slice key) noexcept
+{
+    if (!TryGet(key)) { return false; }
+
+    header_idx_.clear();
+    std::size_t i = 0;
+    auto iter     = fields_.begin();
+    while (iter != fields_.end()) {
+        if (internal::detail::CaseInsensitiveEqualTo()(iter->first, key)) {
+            iter = fields_.erase(iter);
+        } else {
+            if (header_idx_.find(iter->first) == header_idx_.end()) { header_idx_[iter->first] = i; }
+            ++i;
+            ++iter;
+        }
     }
-  }
+
+    return true;
 }
-} // namespace tile
+
+std::string
+HttpHeaders::ToString() const
+{
+    std::string result;
+    for (auto &&item : fields_) {
+        result.append(item.first.data(), item.first.size());
+        result.append(": ");
+        result.append(item.second.data(), item.second.size());
+        result.append("\r\n");
+    }
+    return result;
+}
+
+Slice
+HttpHeaders::RetrieveHeaderStorage(std::pair<std::unique_ptr<char[]>, std::size_t> &&s)
+{
+    owning_strs_2_.clear();
+    header_idx_.clear();
+    header_block_ = std::move(s);
+    return Slice(header_block_.first.get(), header_block_.second);
+}
+
+void
+HttpHeaders::RetrieveFields(NonowningFields &&fields)
+{
+    fields_ = std::move(fields);
+    for (std::size_t index = 0; index != fields_.size(); ++index) {
+        auto &&key = fields_[index].first;
+
+        if (header_idx_.find(key) == header_idx_.end()) { header_idx_[key] = index; }
+    }
+}
+}// namespace tile
diff --git a/tile/net/http/http_headers.h b/tile/net/http/http_headers.h
index 62bc1a2..2df0c35 100644
--- a/tile/net/http/http_headers.h
+++ b/tile/net/http/http_headers.h
@@ -13,85 +13,83 @@
 
 namespace tile {
 class HttpHeaders;
+
 namespace http {
-bool ParseMessagePartial(
-    std::pair<std::unique_ptr<char[]>, std::size_t> &&storage,
-    Slice *start_line, HttpHeaders *headers);
+bool
+ParseMessagePartial(std::pair<std::unique_ptr<char[]>, std::size_t> &&storage, Slice *start_line, HttpHeaders *headers);
 }
 
 class HttpHeaders {
-  using NonowningFields = std::vector<std::pair<Slice, Slice>>;
+    using NonowningFields = std::vector<std::pair<Slice, Slice>>;
 
 public:
-  using iterator = NonowningFields::iterator;
-  using const_iterator = NonowningFields::const_iterator;
+    using iterator                         = NonowningFields::iterator;
+    using const_iterator                   = NonowningFields::const_iterator;
 
-  HttpHeaders() = default;
-  HttpHeaders(HttpHeaders &&) = default;
-  HttpHeaders &operator=(HttpHeaders &&) = default;
+    HttpHeaders()                          = default;
+    HttpHeaders(HttpHeaders &&)            = default;
+    HttpHeaders &operator=(HttpHeaders &&) = default;
 
-  HttpHeaders(const HttpHeaders &);
-  HttpHeaders &operator=(const HttpHeaders &);
+    HttpHeaders(const HttpHeaders &);
+    HttpHeaders &operator=(const HttpHeaders &);
 
-  iterator begin() noexcept { return fields_.begin(); }
-  iterator end() noexcept { return fields_.end(); }
-  const_iterator begin() const noexcept { return fields_.begin(); }
-  const_iterator end() const noexcept { return fields_.end(); }
+    iterator begin() noexcept { return fields_.begin(); }
 
-  bool contains(Slice key) const noexcept {
-    if (header_idx_.find(key) != header_idx_.end()) {
-      return true;
+    iterator end() noexcept { return fields_.end(); }
+
+    const_iterator begin() const noexcept { return fields_.begin(); }
+
+    const_iterator end() const noexcept { return fields_.end(); }
+
+    bool contains(Slice key) const noexcept
+    {
+        if (header_idx_.find(key) != header_idx_.end()) { return true; }
+
+        for (const auto &field : fields_) {
+            if (EqualsIgnoreCase(field.first, key)) { return true; }
+        }
+        return false;
     }
 
-    for (const auto &field : fields_) {
-      if (EqualsIgnoreCase(field.first, key)) {
-        return true;
-      }
+    void clear() noexcept;
+
+    std::optional<Slice> TryGet(Slice key) const noexcept
+    {
+        auto iter = header_idx_.find(key);
+        if (iter == header_idx_.end()) { return std::nullopt; }
+        return fields_[iter->second].second;
     }
-    return false;
-  }
 
-  void clear() noexcept;
-
-  std::optional<Slice> TryGet(Slice key) const noexcept {
-    auto iter = header_idx_.find(key);
-    if (iter == header_idx_.end()) {
-      return std::nullopt;
+    template<typename T>
+    std::optional<T> TryGet(Slice key) const noexcept
+    {
+        auto p = TryGet(key);
+        if (p) { return TryParse<T>(*p); }
+        return std::nullopt;
     }
-    return fields_[iter->second].second;
-  }
 
-  template <typename T> std::optional<T> TryGet(Slice key) const noexcept {
-    auto p = TryGet(key);
-    if (p) {
-      return TryParse<T>(*p);
-    }
-    return std::nullopt;
-  }
-
-  std::vector<Slice> TryGetMultiple(Slice key) const noexcept;
-  void Set(std::string key, std::string value) noexcept;
-  void Append(std::string key, std::string value) noexcept;
-  void Append(std::initializer_list<std::pair<Slice, Slice>> fields) noexcept;
-  bool Remove(Slice key) noexcept;
-  std::string ToString() const;
+    std::vector<Slice> TryGetMultiple(Slice key) const noexcept;
+    void Set(std::string key, std::string value) noexcept;
+    void Append(std::string key, std::string value) noexcept;
+    void Append(std::initializer_list<std::pair<Slice, Slice>> fields) noexcept;
+    bool Remove(Slice key) noexcept;
+    std::string ToString() const;
 
 private:
-  friend bool ::tile::http::ParseMessagePartial(
-      std::pair<std::unique_ptr<char[]>, std::size_t> &&storage,
-      Slice *start_line, HttpHeaders *headers);
-  friend bool Test();
-  Slice
-  RetrieveHeaderStorage(std::pair<std::unique_ptr<char[]>, std::size_t> &&s);
-  void RetrieveFields(NonowningFields &&fields);
+    friend bool ::tile::http::ParseMessagePartial(std::pair<std::unique_ptr<char[]>, std::size_t> &&storage,
+                                                  Slice *start_line,
+                                                  HttpHeaders *headers);
+    friend bool Test();
+    Slice RetrieveHeaderStorage(std::pair<std::unique_ptr<char[]>, std::size_t> &&s);
+    void RetrieveFields(NonowningFields &&fields);
 
 private:
-  std::pair<std::unique_ptr<char[]>, std::size_t> header_block_;
-  std::deque<std::string> owning_strs_2_;
-  // <HeaderName, FieldIndex>
-  internal::CaseInsensitiveHashMap<Slice, std::size_t> header_idx_;
-  NonowningFields fields_;
+    std::pair<std::unique_ptr<char[]>, std::size_t> header_block_;
+    std::deque<std::string> owning_strs_2_;
+    // <HeaderName, FieldIndex>
+    internal::CaseInsensitiveHashMap<Slice, std::size_t> header_idx_;
+    NonowningFields fields_;
 };
-} // namespace tile
+}// namespace tile
 
-#endif // _TILE_NET_HTTP_HTTP_HEADERS_H
+#endif// _TILE_NET_HTTP_HTTP_HEADERS_H
diff --git a/tile/net/http/http_headers_test.cc b/tile/net/http/http_headers_test.cc
index 6576efc..53d302c 100644
--- a/tile/net/http/http_headers_test.cc
+++ b/tile/net/http/http_headers_test.cc
@@ -19,56 +19,60 @@
 
 namespace tile {
 
-TEST(HttpHeaders, All) {
-  HttpHeaders headers;
-  EXPECT_EQ("", headers.ToString());
+TEST(HttpHeaders, All)
+{
+    HttpHeaders headers;
+    EXPECT_EQ("", headers.ToString());
 
-  headers.Append("Hello", "World");
-  EXPECT_EQ("Hello: World\r\n", headers.ToString());
+    headers.Append("Hello", "World");
+    EXPECT_EQ("Hello: World\r\n", headers.ToString());
 
-  headers.Append("Great", "Mall");
-  EXPECT_EQ("Hello: World\r\nGreat: Mall\r\n", headers.ToString());
+    headers.Append("Great", "Mall");
+    EXPECT_EQ("Hello: World\r\nGreat: Mall\r\n", headers.ToString());
 
-  headers.Append({{"X-My-Header-1", "Value-1"}, {"X-My-Header-2", "Value-2"}});
-  EXPECT_EQ("Hello: World\r\n"
-            "Great: Mall\r\n"
-            "X-My-Header-1: Value-1\r\n"
-            "X-My-Header-2: Value-2\r\n",
-            headers.ToString());
+    headers.Append({
+        {"X-My-Header-1", "Value-1"},
+        {"X-My-Header-2", "Value-2"}
+    });
+    EXPECT_EQ("Hello: World\r\n"
+              "Great: Mall\r\n"
+              "X-My-Header-1: Value-1\r\n"
+              "X-My-Header-2: Value-2\r\n",
+              headers.ToString());
 
-  ASSERT_EQ("World", *headers.TryGet("Hello"));
-  ASSERT_EQ("World", *headers.TryGet("hello")); // Lower case.
-  ASSERT_FALSE(headers.TryGet("Hi"));
+    ASSERT_EQ("World", *headers.TryGet("Hello"));
+    ASSERT_EQ("World", *headers.TryGet("hello"));// Lower case.
+    ASSERT_FALSE(headers.TryGet("Hi"));
 
-  ASSERT_EQ(0, headers.TryGetMultiple("404").size());
-  headers.Append("Hello", "World2");
-  ASSERT_THAT(headers.TryGetMultiple("Hello"),
-              testing::ElementsAre("World", "World2"));
-  // Lower case.
-  ASSERT_THAT(headers.TryGetMultiple("hello"),
-              testing::ElementsAre("World", "World2"));
+    ASSERT_EQ(0, headers.TryGetMultiple("404").size());
+    headers.Append("Hello", "World2");
+    ASSERT_THAT(headers.TryGetMultiple("Hello"), testing::ElementsAre("World", "World2"));
+    // Lower case.
+    ASSERT_THAT(headers.TryGetMultiple("hello"), testing::ElementsAre("World", "World2"));
 }
 
-TEST(HttpHeaders, Set) {
-  HttpHeaders headers;
-  ASSERT_FALSE(headers.TryGet("Hi"));
-  headers.Set("Hi", "Abc");
-  ASSERT_EQ("Abc", *headers.TryGet("Hi"));
-  headers.Set("Hi", "Xyz");
-  ASSERT_EQ("Xyz", *headers.TryGet("Hi"));
+TEST(HttpHeaders, Set)
+{
+    HttpHeaders headers;
+    ASSERT_FALSE(headers.TryGet("Hi"));
+    headers.Set("Hi", "Abc");
+    ASSERT_EQ("Abc", *headers.TryGet("Hi"));
+    headers.Set("Hi", "Xyz");
+    ASSERT_EQ("Xyz", *headers.TryGet("Hi"));
 }
 
-TEST(HttpHeaders, Remove) {
-  HttpHeaders headers;
-  headers.Append("Hi", "Abc");
-  headers.Append("Hello", "World");
-  headers.Append("hi", "Def");
-  headers.Append("Hi", "Xyz");
-  ASSERT_EQ("Abc", *headers.TryGet("Hi"));
-  ASSERT_TRUE(headers.Remove("Hi"));
-  ASSERT_FALSE(headers.Remove("Hi"));
-  ASSERT_FALSE(headers.TryGet("hi"));
-  ASSERT_EQ("World", headers.TryGet("Hello"));
+TEST(HttpHeaders, Remove)
+{
+    HttpHeaders headers;
+    headers.Append("Hi", "Abc");
+    headers.Append("Hello", "World");
+    headers.Append("hi", "Def");
+    headers.Append("Hi", "Xyz");
+    ASSERT_EQ("Abc", *headers.TryGet("Hi"));
+    ASSERT_TRUE(headers.Remove("Hi"));
+    ASSERT_FALSE(headers.Remove("Hi"));
+    ASSERT_FALSE(headers.TryGet("hi"));
+    ASSERT_EQ("World", headers.TryGet("Hello"));
 }
 
-} // namespace tile
+}// namespace tile
diff --git a/tile/net/http/http_message.cc b/tile/net/http/http_message.cc
index 981c2a4..ca35a8d 100644
--- a/tile/net/http/http_message.cc
+++ b/tile/net/http/http_message.cc
@@ -2,13 +2,15 @@
 
 namespace tile {
 namespace http {
-std::string *HttpMessage::StringifyBody() const {
-  if (!body_) {
-    body_str_ = "";
-  } else {
-    body_str_ = FlattenSlow(*body_);
-  }
-  return &*body_str_;
+std::string *
+HttpMessage::StringifyBody() const
+{
+    if (!body_) {
+        body_str_ = "";
+    } else {
+        body_str_ = FlattenSlow(*body_);
+    }
+    return &*body_str_;
 }
-} // namespace http
-} // namespace tile
+}// namespace http
+}// namespace tile
diff --git a/tile/net/http/http_message.h b/tile/net/http/http_message.h
index f9220d6..3f492c7 100644
--- a/tile/net/http/http_message.h
+++ b/tile/net/http/http_message.h
@@ -10,65 +10,66 @@ namespace tile {
 namespace http {
 class HttpMessage {
 public:
-  HttpVersion version() const noexcept { return version_; }
-  void set_version(HttpVersion v) noexcept { version_ = v; }
+    HttpVersion version() const noexcept { return version_; }
 
-  HttpHeaders *headers() noexcept { return &headers_; }
-  const HttpHeaders *headers() const noexcept { return &headers_; }
+    void set_version(HttpVersion v) noexcept { version_ = v; }
 
-  std::string *body() noexcept {
-    return body_str_ ? &*body_str_ : StringifyBody();
-  }
+    HttpHeaders *headers() noexcept { return &headers_; }
 
-  const std::string *body() const noexcept {
-    return TILE_LIKELY(body_str_) ? &*body_str_ : StringifyBody();
-  }
+    const HttpHeaders *headers() const noexcept { return &headers_; }
 
-  void set_body(std::string s) {
-    body_ = std::nullopt;
-    body_str_ = std::move(s);
-  }
+    std::string *body() noexcept { return body_str_ ? &*body_str_ : StringifyBody(); }
 
-  void set_body(NoncontiguousBuffer &&nb) noexcept {
-    body_str_ = std::nullopt;
-    body_ = std::move(nb);
-  }
+    const std::string *body() const noexcept { return TILE_LIKELY(body_str_) ? &*body_str_ : StringifyBody(); }
 
-  std::size_t body_size() const noexcept {
-    if (TILE_LIKELY(body_str_)) {
-      return body_str_->size();
-    } else if (TILE_LIKELY(body_)) {
-      return body_->ByteSize();
-    } else {
-      return 0;
+    void set_body(std::string s)
+    {
+        body_     = std::nullopt;
+        body_str_ = std::move(s);
     }
-  }
 
-  NoncontiguousBuffer *noncontiguous_body() noexcept {
-    return body_ ? &*body_ : nullptr;
-  }
+    void set_body(NoncontiguousBuffer &&nb) noexcept
+    {
+        body_str_ = std::nullopt;
+        body_     = std::move(nb);
+    }
 
-  const NoncontiguousBuffer *noncontiguous_body() const noexcept {
-    return const_cast<HttpMessage *>(this)->noncontiguous_body();
-  }
+    std::size_t body_size() const noexcept
+    {
+        if (TILE_LIKELY(body_str_)) {
+            return body_str_->size();
+        } else if (TILE_LIKELY(body_)) {
+            return body_->ByteSize();
+        } else {
+            return 0;
+        }
+    }
 
-  void clear() noexcept {
-    headers_.clear();
-    body_str_ = std::nullopt;
-    body_ = std::nullopt;
-  }
+    NoncontiguousBuffer *noncontiguous_body() noexcept { return body_ ? &*body_ : nullptr; }
+
+    const NoncontiguousBuffer *noncontiguous_body() const noexcept
+    {
+        return const_cast<HttpMessage *>(this)->noncontiguous_body();
+    }
+
+    void clear() noexcept
+    {
+        headers_.clear();
+        body_str_ = std::nullopt;
+        body_     = std::nullopt;
+    }
 
 private:
-  std::string *StringifyBody() const;
+    std::string *StringifyBody() const;
 
 private:
-  HttpVersion version_{HttpVersion::Unspecified};
-  HttpHeaders headers_;
+    HttpVersion version_{HttpVersion::Unspecified};
+    HttpHeaders headers_;
 
-  mutable std::optional<std::string> body_str_;
-  std::optional<NoncontiguousBuffer> body_;
+    mutable std::optional<std::string> body_str_;
+    std::optional<NoncontiguousBuffer> body_;
 };
-} // namespace http
-} // namespace tile
+}// namespace http
+}// namespace tile
 
-#endif // _TILE_NET_HTTP_HTTP_MESSAGE_H
+#endif// _TILE_NET_HTTP_HTTP_MESSAGE_H
diff --git a/tile/net/http/http_reqeust_test.cc b/tile/net/http/http_reqeust_test.cc
index abba03b..d83b052 100644
--- a/tile/net/http/http_reqeust_test.cc
+++ b/tile/net/http/http_reqeust_test.cc
@@ -8,103 +8,105 @@
 
 namespace tile {
 
-TEST(HttpRequest, Basic) {
-  HttpRequest req;
+TEST(HttpRequest, Basic)
+{
+    HttpRequest req;
 
-  req.set_method(HttpMethod::Get);
-  req.set_uri("/path/to/something");
+    req.set_method(HttpMethod::Get);
+    req.set_uri("/path/to/something");
 
-  ASSERT_EQ(HttpMethod::Get, req.method());
-  ASSERT_EQ("/path/to/something", req.uri());
+    ASSERT_EQ(HttpMethod::Get, req.method());
+    ASSERT_EQ("/path/to/something", req.uri());
 }
 
-TEST(HttpRequest, Swap) {
-  HttpRequest req1, req2;
+TEST(HttpRequest, Swap)
+{
+    HttpRequest req1, req2;
 
-  req1.set_method(HttpMethod::Get);
-  req1.set_uri("/path/to/something");
-  req2.set_method(HttpMethod::Post);
-  req2.set_uri("/empty");
+    req1.set_method(HttpMethod::Get);
+    req1.set_uri("/path/to/something");
+    req2.set_method(HttpMethod::Post);
+    req2.set_uri("/empty");
 
-  ASSERT_EQ(HttpMethod::Get, req1.method());
-  ASSERT_EQ("/path/to/something", req1.uri());
-  ASSERT_EQ(HttpMethod::Post, req2.method());
-  ASSERT_EQ("/empty", req2.uri());
+    ASSERT_EQ(HttpMethod::Get, req1.method());
+    ASSERT_EQ("/path/to/something", req1.uri());
+    ASSERT_EQ(HttpMethod::Post, req2.method());
+    ASSERT_EQ("/empty", req2.uri());
 
-  std::swap(req1, req2);
+    std::swap(req1, req2);
 
-  ASSERT_EQ(HttpMethod::Get, req2.method());
-  ASSERT_EQ("/path/to/something", req2.uri());
-  ASSERT_EQ(HttpMethod::Post, req1.method());
-  ASSERT_EQ("/empty", req1.uri());
+    ASSERT_EQ(HttpMethod::Get, req2.method());
+    ASSERT_EQ("/path/to/something", req2.uri());
+    ASSERT_EQ(HttpMethod::Post, req1.method());
+    ASSERT_EQ("/empty", req1.uri());
 }
 
-TEST(HttpRequest, Parsed) {
-  static const auto kMsg =
-      "GET / HTTP/1.1\r\n"
-      "Accept-Language: zh-cn,zh-hk,zh-tw,en-us\r\n"
-      "User-Agent: Sosospider+(+http://help.soso.com/webspider.htm)\r\n"
-      "Accept-Encoding: gzip\r\n"
-      "Connection: Keep-Alive\r\n"
-      "Host: 192.0.2.1\r\n"
-      "\r\n";
-  auto buffer = CreateBufferSlow(kMsg);
+TEST(HttpRequest, Parsed)
+{
+    static const auto kMsg =
+        "GET / HTTP/1.1\r\n"
+        "Accept-Language: zh-cn,zh-hk,zh-tw,en-us\r\n"
+        "User-Agent: Sosospider+(+http://help.soso.com/webspider.htm)\r\n"
+        "Accept-Encoding: gzip\r\n"
+        "Connection: Keep-Alive\r\n"
+        "Host: 192.0.2.1\r\n"
+        "\r\n";
+    auto buffer = CreateBufferSlow(kMsg);
 
-  http::HeaderBlock block;
-  ASSERT_EQ(http::ReadStatus::OK, http::ReadHeader(buffer, &block));
+    http::HeaderBlock block;
+    ASSERT_EQ(http::ReadStatus::OK, http::ReadHeader(buffer, &block));
 
-  Slice start_line;
-  HttpVersion version;
-  HttpMethod method;
-  Slice uri;
-  HttpRequest req;
+    Slice start_line;
+    HttpVersion version;
+    HttpMethod method;
+    Slice uri;
+    HttpRequest req;
 
-  ASSERT_TRUE(
-      http::ParseMessagePartial(std::move(block), &start_line, req.headers()));
-  ASSERT_TRUE(http::ParseRequestStartLine(start_line, &version, &method, &uri));
-  req.set_method(method);
-  req.set_uri(std::string(uri));
+    ASSERT_TRUE(http::ParseMessagePartial(std::move(block), &start_line, req.headers()));
+    ASSERT_TRUE(http::ParseRequestStartLine(start_line, &version, &method, &uri));
+    req.set_method(method);
+    req.set_uri(std::string(uri));
 
-  ASSERT_EQ("Sosospider+(+http://help.soso.com/webspider.htm)",
-            *req.headers()->TryGet("User-Agent"));
-  ASSERT_EQ(HttpMethod::Get, req.method());
+    ASSERT_EQ("Sosospider+(+http://help.soso.com/webspider.htm)", *req.headers()->TryGet("User-Agent"));
+    ASSERT_EQ(HttpMethod::Get, req.method());
 }
 
-TEST(HttpRequest, ParseHttp10) {
-  static const auto kMsg = "GET / HTTP/1.0\r\n"
-                           "\r\n";
-  auto buffer = CreateBufferSlow(kMsg);
+TEST(HttpRequest, ParseHttp10)
+{
+    static const auto kMsg = "GET / HTTP/1.0\r\n"
+                             "\r\n";
+    auto buffer            = CreateBufferSlow(kMsg);
 
-  http::HeaderBlock block;
-  ASSERT_EQ(http::ReadStatus::OK, http::ReadHeader(buffer, &block));
+    http::HeaderBlock block;
+    ASSERT_EQ(http::ReadStatus::OK, http::ReadHeader(buffer, &block));
 
-  Slice start_line;
-  HttpVersion version;
-  HttpMethod method;
-  Slice uri;
-  HttpRequest req;
+    Slice start_line;
+    HttpVersion version;
+    HttpMethod method;
+    Slice uri;
+    HttpRequest req;
 
-  ASSERT_TRUE(
-      http::ParseMessagePartial(std::move(block), &start_line, req.headers()));
-  ASSERT_TRUE(http::ParseRequestStartLine(start_line, &version, &method, &uri));
+    ASSERT_TRUE(http::ParseMessagePartial(std::move(block), &start_line, req.headers()));
+    ASSERT_TRUE(http::ParseRequestStartLine(start_line, &version, &method, &uri));
 
-  EXPECT_EQ(HttpVersion::V_1_0, version);
+    EXPECT_EQ(HttpVersion::V_1_0, version);
 }
 
-TEST(HttpRequest, ToString) {
-  HttpRequest req;
+TEST(HttpRequest, ToString)
+{
+    HttpRequest req;
 
-  req.set_version(HttpVersion::V_1_1);
-  req.set_uri("/path/to/home");
-  req.set_method(HttpMethod::Put);
-  req.headers()->Append("Hello", "World");
-  req.set_body(CreateBufferSlow("something"));
+    req.set_version(HttpVersion::V_1_1);
+    req.set_uri("/path/to/home");
+    req.set_method(HttpMethod::Put);
+    req.headers()->Append("Hello", "World");
+    req.set_body(CreateBufferSlow("something"));
 
-  EXPECT_EQ("PUT /path/to/home HTTP/1.1\r\n"
-            "Hello: World\r\n"
-            "\r\n"
-            "something",
-            req.ToString());
+    EXPECT_EQ("PUT /path/to/home HTTP/1.1\r\n"
+              "Hello: World\r\n"
+              "\r\n"
+              "something",
+              req.ToString());
 }
 
-} // namespace tile
+}// namespace tile
diff --git a/tile/net/http/http_request.cc b/tile/net/http/http_request.cc
index d00615e..80efa2e 100644
--- a/tile/net/http/http_request.cc
+++ b/tile/net/http/http_request.cc
@@ -1,23 +1,29 @@
 #include "tile/net/http/http_request.h"
 
 namespace tile {
-void HttpRequest::clear() noexcept { HttpMessage::clear(); }
-
-std::string HttpRequest::ToString() const {
-  std::string result;
-  result += Format("{} {} {}\r\n", ToSlice(method_), uri_, ToSlice(version()));
-  for (auto header : *headers()) {
-    auto &&key = header.first;
-    auto &&value = header.second;
-    result += Format("{}: {}\r\n", key, value);
-  }
-
-  result += "\r\n";
-  if (auto ptr = noncontiguous_body()) {
-    result += FlattenSlow(*ptr);
-  } else {
-    result += *body();
-  }
-  return result;
+void
+HttpRequest::clear() noexcept
+{
+    HttpMessage::clear();
 }
-} // namespace tile
+
+std::string
+HttpRequest::ToString() const
+{
+    std::string result;
+    result += Format("{} {} {}\r\n", ToSlice(method_), uri_, ToSlice(version()));
+    for (auto header : *headers()) {
+        auto &&key   = header.first;
+        auto &&value = header.second;
+        result += Format("{}: {}\r\n", key, value);
+    }
+
+    result += "\r\n";
+    if (auto ptr = noncontiguous_body()) {
+        result += FlattenSlow(*ptr);
+    } else {
+        result += *body();
+    }
+    return result;
+}
+}// namespace tile
diff --git a/tile/net/http/http_request.h b/tile/net/http/http_request.h
index cea9a13..82f4eea 100644
--- a/tile/net/http/http_request.h
+++ b/tile/net/http/http_request.h
@@ -10,29 +10,31 @@
 namespace tile {
 class HttpRequest : private http::HttpMessage {
 public:
-  using HttpMessage::set_version;
-  using HttpMessage::version;
+    using HttpMessage::set_version;
+    using HttpMessage::version;
 
-  HttpMethod method() const noexcept { return method_; }
-  void set_method(HttpMethod m) noexcept { method_ = m; }
+    HttpMethod method() const noexcept { return method_; }
 
-  const std::string &uri() const noexcept { return uri_; }
-  void set_uri(std::string u) { uri_ = std::move(u); }
+    void set_method(HttpMethod m) noexcept { method_ = m; }
 
-  using HttpMessage::body;
-  using HttpMessage::body_size;
-  using HttpMessage::headers;
-  using HttpMessage::noncontiguous_body;
-  using HttpMessage::set_body;
+    const std::string &uri() const noexcept { return uri_; }
 
-  void clear() noexcept;
+    void set_uri(std::string u) { uri_ = std::move(u); }
 
-  std::string ToString() const;
+    using HttpMessage::body;
+    using HttpMessage::body_size;
+    using HttpMessage::headers;
+    using HttpMessage::noncontiguous_body;
+    using HttpMessage::set_body;
+
+    void clear() noexcept;
+
+    std::string ToString() const;
 
 private:
-  HttpMethod method_{HttpMethod::Unspecified};
-  std::string uri_;
+    HttpMethod method_{HttpMethod::Unspecified};
+    std::string uri_;
 };
-} // namespace tile
+}// namespace tile
 
-#endif // TILE_NET_HTTP_HTTP_REQUEST_H
+#endif// TILE_NET_HTTP_HTTP_REQUEST_H
diff --git a/tile/net/http/http_response.cc b/tile/net/http/http_response.cc
index 3cae4e0..01236ae 100644
--- a/tile/net/http/http_response.cc
+++ b/tile/net/http/http_response.cc
@@ -7,144 +7,153 @@
 
 namespace tile {
 namespace {
-static std::array<Slice, 600> GenStatusCodeDescArray() {
-  std::array<Slice, 600> descs;
-  descs[100] = "100 Continue";
-  descs[101] = "101 Switching Protocols";
-  descs[103] = "103 Early Hints";
-  descs[200] = "200 OK";
-  descs[201] = "201 Created";
-  descs[202] = "202 Accepted";
-  descs[203] = "203 Non-Authoritative Information";
-  descs[204] = "204 No Content";
-  descs[205] = "205 Reset Content";
-  descs[206] = "206 Partial Content";
-  descs[300] = "300 Multiple Choices";
-  descs[301] = "301 Moved Permanently";
-  descs[302] = "302 Found";
-  descs[303] = "303 See Other";
-  descs[304] = "304 Not Modified";
-  descs[307] = "307 Temporary Redirect";
-  descs[308] = "308 Permanent Redirect";
-  descs[400] = "400 Bad Request";
-  descs[401] = "401 Unauthorized";
-  descs[402] = "402 Payment Required";
-  descs[403] = "403 Forbidden";
-  descs[404] = "404 Not Found";
-  descs[405] = "405 Method Not Allowed";
-  descs[406] = "406 Not Acceptable";
-  descs[407] = "407 Proxy Authentication Required";
-  descs[408] = "408 Request Timeout";
-  descs[409] = "409 Conflict";
-  descs[410] = "410 Gone";
-  descs[411] = "411 Length Required";
-  descs[412] = "412 Precondition Failed";
-  descs[413] = "413 Payload Too Large";
-  descs[414] = "414 URI Too Long";
-  descs[415] = "415 Unsupported Media Type";
-  descs[416] = "416 Range Not Satisfiable";
-  descs[417] = "417 Expectation Failed";
-  descs[418] = "418 I'm a teapot";
-  descs[422] = "422 Unprocessable Entity";
-  descs[425] = "425 Too Early";
-  descs[426] = "426 Upgrade Required";
-  descs[428] = "428 Precondition Required";
-  descs[429] = "429 Too Many Requests";
-  descs[431] = "431 Request Header Fields Too Large";
-  descs[451] = "451 Unavailable For Legal Reasons";
-  descs[500] = "500 Internal Server Error";
-  descs[501] = "501 Not Implemented";
-  descs[502] = "502 Bad Gateway";
-  descs[503] = "503 Service Unavailable";
-  descs[504] = "504 Gateway Timeout";
-  descs[505] = "505 HTTP Version Not Supported";
-  descs[506] = "506 Variant Also Negotiates";
-  descs[507] = "507 Insufficient Storage";
-  descs[508] = "508 Loop Detected";
-  descs[510] = "510 Not Extended";
-  descs[511] = "511 Network Authentication Required";
-  return descs;
+static std::array<Slice, 600>
+GenStatusCodeDescArray()
+{
+    std::array<Slice, 600> descs;
+    descs[100] = "100 Continue";
+    descs[101] = "101 Switching Protocols";
+    descs[103] = "103 Early Hints";
+    descs[200] = "200 OK";
+    descs[201] = "201 Created";
+    descs[202] = "202 Accepted";
+    descs[203] = "203 Non-Authoritative Information";
+    descs[204] = "204 No Content";
+    descs[205] = "205 Reset Content";
+    descs[206] = "206 Partial Content";
+    descs[300] = "300 Multiple Choices";
+    descs[301] = "301 Moved Permanently";
+    descs[302] = "302 Found";
+    descs[303] = "303 See Other";
+    descs[304] = "304 Not Modified";
+    descs[307] = "307 Temporary Redirect";
+    descs[308] = "308 Permanent Redirect";
+    descs[400] = "400 Bad Request";
+    descs[401] = "401 Unauthorized";
+    descs[402] = "402 Payment Required";
+    descs[403] = "403 Forbidden";
+    descs[404] = "404 Not Found";
+    descs[405] = "405 Method Not Allowed";
+    descs[406] = "406 Not Acceptable";
+    descs[407] = "407 Proxy Authentication Required";
+    descs[408] = "408 Request Timeout";
+    descs[409] = "409 Conflict";
+    descs[410] = "410 Gone";
+    descs[411] = "411 Length Required";
+    descs[412] = "412 Precondition Failed";
+    descs[413] = "413 Payload Too Large";
+    descs[414] = "414 URI Too Long";
+    descs[415] = "415 Unsupported Media Type";
+    descs[416] = "416 Range Not Satisfiable";
+    descs[417] = "417 Expectation Failed";
+    descs[418] = "418 I'm a teapot";
+    descs[422] = "422 Unprocessable Entity";
+    descs[425] = "425 Too Early";
+    descs[426] = "426 Upgrade Required";
+    descs[428] = "428 Precondition Required";
+    descs[429] = "429 Too Many Requests";
+    descs[431] = "431 Request Header Fields Too Large";
+    descs[451] = "451 Unavailable For Legal Reasons";
+    descs[500] = "500 Internal Server Error";
+    descs[501] = "501 Not Implemented";
+    descs[502] = "502 Bad Gateway";
+    descs[503] = "503 Service Unavailable";
+    descs[504] = "504 Gateway Timeout";
+    descs[505] = "505 HTTP Version Not Supported";
+    descs[506] = "506 Variant Also Negotiates";
+    descs[507] = "507 Insufficient Storage";
+    descs[508] = "508 Loop Detected";
+    descs[510] = "510 Not Extended";
+    descs[511] = "511 Network Authentication Required";
+    return descs;
 }
 
-static std::array<Slice, 600> *GetStatusCodeWithDescArray() {
-  static std::array<Slice, 600> kDescArray = GenStatusCodeDescArray();
-  return &kDescArray;
+static std::array<Slice, 600> *
+GetStatusCodeWithDescArray()
+{
+    static std::array<Slice, 600> kDescArray = GenStatusCodeDescArray();
+    return &kDescArray;
 }
 
-} // namespace
+}// namespace
 
-void HttpResponse::clear() noexcept {
-  HttpMessage::clear();
-  status_ = HttpStatus::OK;
+void
+HttpResponse::clear() noexcept
+{
+    HttpMessage::clear();
+    status_ = HttpStatus::OK;
 }
 
-std::string HttpResponse::ToString() const {
-  std::string result;
+std::string
+HttpResponse::ToString() const
+{
+    std::string result;
 
-  result += Format("{} {} {}\r\n", ToSlice(version()),
-                   underlying_value(status_), ToSlice(status_));
-  for (auto header : *headers()) {
-    auto &&key = header.first;
-    auto &&value = header.second;
-    result += Format("{}: {}\r\n", key, value);
-  }
-
-  result += "\r\n";
-  if (auto ptr = noncontiguous_body()) {
-    result += FlattenSlow(*ptr);
-  } else {
-    result += *body();
-  }
-
-  return result;
-}
-
-void GenerateDefaultResponsePage(HttpStatus status, HttpResponse *response,
-                                 Slice title, Slice body) {
-  response->set_status(status);
-  response->headers()->Append("Content-Type", "text/html");
-  std::string html_body;
-  html_body.assign("<html>\n");
-
-  // add title
-  {
-    html_body.append("<head>\n<title>");
-    if (!title.empty()) {
-      html_body.append(title);
-    } else {
-      html_body.append(
-          Format("HTTP {}", http::GetStatusCodeWithDescString(status)));
+    result += Format("{} {} {}\r\n", ToSlice(version()), underlying_value(status_), ToSlice(status_));
+    for (auto header : *headers()) {
+        auto &&key   = header.first;
+        auto &&value = header.second;
+        result += Format("{}: {}\r\n", key, value);
     }
 
-    html_body.append("</title>\n</head>\n");
-  }
-
-  // add body
-  {
-
-    html_body.append("<body>");
-    if (!body.empty()) {
-      html_body.append(body);
+    result += "\r\n";
+    if (auto ptr = noncontiguous_body()) {
+        result += FlattenSlow(*ptr);
     } else {
-      html_body.append(Format("{}", http::GetStatusCodeWithDescString(status)));
+        result += *body();
     }
-    html_body.append("</body>\n");
-  }
-  html_body.append("</html>\n");
 
-  response->set_body(html_body);
+    return result;
+}
+
+void
+GenerateDefaultResponsePage(HttpStatus status, HttpResponse *response, Slice title, Slice body)
+{
+    response->set_status(status);
+    response->headers()->Append("Content-Type", "text/html");
+    std::string html_body;
+    html_body.assign("<html>\n");
+
+    // add title
+    {
+        html_body.append("<head>\n<title>");
+        if (!title.empty()) {
+            html_body.append(title);
+        } else {
+            html_body.append(Format("HTTP {}", http::GetStatusCodeWithDescString(status)));
+        }
+
+        html_body.append("</title>\n</head>\n");
+    }
+
+    // add body
+    {
+
+        html_body.append("<body>");
+        if (!body.empty()) {
+            html_body.append(body);
+        } else {
+            html_body.append(Format("{}", http::GetStatusCodeWithDescString(status)));
+        }
+        html_body.append("</body>\n");
+    }
+    html_body.append("</html>\n");
+
+    response->set_body(html_body);
 }
 
 namespace http {
-Slice GetStatusCodeWithDescString(HttpStatus status) noexcept {
-  auto v = underlying_value(status);
-  if (TILE_UNLIKELY(v < 0 || v > GetStatusCodeWithDescArray()->size())) {
-    return internal::EarlyInitConstant<Slice>();
-  }
+Slice
+GetStatusCodeWithDescString(HttpStatus status) noexcept
+{
+    auto v = underlying_value(status);
+    if (TILE_UNLIKELY(v < 0 || v > GetStatusCodeWithDescArray()->size())) {
+        return internal::EarlyInitConstant<Slice>();
+    }
 
-  return (*GetStatusCodeWithDescArray())[v];
+    return (*GetStatusCodeWithDescArray())[v];
 }
 
-} // namespace http
+}// namespace http
 
-} // namespace tile
+}// namespace tile
diff --git a/tile/net/http/http_response.h b/tile/net/http/http_response.h
index 8c144f7..1e8c168 100644
--- a/tile/net/http/http_response.h
+++ b/tile/net/http/http_response.h
@@ -10,32 +10,32 @@
 namespace tile {
 class HttpResponse : private http::HttpMessage {
 public:
-  using HttpMessage::set_version;
-  using HttpMessage::version;
+    using HttpMessage::set_version;
+    using HttpMessage::version;
 
-  HttpStatus status() const noexcept { return status_; }
-  void set_status(HttpStatus s) noexcept { status_ = s; }
+    HttpStatus status() const noexcept { return status_; }
 
-  using HttpMessage::body;
-  using HttpMessage::body_size;
-  using HttpMessage::headers;
-  using HttpMessage::noncontiguous_body;
-  using HttpMessage::set_body;
+    void set_status(HttpStatus s) noexcept { status_ = s; }
 
-  void clear() noexcept;
-  std::string ToString() const;
+    using HttpMessage::body;
+    using HttpMessage::body_size;
+    using HttpMessage::headers;
+    using HttpMessage::noncontiguous_body;
+    using HttpMessage::set_body;
+
+    void clear() noexcept;
+    std::string ToString() const;
 
 private:
-  HttpStatus status_{HttpStatus::OK};
+    HttpStatus status_{HttpStatus::OK};
 };
 
-void GenerateDefaultResponsePage(HttpStatus status, HttpResponse *response,
-                                 Slice title = "", Slice body = "");
+void GenerateDefaultResponsePage(HttpStatus status, HttpResponse *response, Slice title = "", Slice body = "");
 
 namespace http {
 Slice GetStatusCodeWithDescString(HttpStatus status) noexcept;
 }
 
-} // namespace tile
+}// namespace tile
 
-#endif // TILE_NET_HTTP_HTTP_RESPONSE_H
+#endif// TILE_NET_HTTP_HTTP_RESPONSE_H
diff --git a/tile/net/http/http_response_test.cc b/tile/net/http/http_response_test.cc
index 3f4df74..fe81b34 100644
--- a/tile/net/http/http_response_test.cc
+++ b/tile/net/http/http_response_test.cc
@@ -11,73 +11,77 @@
 
 namespace tile {
 
-TEST(HttpResponse, Basic) {
-  HttpResponse resp;
+TEST(HttpResponse, Basic)
+{
+    HttpResponse resp;
 
-  resp.set_status(HttpStatus::OK);
-  ASSERT_EQ(HttpStatus::OK, resp.status());
+    resp.set_status(HttpStatus::OK);
+    ASSERT_EQ(HttpStatus::OK, resp.status());
 }
 
-TEST(HttpResponse, Swap) {
-  HttpResponse resp1, resp2;
+TEST(HttpResponse, Swap)
+{
+    HttpResponse resp1, resp2;
 
-  resp1.set_status(HttpStatus::OK);
-  resp2.set_status(HttpStatus::NotFound);
-  ASSERT_EQ(HttpStatus::OK, resp1.status());
-  ASSERT_EQ(HttpStatus::NotFound, resp2.status());
+    resp1.set_status(HttpStatus::OK);
+    resp2.set_status(HttpStatus::NotFound);
+    ASSERT_EQ(HttpStatus::OK, resp1.status());
+    ASSERT_EQ(HttpStatus::NotFound, resp2.status());
 
-  std::swap(resp1, resp2);
-  ASSERT_EQ(HttpStatus::OK, resp2.status());
-  ASSERT_EQ(HttpStatus::NotFound, resp1.status());
+    std::swap(resp1, resp2);
+    ASSERT_EQ(HttpStatus::OK, resp2.status());
+    ASSERT_EQ(HttpStatus::NotFound, resp1.status());
 }
 
-TEST(HttpResponse, Parsed) {
-  static const auto kHeader = "HTTP/1.1 200 OK\r\n"
-                              "Date: Mon, 16 Jan 2012 06:41:37 GMT\r\n"
-                              "Server: Apache/2.2.21 (Unix)\r\n"
-                              "Last-Modified: Wed, 11 Jan 2012 09:15:13 GMT\r\n"
-                              "Accept-Ranges: bytes\r\n"
-                              "Content-Length: 45\r\n"
-                              "Keep-Alive: timeout=5, max=100\r\n"
-                              "Connection: Keep-Alive\r\n"
-                              "Content-Type: text/html\r\n"
-                              "\r\n";
-  static const auto kMsg = kHeader + std::string(45, 'a');
-  auto buffer = CreateBufferSlow(kMsg);
+TEST(HttpResponse, Parsed)
+{
+    static const auto kHeader =
+        "HTTP/1.1 200 OK\r\n"
+        "Date: Mon, 16 Jan 2012 06:41:37 GMT\r\n"
+        "Server: Apache/2.2.21 (Unix)\r\n"
+        "Last-Modified: Wed, 11 Jan 2012 09:15:13 GMT\r\n"
+        "Accept-Ranges: bytes\r\n"
+        "Content-Length: 45\r\n"
+        "Keep-Alive: timeout=5, max=100\r\n"
+        "Connection: Keep-Alive\r\n"
+        "Content-Type: text/html\r\n"
+        "\r\n";
+    static const auto kMsg = kHeader + std::string(45, 'a');
+    auto buffer            = CreateBufferSlow(kMsg);
 
-  http::HeaderBlock block;
-  ASSERT_EQ(http::ReadStatus::OK, http::ReadHeader(buffer, &block));
-  buffer.Skip(block.second);
+    http::HeaderBlock block;
+    ASSERT_EQ(http::ReadStatus::OK, http::ReadHeader(buffer, &block));
+    buffer.Skip(block.second);
 
-  Slice start_line;
-  HttpStatus status;
-  HttpResponse resp;
+    Slice start_line;
+    HttpStatus status;
+    HttpResponse resp;
 
-  ASSERT_TRUE(
-      http::ParseMessagePartial(std::move(block), &start_line, resp.headers()));
-  ASSERT_TRUE(http::ParseResponseStartLine(start_line, &status));
-  resp.set_status(status);
-  resp.set_body(std::move(buffer));
+    ASSERT_TRUE(http::ParseMessagePartial(std::move(block), &start_line, resp.headers()));
+    ASSERT_TRUE(http::ParseResponseStartLine(start_line, &status));
+    resp.set_status(status);
+    resp.set_body(std::move(buffer));
 
-  ASSERT_EQ(HttpStatus::OK, resp.status());
-  ASSERT_EQ("Mon, 16 Jan 2012 06:41:37 GMT", *resp.headers()->TryGet("Date"));
-  ASSERT_EQ(45, *resp.headers()->TryGet<int>("Content-Length"));
-  ASSERT_EQ(std::string(45, 'a'), *resp.body());
+    ASSERT_EQ(HttpStatus::OK, resp.status());
+    ASSERT_EQ("Mon, 16 Jan 2012 06:41:37 GMT", *resp.headers()->TryGet("Date"));
+    ASSERT_EQ(45, *resp.headers()->TryGet<int>("Content-Length"));
+    ASSERT_EQ(std::string(45, 'a'), *resp.body());
 }
 
-TEST(HttpResponse, ToString) {
-  HttpResponse resp;
+TEST(HttpResponse, ToString)
+{
+    HttpResponse resp;
 
-  resp.set_version(HttpVersion::V_1_1);
-  resp.set_status(HttpStatus::ImATeapot);
-  resp.headers()->Append("Hello", "World");
-  resp.set_body(CreateBufferSlow("something"));
+    resp.set_version(HttpVersion::V_1_1);
+    resp.set_status(HttpStatus::ImATeapot);
+    resp.headers()->Append("Hello", "World");
+    resp.set_body(CreateBufferSlow("something"));
 
-  EXPECT_EQ("HTTP/1.1 418 I'm a teapot\r\n"
-            "Hello: World\r\n"
-            "\r\n"
-            "something",
-            resp.ToString());
+    EXPECT_EQ("HTTP/1.1 418 I'm a teapot\r\n"
+              "Hello: World\r\n"
+              "\r\n"
+              "something",
+              resp.ToString());
 }
 
-} // namespace tile
+}// namespace tile
diff --git a/tile/net/http/packet_desc.h b/tile/net/http/packet_desc.h
index 0789581..416f772 100644
--- a/tile/net/http/packet_desc.h
+++ b/tile/net/http/packet_desc.h
@@ -7,7 +7,7 @@
 #include "tile/net/http/http_response.h"
 
 namespace tile {
-namespace http {} // namespace http
-} // namespace tile
+namespace http {}// namespace http
+}// namespace tile
 
-#endif // TILE_NET_HTTP_PACKET_DESC_H
+#endif// TILE_NET_HTTP_PACKET_DESC_H
diff --git a/tile/net/http/types.cc b/tile/net/http/types.cc
index d99ca67..0fe46b5 100644
--- a/tile/net/http/types.cc
+++ b/tile/net/http/types.cc
@@ -25,77 +25,78 @@ namespace tile {
 
 namespace {
 
-const std::array<Slice, 600> GetStatusCodes() {
-  static std::array<Slice, 600> descs;
-  std::once_flag flag;
-  std::call_once(flag, [&] {
-    descs[100] = "Continue";
-    descs[101] = "Switching Protocols";
-    descs[103] = "Early Hints";
-    descs[200] = "OK";
-    descs[201] = "Created";
-    descs[202] = "Accepted";
-    descs[203] = "Non-Authoritative Information";
-    descs[204] = "No Content";
-    descs[205] = "Reset Content";
-    descs[206] = "Partial Content";
-    descs[300] = "Multiple Choices";
-    descs[301] = "Moved Permanently";
-    descs[302] = "Found";
-    descs[303] = "See Other";
-    descs[304] = "Not Modified";
-    descs[307] = "Temporary Redirect";
-    descs[308] = "Permanent Redirect";
-    descs[400] = "Bad Request";
-    descs[401] = "Unauthorized";
-    descs[402] = "Payment Required";
-    descs[403] = "Forbidden";
-    descs[404] = "Not Found";
-    descs[405] = "Method Not Allowed";
-    descs[406] = "Not Acceptable";
-    descs[407] = "Proxy Authentication Required";
-    descs[408] = "Request Timeout";
-    descs[409] = "Conflict";
-    descs[410] = "Gone";
-    descs[411] = "Length Required";
-    descs[412] = "Precondition Failed";
-    descs[413] = "Payload Too Large";
-    descs[414] = "URI Too Long";
-    descs[415] = "Unsupported Media Type";
-    descs[416] = "Range Not Satisfiable";
-    descs[417] = "Expectation Failed";
-    descs[418] = "I'm a teapot";
-    descs[422] = "Unprocessable Entity";
-    descs[425] = "Too Early";
-    descs[426] = "Upgrade Required";
-    descs[428] = "Precondition Required";
-    descs[429] = "Too Many Requests";
-    descs[431] = "Request Header Fields Too Large";
-    descs[451] = "Unavailable For Legal Reasons";
-    descs[500] = "Internal Server Error";
-    descs[501] = "Not Implemented";
-    descs[502] = "Bad Gateway";
-    descs[503] = "Service Unavailable";
-    descs[504] = "Gateway Timeout";
-    descs[505] = "HTTP Version Not Supported";
-    descs[506] = "Variant Also Negotiates";
-    descs[507] = "Insufficient Storage";
-    descs[508] = "Loop Detected";
-    descs[510] = "Not Extended";
-    descs[511] = "Network Authentication Required";
-  });
-  return descs;
+const std::array<Slice, 600>
+GetStatusCodes()
+{
+    static std::array<Slice, 600> descs;
+    std::once_flag flag;
+    std::call_once(flag, [&] {
+        descs[100] = "Continue";
+        descs[101] = "Switching Protocols";
+        descs[103] = "Early Hints";
+        descs[200] = "OK";
+        descs[201] = "Created";
+        descs[202] = "Accepted";
+        descs[203] = "Non-Authoritative Information";
+        descs[204] = "No Content";
+        descs[205] = "Reset Content";
+        descs[206] = "Partial Content";
+        descs[300] = "Multiple Choices";
+        descs[301] = "Moved Permanently";
+        descs[302] = "Found";
+        descs[303] = "See Other";
+        descs[304] = "Not Modified";
+        descs[307] = "Temporary Redirect";
+        descs[308] = "Permanent Redirect";
+        descs[400] = "Bad Request";
+        descs[401] = "Unauthorized";
+        descs[402] = "Payment Required";
+        descs[403] = "Forbidden";
+        descs[404] = "Not Found";
+        descs[405] = "Method Not Allowed";
+        descs[406] = "Not Acceptable";
+        descs[407] = "Proxy Authentication Required";
+        descs[408] = "Request Timeout";
+        descs[409] = "Conflict";
+        descs[410] = "Gone";
+        descs[411] = "Length Required";
+        descs[412] = "Precondition Failed";
+        descs[413] = "Payload Too Large";
+        descs[414] = "URI Too Long";
+        descs[415] = "Unsupported Media Type";
+        descs[416] = "Range Not Satisfiable";
+        descs[417] = "Expectation Failed";
+        descs[418] = "I'm a teapot";
+        descs[422] = "Unprocessable Entity";
+        descs[425] = "Too Early";
+        descs[426] = "Upgrade Required";
+        descs[428] = "Precondition Required";
+        descs[429] = "Too Many Requests";
+        descs[431] = "Request Header Fields Too Large";
+        descs[451] = "Unavailable For Legal Reasons";
+        descs[500] = "Internal Server Error";
+        descs[501] = "Not Implemented";
+        descs[502] = "Bad Gateway";
+        descs[503] = "Service Unavailable";
+        descs[504] = "Gateway Timeout";
+        descs[505] = "HTTP Version Not Supported";
+        descs[506] = "Variant Also Negotiates";
+        descs[507] = "Insufficient Storage";
+        descs[508] = "Loop Detected";
+        descs[510] = "Not Extended";
+        descs[511] = "Network Authentication Required";
+    });
+    return descs;
 };
 
-Slice kStringizedVersion[] = {"(Unspecified)", "HTTP/1.0", "HTTP/1.1", "HTTP/2",
-                              "HTTP/3"};
+Slice kStringizedVersion[] = {"(Unspecified)", "HTTP/1.0", "HTTP/1.1", "HTTP/2", "HTTP/3"};
 
 const std::unordered_map<Slice, HttpVersion> kVersionEnumerators = {
     {"(Unspecified)", HttpVersion::Unspecified},
-    {"HTTP/1.0", HttpVersion::V_1_0},
-    {"HTTP/1.1", HttpVersion::V_1_1},
-    {"HTTP/2", HttpVersion::V_2},
-    {"HTTP/3", HttpVersion::V_3},
+    {"HTTP/1.0",      HttpVersion::V_1_0      },
+    {"HTTP/1.1",      HttpVersion::V_1_1      },
+    {"HTTP/2",        HttpVersion::V_2        },
+    {"HTTP/3",        HttpVersion::V_3        },
 };
 
 Slice kStringifiedMethods[] = {
@@ -113,66 +114,74 @@ Slice kStringifiedMethods[] = {
 
 const std::unordered_map<Slice, HttpMethod> kMethodEnumerators = {
     {"UNSPECIFIED", HttpMethod::Unspecified},
-    {"HEAD", HttpMethod::Head},
-    {"GET", HttpMethod::Get},
-    {"POST", HttpMethod::Post},
-    {"PUT", HttpMethod::Put},
-    {"DELETE", HttpMethod::Delete},
-    {"TRACE", HttpMethod::Trace},
-    {"CONNECT", HttpMethod::Connect},
-    {"PATCH", HttpMethod::Patch},
+    {"HEAD",        HttpMethod::Head       },
+    {"GET",         HttpMethod::Get        },
+    {"POST",        HttpMethod::Post       },
+    {"PUT",         HttpMethod::Put        },
+    {"DELETE",      HttpMethod::Delete     },
+    {"TRACE",       HttpMethod::Trace      },
+    {"CONNECT",     HttpMethod::Connect    },
+    {"PATCH",       HttpMethod::Patch      },
 };
 
-} // namespace
+}// namespace
 
-Slice ToSlice(HttpStatus status) noexcept {
-  auto v = underlying_value(status);
-  if (v < 0 || v > sizeof(GetStatusCodes())) {
-    return internal::EarlyInitConstant<Slice>();
-  }
-  return GetStatusCodes()[v];
+Slice
+ToSlice(HttpStatus status) noexcept
+{
+    auto v = underlying_value(status);
+    if (v < 0 || v > sizeof(GetStatusCodes())) { return internal::EarlyInitConstant<Slice>(); }
+    return GetStatusCodes()[v];
 }
 
-Slice ToSlice(HttpVersion version) noexcept {
-  auto index = underlying_value(version);
-  if (index < 0 || index > sizeof(kStringizedVersion)) {
-    return {};
-  }
-  return kStringizedVersion[index];
+Slice
+ToSlice(HttpVersion version) noexcept
+{
+    auto index = underlying_value(version);
+    if (index < 0 || index > sizeof(kStringizedVersion)) { return {}; }
+    return kStringizedVersion[index];
 }
 
-Slice ToSlice(HttpMethod method) noexcept {
-  auto v = underlying_value(method);
-  if (v < 0 || v > sizeof(kStringifiedMethods)) {
-    return {};
-  }
-  return kStringifiedMethods[v];
+Slice
+ToSlice(HttpMethod method) noexcept
+{
+    auto v = underlying_value(method);
+    if (v < 0 || v > sizeof(kStringifiedMethods)) { return {}; }
+    return kStringifiedMethods[v];
 }
 
-std::optional<HttpMethod> TryParseTraits<HttpMethod>::TryParse(Slice s) {
-  auto iter = kMethodEnumerators.find(s);
-  if (iter == kMethodEnumerators.end()) {
-    return std::nullopt;
-  }
-  return iter->second;
+std::optional<HttpMethod>
+TryParseTraits<HttpMethod>::TryParse(Slice s)
+{
+    auto iter = kMethodEnumerators.find(s);
+    if (iter == kMethodEnumerators.end()) { return std::nullopt; }
+    return iter->second;
 }
+
 std::optional<HttpVersion>
-TryParseTraits<HttpVersion>::TryParse(Slice version) {
-  auto iter = kVersionEnumerators.find(version);
-  if (iter == kVersionEnumerators.end()) {
-    return std::nullopt;
-  }
-  return iter->second;
+TryParseTraits<HttpVersion>::TryParse(Slice version)
+{
+    auto iter = kVersionEnumerators.find(version);
+    if (iter == kVersionEnumerators.end()) { return std::nullopt; }
+    return iter->second;
 }
 
-std::ostream &operator<<(std::ostream &os, HttpMethod method) {
-  return os << ToSlice(method);
-}
-std::ostream &operator<<(std::ostream &os, HttpStatus status) {
-  return os << ToSlice(status);
-}
-std::ostream &operator<<(std::ostream &os, HttpVersion version) {
-  return os << ToSlice(version);
+std::ostream &
+operator<<(std::ostream &os, HttpMethod method)
+{
+    return os << ToSlice(method);
 }
 
-} // namespace tile
+std::ostream &
+operator<<(std::ostream &os, HttpStatus status)
+{
+    return os << ToSlice(status);
+}
+
+std::ostream &
+operator<<(std::ostream &os, HttpVersion version)
+{
+    return os << ToSlice(version);
+}
+
+}// namespace tile
diff --git a/tile/net/http/types.h b/tile/net/http/types.h
index 317181e..7f8d3a0 100644
--- a/tile/net/http/types.h
+++ b/tile/net/http/types.h
@@ -5,78 +5,68 @@
 
 #include "tile/base/optional.h"
 #include "tile/base/string.h"
+
 namespace tile {
 enum class HttpVersion { Unspecified, V_1_0, V_1_1, V_2, V_3 };
 
-enum class HttpMethod {
-  Unspecified,
-  Head,
-  Get,
-  Post,
-  Put,
-  Delete,
-  Options,
-  Trace,
-  Connect,
-  Patch
-};
+enum class HttpMethod { Unspecified, Head, Get, Post, Put, Delete, Options, Trace, Connect, Patch };
 
 // @sa: https://developer.mozilla.org/en-US/docs/Web/HTTP/Status
-enum class HttpStatus { // `HttpStatusCode`?
-  Continue = 100,
-  SwitchingProtocols = 101,
-  EarlyHints = 103,
-  OK = 200,
-  Created = 201,
-  Accepted = 202,
-  NonAuthoritativeInformation = 203,
-  NoContent = 204,
-  ResetContent = 205,
-  PartialContent = 206,
-  MultipleChoices = 300,
-  MovedPermanently = 301,
-  Found = 302,
-  SeeOther = 303,
-  NotModified = 304,
-  TemporaryRedirect = 307,
-  PermanentRedirect = 308,
-  BadRequest = 400,
-  Unauthorized = 401,
-  PaymentRequired = 402,
-  Forbidden = 403,
-  NotFound = 404,
-  MethodNotAllowed = 405,
-  NotAcceptable = 406,
-  ProxyAuthenticationRequired = 407,
-  RequestTimeout = 408,
-  Conflict = 409,
-  Gone = 410,
-  LengthRequired = 411,
-  PreconditionFailed = 412,
-  PayloadTooLarge = 413,
-  URITooLong = 414,
-  UnsupportedMediaType = 415,
-  RangeNotSatisfiable = 416,
-  ExpectationFailed = 417,
-  ImATeapot = 418, // No you're not.
-  UnprocessableEntity = 422,
-  TooEarly = 425,
-  UpgradeRequired = 426,
-  PreconditionRequired = 428,
-  TooManyRequests = 429,
-  RequestHeaderFieldsTooLarge = 431,
-  UnavailableForLegalReasons = 451,
-  InternalServerError = 500,
-  NotImplemented = 501,
-  BadGateway = 502,
-  ServiceUnavailable = 503,
-  GatewayTimeout = 504,
-  HTTPVersionNotSupported = 505,
-  VariantAlsoNegotiates = 506,
-  InsufficientStorage = 507,
-  LoopDetected = 508,
-  NotExtended = 510,
-  NetworkAuthenticationRequired = 511
+enum class HttpStatus {// `HttpStatusCode`?
+    Continue                      = 100,
+    SwitchingProtocols            = 101,
+    EarlyHints                    = 103,
+    OK                            = 200,
+    Created                       = 201,
+    Accepted                      = 202,
+    NonAuthoritativeInformation   = 203,
+    NoContent                     = 204,
+    ResetContent                  = 205,
+    PartialContent                = 206,
+    MultipleChoices               = 300,
+    MovedPermanently              = 301,
+    Found                         = 302,
+    SeeOther                      = 303,
+    NotModified                   = 304,
+    TemporaryRedirect             = 307,
+    PermanentRedirect             = 308,
+    BadRequest                    = 400,
+    Unauthorized                  = 401,
+    PaymentRequired               = 402,
+    Forbidden                     = 403,
+    NotFound                      = 404,
+    MethodNotAllowed              = 405,
+    NotAcceptable                 = 406,
+    ProxyAuthenticationRequired   = 407,
+    RequestTimeout                = 408,
+    Conflict                      = 409,
+    Gone                          = 410,
+    LengthRequired                = 411,
+    PreconditionFailed            = 412,
+    PayloadTooLarge               = 413,
+    URITooLong                    = 414,
+    UnsupportedMediaType          = 415,
+    RangeNotSatisfiable           = 416,
+    ExpectationFailed             = 417,
+    ImATeapot                     = 418,// No you're not.
+    UnprocessableEntity           = 422,
+    TooEarly                      = 425,
+    UpgradeRequired               = 426,
+    PreconditionRequired          = 428,
+    TooManyRequests               = 429,
+    RequestHeaderFieldsTooLarge   = 431,
+    UnavailableForLegalReasons    = 451,
+    InternalServerError           = 500,
+    NotImplemented                = 501,
+    BadGateway                    = 502,
+    ServiceUnavailable            = 503,
+    GatewayTimeout                = 504,
+    HTTPVersionNotSupported       = 505,
+    VariantAlsoNegotiates         = 506,
+    InsufficientStorage           = 507,
+    LoopDetected                  = 508,
+    NotExtended                   = 510,
+    NetworkAuthenticationRequired = 511
 };
 
 // AllHttpStatus for for_each
@@ -105,18 +95,20 @@ Slice ToSlice(HttpVersion method) noexcept;
 Slice ToSlice(HttpMethod) noexcept;
 Slice ToSlice(HttpStatus status) noexcept;
 
-template <> struct TryParseTraits<HttpMethod> {
-  static std::optional<HttpMethod> TryParse(Slice s);
+template<>
+struct TryParseTraits<HttpMethod> {
+    static std::optional<HttpMethod> TryParse(Slice s);
 };
 
-template <> struct TryParseTraits<HttpVersion> {
-  static std::optional<HttpVersion> TryParse(Slice s);
+template<>
+struct TryParseTraits<HttpVersion> {
+    static std::optional<HttpVersion> TryParse(Slice s);
 };
 
 std::ostream &operator<<(std::ostream &os, HttpMethod method);
 std::ostream &operator<<(std::ostream &os, HttpStatus status);
 std::ostream &operator<<(std::ostream &os, HttpVersion version);
 
-} // namespace tile
+}// namespace tile
 
-#endif // _TILE_NET_HTTP_TYPES_H
+#endif// _TILE_NET_HTTP_TYPES_H
diff --git a/tile/net/internal/http_engine.cc b/tile/net/internal/http_engine.cc
index 4296278..f833934 100644
--- a/tile/net/internal/http_engine.cc
+++ b/tile/net/internal/http_engine.cc
@@ -11,84 +11,80 @@
 #include <fcntl.h>
 #include <unistd.h>
 
-DEFINE_int32(tile_http_engine_workers_per_scheduling_group, 1,
-             "http engine background workers per scheduling group");
-DEFINE_int32(tile_http_engine_max_connections_per_host_per_worker, 50,
-             "max connections per host per worker");
-DEFINE_int32(tile_http_engine_max_total_connections_per_worker, 200,
-             "max total connections per worker");
+DEFINE_int32(tile_http_engine_workers_per_scheduling_group, 1, "http engine background workers per scheduling group");
+DEFINE_int32(tile_http_engine_max_connections_per_host_per_worker, 50, "max connections per host per worker");
+DEFINE_int32(tile_http_engine_max_total_connections_per_worker, 200, "max total connections per worker");
 DEFINE_bool(tile_http_engine_use_epoll, false, "http client use epoll or poll");
-DEFINE_bool(tile_http_engine_enable_debug, false,
-            "If set, debugging output from libcurl is logged.");
-DEFINE_bool(tile_http_engine_enable_debug_body, false,
-            "If set, HTTP body is also logged.");
+DEFINE_bool(tile_http_engine_enable_debug, false, "If set, debugging output from libcurl is logged.");
+DEFINE_bool(tile_http_engine_enable_debug_body, false, "If set, HTTP body is also logged.");
 
 namespace tile {
 namespace internal {
 
 class Notifier {
 public:
-  Notifier() {}
-  ~Notifier() {
-    ::close(fds_[0]);
-    ::close(fds_[1]);
-  }
+    Notifier() {}
 
-  bool Init() {
-    TILE_CHECK_EQ(::pipe(fds_), 0);
-    int old_fl = fcntl(fds_[0], F_GETFL, 0);
-    if (old_fl < 0) {
-      return false;
-    }
-    int f = fcntl(fds_[0], F_SETFL, old_fl | O_NONBLOCK);
-    if (f == -1) {
-      return false;
+    ~Notifier()
+    {
+        ::close(fds_[0]);
+        ::close(fds_[1]);
     }
 
-    return true;
-  }
+    bool Init()
+    {
+        TILE_CHECK_EQ(::pipe(fds_), 0);
+        int old_fl = fcntl(fds_[0], F_GETFL, 0);
+        if (old_fl < 0) { return false; }
+        int f = fcntl(fds_[0], F_SETFL, old_fl | O_NONBLOCK);
+        if (f == -1) { return false; }
 
-  void Read() {
-    char c;
-    while (::read(fds_[0], &c, 1) == 0) {
+        return true;
     }
-  }
 
-  bool Notify() {
-    TILE_DCHECK_GE(fds_[0], 0);
-    return write(fds_[1], "a", 1) == 1;
-  }
+    void Read()
+    {
+        char c;
+        while (::read(fds_[0], &c, 1) == 0) {}
+    }
 
-  int fd() const { return fds_[0]; }
+    bool Notify()
+    {
+        TILE_DCHECK_GE(fds_[0], 0);
+        return write(fds_[1], "a", 1) == 1;
+    }
+
+    int fd() const { return fds_[0]; }
 
 private:
-  int fds_[2];
+    int fds_[2];
 };
 
 class CallContextQueue {
 public:
-  void Push(PooledPtr<HttpTaskCallContext> ctx) {
-    ScopedLock _(pending_call_ctx_mutex_);
-    pending_call_ctxs_.push(std::move(ctx));
-  }
-
-  // Out should ensure that the size is at least max_ctxs.
-  // Returns the actual pop number.
-  std::size_t Pop(PooledPtr<HttpTaskCallContext> *out, std::size_t max_ctxs) {
-    if (max_ctxs == 0)
-      return 0;
-    ScopedLock _(pending_call_ctx_mutex_);
-    std::size_t i = 0;
-    while (max_ctxs-- && !pending_call_ctxs_.empty()) {
-      out[i++] = std::move(pending_call_ctxs_.front());
-      pending_call_ctxs_.pop();
+    void Push(PooledPtr<HttpTaskCallContext> ctx)
+    {
+        ScopedLock _(pending_call_ctx_mutex_);
+        pending_call_ctxs_.push(std::move(ctx));
+    }
+
+    // Out should ensure that the size is at least max_ctxs.
+    // Returns the actual pop number.
+    std::size_t Pop(PooledPtr<HttpTaskCallContext> *out, std::size_t max_ctxs)
+    {
+        if (max_ctxs == 0) return 0;
+        ScopedLock _(pending_call_ctx_mutex_);
+        std::size_t i = 0;
+        while (max_ctxs-- && !pending_call_ctxs_.empty()) {
+            out[i++] = std::move(pending_call_ctxs_.front());
+            pending_call_ctxs_.pop();
+        }
+        return i;
     }
-    return i;
-  }
 
 private:
-  Mutex pending_call_ctx_mutex_;
-  std::queue<PooledPtr<HttpTaskCallContext>> pending_call_ctxs_;
+    Mutex pending_call_ctx_mutex_;
+    std::queue<PooledPtr<HttpTaskCallContext>> pending_call_ctxs_;
 };
 
 int SockCallback(CURL *e, curl_socket_t s, int what, void *cbp, void *sockp);
@@ -118,267 +114,256 @@ int SockCallback(CURL *e, curl_socket_t s, int what, void *cbp, void *sockp);
 
 class CurlClient {
 public:
-  CurlClient(std::size_t group, CallContextQueue *call_context_queue,
-             Notifier *notifier)
-      : thread_pool_(1, {}, 0) {
-    multi_handle_ = curl_multi_init();
-    TILE_CHECK(multi_handle_, "Curl multi init failed.");
-    curl_multi_setopt(multi_handle_, CURLMOPT_MAXCONNECTS,
-                      FLAGS_tile_http_engine_max_total_connections_per_worker);
-    curl_multi_setopt(
-        multi_handle_, CURLMOPT_MAX_HOST_CONNECTIONS,
-        FLAGS_tile_http_engine_max_connections_per_host_per_worker);
-    notifier_ = notifier;
-    group_ = group;
-    call_context_queue_ = call_context_queue;
-    worker_ = std::thread([this, group] { LoopPoll(); });
-  }
-
-  void Stop() {
-    exiting_.store(true, std::memory_order_relaxed);
-    thread_pool_.Stop();
-  }
-
-  ~CurlClient() {
-    worker_.join();
-    thread_pool_.Join();
-    curl_multi_cleanup(multi_handle_);
-  }
-
-  void CheckMultiInfo() {
-    CURLMsg *msg;
-    int msgs_left;
-    while ((msg = curl_multi_info_read(multi_handle_, &msgs_left))) {
-      if (msg->msg == CURLMSG_DONE) {
-        CURL *e = msg->easy_handle;
-        curl_multi_remove_handle(multi_handle_, e);
-
-        auto task = [this, e, msg]() mutable {
-          void *pointer;
-          curl_easy_getinfo(e, CURLINFO_PRIVATE, &pointer);
-          EasyHandleDone(e, msg->data.result,
-                         reinterpret_cast<HttpTaskCallContext *>(pointer));
-        };
-        thread_pool_.QueueJob(std::move(task));
-
-        // fiber::internal::StartFiberDetached(
-        //     Fiber::Attributes{.scheduling_group = group_},
-        //     [this, e, msg]() mutable {
-        //       void *pointer;
-        //       curl_easy_getinfo(e, CURLINFO_PRIVATE, &pointer);
-        //       EasyHandlerDone(e, msg->data.result,
-        //                       reinterpret_cast<HttpTaskCallContext
-        //                       *>(pointer));
-        //     });
-      }
+    CurlClient(std::size_t group, CallContextQueue *call_context_queue, Notifier *notifier) : thread_pool_(1, {}, 0)
+    {
+        multi_handle_ = curl_multi_init();
+        TILE_CHECK(multi_handle_, "Curl multi init failed.");
+        curl_multi_setopt(multi_handle_, CURLMOPT_MAXCONNECTS, FLAGS_tile_http_engine_max_total_connections_per_worker);
+        curl_multi_setopt(multi_handle_, CURLMOPT_MAX_HOST_CONNECTIONS,
+                          FLAGS_tile_http_engine_max_connections_per_host_per_worker);
+        notifier_           = notifier;
+        group_              = group;
+        call_context_queue_ = call_context_queue;
+        worker_             = std::thread([this, group] { LoopPoll(); });
     }
-  }
 
-  void AddHandlers() {
-    static constexpr std::size_t kMaxStilRunning = 50;
-    static constexpr std::size_t kLocalPopArraySize = 30;
-    PooledPtr<HttpTaskCallContext> local_pop_array[kLocalPopArraySize];
-    std::size_t max_to_pop = (still_running_ >= kMaxStilRunning)
-                                 ? 1
-                                 : kMaxStilRunning - still_running_;
-    PooledPtr<HttpTaskCallContext> *out;
-    std::vector<PooledPtr<HttpTaskCallContext>> large_pop_array;
-    if (max_to_pop <= kLocalPopArraySize) {
-      out = local_pop_array;
-    } else {
-      large_pop_array.resize(max_to_pop);
-      out = large_pop_array.data();
+    void Stop()
+    {
+        exiting_.store(true, std::memory_order_relaxed);
+        thread_pool_.Stop();
     }
-    auto n = call_context_queue_->Pop(out, max_to_pop);
-    for (std::size_t i = 0; i < n; ++i) {
-      HttpTaskCallContext *ctx = out[i].Leak();
-      TILE_CHECK_EQ(CURLE_OK,
-                    curl_easy_setopt(ctx->curl_handler, CURLOPT_PRIVATE, ctx));
-      curl_multi_add_handle(multi_handle_, ctx->curl_handler);
+
+    ~CurlClient()
+    {
+        worker_.join();
+        thread_pool_.Join();
+        curl_multi_cleanup(multi_handle_);
     }
-  }
 
-  void LoopPoll() {
-    int numfds;
+    void CheckMultiInfo()
+    {
+        CURLMsg *msg;
+        int msgs_left;
+        while ((msg = curl_multi_info_read(multi_handle_, &msgs_left))) {
+            if (msg->msg == CURLMSG_DONE) {
+                CURL *e = msg->easy_handle;
+                curl_multi_remove_handle(multi_handle_, e);
 
-    while (!exiting_.load(std::memory_order_relaxed)) {
-      CURLMcode mc = curl_multi_perform(multi_handle_, &still_running_);
-      if (mc == CURLM_OK) {
-        struct curl_waitfd extra_fds[1];
-        extra_fds[0].fd = notifier_->fd();
-        extra_fds[0].events = CURL_WAIT_POLLIN;
-        extra_fds[0].revents = 0;
+                auto task = [this, e, msg]() mutable {
+                    void *pointer;
+                    curl_easy_getinfo(e, CURLINFO_PRIVATE, &pointer);
+                    EasyHandleDone(e, msg->data.result, reinterpret_cast<HttpTaskCallContext *>(pointer));
+                };
+                thread_pool_.QueueJob(std::move(task));
 
-        CheckMultiInfo();
-        AddHandlers();
-
-        long curl_timeo = -1;
-        curl_multi_timeout(multi_handle_, &curl_timeo);
-        if (curl_timeo < 0) {
-          curl_timeo = 5; // ms
+                // fiber::internal::StartFiberDetached(
+                //     Fiber::Attributes{.scheduling_group = group_},
+                //     [this, e, msg]() mutable {
+                //       void *pointer;
+                //       curl_easy_getinfo(e, CURLINFO_PRIVATE, &pointer);
+                //       EasyHandlerDone(e, msg->data.result,
+                //                       reinterpret_cast<HttpTaskCallContext
+                //                       *>(pointer));
+                //     });
+            }
         }
-        mc = curl_multi_poll(multi_handle_, extra_fds, 1, curl_timeo, &numfds);
-        // TILE_LOG_INFO("CurlClient LoopPoll");
-        notifier_->Read();
-      }
     }
-  }
 
-  void EasyHandleDone(CURL *easy_handler, CURLcode result_code,
-                      HttpTaskCallContext *ctx) {
-    auto done = std::move(ctx->done);
-    if (result_code != CURLE_OK) {
-      done(std::make_unexpected(
-          Status(result_code, curl_easy_strerror(result_code))));
-      object_pool::Put<HttpTaskCallContext>(ctx);
-    } else {
-      done(HttpTaskCompletion(ctx));
+    void AddHandlers()
+    {
+        static constexpr std::size_t kMaxStilRunning    = 50;
+        static constexpr std::size_t kLocalPopArraySize = 30;
+        PooledPtr<HttpTaskCallContext> local_pop_array[kLocalPopArraySize];
+        std::size_t max_to_pop = (still_running_ >= kMaxStilRunning) ? 1 : kMaxStilRunning - still_running_;
+        PooledPtr<HttpTaskCallContext> *out;
+        std::vector<PooledPtr<HttpTaskCallContext>> large_pop_array;
+        if (max_to_pop <= kLocalPopArraySize) {
+            out = local_pop_array;
+        } else {
+            large_pop_array.resize(max_to_pop);
+            out = large_pop_array.data();
+        }
+        auto n = call_context_queue_->Pop(out, max_to_pop);
+        for (std::size_t i = 0; i < n; ++i) {
+            HttpTaskCallContext *ctx = out[i].Leak();
+            TILE_CHECK_EQ(CURLE_OK, curl_easy_setopt(ctx->curl_handler, CURLOPT_PRIVATE, ctx));
+            curl_multi_add_handle(multi_handle_, ctx->curl_handler);
+        }
     }
-  }
 
-  CURLM *multi_handle_;
+    void LoopPoll()
+    {
+        int numfds;
+
+        while (!exiting_.load(std::memory_order_relaxed)) {
+            CURLMcode mc = curl_multi_perform(multi_handle_, &still_running_);
+            if (mc == CURLM_OK) {
+                struct curl_waitfd extra_fds[1];
+                extra_fds[0].fd      = notifier_->fd();
+                extra_fds[0].events  = CURL_WAIT_POLLIN;
+                extra_fds[0].revents = 0;
+
+                CheckMultiInfo();
+                AddHandlers();
+
+                long curl_timeo = -1;
+                curl_multi_timeout(multi_handle_, &curl_timeo);
+                if (curl_timeo < 0) {
+                    curl_timeo = 5;// ms
+                }
+                mc = curl_multi_poll(multi_handle_, extra_fds, 1, curl_timeo, &numfds);
+                // TILE_LOG_INFO("CurlClient LoopPoll");
+                notifier_->Read();
+            }
+        }
+    }
+
+    void EasyHandleDone(CURL *easy_handler, CURLcode result_code, HttpTaskCallContext *ctx)
+    {
+        auto done = std::move(ctx->done);
+        if (result_code != CURLE_OK) {
+            done(std::make_unexpected(Status(result_code, curl_easy_strerror(result_code))));
+            object_pool::Put<HttpTaskCallContext>(ctx);
+        } else {
+            done(HttpTaskCompletion(ctx));
+        }
+    }
+
+    CURLM *multi_handle_;
 
 private:
-  std::atomic<bool> exiting_{false};
-  std::thread worker_;
-  ThreadPool thread_pool_;
+    std::atomic<bool> exiting_{false};
+    std::thread worker_;
+    ThreadPool thread_pool_;
 
-  Notifier *notifier_;
-  std::size_t group_;
-  CallContextQueue *call_context_queue_;
-  int still_running_ = 0;
+    Notifier *notifier_;
+    std::size_t group_;
+    CallContextQueue *call_context_queue_;
+    int still_running_ = 0;
 };
 
 class CurlClientGroup {
 public:
-  CurlClientGroup(std::size_t sz, std::size_t group)
-      : clients_(), queue_(), notifier_() {
-    TILE_PCHECK(notifier_.Init(), "Failed to init notifier");
-    for (std::size_t i = 0; i < sz; ++i) {
-      clients_.push_back(make_unique<CurlClient>(group, &queue_, &notifier_));
-    }
-  }
-
-  void PushContext(PooledPtr<HttpTaskCallContext> ctx) {
-    queue_.Push(std::move(ctx));
-    notifier_.Notify();
-  }
-  void Stop() {
-    for (auto &&c : clients_) {
-      c->Stop();
+    CurlClientGroup(std::size_t sz, std::size_t group) : clients_(), queue_(), notifier_()
+    {
+        TILE_PCHECK(notifier_.Init(), "Failed to init notifier");
+        for (std::size_t i = 0; i < sz; ++i) {
+            clients_.push_back(make_unique<CurlClient>(group, &queue_, &notifier_));
+        }
     }
 
-    for (auto &&c : clients_) {
-      c.reset();
+    void PushContext(PooledPtr<HttpTaskCallContext> ctx)
+    {
+        queue_.Push(std::move(ctx));
+        notifier_.Notify();
+    }
+
+    void Stop()
+    {
+        for (auto &&c : clients_) { c->Stop(); }
+
+        for (auto &&c : clients_) { c.reset(); }
     }
-  }
 
 private:
-  std::vector<std::unique_ptr<CurlClient>> clients_;
-  CallContextQueue queue_;
-  Notifier notifier_;
-  // Notifier notifier_;
+    std::vector<std::unique_ptr<CurlClient>> clients_;
+    CallContextQueue queue_;
+    Notifier notifier_;
+    // Notifier notifier_;
 };
 
-size_t HttpWriteCallback(char *ptr, size_t size, size_t nmemb, void *pstr) {
-  auto bytes = size * nmemb;
-  static_cast<tile::NoncontiguousBufferBuilder *>(pstr)->Append(ptr, bytes);
-  return bytes;
+size_t
+HttpWriteCallback(char *ptr, size_t size, size_t nmemb, void *pstr)
+{
+    auto bytes = size * nmemb;
+    static_cast<tile::NoncontiguousBufferBuilder *>(pstr)->Append(ptr, bytes);
+    return bytes;
 }
 
 // The header callback will be called once for each header and
 // only complete header lines are passed on to the callback.
 // Parsing headers is very easy using this.
-size_t HttpHeaderCallback(char *ptr, size_t size, size_t nmemb, void *pstr) {
-  std::size_t bytes = size * nmemb;
-  Slice s(ptr, bytes);
-  if (s.find(':') == Slice::npos) { // Status-Line.
+size_t
+HttpHeaderCallback(char *ptr, size_t size, size_t nmemb, void *pstr)
+{
+    std::size_t bytes = size * nmemb;
+    Slice s(ptr, bytes);
+    if (s.find(':') == Slice::npos) {// Status-Line.
+        return bytes;
+    }
+    if (s.size() > 2 && s[bytes - 2] == '\r' && s[bytes - 1] == '\n') { s.RemoveSuffix(2); }
+    static_cast<std::vector<std::string> *>(pstr)->emplace_back(s);
     return bytes;
-  }
-  if (s.size() > 2 && s[bytes - 2] == '\r' && s[bytes - 1] == '\n') {
-    s.RemoveSuffix(2);
-  }
-  static_cast<std::vector<std::string> *>(pstr)->emplace_back(s);
-  return bytes;
 }
 
-int HttpDebugCallback(CURL *handle, curl_infotype type, char *data, size_t size,
-                      void *userptr) {
-  Slice data_view(data, size);
-  if (type == CURLINFO_TEXT || type == CURLINFO_HEADER_IN ||
-      type == CURLINFO_HEADER_OUT) {
-    TILE_LOG_INFO("[{}] {}", type, data_view);
-  } else if (type == CURLINFO_DATA_IN || type == CURLINFO_DATA_OUT) {
-    if (FLAGS_tile_http_engine_enable_debug_body) {
-      TILE_LOG_INFO("[{}] {}", type, data_view);
-    } // Ignored otherwise.
-  } // Everything else is ignored.
-  return 0;
+int
+HttpDebugCallback(CURL *handle, curl_infotype type, char *data, size_t size, void *userptr)
+{
+    Slice data_view(data, size);
+    if (type == CURLINFO_TEXT || type == CURLINFO_HEADER_IN || type == CURLINFO_HEADER_OUT) {
+        TILE_LOG_INFO("[{}] {}", type, data_view);
+    } else if (type == CURLINFO_DATA_IN || type == CURLINFO_DATA_OUT) {
+        if (FLAGS_tile_http_engine_enable_debug_body) {
+            TILE_LOG_INFO("[{}] {}", type, data_view);
+        }// Ignored otherwise.
+    }// Everything else is ignored.
+    return 0;
 }
 
 std::vector<std::unique_ptr<CurlClientGroup>> curl_client_groups;
 
-HttpEngine *HttpEngine::Instance() {
-  static NeverDestroyedSingleton<HttpEngine> engine;
-  return engine.Get();
+HttpEngine *
+HttpEngine::Instance()
+{
+    static NeverDestroyedSingleton<HttpEngine> engine;
+    return engine.Get();
 }
 
-void HttpEngine ::StartTask(
-    HttpTask task,
-    std::function<void(std::expected<HttpTaskCompletion, Status>)> done) {
-  auto ctx = task.ctx_.Get();
-  ctx->hdrs = std::move(task.hdrs_);
-  if (FLAGS_tile_http_engine_enable_debug) {
-    TILE_CHECK_EQ(CURLE_OK,
-                  curl_easy_setopt(ctx->curl_handler, CURLOPT_DEBUGFUNCTION,
-                                   HttpDebugCallback));
-    TILE_CHECK_EQ(CURLE_OK,
-                  curl_easy_setopt(ctx->curl_handler, CURLOPT_VERBOSE, 1));
-  }
-  TILE_CHECK_EQ(CURLE_OK,
-                curl_easy_setopt(ctx->curl_handler, CURLOPT_NOSIGNAL, 1));
-  TILE_CHECK_EQ(CURLE_OK,
-                curl_easy_setopt(ctx->curl_handler, CURLOPT_WRITEFUNCTION,
-                                 HttpWriteCallback));
-  ctx->body = make_unique<NoncontiguousBufferBuilder>();
-  TILE_CHECK_EQ(CURLE_OK, curl_easy_setopt(ctx->curl_handler, CURLOPT_WRITEDATA,
-                                           ctx->body.get()));
-  TILE_CHECK_EQ(CURLE_OK,
-                curl_easy_setopt(ctx->curl_handler, CURLOPT_HEADERFUNCTION,
-                                 HttpHeaderCallback));
-  TILE_CHECK_EQ(CURLE_OK, curl_easy_setopt(ctx->curl_handler,
-                                           CURLOPT_HEADERDATA, &ctx->headers));
-  TILE_CHECK_EQ(
-      CURLE_OK,
-      curl_easy_setopt(ctx->curl_handler, CURLOPT_HTTPHEADER, ctx->hdrs.get()));
-  ctx->done = std::move(done);
-  // auto c = curl_client_groups[fiber::GetCurrentSchedulingGroupIndex()].get();
-  // c->PushContext(std::move(task.ctx_));
-  auto c = curl_client_groups[0].get();
-  c->PushContext(std::move(task.ctx_));
+void
+HttpEngine ::StartTask(HttpTask task, std::function<void(std::expected<HttpTaskCompletion, Status>)> done)
+{
+    auto ctx  = task.ctx_.Get();
+    ctx->hdrs = std::move(task.hdrs_);
+    if (FLAGS_tile_http_engine_enable_debug) {
+        TILE_CHECK_EQ(CURLE_OK, curl_easy_setopt(ctx->curl_handler, CURLOPT_DEBUGFUNCTION, HttpDebugCallback));
+        TILE_CHECK_EQ(CURLE_OK, curl_easy_setopt(ctx->curl_handler, CURLOPT_VERBOSE, 1));
+    }
+    TILE_CHECK_EQ(CURLE_OK, curl_easy_setopt(ctx->curl_handler, CURLOPT_NOSIGNAL, 1));
+    TILE_CHECK_EQ(CURLE_OK, curl_easy_setopt(ctx->curl_handler, CURLOPT_WRITEFUNCTION, HttpWriteCallback));
+    ctx->body = make_unique<NoncontiguousBufferBuilder>();
+    TILE_CHECK_EQ(CURLE_OK, curl_easy_setopt(ctx->curl_handler, CURLOPT_WRITEDATA, ctx->body.get()));
+    TILE_CHECK_EQ(CURLE_OK, curl_easy_setopt(ctx->curl_handler, CURLOPT_HEADERFUNCTION, HttpHeaderCallback));
+    TILE_CHECK_EQ(CURLE_OK, curl_easy_setopt(ctx->curl_handler, CURLOPT_HEADERDATA, &ctx->headers));
+    TILE_CHECK_EQ(CURLE_OK, curl_easy_setopt(ctx->curl_handler, CURLOPT_HTTPHEADER, ctx->hdrs.get()));
+    ctx->done = std::move(done);
+    // auto c = curl_client_groups[fiber::GetCurrentSchedulingGroupIndex()].get();
+    // c->PushContext(std::move(task.ctx_));
+    auto c = curl_client_groups[0].get();
+    c->PushContext(std::move(task.ctx_));
 }
 
-void HttpEngine::Stop() {
-  for (auto &&c : curl_client_groups) {
-    c->Stop();
-  }
+void
+HttpEngine::Stop()
+{
+    for (auto &&c : curl_client_groups) { c->Stop(); }
 }
 
-void HttpEngine::Join() {
-  for (auto &&c : curl_client_groups) {
-    c.reset();
-  }
-  curl_global_cleanup();
+void
+HttpEngine::Join()
+{
+    for (auto &&c : curl_client_groups) { c.reset(); }
+    curl_global_cleanup();
 }
 
-HttpEngine::HttpEngine() {
-  auto ret = curl_global_init(CURL_GLOBAL_DEFAULT);
-  TILE_CHECK(!ret, "Curl Init failed {}", ret);
-  for (auto i = 0; i < 5; ++i) {
-    curl_client_groups.push_back(make_unique<CurlClientGroup>(
-        FLAGS_tile_http_engine_workers_per_scheduling_group, i));
-  }
+HttpEngine::HttpEngine()
+{
+    auto ret = curl_global_init(CURL_GLOBAL_DEFAULT);
+    TILE_CHECK(!ret, "Curl Init failed {}", ret);
+    for (auto i = 0; i < 5; ++i) {
+        curl_client_groups.push_back(
+            make_unique<CurlClientGroup>(FLAGS_tile_http_engine_workers_per_scheduling_group, i));
+    }
 }
 
-} // namespace internal
-} // namespace tile
+}// namespace internal
+}// namespace tile
diff --git a/tile/net/internal/http_engine.h b/tile/net/internal/http_engine.h
index 18a49ae..6e8116c 100644
--- a/tile/net/internal/http_engine.h
+++ b/tile/net/internal/http_engine.h
@@ -14,19 +14,17 @@ namespace tile {
 namespace internal {
 class HttpEngine {
 public:
-  static HttpEngine *Instance();
-  void
-  StartTask(HttpTask task,
-            std::function<void(std::expected<HttpTaskCompletion, Status>)>);
+    static HttpEngine *Instance();
+    void StartTask(HttpTask task, std::function<void(std::expected<HttpTaskCompletion, Status>)>);
 
-  static void Stop();
-  static void Join();
+    static void Stop();
+    static void Join();
 
 private:
-  friend class NeverDestroyedSingleton<HttpEngine>;
-  HttpEngine();
+    friend class NeverDestroyedSingleton<HttpEngine>;
+    HttpEngine();
 };
-} // namespace internal
-} // namespace tile
+}// namespace internal
+}// namespace tile
 
-#endif // TILE_NET_INTERNAL_HTTP_ENGINE_H
+#endif// TILE_NET_INTERNAL_HTTP_ENGINE_H
diff --git a/tile/net/internal/http_engine_test.cc b/tile/net/internal/http_engine_test.cc
index d3e34bb..b46342e 100644
--- a/tile/net/internal/http_engine_test.cc
+++ b/tile/net/internal/http_engine_test.cc
@@ -8,15 +8,14 @@
 
 namespace tile {
 namespace internal {
-std::string GetHeader(const std::vector<std::string> &headers,
-                      const std::string &key) {
-  for (auto &&e : headers) {
-    TILE_LOG_INFO(e);
-    if (StartsWithIgnoreCase(e, key)) {
-      return Trim(e.substr(key.size() + 1));
+std::string
+GetHeader(const std::vector<std::string> &headers, const std::string &key)
+{
+    for (auto &&e : headers) {
+        TILE_LOG_INFO(e);
+        if (StartsWithIgnoreCase(e, key)) { return Trim(e.substr(key.size() + 1)); }
     }
-  }
-  return "";
+    return "";
 }
 
 // class HttpEngineTest : public ::testing::Test {
@@ -72,28 +71,29 @@ std::string GetHeader(const std::vector<std::string> &headers,
 // </html>
 class HttpEngineTest : public ::testing::Test {
 public:
-  void SetUp() override { site_url_ = "http://example.com/"; }
-  std::string site_url_;
+    void SetUp() override { site_url_ = "http://example.com/"; }
+
+    std::string site_url_;
 };
 
-TEST_F(HttpEngineTest, Basic) {
-  HttpTask t;
-  t.SetMethod(HttpMethod::Get);
-  t.SetUrl(site_url_);
-  t.SetTimeout(std::chrono::seconds(1));
-  // t.SetUserAgent("curl/8.6.0");
-  Latch l(1);
-  HttpEngine::Instance()->StartTask(
-      std::move(t), [&](std::expected<HttpTaskCompletion, Status> resp) {
+TEST_F(HttpEngineTest, Basic)
+{
+    HttpTask t;
+    t.SetMethod(HttpMethod::Get);
+    t.SetUrl(site_url_);
+    t.SetTimeout(std::chrono::seconds(1));
+    // t.SetUserAgent("curl/8.6.0");
+    Latch l(1);
+    HttpEngine::Instance()->StartTask(std::move(t), [&](std::expected<HttpTaskCompletion, Status> resp) {
         EXPECT_TRUE(resp);
         EXPECT_EQ(GetHeader(*resp->headers(), "Content-Type"), "text/html");
         EXPECT_EQ(GetHeader(*resp->headers(), "Connection"), "Keep-Alive");
         EXPECT_EQ(HttpStatus::OK, resp->status());
         EXPECT_EQ(HttpVersion::V_1_1, resp->version());
         l.CountDown();
-      });
-  l.Wait();
+    });
+    l.Wait();
 }
 
-} // namespace internal
-} // namespace tile
+}// namespace internal
+}// namespace tile
diff --git a/tile/net/internal/http_task.cc b/tile/net/internal/http_task.cc
index 4bbc226..3dec9fa 100644
--- a/tile/net/internal/http_task.cc
+++ b/tile/net/internal/http_task.cc
@@ -6,222 +6,236 @@ namespace tile {
 namespace internal {
 
 HttpTaskCallContext::HttpTaskCallContext()
-    : curl_handler(curl_easy_init()), done(nullptr),
-      hdrs(nullptr, &curl_slist_free_all) {}
+    : curl_handler(curl_easy_init()),
+      done(nullptr),
+      hdrs(nullptr, &curl_slist_free_all)
+{}
 
 HttpTaskCallContext::~HttpTaskCallContext() { curl_easy_cleanup(curl_handler); }
-void HttpTaskCallContext::Reset() {
-  curl_easy_reset(curl_handler);
-  body = nullptr;
-  headers.clear();
-  done = nullptr;
-  hdrs = nullptr;
-  request_body.buffer.Clear();
+
+void
+HttpTaskCallContext::Reset()
+{
+    curl_easy_reset(curl_handler);
+    body = nullptr;
+    headers.clear();
+    done = nullptr;
+    hdrs = nullptr;
+    request_body.buffer.Clear();
 }
 
 HttpTask::HttpTask() : ctx_(object_pool::Get<HttpTaskCallContext>()) {}
-HttpTask::~HttpTask() = default;
+
+HttpTask::~HttpTask()                    = default;
 
 HttpTask::HttpTask(HttpTask &&) noexcept = default;
-void HttpTask::SetUrl(const std::string &url) {
-  TILE_CHECK_EQ(CURLE_OK,
-                curl_easy_setopt(ctx_->curl_handler, CURLOPT_URL, url.c_str()));
-}
-void HttpTask::SetUserAgent(const std::string &user_agent) {
-  TILE_CHECK_EQ(CURLE_OK,
-                curl_easy_setopt(ctx_->curl_handler, CURLOPT_USERAGENT,
-                                 user_agent.c_str()));
+
+void
+HttpTask::SetUrl(const std::string &url)
+{
+    TILE_CHECK_EQ(CURLE_OK, curl_easy_setopt(ctx_->curl_handler, CURLOPT_URL, url.c_str()));
 }
 
-void HttpTask::SetMethod(HttpMethod method) {
-  method_ = method;
-  switch (method) {
-  case HttpMethod::Head:
-    TILE_CHECK_EQ(CURLE_OK,
-                  curl_easy_setopt(ctx_->curl_handler, CURLOPT_NOBODY, 1L));
-    break;
-  case HttpMethod::Get:
-    TILE_CHECK_EQ(CURLE_OK,
-                  curl_easy_setopt(ctx_->curl_handler, CURLOPT_HTTPGET, 1L));
-    break;
-  case HttpMethod::Post:
-    TILE_CHECK_EQ(CURLE_OK,
-                  curl_easy_setopt(ctx_->curl_handler, CURLOPT_POST, 1L));
-  case HttpMethod::Put:
-    TILE_CHECK_EQ(CURLE_OK,
-                  curl_easy_setopt(ctx_->curl_handler, CURLOPT_UPLOAD, 1L));
-  case HttpMethod::Delete:
-    TILE_CHECK_EQ(CURLE_OK, curl_easy_setopt(ctx_->curl_handler,
-                                             CURLOPT_CUSTOMREQUEST, "DELETE"));
-    break;
-  default:
-    TILE_UNEXPECTED("Unsupported HTTP method #{}", underlying_value(method));
-  }
+void
+HttpTask::SetUserAgent(const std::string &user_agent)
+{
+    TILE_CHECK_EQ(CURLE_OK, curl_easy_setopt(ctx_->curl_handler, CURLOPT_USERAGENT, user_agent.c_str()));
 }
 
-void HttpTask::SetTimeout(std::chrono::nanoseconds timeout) {
-  constexpr auto one_ms = std::chrono::milliseconds(1);
-  TILE_CHECK_EQ(CURLE_OK,
-                curl_easy_setopt(ctx_->curl_handler, CURLOPT_TIMEOUT_MS,
-                                 timeout / one_ms));
+void
+HttpTask::SetMethod(HttpMethod method)
+{
+    method_ = method;
+    switch (method) {
+    case HttpMethod::Head:
+        TILE_CHECK_EQ(CURLE_OK, curl_easy_setopt(ctx_->curl_handler, CURLOPT_NOBODY, 1L));
+        break;
+    case HttpMethod::Get:
+        TILE_CHECK_EQ(CURLE_OK, curl_easy_setopt(ctx_->curl_handler, CURLOPT_HTTPGET, 1L));
+        break;
+    case HttpMethod::Post:
+        TILE_CHECK_EQ(CURLE_OK, curl_easy_setopt(ctx_->curl_handler, CURLOPT_POST, 1L));
+    case HttpMethod::Put:
+        TILE_CHECK_EQ(CURLE_OK, curl_easy_setopt(ctx_->curl_handler, CURLOPT_UPLOAD, 1L));
+    case HttpMethod::Delete:
+        TILE_CHECK_EQ(CURLE_OK, curl_easy_setopt(ctx_->curl_handler, CURLOPT_CUSTOMREQUEST, "DELETE"));
+        break;
+    default:
+        TILE_UNEXPECTED("Unsupported HTTP method #{}", underlying_value(method));
+    }
 }
 
-CURL *HttpTask::GetNativeHandle() noexcept { return ctx_->curl_handler; }
-
-void HttpTask::SetBody(std::string body) {
-  NoncontiguousBufferBuilder builder;
-  builder.Append(MakeForeignBuffer(std::move(body)));
-  SetBody(builder.DestructiveGet());
+void
+HttpTask::SetTimeout(std::chrono::nanoseconds timeout)
+{
+    constexpr auto one_ms = std::chrono::milliseconds(1);
+    TILE_CHECK_EQ(CURLE_OK, curl_easy_setopt(ctx_->curl_handler, CURLOPT_TIMEOUT_MS, timeout / one_ms));
 }
 
-size_t HttpReadCallback(char *ptr, size_t size, size_t nmemb, void *userdata) {
-  auto body = reinterpret_cast<HttpTaskCallContext::RequestBody *>(userdata);
-  if (body->current_block == body->buffer.end()) {
-    return 0;
-  }
+CURL *
+HttpTask::GetNativeHandle() noexcept
+{
+    return ctx_->curl_handler;
+}
 
-  auto n_copy = std::min(
-      body->current_block->size() - body->buffer_block_inner_pos, size * nmemb);
-  memcpy(ptr, body->current_block->data() + body->buffer_block_inner_pos,
-         n_copy);
-  body->buffer_block_inner_pos += n_copy;
-  if (body->buffer_block_inner_pos == body->current_block->size()) {
+void
+HttpTask::SetBody(std::string body)
+{
+    NoncontiguousBufferBuilder builder;
+    builder.Append(MakeForeignBuffer(std::move(body)));
+    SetBody(builder.DestructiveGet());
+}
+
+size_t
+HttpReadCallback(char *ptr, size_t size, size_t nmemb, void *userdata)
+{
+    auto body = reinterpret_cast<HttpTaskCallContext::RequestBody *>(userdata);
+    if (body->current_block == body->buffer.end()) { return 0; }
+
+    auto n_copy = std::min(body->current_block->size() - body->buffer_block_inner_pos, size * nmemb);
+    memcpy(ptr, body->current_block->data() + body->buffer_block_inner_pos, n_copy);
+    body->buffer_block_inner_pos += n_copy;
+    if (body->buffer_block_inner_pos == body->current_block->size()) {
+        body->buffer_block_inner_pos = 0;
+        ++body->current_block;
+    }
+    return n_copy;
+}
+
+static int
+HttpSeekCallback(void *userdata, curl_off_t offset, int origin)
+{
+    if (origin != SEEK_SET || offset < 0) {
+        TILE_NOT_IMPLEMENTED("libcurl currently only passes SEEK_SET, and we only archieved this.");
+    }
+
+    auto body                    = reinterpret_cast<HttpTaskCallContext::RequestBody *>(userdata);
+
+    body->current_block          = body->buffer.begin();
     body->buffer_block_inner_pos = 0;
-    ++body->current_block;
-  }
-  return n_copy;
-}
+    while (offset > 0) {
+        if (body->current_block == body->buffer.end()) { return CURL_SEEKFUNC_OK; }
 
-static int HttpSeekCallback(void *userdata, curl_off_t offset, int origin) {
-  if (origin != SEEK_SET || offset < 0) {
-    TILE_NOT_IMPLEMENTED(
-        "libcurl currently only passes SEEK_SET, and we only archieved this.");
-  }
+        if (offset < body->current_block->size()) {
+            body->buffer_block_inner_pos = offset;
+            return CURL_SEEKFUNC_OK;
+        }
 
-  auto body = reinterpret_cast<HttpTaskCallContext::RequestBody *>(userdata);
-
-  body->current_block = body->buffer.begin();
-  body->buffer_block_inner_pos = 0;
-  while (offset > 0) {
-    if (body->current_block == body->buffer.end()) {
-      return CURL_SEEKFUNC_OK;
+        offset -= body->current_block->size();
+        ++body->current_block;
     }
 
-    if (offset < body->current_block->size()) {
-      body->buffer_block_inner_pos = offset;
-      return CURL_SEEKFUNC_OK;
+    return CURL_SEEKFUNC_OK;
+}
+
+void
+HttpTask::SetBody(NoncontiguousBuffer body)
+{
+    TILE_CHECK(method_ != HttpMethod::Unspecified);
+    TILE_CHECK(method_ != HttpMethod::Head && method_ != HttpMethod::Get, "HEAD/GET request should not carry a body.");
+
+    ctx_->request_body.buffer = std::move(body);
+    if (method_ == HttpMethod::Post) {
+        TILE_CHECK_EQ(
+            CURLE_OK,
+            curl_easy_setopt(ctx_->curl_handler, CURLOPT_POSTFIELDSIZE_LARGE, ctx_->request_body.buffer.ByteSize()));
+
+        if (ctx_->request_body.buffer.ByteSize() == ctx_->request_body.buffer.FirstContiguous().size()) {
+            TILE_CHECK_EQ(CURLE_OK,
+                          curl_easy_setopt(ctx_->curl_handler, CURLOPT_POSTFIELDS,
+                                           ctx_->request_body.buffer.FirstContiguous().data()));
+            return;
+        }
+    } else if (method_ == HttpMethod::Put) {
+        TILE_CHECK_EQ(
+            CURLE_OK,
+            curl_easy_setopt(ctx_->curl_handler, CURLOPT_INFILESIZE_LARGE, ctx_->request_body.buffer.ByteSize()));
+    } else {
+        TILE_UNEXPECTED("Unexpected HTTP method #{}.", underlying_value(method_));
     }
 
-    offset -= body->current_block->size();
-    ++body->current_block;
-  }
+    ctx_->request_body.current_block          = ctx_->request_body.buffer.begin();
+    ctx_->request_body.buffer_block_inner_pos = 0;
 
-  return CURL_SEEKFUNC_OK;
+    TILE_CHECK_EQ(CURLE_OK, curl_easy_setopt(ctx_->curl_handler, CURLOPT_READFUNCTION, HttpReadCallback));
+    TILE_CHECK_EQ(CURLE_OK, curl_easy_setopt(ctx_->curl_handler, CURLOPT_READDATA, &ctx_->request_body));
+    TILE_CHECK_EQ(CURLE_OK, curl_easy_setopt(ctx_->curl_handler, CURLOPT_SEEKFUNCTION, HttpSeekCallback));
+    TILE_CHECK_EQ(CURLE_OK, curl_easy_setopt(ctx_->curl_handler, CURLOPT_SEEKDATA, &ctx_->request_body));
 }
 
-void HttpTask::SetBody(NoncontiguousBuffer body) {
-  TILE_CHECK(method_ != HttpMethod::Unspecified);
-  TILE_CHECK(method_ != HttpMethod::Head && method_ != HttpMethod::Get,
-             "HEAD/GET request should not carry a body.");
-
-  ctx_->request_body.buffer = std::move(body);
-  if (method_ == HttpMethod::Post) {
-    TILE_CHECK_EQ(CURLE_OK, curl_easy_setopt(
-                                ctx_->curl_handler, CURLOPT_POSTFIELDSIZE_LARGE,
-                                ctx_->request_body.buffer.ByteSize()));
-
-    if (ctx_->request_body.buffer.ByteSize() ==
-        ctx_->request_body.buffer.FirstContiguous().size()) {
-      TILE_CHECK_EQ(
-          CURLE_OK,
-          curl_easy_setopt(ctx_->curl_handler, CURLOPT_POSTFIELDS,
-                           ctx_->request_body.buffer.FirstContiguous().data()));
-      return;
-    }
-  } else if (method_ == HttpMethod::Put) {
-    TILE_CHECK_EQ(CURLE_OK,
-                  curl_easy_setopt(ctx_->curl_handler, CURLOPT_INFILESIZE_LARGE,
-                                   ctx_->request_body.buffer.ByteSize()));
-  } else {
-    TILE_UNEXPECTED("Unexpected HTTP method #{}.", underlying_value(method_));
-  }
-
-  ctx_->request_body.current_block = ctx_->request_body.buffer.begin();
-  ctx_->request_body.buffer_block_inner_pos = 0;
-
-  TILE_CHECK_EQ(CURLE_OK,
-                curl_easy_setopt(ctx_->curl_handler, CURLOPT_READFUNCTION,
-                                 HttpReadCallback));
-  TILE_CHECK_EQ(CURLE_OK, curl_easy_setopt(ctx_->curl_handler, CURLOPT_READDATA,
-                                           &ctx_->request_body));
-  TILE_CHECK_EQ(CURLE_OK,
-                curl_easy_setopt(ctx_->curl_handler, CURLOPT_SEEKFUNCTION,
-                                 HttpSeekCallback));
-  TILE_CHECK_EQ(CURLE_OK, curl_easy_setopt(ctx_->curl_handler, CURLOPT_SEEKDATA,
-                                           &ctx_->request_body));
+void
+HttpTask::AddHeader(const std::string &header)
+{
+    hdrs_.reset(curl_slist_append(hdrs_.release(), header.c_str()));
 }
 
-void HttpTask::AddHeader(const std::string &header) {
-  hdrs_.reset(curl_slist_append(hdrs_.release(), header.c_str()));
-}
-
-HttpTaskCompletion::HttpTaskCompletion(HttpTaskCallContext *ctx)
-    : ctx_(ctx), body_(ctx_->body->DestructiveGet()) {}
+HttpTaskCompletion::HttpTaskCompletion(HttpTaskCallContext *ctx) : ctx_(ctx), body_(ctx_->body->DestructiveGet()) {}
 
 HttpTaskCompletion::~HttpTaskCompletion() = default;
 
-NoncontiguousBuffer *HttpTaskCompletion::body() noexcept { return &body_; }
-HttpTaskCompletion::HttpTaskCompletion(HttpTaskCompletion &&) noexcept =
-    default;
-
-std::vector<std::string> *HttpTaskCompletion::headers() noexcept {
-  return &ctx_->headers;
+NoncontiguousBuffer *
+HttpTaskCompletion::body() noexcept
+{
+    return &body_;
 }
 
-HttpStatus HttpTaskCompletion::status() noexcept {
-  // `CURLINFO_RESPONSE_CODE` needs a `long`..
-  long resp_code; // NOLINT
-  curl_easy_getinfo(ctx_->curl_handler, CURLINFO_RESPONSE_CODE, &resp_code);
-  return static_cast<HttpStatus>(resp_code);
+HttpTaskCompletion::HttpTaskCompletion(HttpTaskCompletion &&) noexcept = default;
+
+std::vector<std::string> *
+HttpTaskCompletion::headers() noexcept
+{
+    return &ctx_->headers;
 }
 
-CURL *HttpTaskCompletion::GetNativeHandle() noexcept {
-  return ctx_->curl_handler;
+HttpStatus
+HttpTaskCompletion::status() noexcept
+{
+    // `CURLINFO_RESPONSE_CODE` needs a `long`..
+    long resp_code;// NOLINT
+    curl_easy_getinfo(ctx_->curl_handler, CURLINFO_RESPONSE_CODE, &resp_code);
+    return static_cast<HttpStatus>(resp_code);
+}
+
+CURL *
+HttpTaskCompletion::GetNativeHandle() noexcept
+{
+    return ctx_->curl_handler;
 }
 
 HttpVersion
-TranslateCurlHttpVersion(long version /* libcurl uses `long` */) { // NOLINT
-  if (version == CURL_HTTP_VERSION_1_0) {
-    return HttpVersion::V_1_0;
-  } else if (version == CURL_HTTP_VERSION_1_1) {
-    return HttpVersion::V_1_1;
-  } else if (version == CURL_HTTP_VERSION_2_0) {
-    return HttpVersion::V_2;
-  } else if (version == CURL_HTTP_VERSION_3) {
-    return HttpVersion::V_3;
-  }
-  TILE_UNEXPECTED("Unrecognized HTTP version [{}] from libcurl.", version);
-  return HttpVersion::Unspecified;
+TranslateCurlHttpVersion(long version /* libcurl uses `long` */)
+{// NOLINT
+    if (version == CURL_HTTP_VERSION_1_0) {
+        return HttpVersion::V_1_0;
+    } else if (version == CURL_HTTP_VERSION_1_1) {
+        return HttpVersion::V_1_1;
+    } else if (version == CURL_HTTP_VERSION_2_0) {
+        return HttpVersion::V_2;
+    } else if (version == CURL_HTTP_VERSION_3) {
+        return HttpVersion::V_3;
+    }
+    TILE_UNEXPECTED("Unrecognized HTTP version [{}] from libcurl.", version);
+    return HttpVersion::Unspecified;
 }
 
-HttpVersion HttpTaskCompletion::version() noexcept {
+HttpVersion
+HttpTaskCompletion::version() noexcept
+{
 
-  // `CURLOPT_HTTP_VERSION ` requires this.
-  long version; // NOLINT
-  curl_easy_getinfo(ctx_->curl_handler, CURLINFO_HTTP_VERSION, &version);
-  return TranslateCurlHttpVersion(version);
+    // `CURLOPT_HTTP_VERSION ` requires this.
+    long version;// NOLINT
+    curl_easy_getinfo(ctx_->curl_handler, CURLINFO_HTTP_VERSION, &version);
+    return TranslateCurlHttpVersion(version);
 }
 
-} // namespace internal
-} // namespace tile
+}// namespace internal
+}// namespace tile
+
 namespace tile {
 constexpr PoolType PoolTraits<internal::HttpTaskCallContext>::kType;
 constexpr std::size_t PoolTraits<internal::HttpTaskCallContext>::kLowWaterMark;
 constexpr std::size_t PoolTraits<internal::HttpTaskCallContext>::kHighWaterMark;
-constexpr std::chrono::seconds
-    PoolTraits<internal::HttpTaskCallContext>::kMaxIdle;
-constexpr std::size_t
-    PoolTraits<internal::HttpTaskCallContext>::kMinimumThreadCacheSize;
-constexpr std::size_t
-    PoolTraits<internal::HttpTaskCallContext>::kTransferBatchSize;
-} // namespace tile
+constexpr std::chrono::seconds PoolTraits<internal::HttpTaskCallContext>::kMaxIdle;
+constexpr std::size_t PoolTraits<internal::HttpTaskCallContext>::kMinimumThreadCacheSize;
+constexpr std::size_t PoolTraits<internal::HttpTaskCallContext>::kTransferBatchSize;
+}// namespace tile
diff --git a/tile/net/internal/http_task.h b/tile/net/internal/http_task.h
index d2d6443..62056ce 100644
--- a/tile/net/internal/http_task.h
+++ b/tile/net/internal/http_task.h
@@ -14,79 +14,82 @@ namespace tile {
 
 namespace internal {
 class HttpTaskCallContext;
+
 class HttpTask {
 public:
-  HttpTask();
-  ~HttpTask();
-  HttpTask(HttpTask &&) noexcept;
+    HttpTask();
+    ~HttpTask();
+    HttpTask(HttpTask &&) noexcept;
 
-  void SetUserAgent(const std::string &user_agent);
-  void SetMethod(HttpMethod method);
-  void SetUrl(const std::string &url);
-  void SetTimeout(std::chrono::nanoseconds timeout);
-  void SetBody(std::string body);
-  void SetBody(NoncontiguousBuffer body);
-  void AddHeader(const std::string &header);
+    void SetUserAgent(const std::string &user_agent);
+    void SetMethod(HttpMethod method);
+    void SetUrl(const std::string &url);
+    void SetTimeout(std::chrono::nanoseconds timeout);
+    void SetBody(std::string body);
+    void SetBody(NoncontiguousBuffer body);
+    void AddHeader(const std::string &header);
 
-  CURL *GetNativeHandle() noexcept;
+    CURL *GetNativeHandle() noexcept;
 
 private:
-  friend class HttpEngine;
-  HttpMethod method_ = HttpMethod::Unspecified;
-  PooledPtr<HttpTaskCallContext> ctx_;
-  std::unique_ptr<curl_slist, decltype(&curl_slist_free_all)> hdrs_{
-      nullptr, &curl_slist_free_all};
+    friend class HttpEngine;
+    HttpMethod method_ = HttpMethod::Unspecified;
+    PooledPtr<HttpTaskCallContext> ctx_;
+    std::unique_ptr<curl_slist, decltype(&curl_slist_free_all)> hdrs_{nullptr, &curl_slist_free_all};
 };
 
 class HttpTaskCompletion {
 public:
-  explicit HttpTaskCompletion(HttpTaskCallContext *ctx);
-  ~HttpTaskCompletion();
-  HttpTaskCompletion(HttpTaskCompletion &&) noexcept;
+    explicit HttpTaskCompletion(HttpTaskCallContext *ctx);
+    ~HttpTaskCompletion();
+    HttpTaskCompletion(HttpTaskCompletion &&) noexcept;
 
-  HttpStatus status() noexcept;
-  HttpVersion version() noexcept;
-  std::vector<std::string> *headers() noexcept;
-  NoncontiguousBuffer *body() noexcept;
+    HttpStatus status() noexcept;
+    HttpVersion version() noexcept;
+    std::vector<std::string> *headers() noexcept;
+    NoncontiguousBuffer *body() noexcept;
 
-  CURL *GetNativeHandle() noexcept;
+    CURL *GetNativeHandle() noexcept;
 
 private:
-  PooledPtr<HttpTaskCallContext> ctx_;
-  NoncontiguousBuffer body_;
+    PooledPtr<HttpTaskCallContext> ctx_;
+    NoncontiguousBuffer body_;
 };
 
 struct HttpTaskCallContext {
-  HttpTaskCallContext();
-  ~HttpTaskCallContext();
-  void Reset();
+    HttpTaskCallContext();
+    ~HttpTaskCallContext();
+    void Reset();
 
-  CURL *curl_handler;
-  std::unique_ptr<NoncontiguousBufferBuilder> body;
-  std::vector<std::string> headers;
-  std::function<void(std::expected<HttpTaskCompletion, Status>)> done;
-  std::unique_ptr<curl_slist, decltype(&curl_slist_free_all)> hdrs;
-  struct RequestBody {
-    NoncontiguousBuffer buffer;
-    NoncontiguousBuffer::const_iterator current_block;
-    std::size_t buffer_block_inner_pos = 0;
-  };
-  RequestBody request_body;
+    CURL *curl_handler;
+    std::unique_ptr<NoncontiguousBufferBuilder> body;
+    std::vector<std::string> headers;
+    std::function<void(std::expected<HttpTaskCompletion, Status>)> done;
+    std::unique_ptr<curl_slist, decltype(&curl_slist_free_all)> hdrs;
+
+    struct RequestBody {
+        NoncontiguousBuffer buffer;
+        NoncontiguousBuffer::const_iterator current_block;
+        std::size_t buffer_block_inner_pos = 0;
+    };
+
+    RequestBody request_body;
 };
 
-} // namespace internal
-} // namespace tile
+}// namespace internal
+}// namespace tile
 
 namespace tile {
-template <> struct PoolTraits<internal::HttpTaskCallContext> {
-  static constexpr auto kType = PoolType::MemoryNodeShared;
-  static constexpr std::size_t kLowWaterMark = 8192;
-  static constexpr std::size_t kHighWaterMark =
-      std::numeric_limits<std::size_t>::max();
-  static constexpr std::chrono::seconds kMaxIdle = std::chrono::seconds(10);
-  static constexpr std::size_t kMinimumThreadCacheSize = 1024;
-  static constexpr std::size_t kTransferBatchSize = 2048;
-  static void OnPut(internal::HttpTaskCallContext *cw) { cw->Reset(); }
+template<>
+struct PoolTraits<internal::HttpTaskCallContext> {
+    static constexpr auto kType                          = PoolType::MemoryNodeShared;
+    static constexpr std::size_t kLowWaterMark           = 8192;
+    static constexpr std::size_t kHighWaterMark          = std::numeric_limits<std::size_t>::max();
+    static constexpr std::chrono::seconds kMaxIdle       = std::chrono::seconds(10);
+    static constexpr std::size_t kMinimumThreadCacheSize = 1024;
+    static constexpr std::size_t kTransferBatchSize      = 2048;
+
+    static void OnPut(internal::HttpTaskCallContext *cw) { cw->Reset(); }
 };
-} // namespace tile
-#endif // TILE_NET_INTERNAL_HTTP_TASK_H
+}// namespace tile
+#endif// TILE_NET_INTERNAL_HTTP_TASK_H
diff --git a/tile/net/internal/http_task_test.cc b/tile/net/internal/http_task_test.cc
index f8a59e3..f94db1c 100644
--- a/tile/net/internal/http_task_test.cc
+++ b/tile/net/internal/http_task_test.cc
@@ -10,22 +10,24 @@
 namespace tile {
 namespace internal {
 
-TEST(HttpTask, All) {
-  HttpTask task;
-  task.AddHeader("a:b");
-  auto task2 = std::move(task);
+TEST(HttpTask, All)
+{
+    HttpTask task;
+    task.AddHeader("a:b");
+    auto task2 = std::move(task);
 
-  // Nothing to check. This UT indirectly tests there's no leak (via
-  // heap-checker), no crash would occur.
+    // Nothing to check. This UT indirectly tests there's no leak (via
+    // heap-checker), no crash would occur.
 }
 
-TEST(HttpTaskCompletion, All) {
-  auto ptr = object_pool::Get<HttpTaskCallContext>();
-  ptr->body = make_unique<tile::NoncontiguousBufferBuilder>();
-  HttpTaskCompletion comp(ptr.Leak());
-  auto comp2 = std::move(comp);
-  // No leak, no crash.
+TEST(HttpTaskCompletion, All)
+{
+    auto ptr  = object_pool::Get<HttpTaskCallContext>();
+    ptr->body = make_unique<tile::NoncontiguousBufferBuilder>();
+    HttpTaskCompletion comp(ptr.Leak());
+    auto comp2 = std::move(comp);
+    // No leak, no crash.
 }
 
-} // namespace internal
-} // namespace tile
+}// namespace internal
+}// namespace tile
diff --git a/tile/rpc/protocol/http/buffer_io.cc b/tile/rpc/protocol/http/buffer_io.cc
index e1395d0..275e647 100644
--- a/tile/rpc/protocol/http/buffer_io.cc
+++ b/tile/rpc/protocol/http/buffer_io.cc
@@ -12,284 +12,282 @@
 #include <cstdlib>
 #include <cstring>
 
-DEFINE_int32(tile_http_max_header_size, 8192,
-             "Maximum size of total size of HTTP headers");
+DEFINE_int32(tile_http_max_header_size, 8192, "Maximum size of total size of HTTP headers");
 
 namespace tile {
 namespace http {
 namespace {
-inline void WriteHeader(const HttpHeaders &headers,
-                        NoncontiguousBufferBuilder *builder) {
-  for (auto header : headers) {
-    auto &&key = header.first;
-    auto &&value = header.second;
-    builder->Append(key, ": ", value, "\r\n");
-  }
+inline void
+WriteHeader(const HttpHeaders &headers, NoncontiguousBufferBuilder *builder)
+{
+    for (auto header : headers) {
+        auto &&key   = header.first;
+        auto &&value = header.second;
+        builder->Append(key, ": ", value, "\r\n");
+    }
 }
 
-template <typename T> inline Slice ToSlice(const T &block) {
-  return Slice(block.data(), block.size());
+template<typename T>
+inline Slice
+ToSlice(const T &block)
+{
+    return Slice(block.data(), block.size());
 }
 
-constexpr auto kEndOfHeaderMarker = "\r\n\r\n";
+constexpr auto kEndOfHeaderMarker        = "\r\n\r\n";
 static const auto kEndOfHeaderMarkerSize = strlen(kEndOfHeaderMarker);
 
-inline bool EasyDetectHttp(const void *data, std::size_t length) {
-  static const Slice kLeadingWords[] = {"HTTP/1.1", "HEAD",    "GET ",
-                                        "POST",     "PUT ",    "DELETE",
-                                        "TRACE",    "CONNECT", "PATCH"};
-  static const std::size_t kMinLength = Slice("HTTP/1.1").size();
+inline bool
+EasyDetectHttp(const void *data, std::size_t length)
+{
+    static const Slice kLeadingWords[] = {
+        "HTTP/1.1", "HEAD", "GET ", "POST", "PUT ", "DELETE", "TRACE", "CONNECT", "PATCH"};
+    static const std::size_t kMinLength = Slice("HTTP/1.1").size();
+
+    if (length < kMinLength) { return false; }
+
+    for (auto &&e : kLeadingWords) {
+        if (memcmp(data, e.data(), 4) == 0) { return true; }
+    }
 
-  if (length < kMinLength) {
     return false;
-  }
-
-  for (auto &&e : kLeadingWords) {
-    if (memcmp(data, e.data(), 4) == 0) {
-      return true;
-    }
-  }
-
-  return false;
 }
 
-std::size_t DetermineHeaderSizeFast(const char *const ptr, std::size_t limit) {
-  auto ep = ptr + limit;
-  auto p = ptr + 1;
-  while (true) {
-    // First '\n' in '\r\n\r\n'
-    p = static_cast<char *>(memchr(const_cast<char *>(p), '\n', ep - p));
-    if (TILE_UNLIKELY(p == nullptr || ep - p < 3)) {
-      return -1;
-    }
+std::size_t
+DetermineHeaderSizeFast(const char *const ptr, std::size_t limit)
+{
+    auto ep = ptr + limit;
+    auto p  = ptr + 1;
+    while (true) {
+        // First '\n' in '\r\n\r\n'
+        p = static_cast<char *>(memchr(const_cast<char *>(p), '\n', ep - p));
+        if (TILE_UNLIKELY(p == nullptr || ep - p < 3)) { return -1; }
 
-    if (p[2] == '\n') {
-      TILE_CHECK_GE(p - 1, ptr);
-      if (TILE_LIKELY(Slice(p - 1, 4) == kEndOfHeaderMarker)) {
-        return (p + 3) - ptr;
-      } else {
-        return -1;
-      }
+        if (p[2] == '\n') {
+            TILE_CHECK_GE(p - 1, ptr);
+            if (TILE_LIKELY(Slice(p - 1, 4) == kEndOfHeaderMarker)) {
+                return (p + 3) - ptr;
+            } else {
+                return -1;
+            }
+        }
+        ++p;
     }
-    ++p;
-  }
 }
 
-} // namespace
+}// namespace
 
-ReadStatus ReadHeader(const NoncontiguousBuffer &buffer, HeaderBlock *header) {
-  auto first_block = buffer.FirstContiguous();
-  const auto size =
-      DetermineHeaderSizeFast(first_block.data(), first_block.size());
+ReadStatus
+ReadHeader(const NoncontiguousBuffer &buffer, HeaderBlock *header)
+{
+    auto first_block = buffer.FirstContiguous();
+    const auto size  = DetermineHeaderSizeFast(first_block.data(), first_block.size());
 
-  // Find a header
-  if (TILE_LIKELY(size != -1)) {
-    header->first = std::unique_ptr<char[]>(new char[size]);
-    header->second = size;
-    memcpy(header->first.get(), first_block.data(), size);
-  } else {
-    if (first_block.size() >= 10 &&
-        !EasyDetectHttp(first_block.data(), first_block.size())) {
-      return ReadStatus::UnexpectedFormat;
+    // Find a header
+    if (TILE_LIKELY(size != -1)) {
+        header->first  = std::unique_ptr<char[]>(new char[size]);
+        header->second = size;
+        memcpy(header->first.get(), first_block.data(), size);
+    } else {
+        if (first_block.size() >= 10 && !EasyDetectHttp(first_block.data(), first_block.size())) {
+            return ReadStatus::UnexpectedFormat;
+        }
+
+        if (buffer.ByteSize() == first_block.size()) {
+            return first_block.size() < FLAGS_tile_http_max_header_size ? ReadStatus::NoEnoughData : ReadStatus::Error;
+        }
+
+        auto slow_buffer = FlattenSlowUntil(buffer, kEndOfHeaderMarker);
+        if (!EndsWith(slow_buffer, kEndOfHeaderMarker)) {
+            return slow_buffer.size() < FLAGS_tile_http_max_header_size ? ReadStatus::NoEnoughData : ReadStatus::Error;
+        }
+
+        const auto slow_buffer_size = slow_buffer.size();
+        header->first               = std::unique_ptr<char[]>(new char[slow_buffer_size]);
+        header->second              = slow_buffer_size;
+        memcpy(header->first.get(), slow_buffer.data(), slow_buffer_size);
     }
 
-    if (buffer.ByteSize() == first_block.size()) {
-      return first_block.size() < FLAGS_tile_http_max_header_size
-                 ? ReadStatus::NoEnoughData
-                 : ReadStatus::Error;
-    }
+    if (TILE_UNLIKELY(!EasyDetectHttp(header->first.get(), header->second))) { return ReadStatus::UnexpectedFormat; }
 
-    auto slow_buffer = FlattenSlowUntil(buffer, kEndOfHeaderMarker);
-    if (!EndsWith(slow_buffer, kEndOfHeaderMarker)) {
-      return slow_buffer.size() < FLAGS_tile_http_max_header_size
-                 ? ReadStatus::NoEnoughData
-                 : ReadStatus::Error;
-    }
-
-    const auto slow_buffer_size = slow_buffer.size();
-    header->first = std::unique_ptr<char[]>(new char[slow_buffer_size]);
-    header->second = slow_buffer_size;
-    memcpy(header->first.get(), slow_buffer.data(), slow_buffer_size);
-  }
-
-  if (TILE_UNLIKELY(!EasyDetectHttp(header->first.get(), header->second))) {
-    return ReadStatus::UnexpectedFormat;
-  }
-
-  return ReadStatus::OK;
+    return ReadStatus::OK;
 }
 
-Slice ReadFieldFromRawBytes(Slice view, Slice key) {
-  std::size_t pos = 0;
-  while (true) {
-    auto field = view.substr(pos);
-    // message-header = field-name ":" [ field-value ]
-    // field-name = token
-    // field-value = *( field-content | LWS )
+Slice
+ReadFieldFromRawBytes(Slice view, Slice key)
+{
+    std::size_t pos = 0;
+    while (true) {
+        auto field = view.substr(pos);
+        // message-header = field-name ":" [ field-value ]
+        // field-name = token
+        // field-value = *( field-content | LWS )
 
-    // min size is [key:\r\n\r\n]
-    // if (view.size() < key.size() + kEndOfHeaderMarkerSize + 1) {
-    //   return "";
-    // }
+        // min size is [key:\r\n\r\n]
+        // if (view.size() < key.size() + kEndOfHeaderMarkerSize + 1) {
+        //   return "";
+        // }
 
-    if (EqualsIgnoreCase(field.substr(0, key.size()), key)) {
-      if (TILE_UNLIKELY(field.size() == key.size())) {
-        TILE_LOG_WARNING_EVERY_SECOND("Invalid Http header? When read [{}].",
-                                      field);
-        return "";
-      }
+        if (EqualsIgnoreCase(field.substr(0, key.size()), key)) {
+            if (TILE_UNLIKELY(field.size() == key.size())) {
+                TILE_LOG_WARNING_EVERY_SECOND("Invalid Http header? When read [{}].", field);
+                return "";
+            }
 
-      if (TILE_LIKELY(field[key.size()] == ':')) {
-        const auto last_pos = field.find('\r');
+            if (TILE_LIKELY(field[key.size()] == ':')) {
+                const auto last_pos = field.find('\r');
 
-        TILE_CHECK_NE(last_pos, Slice::npos);
-        TILE_CHECK_GT(last_pos, key.size() + 1);
+                TILE_CHECK_NE(last_pos, Slice::npos);
+                TILE_CHECK_GT(last_pos, key.size() + 1);
 
-        const auto start_pos = key.size() + 1;
-        return Trim(field.substr(start_pos, last_pos - (start_pos)));
-      }
+                const auto start_pos = key.size() + 1;
+                return Trim(field.substr(start_pos, last_pos - (start_pos)));
+            }
+        }
+
+        pos = view.find('\n', pos + 1);
+        if (pos == Slice::npos) { return ""; }
+        ++pos;
     }
-
-    pos = view.find('\n', pos + 1);
-    if (pos == Slice::npos) {
-      return "";
-    }
-    ++pos;
-  }
 }
-bool ParseMessagePartial(HeaderBlock &&storage, Slice *start_line,
-                         HttpHeaders *headers) {
-  auto storage_ref = headers->RetrieveHeaderStorage(std::move(storage));
-  std::vector<std::pair<Slice, Slice>> fields;
-  fields.reserve(8);
 
-  TILE_CHECK(EndsWith(storage_ref, kEndOfHeaderMarker));
-  auto view = storage_ref.substr(0, storage_ref.size() - 2);
-  auto pos = view.find('\n');
-  TILE_CHECK_NE(pos, Slice::npos);
-  if (TILE_UNLIKELY(pos == 1)) {
-    // is [\r\n\r\n]
-    return false;
-  }
-  *start_line = view.substr(0, pos - 1);
-  view = view.substr(pos + 1);
-  while (!view.empty()) {
-    auto pos = view.find('\n');
+bool
+ParseMessagePartial(HeaderBlock &&storage, Slice *start_line, HttpHeaders *headers)
+{
+    auto storage_ref = headers->RetrieveHeaderStorage(std::move(storage));
+    std::vector<std::pair<Slice, Slice>> fields;
+    fields.reserve(8);
+
+    TILE_CHECK(EndsWith(storage_ref, kEndOfHeaderMarker));
+    auto view = storage_ref.substr(0, storage_ref.size() - 2);
+    auto pos  = view.find('\n');
     TILE_CHECK_NE(pos, Slice::npos);
-    if (TILE_UNLIKELY(pos < 2 || view[pos - 1] != '\r')) {
-      TILE_LOG_WARNING_EVERY_SECOND("Invalid Http header?");
-      return false;
+    if (TILE_UNLIKELY(pos == 1)) {
+        // is [\r\n\r\n]
+        return false;
+    }
+    *start_line = view.substr(0, pos - 1);
+    view        = view.substr(pos + 1);
+    while (!view.empty()) {
+        auto pos = view.find('\n');
+        TILE_CHECK_NE(pos, Slice::npos);
+        if (TILE_UNLIKELY(pos < 2 || view[pos - 1] != '\r')) {
+            TILE_LOG_WARNING_EVERY_SECOND("Invalid Http header?");
+            return false;
+        }
+
+        // get a line
+        auto current = view.substr(0, pos - 1);
+        auto poclon  = current.find(':');
+        if (poclon == Slice::npos) {
+            TILE_LOG_WARNING_EVERY_SECOND("Invalid message header? Read [{}].", current);
+            return false;
+        }
+
+        auto name  = current.substr(0, poclon);
+        auto value = current.substr(poclon + 1);
+
+        if (name.empty()) {
+            TILE_LOG_WARNING_EVERY_SECOND("Empty field-name? Read [{}].", current);
+            return false;
+        }
+
+        fields.emplace_back(name, Trim(value));
+        view = view.substr(pos + 1);
     }
 
-    // get a line
-    auto current = view.substr(0, pos - 1);
-    auto poclon = current.find(':');
-    if (poclon == Slice::npos) {
-      TILE_LOG_WARNING_EVERY_SECOND("Invalid message header? Read [{}].",
-                                    current);
-      return false;
-    }
-
-    auto name = current.substr(0, poclon);
-    auto value = current.substr(poclon + 1);
-
-    if (name.empty()) {
-      TILE_LOG_WARNING_EVERY_SECOND("Empty field-name? Read [{}].", current);
-      return false;
-    }
-
-    fields.emplace_back(name, Trim(value));
-    view = view.substr(pos + 1);
-  }
-
-  headers->RetrieveFields(std::move(fields));
-  return true;
+    headers->RetrieveFields(std::move(fields));
+    return true;
 }
 
-bool ParseRequestStartLine(Slice s, HttpVersion *version, HttpMethod *method,
-                           Slice *uri) {
-  // Request-Line: Method SP Request-URI SP HTTP-Version CRLF
-  auto splitted = Split(s, " ");
-  if (splitted.size() < 3) {
-    TILE_LOG_WARNING_EVERY_SECOND("Invalid HTTP request Start-Line: {}", s);
-    return false;
-  }
+bool
+ParseRequestStartLine(Slice s, HttpVersion *version, HttpMethod *method, Slice *uri)
+{
+    // Request-Line: Method SP Request-URI SP HTTP-Version CRLF
+    auto splitted = Split(s, " ");
+    if (splitted.size() < 3) {
+        TILE_LOG_WARNING_EVERY_SECOND("Invalid HTTP request Start-Line: {}", s);
+        return false;
+    }
 
-  // Parse HttpVersion
-  {
-    auto opt = TryParse<HttpVersion>(splitted[2]);
+    // Parse HttpVersion
+    {
+        auto opt = TryParse<HttpVersion>(splitted[2]);
+        if (!opt) {
+            TILE_LOG_WARNING_EVERY_SECOND("Invalid HTTP request Start-Line: {}", s);
+            return false;
+        } else if (*opt != HttpVersion::V_1_0 && *opt != HttpVersion::V_1_1) {
+            TILE_LOG_WARNING_EVERY_SECOND("Unsupport HttpVersion Start-Line: {}", s);
+            return false;
+        } else {
+            *version = *opt;
+        }
+    }
+
+    // Parse HttpMethod
+    {
+        auto opt = TryParse<HttpMethod>(splitted[0]);
+        if (!opt) {
+            TILE_LOG_WARNING_EVERY_SECOND("Invalid HTTP request Start-Line: {}", s);
+            return false;
+        } else {
+            *method = *opt;
+        }
+    }
+
+    *uri = splitted[1];
+    return true;
+}
+
+bool
+ParseResponseStartLine(Slice s, HttpStatus *code)
+{
+    // HTTP/1.1 301 Moved Permanently
+    auto splitted = Split(s, " ", false, 3);
+    if (splitted.size() < 2) {
+        TILE_LOG_WARNING_EVERY_SECOND("Invalid HTTP response Start-Line: {}", s);
+        return false;
+    }
+
+    auto opt = TryParse<int>(splitted[1]);
     if (!opt) {
-      TILE_LOG_WARNING_EVERY_SECOND("Invalid HTTP request Start-Line: {}", s);
-      return false;
-    } else if (*opt != HttpVersion::V_1_0 && *opt != HttpVersion::V_1_1) {
-      TILE_LOG_WARNING_EVERY_SECOND("Unsupport HttpVersion Start-Line: {}", s);
-      return false;
+        TILE_LOG_WARNING_EVERY_SECOND("Invalid HTTP response Start-Line: {}", s);
+        return false;
     } else {
-      *version = *opt;
+        *code = static_cast<HttpStatus>(*opt);
     }
-  }
+    return true;
+}
 
-  // Parse HttpMethod
-  {
-    auto opt = TryParse<HttpMethod>(splitted[0]);
-    if (!opt) {
-      TILE_LOG_WARNING_EVERY_SECOND("Invalid HTTP request Start-Line: {}", s);
-      return false;
+void
+WriteMessage(const HttpRequest &req, NoncontiguousBufferBuilder *builder)
+{
+    // Request-Line: Method SP Request-URI SP HTTP-Version CRLF
+    builder->Append(ToSlice(req.method()), " ", req.uri(), " ", ToSlice(req.version()), "\r\n");
+
+    WriteHeader(*req.headers(), builder);
+    builder->Append("\r\n");
+    if (req.noncontiguous_body()) {
+        builder->Append(*req.noncontiguous_body());
     } else {
-      *method = *opt;
+        builder->Append(*req.body());
     }
-  }
-
-  *uri = splitted[1];
-  return true;
 }
 
-bool ParseResponseStartLine(Slice s, HttpStatus *code) {
-  // HTTP/1.1 301 Moved Permanently
-  auto splitted = Split(s, " ", false, 3);
-  if (splitted.size() < 2) {
-    TILE_LOG_WARNING_EVERY_SECOND("Invalid HTTP response Start-Line: {}", s);
-    return false;
-  }
+void
+WriteMessage(const HttpResponse &resp, NoncontiguousBufferBuilder *builder)
+{
+    // Status-Line: HTTP-Version SP Status-Code SP Reason-Phrase CRLF
+    builder->Append(ToSlice(resp.version()), " ", GetStatusCodeWithDescString(resp.status()), "\r\n");
 
-  auto opt = TryParse<int>(splitted[1]);
-  if (!opt) {
-    TILE_LOG_WARNING_EVERY_SECOND("Invalid HTTP response Start-Line: {}", s);
-    return false;
-  } else {
-    *code = static_cast<HttpStatus>(*opt);
-  }
-  return true;
+    WriteHeader(*resp.headers(), builder);
+    builder->Append("\r\n");
+    if (resp.noncontiguous_body()) {
+        builder->Append(*resp.noncontiguous_body());
+    } else {
+        builder->Append(*resp.body());
+    }
 }
 
-void WriteMessage(const HttpRequest &req, NoncontiguousBufferBuilder *builder) {
-  // Request-Line: Method SP Request-URI SP HTTP-Version CRLF
-  builder->Append(ToSlice(req.method()), " ", req.uri(), " ",
-                  ToSlice(req.version()), "\r\n");
-
-  WriteHeader(*req.headers(), builder);
-  builder->Append("\r\n");
-  if (req.noncontiguous_body()) {
-    builder->Append(*req.noncontiguous_body());
-  } else {
-    builder->Append(*req.body());
-  }
-}
-
-void WriteMessage(const HttpResponse &resp,
-                  NoncontiguousBufferBuilder *builder) {
-  // Status-Line: HTTP-Version SP Status-Code SP Reason-Phrase CRLF
-  builder->Append(ToSlice(resp.version()), " ",
-                  GetStatusCodeWithDescString(resp.status()), "\r\n");
-
-  WriteHeader(*resp.headers(), builder);
-  builder->Append("\r\n");
-  if (resp.noncontiguous_body()) {
-    builder->Append(*resp.noncontiguous_body());
-  } else {
-    builder->Append(*resp.body());
-  }
-}
-
-} // namespace http
-} // namespace tile
+}// namespace http
+}// namespace tile
diff --git a/tile/rpc/protocol/http/buffer_io.h b/tile/rpc/protocol/http/buffer_io.h
index fd6cfd4..a67247e 100644
--- a/tile/rpc/protocol/http/buffer_io.h
+++ b/tile/rpc/protocol/http/buffer_io.h
@@ -14,7 +14,8 @@ class HttpRequest;
 class HttpHeaders;
 class HttpResponse;
 
-} // namespace tile
+}// namespace tile
+
 namespace tile {
 namespace http {
 enum class ReadStatus { OK, NoEnoughData, UnexpectedFormat, Error };
@@ -28,19 +29,16 @@ using HeaderBlock = std::pair<std::unique_ptr<char[]>, std::size_t>;
 ReadStatus ReadHeader(const NoncontiguousBuffer &buffer, HeaderBlock *storage);
 
 Slice ReadFieldFromRawBytes(Slice view, Slice key);
-bool ParseMessagePartial(HeaderBlock &&storage, Slice *start_line,
-                         HttpHeaders *headers);
+bool ParseMessagePartial(HeaderBlock &&storage, Slice *start_line, HttpHeaders *headers);
 // bool ParseMessagePartial(HeaderBlock &&storage, Slice *start_line,
 //                          HttpHeaders *headers);
-bool ParseRequestStartLine(Slice s, HttpVersion *version, HttpMethod *method,
-                           Slice *uri);
+bool ParseRequestStartLine(Slice s, HttpVersion *version, HttpMethod *method, Slice *uri);
 bool ParseResponseStartLine(Slice s, HttpStatus *code);
 
 void WriteMessage(const HttpRequest &req, NoncontiguousBufferBuilder *builder);
-void WriteMessage(const HttpResponse &resp,
-                  NoncontiguousBufferBuilder *builder);
+void WriteMessage(const HttpResponse &resp, NoncontiguousBufferBuilder *builder);
 
-} // namespace http
-} // namespace tile
+}// namespace http
+}// namespace tile
 
-#endif // TILE_RPC_PROTOCOL_HTTP_BUFFER_IO_H
+#endif// TILE_RPC_PROTOCOL_HTTP_BUFFER_IO_H
diff --git a/tile/rpc/protocol/http/buffer_io_test.cc b/tile/rpc/protocol/http/buffer_io_test.cc
index ec8ea36..67c5e12 100644
--- a/tile/rpc/protocol/http/buffer_io_test.cc
+++ b/tile/rpc/protocol/http/buffer_io_test.cc
@@ -13,235 +13,238 @@
 namespace tile {
 namespace http {
 
-TEST(ReadHeaderAndParse, Easy) {
-  static const auto header = "GET / HTTP/1.1\r\n"
-                             "Content-Type:    application/json\r\n"
-                             "Content-Length: 10   \r\n"
-                             "X-Empty-Header:    \r\n"
-                             "X-Duplicate-Header:   1\r\n"
-                             "X-Duplicate-Header: 2\r\n"
-                             "\r\n";
-  NoncontiguousBuffer buffer;
+TEST(ReadHeaderAndParse, Easy)
+{
+    static const auto header =
+        "GET / HTTP/1.1\r\n"
+        "Content-Type:    application/json\r\n"
+        "Content-Length: 10   \r\n"
+        "X-Empty-Header:    \r\n"
+        "X-Duplicate-Header:   1\r\n"
+        "X-Duplicate-Header: 2\r\n"
+        "\r\n";
+    NoncontiguousBuffer buffer;
 
-  buffer.Append(CreateBufferSlow(header));
-  HeaderBlock header_block;
-  ASSERT_EQ(ReadStatus::OK, ReadHeader(buffer, &header_block));
+    buffer.Append(CreateBufferSlow(header));
+    HeaderBlock header_block;
+    ASSERT_EQ(ReadStatus::OK, ReadHeader(buffer, &header_block));
 
-  HttpHeaders headers;
-  Slice start_line;
-  ASSERT_TRUE(
-      ParseMessagePartial(std::move(header_block), &start_line, &headers));
-  ASSERT_EQ("10", *headers.TryGet("Content-Length"));
-  ASSERT_EQ("application/json", *headers.TryGet("Content-Type"));
-  ASSERT_EQ("", *headers.TryGet("X-Empty-Header"));
-  ASSERT_THAT(headers.TryGetMultiple("X-Duplicate-Header"),
-              ::testing::ElementsAre("1", "2"));
-  ASSERT_EQ("Content-Type: application/json\r\n"
-            "Content-Length: 10\r\n"
-            "X-Empty-Header: \r\n"
-            "X-Duplicate-Header: 1\r\n"
-            "X-Duplicate-Header: 2\r\n",
-            headers.ToString());
-  ASSERT_EQ("GET / HTTP/1.1", start_line);
+    HttpHeaders headers;
+    Slice start_line;
+    ASSERT_TRUE(ParseMessagePartial(std::move(header_block), &start_line, &headers));
+    ASSERT_EQ("10", *headers.TryGet("Content-Length"));
+    ASSERT_EQ("application/json", *headers.TryGet("Content-Type"));
+    ASSERT_EQ("", *headers.TryGet("X-Empty-Header"));
+    ASSERT_THAT(headers.TryGetMultiple("X-Duplicate-Header"), ::testing::ElementsAre("1", "2"));
+    ASSERT_EQ("Content-Type: application/json\r\n"
+              "Content-Length: 10\r\n"
+              "X-Empty-Header: \r\n"
+              "X-Duplicate-Header: 1\r\n"
+              "X-Duplicate-Header: 2\r\n",
+              headers.ToString());
+    ASSERT_EQ("GET / HTTP/1.1", start_line);
 }
 
-TEST(ReadHeaderAndParse, Normal) {
-  NoncontiguousBuffer buffer;
-  HeaderBlock header_block;
+TEST(ReadHeaderAndParse, Normal)
+{
+    NoncontiguousBuffer buffer;
+    HeaderBlock header_block;
 
-  buffer.Append(CreateBufferSlow("HTTP/1.1 "));
-  buffer.Append(CreateBufferSlow("B"));
-  buffer.Append(CreateBufferSlow("o"));
-  buffer.Append(CreateBufferSlow("r"));
-  buffer.Append(CreateBufferSlow("i"));
-  buffer.Append(CreateBufferSlow("n"));
-  buffer.Append(CreateBufferSlow("g"));
-  buffer.Append(CreateBufferSlow(" "));
-  buffer.Append(CreateBufferSlow("l"));
-  buffer.Append(CreateBufferSlow("i"));
-  buffer.Append(CreateBufferSlow("n"));
-  buffer.Append(CreateBufferSlow("e\r"));
-  buffer.Append(CreateBufferSlow("\nContent-Type"));
-  ASSERT_EQ(ReadStatus::NoEnoughData, ReadHeader(buffer, &header_block));
-  buffer.Append(CreateBufferSlow(":"));
-  ASSERT_EQ(ReadStatus::NoEnoughData, ReadHeader(buffer, &header_block));
-  buffer.Append(CreateBufferSlow("application/json"));
-  ASSERT_EQ(ReadStatus::NoEnoughData, ReadHeader(buffer, &header_block));
-  buffer.Append(CreateBufferSlow("\r"));
-  ASSERT_EQ(ReadStatus::NoEnoughData, ReadHeader(buffer, &header_block));
-  buffer.Append(CreateBufferSlow("\n"));
-  ASSERT_EQ(ReadStatus::NoEnoughData, ReadHeader(buffer, &header_block));
-  buffer.Append(CreateBufferSlow("Content-Length:"));
-  ASSERT_EQ(ReadStatus::NoEnoughData, ReadHeader(buffer, &header_block));
-  buffer.Append(CreateBufferSlow(" 10     \r"));
-  ASSERT_EQ(ReadStatus::NoEnoughData, ReadHeader(buffer, &header_block));
-  buffer.Append(CreateBufferSlow("\n"));
-  buffer.Append(CreateBufferSlow("X-Empty-"));
-  buffer.Append(CreateBufferSlow("Heade"));
-  buffer.Append(CreateBufferSlow("r:"));
-  ASSERT_EQ(ReadStatus::NoEnoughData, ReadHeader(buffer, &header_block));
-  buffer.Append(CreateBufferSlow("\r"));
-  ASSERT_EQ(ReadStatus::NoEnoughData, ReadHeader(buffer, &header_block));
-  buffer.Append(CreateBufferSlow("\n"));
-  buffer.Append(CreateBufferSlow("X-Duplicate-Header:   1\r\n"));
-  buffer.Append(CreateBufferSlow("X-Duplicate-Header: 2  \r\n"));
-  ASSERT_EQ(ReadStatus::NoEnoughData, ReadHeader(buffer, &header_block));
-  buffer.Append(CreateBufferSlow("\r"));
-  ASSERT_EQ(ReadStatus::NoEnoughData, ReadHeader(buffer, &header_block));
-  buffer.Append(CreateBufferSlow("\n"));
-  ASSERT_EQ(ReadStatus::OK, ReadHeader(buffer, &header_block));
+    buffer.Append(CreateBufferSlow("HTTP/1.1 "));
+    buffer.Append(CreateBufferSlow("B"));
+    buffer.Append(CreateBufferSlow("o"));
+    buffer.Append(CreateBufferSlow("r"));
+    buffer.Append(CreateBufferSlow("i"));
+    buffer.Append(CreateBufferSlow("n"));
+    buffer.Append(CreateBufferSlow("g"));
+    buffer.Append(CreateBufferSlow(" "));
+    buffer.Append(CreateBufferSlow("l"));
+    buffer.Append(CreateBufferSlow("i"));
+    buffer.Append(CreateBufferSlow("n"));
+    buffer.Append(CreateBufferSlow("e\r"));
+    buffer.Append(CreateBufferSlow("\nContent-Type"));
+    ASSERT_EQ(ReadStatus::NoEnoughData, ReadHeader(buffer, &header_block));
+    buffer.Append(CreateBufferSlow(":"));
+    ASSERT_EQ(ReadStatus::NoEnoughData, ReadHeader(buffer, &header_block));
+    buffer.Append(CreateBufferSlow("application/json"));
+    ASSERT_EQ(ReadStatus::NoEnoughData, ReadHeader(buffer, &header_block));
+    buffer.Append(CreateBufferSlow("\r"));
+    ASSERT_EQ(ReadStatus::NoEnoughData, ReadHeader(buffer, &header_block));
+    buffer.Append(CreateBufferSlow("\n"));
+    ASSERT_EQ(ReadStatus::NoEnoughData, ReadHeader(buffer, &header_block));
+    buffer.Append(CreateBufferSlow("Content-Length:"));
+    ASSERT_EQ(ReadStatus::NoEnoughData, ReadHeader(buffer, &header_block));
+    buffer.Append(CreateBufferSlow(" 10     \r"));
+    ASSERT_EQ(ReadStatus::NoEnoughData, ReadHeader(buffer, &header_block));
+    buffer.Append(CreateBufferSlow("\n"));
+    buffer.Append(CreateBufferSlow("X-Empty-"));
+    buffer.Append(CreateBufferSlow("Heade"));
+    buffer.Append(CreateBufferSlow("r:"));
+    ASSERT_EQ(ReadStatus::NoEnoughData, ReadHeader(buffer, &header_block));
+    buffer.Append(CreateBufferSlow("\r"));
+    ASSERT_EQ(ReadStatus::NoEnoughData, ReadHeader(buffer, &header_block));
+    buffer.Append(CreateBufferSlow("\n"));
+    buffer.Append(CreateBufferSlow("X-Duplicate-Header:   1\r\n"));
+    buffer.Append(CreateBufferSlow("X-Duplicate-Header: 2  \r\n"));
+    ASSERT_EQ(ReadStatus::NoEnoughData, ReadHeader(buffer, &header_block));
+    buffer.Append(CreateBufferSlow("\r"));
+    ASSERT_EQ(ReadStatus::NoEnoughData, ReadHeader(buffer, &header_block));
+    buffer.Append(CreateBufferSlow("\n"));
+    ASSERT_EQ(ReadStatus::OK, ReadHeader(buffer, &header_block));
 
-  HttpHeaders headers;
-  Slice start_line;
-  ASSERT_TRUE(
-      ParseMessagePartial(std::move(header_block), &start_line, &headers));
-  ASSERT_EQ("10", *headers.TryGet("Content-Length"));
-  ASSERT_EQ("application/json", *headers.TryGet("Content-Type"));
-  ASSERT_EQ("", *headers.TryGet("X-Empty-Header"));
-  ASSERT_THAT(headers.TryGetMultiple("X-Duplicate-Header"),
-              ::testing::ElementsAre("1", "2"));
-  ASSERT_EQ("Content-Type: application/json\r\n"
-            "Content-Length: 10\r\n"
-            "X-Empty-Header: \r\n"
-            "X-Duplicate-Header: 1\r\n"
-            "X-Duplicate-Header: 2\r\n",
-            headers.ToString());
-  ASSERT_EQ("HTTP/1.1 Boring line", start_line);
+    HttpHeaders headers;
+    Slice start_line;
+    ASSERT_TRUE(ParseMessagePartial(std::move(header_block), &start_line, &headers));
+    ASSERT_EQ("10", *headers.TryGet("Content-Length"));
+    ASSERT_EQ("application/json", *headers.TryGet("Content-Type"));
+    ASSERT_EQ("", *headers.TryGet("X-Empty-Header"));
+    ASSERT_THAT(headers.TryGetMultiple("X-Duplicate-Header"), ::testing::ElementsAre("1", "2"));
+    ASSERT_EQ("Content-Type: application/json\r\n"
+              "Content-Length: 10\r\n"
+              "X-Empty-Header: \r\n"
+              "X-Duplicate-Header: 1\r\n"
+              "X-Duplicate-Header: 2\r\n",
+              headers.ToString());
+    ASSERT_EQ("HTTP/1.1 Boring line", start_line);
 }
 
-TEST(ReadHeader, NoEnoughData) {
-  NoncontiguousBuffer buffer;
-  HeaderBlock header_block;
+TEST(ReadHeader, NoEnoughData)
+{
+    NoncontiguousBuffer buffer;
+    HeaderBlock header_block;
 
-  buffer.Append(CreateBufferSlow("GET / HTTP/1.1\r\nContent-Type"));
-  ASSERT_EQ(ReadStatus::NoEnoughData, ReadHeader(buffer, &header_block));
+    buffer.Append(CreateBufferSlow("GET / HTTP/1.1\r\nContent-Type"));
+    ASSERT_EQ(ReadStatus::NoEnoughData, ReadHeader(buffer, &header_block));
 }
 
-TEST(ReadHeader, NoEnoughData2) {
-  NoncontiguousBuffer buffer;
-  HeaderBlock header_block;
+TEST(ReadHeader, NoEnoughData2)
+{
+    NoncontiguousBuffer buffer;
+    HeaderBlock header_block;
 
-  buffer.Append(CreateBufferSlow("GET / HTTP/1.1\r\nContent-Type:aaa\r\n:"));
-  ASSERT_EQ(ReadStatus::NoEnoughData, ReadHeader(buffer, &header_block));
+    buffer.Append(CreateBufferSlow("GET / HTTP/1.1\r\nContent-Type:aaa\r\n:"));
+    ASSERT_EQ(ReadStatus::NoEnoughData, ReadHeader(buffer, &header_block));
 }
 
-TEST(ParseMessagePartial, Malformed0) {
-  NoncontiguousBuffer buffer;
-  HeaderBlock header_block;
+TEST(ParseMessagePartial, Malformed0)
+{
+    NoncontiguousBuffer buffer;
+    HeaderBlock header_block;
 
-  buffer.Append(CreateBufferSlow("GET / HTTP/1.1\r\nContent-Type"));
-  buffer.Append(CreateBufferSlow("\r\n\r\n"));
-  ASSERT_EQ(ReadStatus::OK, ReadHeader(buffer, &header_block));
+    buffer.Append(CreateBufferSlow("GET / HTTP/1.1\r\nContent-Type"));
+    buffer.Append(CreateBufferSlow("\r\n\r\n"));
+    ASSERT_EQ(ReadStatus::OK, ReadHeader(buffer, &header_block));
 
-  Slice start_line;
-  HttpHeaders headers;
-  ASSERT_FALSE(
-      ParseMessagePartial(std::move(header_block), &start_line, &headers));
+    Slice start_line;
+    HttpHeaders headers;
+    ASSERT_FALSE(ParseMessagePartial(std::move(header_block), &start_line, &headers));
 }
 
-TEST(ParseMessagePartial, Malformed1) {
-  NoncontiguousBuffer buffer;
-  HeaderBlock header_block;
+TEST(ParseMessagePartial, Malformed1)
+{
+    NoncontiguousBuffer buffer;
+    HeaderBlock header_block;
 
-  buffer.Append(CreateBufferSlow("GET / HTTP/1.1\r\n"
-                                 "Content-Type\r\n\r\n"
-                                 "Content-Type:aaa\r\n"
-                                 "Content-Length:123\r\n\r\n"));
-  ASSERT_EQ(ReadStatus::OK, ReadHeader(buffer, &header_block));
+    buffer.Append(CreateBufferSlow("GET / HTTP/1.1\r\n"
+                                   "Content-Type\r\n\r\n"
+                                   "Content-Type:aaa\r\n"
+                                   "Content-Length:123\r\n\r\n"));
+    ASSERT_EQ(ReadStatus::OK, ReadHeader(buffer, &header_block));
 
-  Slice start_line;
-  HttpHeaders headers;
-  ASSERT_FALSE(
-      ParseMessagePartial(std::move(header_block), &start_line, &headers));
+    Slice start_line;
+    HttpHeaders headers;
+    ASSERT_FALSE(ParseMessagePartial(std::move(header_block), &start_line, &headers));
 }
 
-TEST(ParseMessagePartial, Malformed2) {
-  NoncontiguousBuffer buffer;
-  HeaderBlock header_block;
+TEST(ParseMessagePartial, Malformed2)
+{
+    NoncontiguousBuffer buffer;
+    HeaderBlock header_block;
 
-  buffer.Append(CreateBufferSlow("GET / HTTP/1.1\r\n:\r\n\r\n"));
-  ASSERT_EQ(ReadStatus::OK, ReadHeader(buffer, &header_block));
+    buffer.Append(CreateBufferSlow("GET / HTTP/1.1\r\n:\r\n\r\n"));
+    ASSERT_EQ(ReadStatus::OK, ReadHeader(buffer, &header_block));
 
-  Slice start_line;
-  HttpHeaders headers;
-  ASSERT_FALSE(
-      ParseMessagePartial(std::move(header_block), &start_line, &headers));
+    Slice start_line;
+    HttpHeaders headers;
+    ASSERT_FALSE(ParseMessagePartial(std::move(header_block), &start_line, &headers));
 }
 
-TEST(ParseMessagePartial, Malformed3) {
-  NoncontiguousBuffer buffer;
-  HeaderBlock header_block;
+TEST(ParseMessagePartial, Malformed3)
+{
+    NoncontiguousBuffer buffer;
+    HeaderBlock header_block;
 
-  buffer.Append(
-      CreateBufferSlow("GET / HTTP/1.1\r\nContent-Type:aaa\r\n:\r\n\r\n"));
-  ASSERT_EQ(ReadStatus::OK, ReadHeader(buffer, &header_block));
+    buffer.Append(CreateBufferSlow("GET / HTTP/1.1\r\nContent-Type:aaa\r\n:\r\n\r\n"));
+    ASSERT_EQ(ReadStatus::OK, ReadHeader(buffer, &header_block));
 
-  Slice start_line;
-  HttpHeaders headers;
-  ASSERT_FALSE(
-      ParseMessagePartial(std::move(header_block), &start_line, &headers));
+    Slice start_line;
+    HttpHeaders headers;
+    ASSERT_FALSE(ParseMessagePartial(std::move(header_block), &start_line, &headers));
 }
 
-TEST(ParseMessagePartial, NoHttpHeaders) {
-  NoncontiguousBuffer buffer;
-  HeaderBlock header_block;
+TEST(ParseMessagePartial, NoHttpHeaders)
+{
+    NoncontiguousBuffer buffer;
+    HeaderBlock header_block;
 
-  buffer.Append(CreateBufferSlow("GET / HTTP/1.1\r\n\r\n"));
-  ASSERT_EQ(ReadStatus::OK, ReadHeader(buffer, &header_block));
-  HttpHeaders headers;
-  Slice start_line;
-  ASSERT_TRUE(
-      ParseMessagePartial(std::move(header_block), &start_line, &headers));
-  ASSERT_EQ("", headers.ToString());
-  ASSERT_EQ("GET / HTTP/1.1", start_line);
+    buffer.Append(CreateBufferSlow("GET / HTTP/1.1\r\n\r\n"));
+    ASSERT_EQ(ReadStatus::OK, ReadHeader(buffer, &header_block));
+    HttpHeaders headers;
+    Slice start_line;
+    ASSERT_TRUE(ParseMessagePartial(std::move(header_block), &start_line, &headers));
+    ASSERT_EQ("", headers.ToString());
+    ASSERT_EQ("GET / HTTP/1.1", start_line);
 }
 
-TEST(ReadHeader, EntityTooLarge) {
-  NoncontiguousBuffer buffer;
-  HeaderBlock header_block;
+TEST(ReadHeader, EntityTooLarge)
+{
+    NoncontiguousBuffer buffer;
+    HeaderBlock header_block;
 
-  buffer.Append(CreateBufferSlow("GET / HTTP/1.1" + std::string(1000000, 'c')));
-  ASSERT_EQ(ReadStatus::Error, ReadHeader(buffer, &header_block));
+    buffer.Append(CreateBufferSlow("GET / HTTP/1.1" + std::string(1000000, 'c')));
+    ASSERT_EQ(ReadStatus::Error, ReadHeader(buffer, &header_block));
 }
 
-TEST(WriteMessage, Request) {
-  HttpRequest request;
-  request.set_version(HttpVersion::V_1_0);
-  request.set_method(HttpMethod::Post);
-  request.set_uri("/path/to/something");
-  request.set_body("body123456");
-  request.headers()->Append("X-Duplicate-Header", "1");
-  request.headers()->Append("X-Duplicate-Header", "2");
-  request.headers()->Append("Content-Length", "10");
-  NoncontiguousBufferBuilder builder;
-  WriteMessage(request, &builder);
-  ASSERT_EQ("POST /path/to/something HTTP/1.0\r\n"
-            "X-Duplicate-Header: 1\r\n"
-            "X-Duplicate-Header: 2\r\n"
-            "Content-Length: 10\r\n"
-            "\r\n"
-            "body123456",
-            FlattenSlow(builder.DestructiveGet()));
+TEST(WriteMessage, Request)
+{
+    HttpRequest request;
+    request.set_version(HttpVersion::V_1_0);
+    request.set_method(HttpMethod::Post);
+    request.set_uri("/path/to/something");
+    request.set_body("body123456");
+    request.headers()->Append("X-Duplicate-Header", "1");
+    request.headers()->Append("X-Duplicate-Header", "2");
+    request.headers()->Append("Content-Length", "10");
+    NoncontiguousBufferBuilder builder;
+    WriteMessage(request, &builder);
+    ASSERT_EQ("POST /path/to/something HTTP/1.0\r\n"
+              "X-Duplicate-Header: 1\r\n"
+              "X-Duplicate-Header: 2\r\n"
+              "Content-Length: 10\r\n"
+              "\r\n"
+              "body123456",
+              FlattenSlow(builder.DestructiveGet()));
 }
 
-TEST(WriteMessage, Response) {
-  HttpResponse response;
-  response.set_version(HttpVersion::V_1_1);
-  response.set_status(HttpStatus::OK);
-  response.set_body("123");
-  response.headers()->Append("X-Response-Header", "1");
-  response.headers()->Append("X-Response-Header", "2");
-  response.headers()->Append("Content-Length", "3");
-  NoncontiguousBufferBuilder builder;
-  WriteMessage(response, &builder);
-  ASSERT_EQ("HTTP/1.1 200 OK\r\n"
-            "X-Response-Header: 1\r\n"
-            "X-Response-Header: 2\r\n"
-            "Content-Length: 3\r\n"
-            "\r\n"
-            "123",
-            FlattenSlow(builder.DestructiveGet()));
+TEST(WriteMessage, Response)
+{
+    HttpResponse response;
+    response.set_version(HttpVersion::V_1_1);
+    response.set_status(HttpStatus::OK);
+    response.set_body("123");
+    response.headers()->Append("X-Response-Header", "1");
+    response.headers()->Append("X-Response-Header", "2");
+    response.headers()->Append("Content-Length", "3");
+    NoncontiguousBufferBuilder builder;
+    WriteMessage(response, &builder);
+    ASSERT_EQ("HTTP/1.1 200 OK\r\n"
+              "X-Response-Header: 1\r\n"
+              "X-Response-Header: 2\r\n"
+              "Content-Length: 3\r\n"
+              "\r\n"
+              "123",
+              FlattenSlow(builder.DestructiveGet()));
 }
 
-} // namespace http
-} // namespace tile
+}// namespace http
+}// namespace tile
diff --git a/tile/rpc/protocol/message.cc b/tile/rpc/protocol/message.cc
index 7329198..39f09cd 100644
--- a/tile/rpc/protocol/message.cc
+++ b/tile/rpc/protocol/message.cc
@@ -6,14 +6,13 @@ namespace tile {
 namespace {
 class NullFactory : public MessageFactory {
 public:
-  std::unique_ptr<Message> Create(Type type, std::uint64_t correlation_id,
-                                  bool stream) const override {
-    return nullptr;
-  }
+    std::unique_ptr<Message> Create(Type type, std::uint64_t correlation_id, bool stream) const override
+    {
+        return nullptr;
+    }
 };
-} // namespace
+}// namespace
 
-const MessageFactory *MessageFactory::null_factory =
-    internal::LazyInit<NullFactory>();
+const MessageFactory *MessageFactory::null_factory = internal::LazyInit<NullFactory>();
 
-} // namespace tile
+}// namespace tile
diff --git a/tile/rpc/protocol/message.h b/tile/rpc/protocol/message.h
index 56a6e4b..2438a59 100644
--- a/tile/rpc/protocol/message.h
+++ b/tile/rpc/protocol/message.h
@@ -9,36 +9,35 @@
 namespace tile {
 class Message : public ExactMatchCastable {
 public:
-  virtual ~Message() = default;
+    virtual ~Message() = default;
 
-  enum class Type : std::uint64_t {
-    Single,
-    Stream, // with both `StartOfStream` and `EndOfStream`
-    StartOfStream = 1ULL << 62,
-    EndOfStream = 1ULL << 63
-  };
+    enum class Type : std::uint64_t {
+        Single,
+        Stream,// with both `StartOfStream` and `EndOfStream`
+        StartOfStream = 1ULL << 62,
+        EndOfStream   = 1ULL << 63
+    };
 
-  static constexpr std::uint64_t kNonmultiplexableCorrelationId = 1;
-  virtual std::uint64_t GetCorrelationId() const noexcept = 0;
-  virtual Type GetType() const noexcept = 0;
+    static constexpr std::uint64_t kNonmultiplexableCorrelationId = 1;
+    virtual std::uint64_t GetCorrelationId() const noexcept       = 0;
+    virtual Type GetType() const noexcept                         = 0;
 };
 
 class MessageFactory {
 public:
-  virtual ~MessageFactory() = default;
+    virtual ~MessageFactory() = default;
 
-  enum class Type {
-    Overloaded,    // Server side
-    CircuitBroken, // Client side
-  };
+    enum class Type {
+        Overloaded,   // Server side
+        CircuitBroken,// Client side
+    };
 
-  virtual std::unique_ptr<Message>
-  Create(Type type, std::uint64_t correlation_id, bool stream) const = 0;
-  static const MessageFactory *null_factory;
+    virtual std::unique_ptr<Message> Create(Type type, std::uint64_t correlation_id, bool stream) const = 0;
+    static const MessageFactory *null_factory;
 };
 
 TILE_DEFINE_ENUM_BITMASK_OPS(Message::Type);
 
-} // namespace tile
+}// namespace tile
 
-#endif // TILE_RPC_PROTOCOL_MESSAGE_H
+#endif// TILE_RPC_PROTOCOL_MESSAGE_H
diff --git a/tile/rpc/server.cc b/tile/rpc/server.cc
index a03e3d9..4cce134 100644
--- a/tile/rpc/server.cc
+++ b/tile/rpc/server.cc
@@ -12,32 +12,35 @@ DEFINE_int32(tile_rpc_server_max_ongoing_calls, 10000, "");
 namespace tile {
 
 struct Server::ConnectionContext {
-  ConnectionId conn_id;
-  Endpoint remote_peer;
-  rpc::detail::ServerConnectionHandler *handler;
+    ConnectionId conn_id;
+    Endpoint remote_peer;
+    rpc::detail::ServerConnectionHandler *handler;
 };
 
-Server::Server() : Server(Options()) {
-  idle_connn_cleaner_ = internal::TimeKeeper::Instance()->AddTimer(
-      ReadSteadyClock(), 15 * std::chrono::seconds(1),
-      [this]() { OnConnectionCleanupTimer(); }, true);
+Server::Server() : Server(Options())
+{
+    idle_connn_cleaner_ = internal::TimeKeeper::Instance()->AddTimer(
+        ReadSteadyClock(), 15 * std::chrono::seconds(1), [this]() { OnConnectionCleanupTimer(); }, true);
 }
+
 Server::Server(Options opt) : options_(std::move(opt)) {}
 
-Server::~Server() {
-  if (state_ == ServerState::Initialized || state_ == ServerState::Joined) {
-    // Nothing to do then
-  } else if (state_ == ServerState::Running) {
-    Stop();
-    Join();
-  } else {
-    TILE_CHECK(state_ == ServerState::Stopped);
-    TILE_LOG_FATAL("!!!");
-  }
+Server::~Server()
+{
+    if (state_ == ServerState::Initialized || state_ == ServerState::Joined) {
+        // Nothing to do then
+    } else if (state_ == ServerState::Running) {
+        Stop();
+        Join();
+    } else {
+        TILE_CHECK(state_ == ServerState::Stopped);
+        TILE_LOG_FATAL("!!!");
+    }
 }
 
-void Server::AddProtocol(const std::string &name) {
-  if (known_protocols_.find(name) == known_protocols_.end()) {
-  }
+void
+Server::AddProtocol(const std::string &name)
+{
+    if (known_protocols_.find(name) == known_protocols_.end()) {}
 }
-} // namespace tile
+}// namespace tile
diff --git a/tile/rpc/server.h b/tile/rpc/server.h
index 3fd8d1f..0a5dbb2 100644
--- a/tile/rpc/server.h
+++ b/tile/rpc/server.h
@@ -30,7 +30,7 @@ namespace rpc {
 namespace detail {
 class ServerConnectionHandler;
 }
-} // namespace rpc
+}// namespace rpc
 
 using ConnectionId = std::uint64_t;
 
@@ -42,118 +42,113 @@ class HttpFilter;
 class HttpHandler;
 
 class Server {
-  template <typename T> using Factory = std::function<std::unique_ptr<T>>;
+    template<typename T>
+    using Factory = std::function<std::unique_ptr<T>>;
 
 public:
-  struct Options {
-    std::string service_name;
-    std::size_t maximum_packet_size = FLAGS_tile_rpc_server_max_packet_size;
-    std::size_t maximum_concurrent_request =
-        FLAGS_tile_rpc_server_max_ongoing_calls;
-    std::size_t max_concurrent_connections =
-        FLAGS_tile_rpc_server_max_connections;
+    struct Options {
+        std::string service_name;
+        std::size_t maximum_packet_size        = FLAGS_tile_rpc_server_max_packet_size;
+        std::size_t maximum_concurrent_request = FLAGS_tile_rpc_server_max_ongoing_calls;
+        std::size_t max_concurrent_connections = FLAGS_tile_rpc_server_max_connections;
 
-    std::chrono::nanoseconds max_request_queueing_delay =
-        FLAGS_tile_rpc_server_max_request_queuing_delay *
-        std::chrono::milliseconds(1);
+        std::chrono::nanoseconds max_request_queueing_delay =
+            FLAGS_tile_rpc_server_max_request_queuing_delay * std::chrono::milliseconds(1);
 
-    std::function<bool(const Endpoint &)> conn_filter = [](const Endpoint &) {
-      return true;
+        std::function<bool(const Endpoint &)> conn_filter = [](const Endpoint &) { return true; };
     };
-  };
 
-  Server();
-  explicit Server(Options opt);
-  ~Server();
+    Server();
+    explicit Server(Options opt);
+    ~Server();
 
-  void AddProtocol(const std::string &name);
-  void AddProtocol(std::initializer_list<std::string>) = delete;
-  void AddProtocol(Factory<StreamProtocol> factory);
+    void AddProtocol(const std::string &name);
+    void AddProtocol(std::initializer_list<std::string>) = delete;
+    void AddProtocol(Factory<StreamProtocol> factory);
 
-  void AddProtocols(const std::vector<std::string> &names);
+    void AddProtocols(const std::vector<std::string> &names);
 
-  void ListenOn(const Endpoint &endpoint, int backlog = 128);
+    void ListenOn(const Endpoint &endpoint, int backlog = 128);
 
-  bool Start();
-  void Stop();
-  void Join();
+    bool Start();
+    void Stop();
+    void Join();
 
-  void AddHttpFilter(MaybeOwningArgument<HttpFilter> filter);
-  void AddHttpHandler(std::regex path,
-                      MaybeOwningArgument<HttpHandler> handler);
-  void AddHttpPrefixHandler(std::string prefix,
-                            MaybeOwningArgument<HttpHandler> handler);
-  void SetDefaultHttpHandler(MaybeOwningArgument<HttpHandler> handler);
+    void AddHttpFilter(MaybeOwningArgument<HttpFilter> filter);
+    void AddHttpHandler(std::regex path, MaybeOwningArgument<HttpHandler> handler);
+    void AddHttpPrefixHandler(std::string prefix, MaybeOwningArgument<HttpHandler> handler);
+    void SetDefaultHttpHandler(MaybeOwningArgument<HttpHandler> handler);
 
-  template <typename T> T *GetBuiltinNativeService();
+    template<typename T>
+    T *GetBuiltinNativeService();
 
 private:
-  struct ConnectionContext;
+    struct ConnectionContext;
 
-  enum class ServerState { Initialized, Running, Stopped, Joined };
+    enum class ServerState { Initialized, Running, Stopped, Joined };
 
 private:
-  void OnConnection(Handle fd, Endpoint peer);
+    void OnConnection(Handle fd, Endpoint peer);
 
-  void OnNewCall();
-  void OnCallCompletion();
-  void OnConnectionClosed(ConnectionId id);
-  void OnConnectionCleanupTimer();
+    void OnNewCall();
+    void OnCallCompletion();
+    void OnConnectionClosed(ConnectionId id);
+    void OnConnectionCleanupTimer();
 
-  std::unique_ptr<rpc::detail::ServerConnectionHandler>
-  CreateNormalConnectionHandler(ConnectionId id, Endpoint peer);
+    std::unique_ptr<rpc::detail::ServerConnectionHandler> CreateNormalConnectionHandler(ConnectionId id, Endpoint peer);
 
-  void StartBackgroundJob(std::function<void()> cb);
+    void StartBackgroundJob(std::function<void()> cb);
 
 private:
-  Options options_;
-  ServerState state_{ServerState::Initialized};
+    Options options_;
+    ServerState state_{ServerState::Initialized};
 
-  internal::TimerID idle_connn_cleaner_;
+    internal::TimerID idle_connn_cleaner_;
 
-  // Set by `ListenOn`
-  Endpoint listening_on_;
-  std::function<void()> listen_cb_;
+    // Set by `ListenOn`
+    Endpoint listening_on_;
+    std::function<void()> listen_cb_;
 
-  std::atomic<std::size_t> alive_conns_{0};
+    std::atomic<std::size_t> alive_conns_{0};
 
-  std::vector<std::pair<std::unique_ptr<HttpHandler>, std::vector<std::string>>>
-      builtin_http_handlers;
-  std::vector<std::pair<std::unique_ptr<HttpHandler>, std::vector<std::string>>>
-      builtin_http_prefix_handlers;
+    std::vector<std::pair<std::unique_ptr<HttpHandler>, std::vector<std::string>>> builtin_http_handlers;
+    std::vector<std::pair<std::unique_ptr<HttpHandler>, std::vector<std::string>>> builtin_http_prefix_handlers;
 
-  // === for protobuf ===
-  std::unordered_set<std::string> known_protocols_;
+    // === for protobuf ===
+    std::unordered_set<std::string> known_protocols_;
 
-  std::vector<Factory<StreamProtocol>> protocol_factories_;
-  RefPtr<NativeAcceptor> acceptor_;
+    std::vector<Factory<StreamProtocol>> protocol_factories_;
+    RefPtr<NativeAcceptor> acceptor_;
 
-  // `TypeIndex` -> `protobuf::Service*`
-  std::unordered_map<TypeIndex, StreamService *> builtin_services_;
-  std::deque<MaybeOwning<StreamService>> services_;
+    // `TypeIndex` -> `protobuf::Service*`
+    std::unordered_map<TypeIndex, StreamService *> builtin_services_;
+    std::deque<MaybeOwning<StreamService>> services_;
 
-  std::atomic<std::size_t> ongoing_calls_{0};
+    std::atomic<std::size_t> ongoing_calls_{0};
 
-  Mutex conns_lock_;
-  std::unordered_map<ConnectionId, std::unique_ptr<ConnectionContext>> conns_;
+    Mutex conns_lock_;
+    std::unordered_map<ConnectionId, std::unique_ptr<ConnectionContext>> conns_;
 
-  // Number of outstanding `StartBackgroundJob`
-  std::atomic<std::size_t> outstanding_jobs_{};
+    // Number of outstanding `StartBackgroundJob`
+    std::atomic<std::size_t> outstanding_jobs_{};
 };
 
-template <typename T> T *Server::GetBuiltinNativeService() {
-  auto key = GetTypeIndex<T>();
-  auto iter = builtin_services_.find(key);
-  if (iter == builtin_services_.end()) {
-    TILE_CHECK(!acceptor_, "Please ensure `Start()` is called.");
-    services_.push_back(make_unique<T>());
-    builtin_services_[key] = services_.back().Get();
-    iter = builtin_services_.find(key);
-  }
+template<typename T>
+T *
+Server::GetBuiltinNativeService()
+{
+    auto key  = GetTypeIndex<T>();
+    auto iter = builtin_services_.find(key);
+    if (iter == builtin_services_.end()) {
+        TILE_CHECK(!acceptor_, "Please ensure `Start()` is called.");
+        services_.push_back(make_unique<T>());
+        builtin_services_[key] = services_.back().Get();
+        iter                   = builtin_services_.find(key);
+    }
 
-  return down_cast<T>(iter->second);
+    return down_cast<T>(iter->second);
 }
 
-} // namespace tile
+}// namespace tile
 
-#endif // TILE_RPC_SERVER_H
+#endif// TILE_RPC_SERVER_H
diff --git a/tile/sigslot/sigslot.h b/tile/sigslot/sigslot.h
index 912b235..572a3ac 100644
--- a/tile/sigslot/sigslot.h
+++ b/tile/sigslot/sigslot.h
@@ -82,1524 +82,1410 @@
 #include <set>
 
 #if defined(SIGSLOT_PURE_ISO) || (!defined(WIN32) && !defined(__GNUG__) && !defined(SIGSLOT_USE_POSIX_THREADS))
-#	define _SIGSLOT_SINGLE_THREADED
+#define _SIGSLOT_SINGLE_THREADED
 #elif defined(WIN32)
-#	define _SIGSLOT_HAS_WIN32_THREADS
-#	include <windows.h>
+#define _SIGSLOT_HAS_WIN32_THREADS
+#include <windows.h>
 #elif defined(__GNUG__) || defined(SIGSLOT_USE_POSIX_THREADS)
-#	define _SIGSLOT_HAS_POSIX_THREADS
-#	include <pthread.h>
+#define _SIGSLOT_HAS_POSIX_THREADS
+#include <pthread.h>
 #else
-#	define _SIGSLOT_SINGLE_THREADED
+#define _SIGSLOT_SINGLE_THREADED
 #endif
 
 #ifndef SIGSLOT_DEFAULT_MT_POLICY
-#	ifdef _SIGSLOT_SINGLE_THREADED
-#		define SIGSLOT_DEFAULT_MT_POLICY single_threaded
-#	else
-#		define SIGSLOT_DEFAULT_MT_POLICY multi_threaded_local
-#	endif
+#ifdef _SIGSLOT_SINGLE_THREADED
+#define SIGSLOT_DEFAULT_MT_POLICY single_threaded
+#else
+#define SIGSLOT_DEFAULT_MT_POLICY multi_threaded_local
+#endif
 #endif
 
 #ifndef SIGSLOT_EMIT
-#	ifdef QT_VERSION
-#		define SIGSLOT_EMIT broadcast
-#	else
-#		define SIGSLOT_EMIT emit
-#	endif
+#ifdef QT_VERSION
+#define SIGSLOT_EMIT broadcast
+#else
+#define SIGSLOT_EMIT emit
+#endif
 #endif
 
 namespace sigslot {
 
-class single_threaded
-{
+class single_threaded {
 public:
-        single_threaded() {}
-        virtual ~single_threaded() {}
-        virtual void lock() {}
-        virtual void unlock() {}
+    single_threaded() {}
+
+    virtual ~single_threaded() {}
+
+    virtual void lock() {}
+
+    virtual void unlock() {}
 };
 
 #ifdef _SIGSLOT_HAS_WIN32_THREADS
 // The multi threading policies only get compiled in if they are enabled.
-class multi_threaded_global
-{
+class multi_threaded_global {
 public:
-        multi_threaded_global()
-        {
-                static bool isinitialised = false;
+    multi_threaded_global()
+    {
+        static bool isinitialised = false;
 
-                if(!isinitialised)
-                {
-                        InitializeCriticalSection(get_critsec());
-                        isinitialised = true;
-                }
+        if (!isinitialised) {
+            InitializeCriticalSection(get_critsec());
+            isinitialised = true;
         }
+    }
 
-        multi_threaded_global(const multi_threaded_global&)
-        {}
+    multi_threaded_global(const multi_threaded_global &) {}
 
-        virtual ~multi_threaded_global()
-        {}
+    virtual ~multi_threaded_global() {}
 
-        virtual void lock()
-        {
-                EnterCriticalSection(get_critsec());
-        }
+    virtual void lock() { EnterCriticalSection(get_critsec()); }
 
-        virtual void unlock()
-        {
-                LeaveCriticalSection(get_critsec());
-        }
+    virtual void unlock() { LeaveCriticalSection(get_critsec()); }
 
 private:
-        CRITICAL_SECTION* get_critsec()
-        {
-                static CRITICAL_SECTION g_critsec;
-                return &g_critsec;
-        }
+    CRITICAL_SECTION *get_critsec()
+    {
+        static CRITICAL_SECTION g_critsec;
+        return &g_critsec;
+    }
 };
 
-class multi_threaded_local
-{
+class multi_threaded_local {
 public:
-        multi_threaded_local()
-        {
-                InitializeCriticalSection(&m_critsec);
-        }
+    multi_threaded_local() { InitializeCriticalSection(&m_critsec); }
 
-        multi_threaded_local(const multi_threaded_local&)
-        {
-                InitializeCriticalSection(&m_critsec);
-        }
+    multi_threaded_local(const multi_threaded_local &) { InitializeCriticalSection(&m_critsec); }
 
-        virtual ~multi_threaded_local()
-        {
-                DeleteCriticalSection(&m_critsec);
-        }
+    virtual ~multi_threaded_local() { DeleteCriticalSection(&m_critsec); }
 
-        virtual void lock()
-        {
-                EnterCriticalSection(&m_critsec);
-        }
+    virtual void lock() { EnterCriticalSection(&m_critsec); }
 
-        virtual void unlock()
-        {
-                LeaveCriticalSection(&m_critsec);
-        }
+    virtual void unlock() { LeaveCriticalSection(&m_critsec); }
 
 private:
-        CRITICAL_SECTION m_critsec;
+    CRITICAL_SECTION m_critsec;
 };
-#endif // _SIGSLOT_HAS_WIN32_THREADS
+#endif// _SIGSLOT_HAS_WIN32_THREADS
 
 #ifdef _SIGSLOT_HAS_POSIX_THREADS
 // The multi threading policies only get compiled in if they are enabled.
-class multi_threaded_global
-{
+class multi_threaded_global {
 public:
-        multi_threaded_global()
-        {
-                pthread_mutex_init(get_mutex(), NULL);
-        }
+    multi_threaded_global() { pthread_mutex_init(get_mutex(), NULL); }
 
-        multi_threaded_global(const multi_threaded_global&)
-        {}
+    multi_threaded_global(const multi_threaded_global &) {}
 
-        virtual ~multi_threaded_global()
-        {}
+    virtual ~multi_threaded_global() {}
 
-        virtual void lock()
-        {
-                pthread_mutex_lock(get_mutex());
-        }
+    virtual void lock() { pthread_mutex_lock(get_mutex()); }
 
-        virtual void unlock()
-        {
-                pthread_mutex_unlock(get_mutex());
-        }
+    virtual void unlock() { pthread_mutex_unlock(get_mutex()); }
 
 private:
-        pthread_mutex_t* get_mutex()
-        {
-                static pthread_mutex_t g_mutex;
-                return &g_mutex;
-        }
+    pthread_mutex_t *get_mutex()
+    {
+        static pthread_mutex_t g_mutex;
+        return &g_mutex;
+    }
 };
 
-class multi_threaded_local
-{
+class multi_threaded_local {
 public:
-        multi_threaded_local()
-        {
-                pthread_mutex_init(&m_mutex, NULL);
-        }
+    multi_threaded_local() { pthread_mutex_init(&m_mutex, NULL); }
 
-        multi_threaded_local(const multi_threaded_local&)
-        {
-                pthread_mutex_init(&m_mutex, NULL);
-        }
+    multi_threaded_local(const multi_threaded_local &) { pthread_mutex_init(&m_mutex, NULL); }
 
-        virtual ~multi_threaded_local()
-        {
-                pthread_mutex_destroy(&m_mutex);
-        }
+    virtual ~multi_threaded_local() { pthread_mutex_destroy(&m_mutex); }
 
-        virtual void lock()
-        {
-                pthread_mutex_lock(&m_mutex);
-        }
+    virtual void lock() { pthread_mutex_lock(&m_mutex); }
 
-        virtual void unlock()
-        {
-                pthread_mutex_unlock(&m_mutex);
-        }
+    virtual void unlock() { pthread_mutex_unlock(&m_mutex); }
 
 private:
-        pthread_mutex_t m_mutex;
+    pthread_mutex_t m_mutex;
 };
-#endif // _SIGSLOT_HAS_POSIX_THREADS
+#endif// _SIGSLOT_HAS_POSIX_THREADS
 
 template<class mt_policy>
-class lock_block
-{
+class lock_block {
 public:
-        mt_policy *m_mutex;
+    mt_policy *m_mutex;
 
-        lock_block(mt_policy *mtx)
-            : m_mutex(mtx)
-        {
-                m_mutex->lock();
-        }
+    lock_block(mt_policy *mtx) : m_mutex(mtx) { m_mutex->lock(); }
 
-        ~lock_block()
-        {
-                m_mutex->unlock();
-        }
+    ~lock_block() { m_mutex->unlock(); }
 };
 
 template<class mt_policy>
 class has_slots;
 
 template<class mt_policy>
-class _connection_base0
-{
+class _connection_base0 {
 public:
-        virtual ~_connection_base0() {}
-        virtual has_slots<mt_policy>* getdest() const = 0;
-        virtual void SIGSLOT_EMIT() = 0;
-        virtual _connection_base0* clone() = 0;
-        virtual _connection_base0* duplicate(has_slots<mt_policy>* pnewdest) = 0;
+    virtual ~_connection_base0() {}
+
+    virtual has_slots<mt_policy> *getdest() const                        = 0;
+    virtual void SIGSLOT_EMIT()                                          = 0;
+    virtual _connection_base0 *clone()                                   = 0;
+    virtual _connection_base0 *duplicate(has_slots<mt_policy> *pnewdest) = 0;
 };
 
 template<class arg1_type, class mt_policy>
-class _connection_base1
-{
+class _connection_base1 {
 public:
-        virtual ~_connection_base1() {}
-        virtual has_slots<mt_policy>* getdest() const = 0;
-        virtual void SIGSLOT_EMIT(arg1_type) = 0;
-        virtual _connection_base1<arg1_type, mt_policy>* clone() = 0;
-        virtual _connection_base1<arg1_type, mt_policy>* duplicate(has_slots<mt_policy>* pnewdest) = 0;
+    virtual ~_connection_base1() {}
+
+    virtual has_slots<mt_policy> *getdest() const                                              = 0;
+    virtual void SIGSLOT_EMIT(arg1_type)                                                       = 0;
+    virtual _connection_base1<arg1_type, mt_policy> *clone()                                   = 0;
+    virtual _connection_base1<arg1_type, mt_policy> *duplicate(has_slots<mt_policy> *pnewdest) = 0;
 };
 
 template<class arg1_type, class arg2_type, class mt_policy>
-class _connection_base2
-{
+class _connection_base2 {
 public:
-        virtual ~_connection_base2() {}
-        virtual has_slots<mt_policy>* getdest() const = 0;
-        virtual void SIGSLOT_EMIT(arg1_type, arg2_type) = 0;
-        virtual _connection_base2<arg1_type, arg2_type, mt_policy>* clone() = 0;
-        virtual _connection_base2<arg1_type, arg2_type, mt_policy>* duplicate(has_slots<mt_policy>* pnewdest) = 0;
+    virtual ~_connection_base2() {}
+
+    virtual has_slots<mt_policy> *getdest() const                                                         = 0;
+    virtual void SIGSLOT_EMIT(arg1_type, arg2_type)                                                       = 0;
+    virtual _connection_base2<arg1_type, arg2_type, mt_policy> *clone()                                   = 0;
+    virtual _connection_base2<arg1_type, arg2_type, mt_policy> *duplicate(has_slots<mt_policy> *pnewdest) = 0;
 };
 
 template<class arg1_type, class arg2_type, class arg3_type, class mt_policy>
-class _connection_base3
-{
+class _connection_base3 {
 public:
-        virtual ~_connection_base3() {}
-        virtual has_slots<mt_policy>* getdest() const = 0;
-        virtual void SIGSLOT_EMIT(arg1_type, arg2_type, arg3_type) = 0;
-        virtual _connection_base3<arg1_type, arg2_type, arg3_type, mt_policy>* clone() = 0;
-        virtual _connection_base3<arg1_type, arg2_type, arg3_type, mt_policy>* duplicate(has_slots<mt_policy>* pnewdest) = 0;
+    virtual ~_connection_base3() {}
+
+    virtual has_slots<mt_policy> *getdest() const                                  = 0;
+    virtual void SIGSLOT_EMIT(arg1_type, arg2_type, arg3_type)                     = 0;
+    virtual _connection_base3<arg1_type, arg2_type, arg3_type, mt_policy> *clone() = 0;
+    virtual _connection_base3<arg1_type, arg2_type, arg3_type, mt_policy> *
+    duplicate(has_slots<mt_policy> *pnewdest) = 0;
 };
 
 template<class arg1_type, class arg2_type, class arg3_type, class arg4_type, class mt_policy>
-class _connection_base4
-{
+class _connection_base4 {
 public:
-        virtual ~_connection_base4() {}
-        virtual has_slots<mt_policy>* getdest() const = 0;
-        virtual void SIGSLOT_EMIT(arg1_type, arg2_type, arg3_type, arg4_type) = 0;
-        virtual _connection_base4<arg1_type, arg2_type, arg3_type, arg4_type, mt_policy>* clone() = 0;
-        virtual _connection_base4<arg1_type, arg2_type, arg3_type, arg4_type, mt_policy>* duplicate(has_slots<mt_policy>* pnewdest) = 0;
+    virtual ~_connection_base4() {}
+
+    virtual has_slots<mt_policy> *getdest() const                                             = 0;
+    virtual void SIGSLOT_EMIT(arg1_type, arg2_type, arg3_type, arg4_type)                     = 0;
+    virtual _connection_base4<arg1_type, arg2_type, arg3_type, arg4_type, mt_policy> *clone() = 0;
+    virtual _connection_base4<arg1_type, arg2_type, arg3_type, arg4_type, mt_policy> *
+    duplicate(has_slots<mt_policy> *pnewdest) = 0;
 };
 
-template<class arg1_type, class arg2_type, class arg3_type, class arg4_type,
-         class arg5_type, class mt_policy>
-class _connection_base5
-{
+template<class arg1_type, class arg2_type, class arg3_type, class arg4_type, class arg5_type, class mt_policy>
+class _connection_base5 {
 public:
-        virtual ~_connection_base5() {}
-        virtual has_slots<mt_policy>* getdest() const = 0;
-        virtual void SIGSLOT_EMIT(arg1_type, arg2_type, arg3_type, arg4_type,
-                                  arg5_type) = 0;
-        virtual _connection_base5<arg1_type, arg2_type, arg3_type, arg4_type,
-                                  arg5_type, mt_policy>* clone() = 0;
-        virtual _connection_base5<arg1_type, arg2_type, arg3_type, arg4_type,
-                                  arg5_type, mt_policy>* duplicate(has_slots<mt_policy>* pnewdest) = 0;
+    virtual ~_connection_base5() {}
+
+    virtual has_slots<mt_policy> *getdest() const                                                        = 0;
+    virtual void SIGSLOT_EMIT(arg1_type, arg2_type, arg3_type, arg4_type, arg5_type)                     = 0;
+    virtual _connection_base5<arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, mt_policy> *clone() = 0;
+    virtual _connection_base5<arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, mt_policy> *
+    duplicate(has_slots<mt_policy> *pnewdest) = 0;
 };
 
-template<class arg1_type, class arg2_type, class arg3_type, class arg4_type,
-         class arg5_type, class arg6_type, class mt_policy>
-class _connection_base6
-{
+template<class arg1_type,
+         class arg2_type,
+         class arg3_type,
+         class arg4_type,
+         class arg5_type,
+         class arg6_type,
+         class mt_policy>
+class _connection_base6 {
 public:
-        virtual ~_connection_base6() {}
-        virtual has_slots<mt_policy>* getdest() const = 0;
-        virtual void SIGSLOT_EMIT(arg1_type, arg2_type, arg3_type, arg4_type, arg5_type,
-                                  arg6_type) = 0;
-        virtual _connection_base6<arg1_type, arg2_type, arg3_type, arg4_type,
-                                  arg5_type, arg6_type, mt_policy>* clone() = 0;
-        virtual _connection_base6<arg1_type, arg2_type, arg3_type, arg4_type,
-                                  arg5_type, arg6_type, mt_policy>* duplicate(has_slots<mt_policy>* pnewdest) = 0;
+    virtual ~_connection_base6() {}
+
+    virtual has_slots<mt_policy> *getdest() const                                                                   = 0;
+    virtual void SIGSLOT_EMIT(arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, arg6_type)                     = 0;
+    virtual _connection_base6<arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, arg6_type, mt_policy> *clone() = 0;
+    virtual _connection_base6<arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, arg6_type, mt_policy> *
+    duplicate(has_slots<mt_policy> *pnewdest) = 0;
 };
 
-template<class arg1_type, class arg2_type, class arg3_type, class arg4_type,
-         class arg5_type, class arg6_type, class arg7_type, class mt_policy>
-class _connection_base7
-{
+template<class arg1_type,
+         class arg2_type,
+         class arg3_type,
+         class arg4_type,
+         class arg5_type,
+         class arg6_type,
+         class arg7_type,
+         class mt_policy>
+class _connection_base7 {
 public:
-        virtual ~_connection_base7() {}
-        virtual has_slots<mt_policy>* getdest() const = 0;
-        virtual void SIGSLOT_EMIT(arg1_type, arg2_type, arg3_type, arg4_type, arg5_type,
-                                  arg6_type, arg7_type) = 0;
-        virtual _connection_base7<arg1_type, arg2_type, arg3_type, arg4_type,
-                                  arg5_type, arg6_type, arg7_type, mt_policy>* clone() = 0;
-        virtual _connection_base7<arg1_type, arg2_type, arg3_type, arg4_type,
-                                  arg5_type, arg6_type, arg7_type, mt_policy>* duplicate(has_slots<mt_policy>* pnewdest) = 0;
+    virtual ~_connection_base7() {}
+
+    virtual has_slots<mt_policy> *getdest() const                                                          = 0;
+    virtual void SIGSLOT_EMIT(arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, arg6_type, arg7_type) = 0;
+    virtual _connection_base7<arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, arg6_type, arg7_type, mt_policy> *
+    clone() = 0;
+    virtual _connection_base7<arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, arg6_type, arg7_type, mt_policy> *
+    duplicate(has_slots<mt_policy> *pnewdest) = 0;
 };
 
-template<class arg1_type, class arg2_type, class arg3_type, class arg4_type,
-         class arg5_type, class arg6_type, class arg7_type, class arg8_type, class mt_policy>
-class _connection_base8
-{
+template<class arg1_type,
+         class arg2_type,
+         class arg3_type,
+         class arg4_type,
+         class arg5_type,
+         class arg6_type,
+         class arg7_type,
+         class arg8_type,
+         class mt_policy>
+class _connection_base8 {
 public:
-        virtual ~_connection_base8() {}
-        virtual has_slots<mt_policy>* getdest() const = 0;
-        virtual void SIGSLOT_EMIT(arg1_type, arg2_type, arg3_type, arg4_type, arg5_type,
-                                  arg6_type, arg7_type, arg8_type) = 0;
-        virtual _connection_base8<arg1_type, arg2_type, arg3_type, arg4_type,
-                                  arg5_type, arg6_type, arg7_type, arg8_type, mt_policy>* clone() = 0;
-        virtual _connection_base8<arg1_type, arg2_type, arg3_type, arg4_type,
-                                  arg5_type, arg6_type, arg7_type, arg8_type, mt_policy>* duplicate(has_slots<mt_policy>* pnewdest) = 0;
+    virtual ~_connection_base8() {}
+
+    virtual has_slots<mt_policy> *getdest() const = 0;
+    virtual void
+        SIGSLOT_EMIT(arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, arg6_type, arg7_type, arg8_type) = 0;
+    virtual _connection_base8<arg1_type,
+                              arg2_type,
+                              arg3_type,
+                              arg4_type,
+                              arg5_type,
+                              arg6_type,
+                              arg7_type,
+                              arg8_type,
+                              mt_policy> *
+    clone() = 0;
+    virtual _connection_base8<arg1_type,
+                              arg2_type,
+                              arg3_type,
+                              arg4_type,
+                              arg5_type,
+                              arg6_type,
+                              arg7_type,
+                              arg8_type,
+                              mt_policy> *
+    duplicate(has_slots<mt_policy> *pnewdest) = 0;
 };
 
 template<class mt_policy>
-class _signal_base : public mt_policy
-{
+class _signal_base : public mt_policy {
 public:
-        virtual void slot_disconnect(has_slots<mt_policy>* pslot) = 0;
-        virtual void slot_duplicate(const has_slots<mt_policy>* poldslot, has_slots<mt_policy>* pnewslot) = 0;
+    virtual void slot_disconnect(has_slots<mt_policy> *pslot)                                         = 0;
+    virtual void slot_duplicate(const has_slots<mt_policy> *poldslot, has_slots<mt_policy> *pnewslot) = 0;
 };
 
 // Implements common functionality of signalN classes. signalN classes
 // derive from this class.
 template<class T, class mt_policy>
-class _signal_base_middle: public _signal_base<mt_policy>
-{
+class _signal_base_middle : public _signal_base<mt_policy> {
 public:
+    typedef T connections_list;
+    typedef typename connections_list::iterator iterator;
+    typedef typename connections_list::const_iterator const_iterator;
 
-        typedef T connections_list;
-        typedef typename connections_list::iterator iterator;
-        typedef typename connections_list::const_iterator const_iterator;
+    _signal_base_middle() {}
 
-        _signal_base_middle() {}
+    _signal_base_middle(const _signal_base_middle<connections_list, mt_policy> &s) : _signal_base<mt_policy>(s)
+    {
+        lock_block<mt_policy> lock(this);
 
-        _signal_base_middle(const _signal_base_middle<connections_list, mt_policy> &s)
-            : _signal_base<mt_policy>(s)
-        {
-                lock_block<mt_policy> lock(this);
+        const_iterator it    = s.m_connected_slots.begin();
+        const_iterator itEnd = s.m_connected_slots.end();
 
-                const_iterator it = s.m_connected_slots.begin();
-                const_iterator itEnd = s.m_connected_slots.end();
+        while (it != itEnd) {
+            (*it)->getdest()->signal_connect(this);
+            m_connected_slots.push_back((*it)->clone());
+            ++it;
+        }
+    }
 
-                while(it != itEnd)
-                {
-                        (*it)->getdest()->signal_connect(this);
-                        m_connected_slots.push_back((*it)->clone());
-                        ++it;
-                }
+    virtual ~_signal_base_middle() {}
+
+    void disconnect_all()
+    {
+        lock_block<mt_policy> lock(this);
+
+        const_iterator it    = m_connected_slots.begin();
+        const_iterator itEnd = m_connected_slots.end();
+
+        while (it != itEnd) {
+            (*it)->getdest()->signal_disconnect(this);
+            delete *it;
+
+            ++it;
         }
 
-        virtual ~_signal_base_middle() {}
+        m_connected_slots.erase(m_connected_slots.begin(), m_connected_slots.end());
+    }
 
-        void disconnect_all()
-        {
-                lock_block<mt_policy> lock(this);
+    bool is_empty()
+    {
+        lock_block<mt_policy> lock(this);
 
-                const_iterator it = m_connected_slots.begin();
-                const_iterator itEnd = m_connected_slots.end();
+        const_iterator it    = m_connected_slots.begin();
+        const_iterator itEnd = m_connected_slots.end();
 
-                while(it != itEnd)
-                {
-                        (*it)->getdest()->signal_disconnect(this);
-                        delete *it;
-
-                        ++it;
-                }
-
-                m_connected_slots.erase(m_connected_slots.begin(), m_connected_slots.end());
-        }
-
-        bool is_empty()
-        {
-                lock_block<mt_policy> lock(this);
-
-                const_iterator it = m_connected_slots.begin();
-                const_iterator itEnd = m_connected_slots.end();
-
-                return it == itEnd;
-        }
+        return it == itEnd;
+    }
 
 #ifdef _DEBUG
-        bool connected(has_slots<mt_policy>* pclass)
-        {
-                lock_block<mt_policy> lock(this);
+    bool connected(has_slots<mt_policy> *pclass)
+    {
+        lock_block<mt_policy> lock(this);
 
-                const_iterator itNext, it = m_connected_slots.begin();
-                const_iterator itEnd = m_connected_slots.end();
+        const_iterator itNext, it = m_connected_slots.begin();
+        const_iterator itEnd = m_connected_slots.end();
 
-                while(it != itEnd)
-                {
-                        itNext = it;
-                        ++itNext;
-                        if ((*it)->getdest() == pclass)
-                                return true;
-                        it = itNext;
-                }
-                return false;
+        while (it != itEnd) {
+            itNext = it;
+            ++itNext;
+            if ((*it)->getdest() == pclass) return true;
+            it = itNext;
         }
+        return false;
+    }
 #endif
 
-        void disconnect(has_slots<mt_policy>* pclass)
-        {
-                lock_block<mt_policy> lock(this);
+    void disconnect(has_slots<mt_policy> *pclass)
+    {
+        lock_block<mt_policy> lock(this);
 
-                iterator it = m_connected_slots.begin();
-                iterator itEnd = m_connected_slots.end();
+        iterator it    = m_connected_slots.begin();
+        iterator itEnd = m_connected_slots.end();
 
-                while(it != itEnd)
-                {
-                        if((*it)->getdest() == pclass)
-                        {
-                                delete *it;
-                                m_connected_slots.erase(it);
-                                pclass->signal_disconnect(this);
-                                return;
-                        }
+        while (it != itEnd) {
+            if ((*it)->getdest() == pclass) {
+                delete *it;
+                m_connected_slots.erase(it);
+                pclass->signal_disconnect(this);
+                return;
+            }
 
-                        ++it;
-                }
+            ++it;
         }
+    }
 
-        void slot_disconnect(has_slots<mt_policy>* pslot)
-        {
-                lock_block<mt_policy> lock(this);
+    void slot_disconnect(has_slots<mt_policy> *pslot)
+    {
+        lock_block<mt_policy> lock(this);
 
-                iterator it = m_connected_slots.begin();
-                iterator itEnd = m_connected_slots.end();
+        iterator it    = m_connected_slots.begin();
+        iterator itEnd = m_connected_slots.end();
 
-                while(it != itEnd)
-                {
-                        iterator itNext = it;
-                        ++itNext;
+        while (it != itEnd) {
+            iterator itNext = it;
+            ++itNext;
 
-                        if((*it)->getdest() == pslot)
-                        {
-                                delete *it;
-                                m_connected_slots.erase(it);
-                        }
+            if ((*it)->getdest() == pslot) {
+                delete *it;
+                m_connected_slots.erase(it);
+            }
 
-                        it = itNext;
-                }
+            it = itNext;
         }
+    }
 
-        void slot_duplicate(const has_slots<mt_policy>* oldtarget, has_slots<mt_policy>* newtarget)
-        {
-                lock_block<mt_policy> lock(this);
+    void slot_duplicate(const has_slots<mt_policy> *oldtarget, has_slots<mt_policy> *newtarget)
+    {
+        lock_block<mt_policy> lock(this);
 
-                iterator it = m_connected_slots.begin();
-                iterator itEnd = m_connected_slots.end();
+        iterator it    = m_connected_slots.begin();
+        iterator itEnd = m_connected_slots.end();
 
-                while(it != itEnd)
-                {
-                        if((*it)->getdest() == oldtarget)
-                        {
-                                m_connected_slots.push_back((*it)->duplicate(newtarget));
-                        }
+        while (it != itEnd) {
+            if ((*it)->getdest() == oldtarget) { m_connected_slots.push_back((*it)->duplicate(newtarget)); }
 
-                        ++it;
-                }
+            ++it;
         }
+    }
 
 protected:
-
-        connections_list m_connected_slots;
-
+    connections_list m_connected_slots;
 };
 
 template<class mt_policy = SIGSLOT_DEFAULT_MT_POLICY>
-class has_slots : public mt_policy
-{
+class has_slots : public mt_policy {
 private:
-        typedef typename std::set<_signal_base<mt_policy> *> sender_set;
-        typedef typename sender_set::const_iterator const_iterator;
+    typedef typename std::set<_signal_base<mt_policy> *> sender_set;
+    typedef typename sender_set::const_iterator const_iterator;
 
 public:
-        has_slots()
-        {}
+    has_slots() {}
 
-        has_slots(const has_slots& hs)
-            : mt_policy(hs)
-        {
-                lock_block<mt_policy> lock(this);
-                const_iterator it = hs.m_senders.begin();
-                const_iterator itEnd = hs.m_senders.end();
+    has_slots(const has_slots &hs) : mt_policy(hs)
+    {
+        lock_block<mt_policy> lock(this);
+        const_iterator it    = hs.m_senders.begin();
+        const_iterator itEnd = hs.m_senders.end();
 
-                while(it != itEnd)
-                {
-                        (*it)->slot_duplicate(&hs, this);
-                        m_senders.insert(*it);
-                        ++it;
-                }
+        while (it != itEnd) {
+            (*it)->slot_duplicate(&hs, this);
+            m_senders.insert(*it);
+            ++it;
+        }
+    }
+
+    void signal_connect(_signal_base<mt_policy> *sender)
+    {
+        lock_block<mt_policy> lock(this);
+        m_senders.insert(sender);
+    }
+
+    void signal_disconnect(_signal_base<mt_policy> *sender)
+    {
+        lock_block<mt_policy> lock(this);
+        m_senders.erase(sender);
+    }
+
+    virtual ~has_slots() { disconnect_all(); }
+
+    void disconnect_all()
+    {
+        lock_block<mt_policy> lock(this);
+        const_iterator it    = m_senders.begin();
+        const_iterator itEnd = m_senders.end();
+
+        while (it != itEnd) {
+            (*it)->slot_disconnect(this);
+            ++it;
         }
 
-        void signal_connect(_signal_base<mt_policy>* sender)
-        {
-                lock_block<mt_policy> lock(this);
-                m_senders.insert(sender);
-        }
-
-        void signal_disconnect(_signal_base<mt_policy>* sender)
-        {
-                lock_block<mt_policy> lock(this);
-                m_senders.erase(sender);
-        }
-
-        virtual ~has_slots()
-        {
-                disconnect_all();
-        }
-
-        void disconnect_all()
-        {
-                lock_block<mt_policy> lock(this);
-                const_iterator it = m_senders.begin();
-                const_iterator itEnd = m_senders.end();
-
-                while(it != itEnd)
-                {
-                        (*it)->slot_disconnect(this);
-                        ++it;
-                }
-
-                m_senders.erase(m_senders.begin(), m_senders.end());
-        }
+        m_senders.erase(m_senders.begin(), m_senders.end());
+    }
 
 private:
-        sender_set m_senders;
+    sender_set m_senders;
 };
 
-
-
 template<class dest_type, class mt_policy>
-class _connection0 : public _connection_base0<mt_policy>
-{
+class _connection0 : public _connection_base0<mt_policy> {
 public:
-        _connection0()
-        {
-                m_pobject = NULL;
-                m_pmemfun = NULL;
-        }
+    _connection0()
+    {
+        m_pobject = NULL;
+        m_pmemfun = NULL;
+    }
 
-        _connection0(dest_type* pobject, void (dest_type::*pmemfun)())
-        {
-                m_pobject = pobject;
-                m_pmemfun = pmemfun;
-        }
+    _connection0(dest_type *pobject, void (dest_type::*pmemfun)())
+    {
+        m_pobject = pobject;
+        m_pmemfun = pmemfun;
+    }
 
-        virtual ~_connection0()
-        {}
+    virtual ~_connection0() {}
 
-        virtual _connection_base0<mt_policy>* clone()
-        {
-                return new _connection0<dest_type, mt_policy>(*this);
-        }
+    virtual _connection_base0<mt_policy> *clone() { return new _connection0<dest_type, mt_policy>(*this); }
 
-        virtual _connection_base0<mt_policy>* duplicate(has_slots<mt_policy>* pnewdest)
-        {
-                return new _connection0<dest_type, mt_policy>((dest_type *)pnewdest, m_pmemfun);
-        }
+    virtual _connection_base0<mt_policy> *duplicate(has_slots<mt_policy> *pnewdest)
+    {
+        return new _connection0<dest_type, mt_policy>((dest_type *) pnewdest, m_pmemfun);
+    }
 
-        virtual void SIGSLOT_EMIT()
-        {
-                (m_pobject->*m_pmemfun)();
-        }
+    virtual void SIGSLOT_EMIT() { (m_pobject->*m_pmemfun)(); }
 
-        virtual has_slots<mt_policy>* getdest() const
-        {
-                return m_pobject;
-        }
+    virtual has_slots<mt_policy> *getdest() const { return m_pobject; }
 
 private:
-        dest_type* m_pobject;
-        void (dest_type::* m_pmemfun)();
+    dest_type *m_pobject;
+    void (dest_type::*m_pmemfun)();
 };
 
 template<class dest_type, class arg1_type, class mt_policy>
-class _connection1 : public _connection_base1<arg1_type, mt_policy>
-{
+class _connection1 : public _connection_base1<arg1_type, mt_policy> {
 public:
-        _connection1()
-        {
-                m_pobject = NULL;
-                m_pmemfun = NULL;
-        }
+    _connection1()
+    {
+        m_pobject = NULL;
+        m_pmemfun = NULL;
+    }
 
-        _connection1(dest_type* pobject, void (dest_type::*pmemfun)(arg1_type))
-        {
-                m_pobject = pobject;
-                m_pmemfun = pmemfun;
-        }
+    _connection1(dest_type *pobject, void (dest_type::*pmemfun)(arg1_type))
+    {
+        m_pobject = pobject;
+        m_pmemfun = pmemfun;
+    }
 
-        virtual ~_connection1()
-        {}
+    virtual ~_connection1() {}
 
-        virtual _connection_base1<arg1_type, mt_policy>* clone()
-        {
-                return new _connection1<dest_type, arg1_type, mt_policy>(*this);
-        }
+    virtual _connection_base1<arg1_type, mt_policy> *clone()
+    {
+        return new _connection1<dest_type, arg1_type, mt_policy>(*this);
+    }
 
-        virtual _connection_base1<arg1_type, mt_policy>* duplicate(has_slots<mt_policy>* pnewdest)
-        {
-                return new _connection1<dest_type, arg1_type, mt_policy>((dest_type *)pnewdest, m_pmemfun);
-        }
+    virtual _connection_base1<arg1_type, mt_policy> *duplicate(has_slots<mt_policy> *pnewdest)
+    {
+        return new _connection1<dest_type, arg1_type, mt_policy>((dest_type *) pnewdest, m_pmemfun);
+    }
 
-        virtual void SIGSLOT_EMIT(arg1_type a1)
-        {
-                (m_pobject->*m_pmemfun)(a1);
-        }
+    virtual void SIGSLOT_EMIT(arg1_type a1) { (m_pobject->*m_pmemfun)(a1); }
 
-        virtual has_slots<mt_policy>* getdest() const
-        {
-                return m_pobject;
-        }
+    virtual has_slots<mt_policy> *getdest() const { return m_pobject; }
 
 private:
-        dest_type* m_pobject;
-        void (dest_type::* m_pmemfun)(arg1_type);
+    dest_type *m_pobject;
+    void (dest_type::*m_pmemfun)(arg1_type);
 };
 
 template<class dest_type, class arg1_type, class arg2_type, class mt_policy>
-class _connection2 : public _connection_base2<arg1_type, arg2_type, mt_policy>
-{
+class _connection2 : public _connection_base2<arg1_type, arg2_type, mt_policy> {
 public:
-        _connection2()
-        {
-                m_pobject = NULL;
-                m_pmemfun = NULL;
-        }
+    _connection2()
+    {
+        m_pobject = NULL;
+        m_pmemfun = NULL;
+    }
 
-        _connection2(dest_type* pobject, void (dest_type::*pmemfun)(arg1_type,
-                                                                    arg2_type))
-        {
-                m_pobject = pobject;
-                m_pmemfun = pmemfun;
-        }
+    _connection2(dest_type *pobject, void (dest_type::*pmemfun)(arg1_type, arg2_type))
+    {
+        m_pobject = pobject;
+        m_pmemfun = pmemfun;
+    }
 
-        virtual ~_connection2()
-        {}
+    virtual ~_connection2() {}
 
-        virtual _connection_base2<arg1_type, arg2_type, mt_policy>* clone()
-        {
-                return new _connection2<dest_type, arg1_type, arg2_type, mt_policy>(*this);
-        }
+    virtual _connection_base2<arg1_type, arg2_type, mt_policy> *clone()
+    {
+        return new _connection2<dest_type, arg1_type, arg2_type, mt_policy>(*this);
+    }
 
-        virtual _connection_base2<arg1_type, arg2_type, mt_policy>* duplicate(has_slots<mt_policy>* pnewdest)
-        {
-                return new _connection2<dest_type, arg1_type, arg2_type, mt_policy>((dest_type *)pnewdest, m_pmemfun);
-        }
+    virtual _connection_base2<arg1_type, arg2_type, mt_policy> *duplicate(has_slots<mt_policy> *pnewdest)
+    {
+        return new _connection2<dest_type, arg1_type, arg2_type, mt_policy>((dest_type *) pnewdest, m_pmemfun);
+    }
 
-        virtual void SIGSLOT_EMIT(arg1_type a1, arg2_type a2)
-        {
-                (m_pobject->*m_pmemfun)(a1, a2);
-        }
+    virtual void SIGSLOT_EMIT(arg1_type a1, arg2_type a2) { (m_pobject->*m_pmemfun)(a1, a2); }
 
-        virtual has_slots<mt_policy>* getdest() const
-        {
-                return m_pobject;
-        }
+    virtual has_slots<mt_policy> *getdest() const { return m_pobject; }
 
 private:
-        dest_type* m_pobject;
-        void (dest_type::* m_pmemfun)(arg1_type, arg2_type);
+    dest_type *m_pobject;
+    void (dest_type::*m_pmemfun)(arg1_type, arg2_type);
 };
 
 template<class dest_type, class arg1_type, class arg2_type, class arg3_type, class mt_policy>
-class _connection3 : public _connection_base3<arg1_type, arg2_type, arg3_type, mt_policy>
-{
+class _connection3 : public _connection_base3<arg1_type, arg2_type, arg3_type, mt_policy> {
 public:
-        _connection3()
-        {
-                m_pobject = NULL;
-                m_pmemfun = NULL;
-        }
+    _connection3()
+    {
+        m_pobject = NULL;
+        m_pmemfun = NULL;
+    }
 
-        _connection3(dest_type* pobject, void (dest_type::*pmemfun)(arg1_type,
-                                                                    arg2_type, arg3_type))
-        {
-                m_pobject = pobject;
-                m_pmemfun = pmemfun;
-        }
+    _connection3(dest_type *pobject, void (dest_type::*pmemfun)(arg1_type, arg2_type, arg3_type))
+    {
+        m_pobject = pobject;
+        m_pmemfun = pmemfun;
+    }
 
-        virtual ~_connection3()
-        {}
+    virtual ~_connection3() {}
 
-        virtual _connection_base3<arg1_type, arg2_type, arg3_type, mt_policy>* clone()
-        {
-                return new _connection3<dest_type, arg1_type, arg2_type, arg3_type, mt_policy>(*this);
-        }
+    virtual _connection_base3<arg1_type, arg2_type, arg3_type, mt_policy> *clone()
+    {
+        return new _connection3<dest_type, arg1_type, arg2_type, arg3_type, mt_policy>(*this);
+    }
 
-        virtual _connection_base3<arg1_type, arg2_type, arg3_type, mt_policy>* duplicate(has_slots<mt_policy>* pnewdest)
-        {
-                return new _connection3<dest_type, arg1_type, arg2_type, arg3_type, mt_policy>((dest_type *)pnewdest, m_pmemfun);
-        }
+    virtual _connection_base3<arg1_type, arg2_type, arg3_type, mt_policy> *duplicate(has_slots<mt_policy> *pnewdest)
+    {
+        return new _connection3<dest_type, arg1_type, arg2_type, arg3_type, mt_policy>(
+            (dest_type *) pnewdest, m_pmemfun);
+    }
 
-        virtual void SIGSLOT_EMIT(arg1_type a1, arg2_type a2, arg3_type a3)
-        {
-                (m_pobject->*m_pmemfun)(a1, a2, a3);
-        }
+    virtual void SIGSLOT_EMIT(arg1_type a1, arg2_type a2, arg3_type a3) { (m_pobject->*m_pmemfun)(a1, a2, a3); }
 
-        virtual has_slots<mt_policy>* getdest() const
-        {
-                return m_pobject;
-        }
+    virtual has_slots<mt_policy> *getdest() const { return m_pobject; }
 
 private:
-        dest_type* m_pobject;
-        void (dest_type::* m_pmemfun)(arg1_type, arg2_type, arg3_type);
+    dest_type *m_pobject;
+    void (dest_type::*m_pmemfun)(arg1_type, arg2_type, arg3_type);
 };
 
-template<class dest_type, class arg1_type, class arg2_type, class arg3_type,
-         class arg4_type, class mt_policy>
-class _connection4 : public _connection_base4<arg1_type, arg2_type,
-                                              arg3_type, arg4_type, mt_policy>
-{
+template<class dest_type, class arg1_type, class arg2_type, class arg3_type, class arg4_type, class mt_policy>
+class _connection4 : public _connection_base4<arg1_type, arg2_type, arg3_type, arg4_type, mt_policy> {
 public:
-        _connection4()
-        {
-                m_pobject = NULL;
-                m_pmemfun = NULL;
-        }
+    _connection4()
+    {
+        m_pobject = NULL;
+        m_pmemfun = NULL;
+    }
 
-        _connection4(dest_type* pobject, void (dest_type::*pmemfun)(arg1_type,
-                                                                    arg2_type, arg3_type, arg4_type))
-        {
-                m_pobject = pobject;
-                m_pmemfun = pmemfun;
-        }
+    _connection4(dest_type *pobject, void (dest_type::*pmemfun)(arg1_type, arg2_type, arg3_type, arg4_type))
+    {
+        m_pobject = pobject;
+        m_pmemfun = pmemfun;
+    }
 
-        virtual ~_connection4()
-        {}
+    virtual ~_connection4() {}
 
-        virtual _connection_base4<arg1_type, arg2_type, arg3_type, arg4_type, mt_policy>* clone()
-        {
-                return new _connection4<dest_type, arg1_type, arg2_type, arg3_type, arg4_type, mt_policy>(*this);
-        }
+    virtual _connection_base4<arg1_type, arg2_type, arg3_type, arg4_type, mt_policy> *clone()
+    {
+        return new _connection4<dest_type, arg1_type, arg2_type, arg3_type, arg4_type, mt_policy>(*this);
+    }
 
-        virtual _connection_base4<arg1_type, arg2_type, arg3_type, arg4_type, mt_policy>* duplicate(has_slots<mt_policy>* pnewdest)
-        {
-                return new _connection4<dest_type, arg1_type, arg2_type, arg3_type, arg4_type, mt_policy>((dest_type *)pnewdest, m_pmemfun);
-        }
+    virtual _connection_base4<arg1_type, arg2_type, arg3_type, arg4_type, mt_policy> *
+    duplicate(has_slots<mt_policy> *pnewdest)
+    {
+        return new _connection4<dest_type, arg1_type, arg2_type, arg3_type, arg4_type, mt_policy>(
+            (dest_type *) pnewdest, m_pmemfun);
+    }
 
-        virtual void SIGSLOT_EMIT(arg1_type a1, arg2_type a2, arg3_type a3,
-                                  arg4_type a4)
-        {
-                (m_pobject->*m_pmemfun)(a1, a2, a3, a4);
-        }
+    virtual void SIGSLOT_EMIT(arg1_type a1, arg2_type a2, arg3_type a3, arg4_type a4)
+    {
+        (m_pobject->*m_pmemfun)(a1, a2, a3, a4);
+    }
 
-        virtual has_slots<mt_policy>* getdest() const
-        {
-                return m_pobject;
-        }
+    virtual has_slots<mt_policy> *getdest() const { return m_pobject; }
 
 private:
-        dest_type* m_pobject;
-        void (dest_type::* m_pmemfun)(arg1_type, arg2_type, arg3_type,
-                                     arg4_type);
+    dest_type *m_pobject;
+    void (dest_type::*m_pmemfun)(arg1_type, arg2_type, arg3_type, arg4_type);
 };
 
-template<class dest_type, class arg1_type, class arg2_type, class arg3_type,
-         class arg4_type, class arg5_type, class mt_policy>
-class _connection5 : public _connection_base5<arg1_type, arg2_type,
-                                              arg3_type, arg4_type, arg5_type, mt_policy>
-{
+template<class dest_type,
+         class arg1_type,
+         class arg2_type,
+         class arg3_type,
+         class arg4_type,
+         class arg5_type,
+         class mt_policy>
+class _connection5 : public _connection_base5<arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, mt_policy> {
 public:
-        _connection5()
-        {
-                m_pobject = NULL;
-                m_pmemfun = NULL;
-        }
+    _connection5()
+    {
+        m_pobject = NULL;
+        m_pmemfun = NULL;
+    }
 
-        _connection5(dest_type* pobject, void (dest_type::*pmemfun)(arg1_type,
-                                                                    arg2_type, arg3_type, arg4_type, arg5_type))
-        {
-                m_pobject = pobject;
-                m_pmemfun = pmemfun;
-        }
+    _connection5(dest_type *pobject, void (dest_type::*pmemfun)(arg1_type, arg2_type, arg3_type, arg4_type, arg5_type))
+    {
+        m_pobject = pobject;
+        m_pmemfun = pmemfun;
+    }
 
-        virtual ~_connection5()
-        {}
+    virtual ~_connection5() {}
 
-        virtual _connection_base5<arg1_type, arg2_type, arg3_type, arg4_type,
-                                  arg5_type, mt_policy>* clone()
-        {
-                return new _connection5<dest_type, arg1_type, arg2_type, arg3_type, arg4_type,
-                                        arg5_type, mt_policy>(*this);
-        }
+    virtual _connection_base5<arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, mt_policy> *clone()
+    {
+        return new _connection5<dest_type, arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, mt_policy>(*this);
+    }
 
-        virtual _connection_base5<arg1_type, arg2_type, arg3_type, arg4_type,
-                                  arg5_type, mt_policy>* duplicate(has_slots<mt_policy>* pnewdest)
-        {
-                return new _connection5<dest_type, arg1_type, arg2_type, arg3_type, arg4_type,
-                                        arg5_type, mt_policy>((dest_type *)pnewdest, m_pmemfun);
-        }
+    virtual _connection_base5<arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, mt_policy> *
+    duplicate(has_slots<mt_policy> *pnewdest)
+    {
+        return new _connection5<dest_type, arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, mt_policy>(
+            (dest_type *) pnewdest, m_pmemfun);
+    }
 
-        virtual void SIGSLOT_EMIT(arg1_type a1, arg2_type a2, arg3_type a3, arg4_type a4,
-                                  arg5_type a5)
-        {
-                (m_pobject->*m_pmemfun)(a1, a2, a3, a4, a5);
-        }
+    virtual void SIGSLOT_EMIT(arg1_type a1, arg2_type a2, arg3_type a3, arg4_type a4, arg5_type a5)
+    {
+        (m_pobject->*m_pmemfun)(a1, a2, a3, a4, a5);
+    }
 
-        virtual has_slots<mt_policy>* getdest() const
-        {
-                return m_pobject;
-        }
+    virtual has_slots<mt_policy> *getdest() const { return m_pobject; }
 
 private:
-        dest_type* m_pobject;
-        void (dest_type::* m_pmemfun)(arg1_type, arg2_type, arg3_type, arg4_type,
-                                     arg5_type);
+    dest_type *m_pobject;
+    void (dest_type::*m_pmemfun)(arg1_type, arg2_type, arg3_type, arg4_type, arg5_type);
 };
 
-template<class dest_type, class arg1_type, class arg2_type, class arg3_type,
-         class arg4_type, class arg5_type, class arg6_type, class mt_policy>
-class _connection6 : public _connection_base6<arg1_type, arg2_type,
-                                              arg3_type, arg4_type, arg5_type, arg6_type, mt_policy>
-{
+template<class dest_type,
+         class arg1_type,
+         class arg2_type,
+         class arg3_type,
+         class arg4_type,
+         class arg5_type,
+         class arg6_type,
+         class mt_policy>
+class _connection6
+    : public _connection_base6<arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, arg6_type, mt_policy> {
 public:
-        _connection6()
-        {
-                m_pobject = NULL;
-                m_pmemfun = NULL;
-        }
+    _connection6()
+    {
+        m_pobject = NULL;
+        m_pmemfun = NULL;
+    }
 
-        _connection6(dest_type* pobject, void (dest_type::*pmemfun)(arg1_type,
-                                                                    arg2_type, arg3_type, arg4_type, arg5_type, arg6_type))
-        {
-                m_pobject = pobject;
-                m_pmemfun = pmemfun;
-        }
+    _connection6(dest_type *pobject,
+                 void (dest_type::*pmemfun)(arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, arg6_type))
+    {
+        m_pobject = pobject;
+        m_pmemfun = pmemfun;
+    }
 
-        virtual ~_connection6()
-        {}
+    virtual ~_connection6() {}
 
-        virtual _connection_base6<arg1_type, arg2_type, arg3_type, arg4_type,
-                                  arg5_type, arg6_type, mt_policy>* clone()
-        {
-                return new _connection6<dest_type, arg1_type, arg2_type, arg3_type, arg4_type,
-                                        arg5_type, arg6_type, mt_policy>(*this);
-        }
+    virtual _connection_base6<arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, arg6_type, mt_policy> *clone()
+    {
+        return new _connection6<dest_type, arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, arg6_type, mt_policy>(
+            *this);
+    }
 
-        virtual _connection_base6<arg1_type, arg2_type, arg3_type, arg4_type,
-                                  arg5_type, arg6_type, mt_policy>* duplicate(has_slots<mt_policy>* pnewdest)
-        {
-                return new _connection6<dest_type, arg1_type, arg2_type, arg3_type, arg4_type,
-                                        arg5_type, arg6_type, mt_policy>((dest_type *)pnewdest, m_pmemfun);
-        }
+    virtual _connection_base6<arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, arg6_type, mt_policy> *
+    duplicate(has_slots<mt_policy> *pnewdest)
+    {
+        return new _connection6<dest_type, arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, arg6_type, mt_policy>(
+            (dest_type *) pnewdest, m_pmemfun);
+    }
 
-        virtual void SIGSLOT_EMIT(arg1_type a1, arg2_type a2, arg3_type a3, arg4_type a4,
-                                  arg5_type a5, arg6_type a6)
-        {
-                (m_pobject->*m_pmemfun)(a1, a2, a3, a4, a5, a6);
-        }
+    virtual void SIGSLOT_EMIT(arg1_type a1, arg2_type a2, arg3_type a3, arg4_type a4, arg5_type a5, arg6_type a6)
+    {
+        (m_pobject->*m_pmemfun)(a1, a2, a3, a4, a5, a6);
+    }
 
-        virtual has_slots<mt_policy>* getdest() const
-        {
-                return m_pobject;
-        }
+    virtual has_slots<mt_policy> *getdest() const { return m_pobject; }
 
 private:
-        dest_type* m_pobject;
-        void (dest_type::* m_pmemfun)(arg1_type, arg2_type, arg3_type, arg4_type,
-                                     arg5_type, arg6_type);
+    dest_type *m_pobject;
+    void (dest_type::*m_pmemfun)(arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, arg6_type);
 };
 
-template<class dest_type, class arg1_type, class arg2_type, class arg3_type,
-         class arg4_type, class arg5_type, class arg6_type, class arg7_type, class mt_policy>
-class _connection7 : public _connection_base7<arg1_type, arg2_type,
-                                              arg3_type, arg4_type, arg5_type, arg6_type, arg7_type, mt_policy>
-{
+template<class dest_type,
+         class arg1_type,
+         class arg2_type,
+         class arg3_type,
+         class arg4_type,
+         class arg5_type,
+         class arg6_type,
+         class arg7_type,
+         class mt_policy>
+class _connection7
+    : public _connection_base7<arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, arg6_type, arg7_type, mt_policy> {
 public:
-        _connection7()
-        {
-                m_pobject = NULL;
-                m_pmemfun = NULL;
-        }
+    _connection7()
+    {
+        m_pobject = NULL;
+        m_pmemfun = NULL;
+    }
 
-        _connection7(dest_type* pobject, void (dest_type::*pmemfun)(arg1_type,
-                                                                    arg2_type, arg3_type, arg4_type, arg5_type, arg6_type, arg7_type))
-        {
-                m_pobject = pobject;
-                m_pmemfun = pmemfun;
-        }
+    _connection7(
+        dest_type *pobject,
+        void (dest_type::*pmemfun)(arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, arg6_type, arg7_type))
+    {
+        m_pobject = pobject;
+        m_pmemfun = pmemfun;
+    }
 
-        virtual ~_connection7()
-        {}
+    virtual ~_connection7() {}
 
-        virtual _connection_base7<arg1_type, arg2_type, arg3_type, arg4_type,
-                                  arg5_type, arg6_type, arg7_type, mt_policy>* clone()
-        {
-                return new _connection7<dest_type, arg1_type, arg2_type, arg3_type, arg4_type,
-                                        arg5_type, arg6_type, arg7_type, mt_policy>(*this);
-        }
+    virtual _connection_base7<arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, arg6_type, arg7_type, mt_policy> *
+    clone()
+    {
+        return new _connection7<dest_type, arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, arg6_type, arg7_type,
+                                mt_policy>(*this);
+    }
 
-        virtual _connection_base7<arg1_type, arg2_type, arg3_type, arg4_type,
-                                  arg5_type, arg6_type, arg7_type, mt_policy>* duplicate(has_slots<mt_policy>* pnewdest)
-        {
-                return new _connection7<dest_type, arg1_type, arg2_type, arg3_type, arg4_type,
-                                        arg5_type, arg6_type, arg7_type, mt_policy>((dest_type *)pnewdest, m_pmemfun);
-        }
+    virtual _connection_base7<arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, arg6_type, arg7_type, mt_policy> *
+    duplicate(has_slots<mt_policy> *pnewdest)
+    {
+        return new _connection7<dest_type, arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, arg6_type, arg7_type,
+                                mt_policy>((dest_type *) pnewdest, m_pmemfun);
+    }
 
-        virtual void SIGSLOT_EMIT(arg1_type a1, arg2_type a2, arg3_type a3, arg4_type a4,
-                                  arg5_type a5, arg6_type a6, arg7_type a7)
-        {
-                (m_pobject->*m_pmemfun)(a1, a2, a3, a4, a5, a6, a7);
-        }
+    virtual void
+    SIGSLOT_EMIT(arg1_type a1, arg2_type a2, arg3_type a3, arg4_type a4, arg5_type a5, arg6_type a6, arg7_type a7)
+    {
+        (m_pobject->*m_pmemfun)(a1, a2, a3, a4, a5, a6, a7);
+    }
 
-        virtual has_slots<mt_policy>* getdest() const
-        {
-                return m_pobject;
-        }
+    virtual has_slots<mt_policy> *getdest() const { return m_pobject; }
 
 private:
-        dest_type* m_pobject;
-        void (dest_type::* m_pmemfun)(arg1_type, arg2_type, arg3_type, arg4_type,
-                                     arg5_type, arg6_type, arg7_type);
+    dest_type *m_pobject;
+    void (dest_type::*m_pmemfun)(arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, arg6_type, arg7_type);
 };
 
-template<class dest_type, class arg1_type, class arg2_type, class arg3_type,
-         class arg4_type, class arg5_type, class arg6_type, class arg7_type,
-         class arg8_type, class mt_policy>
-class _connection8 : public _connection_base8<arg1_type, arg2_type,
-                                              arg3_type, arg4_type, arg5_type, arg6_type, arg7_type, arg8_type, mt_policy>
-{
+template<class dest_type,
+         class arg1_type,
+         class arg2_type,
+         class arg3_type,
+         class arg4_type,
+         class arg5_type,
+         class arg6_type,
+         class arg7_type,
+         class arg8_type,
+         class mt_policy>
+class _connection8
+    : public _connection_base8<arg1_type,
+                               arg2_type,
+                               arg3_type,
+                               arg4_type,
+                               arg5_type,
+                               arg6_type,
+                               arg7_type,
+                               arg8_type,
+                               mt_policy> {
 public:
-        _connection8()
-        {
-                m_pobject = NULL;
-                m_pmemfun = NULL;
-        }
+    _connection8()
+    {
+        m_pobject = NULL;
+        m_pmemfun = NULL;
+    }
 
-        _connection8(dest_type* pobject, void (dest_type::*pmemfun)(arg1_type,
-                                                                    arg2_type, arg3_type, arg4_type, arg5_type, arg6_type,
-                                                                    arg7_type, arg8_type))
-        {
-                m_pobject = pobject;
-                m_pmemfun = pmemfun;
-        }
+    _connection8(
+        dest_type *pobject,
+        void (dest_type::*
+                  pmemfun)(arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, arg6_type, arg7_type, arg8_type))
+    {
+        m_pobject = pobject;
+        m_pmemfun = pmemfun;
+    }
 
-        virtual ~_connection8()
-        {}
+    virtual ~_connection8() {}
 
-        virtual _connection_base8<arg1_type, arg2_type, arg3_type, arg4_type,
-                                  arg5_type, arg6_type, arg7_type, arg8_type, mt_policy>* clone()
-        {
-                return new _connection8<dest_type, arg1_type, arg2_type, arg3_type, arg4_type,
-                                        arg5_type, arg6_type, arg7_type, arg8_type, mt_policy>(*this);
-        }
+    virtual _connection_base8<arg1_type,
+                              arg2_type,
+                              arg3_type,
+                              arg4_type,
+                              arg5_type,
+                              arg6_type,
+                              arg7_type,
+                              arg8_type,
+                              mt_policy> *
+    clone()
+    {
+        return new _connection8<dest_type, arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, arg6_type, arg7_type,
+                                arg8_type, mt_policy>(*this);
+    }
 
-        virtual _connection_base8<arg1_type, arg2_type, arg3_type, arg4_type,
-                                  arg5_type, arg6_type, arg7_type, arg8_type, mt_policy>* duplicate(has_slots<mt_policy>* pnewdest)
-        {
-                return new _connection8<dest_type, arg1_type, arg2_type, arg3_type, arg4_type,
-                                        arg5_type, arg6_type, arg7_type, arg8_type, mt_policy>((dest_type *)pnewdest, m_pmemfun);
-        }
+    virtual _connection_base8<arg1_type,
+                              arg2_type,
+                              arg3_type,
+                              arg4_type,
+                              arg5_type,
+                              arg6_type,
+                              arg7_type,
+                              arg8_type,
+                              mt_policy> *
+    duplicate(has_slots<mt_policy> *pnewdest)
+    {
+        return new _connection8<dest_type, arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, arg6_type, arg7_type,
+                                arg8_type, mt_policy>((dest_type *) pnewdest, m_pmemfun);
+    }
 
-        virtual void SIGSLOT_EMIT(arg1_type a1, arg2_type a2, arg3_type a3, arg4_type a4,
-                                  arg5_type a5, arg6_type a6, arg7_type a7, arg8_type a8)
-        {
-                (m_pobject->*m_pmemfun)(a1, a2, a3, a4, a5, a6, a7, a8);
-        }
+    virtual void SIGSLOT_EMIT(arg1_type a1,
+                              arg2_type a2,
+                              arg3_type a3,
+                              arg4_type a4,
+                              arg5_type a5,
+                              arg6_type a6,
+                              arg7_type a7,
+                              arg8_type a8)
+    {
+        (m_pobject->*m_pmemfun)(a1, a2, a3, a4, a5, a6, a7, a8);
+    }
 
-        virtual has_slots<mt_policy>* getdest() const
-        {
-                return m_pobject;
-        }
+    virtual has_slots<mt_policy> *getdest() const { return m_pobject; }
 
 private:
-        dest_type* m_pobject;
-        void (dest_type::* m_pmemfun)(arg1_type, arg2_type, arg3_type, arg4_type,
-                                     arg5_type, arg6_type, arg7_type, arg8_type);
+    dest_type *m_pobject;
+    void (
+        dest_type::*m_pmemfun)(arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, arg6_type, arg7_type, arg8_type);
 };
 
 template<class mt_policy = SIGSLOT_DEFAULT_MT_POLICY>
-class signal0 : public _signal_base_middle<std::list<_connection_base0<mt_policy>*>, mt_policy>
-{
+class signal0 : public _signal_base_middle<std::list<_connection_base0<mt_policy> *>, mt_policy> {
 public:
+    typedef signal0<mt_policy> this_type;
+    typedef std::list<_connection_base0<mt_policy> *> connections_list;
+    typedef _signal_base_middle<connections_list, mt_policy> base_type;
 
-        typedef signal0<mt_policy> this_type;
-        typedef std::list<_connection_base0<mt_policy>*> connections_list;
-        typedef _signal_base_middle<connections_list, mt_policy> base_type;
+    using base_type::m_connected_slots;
 
-        using base_type::m_connected_slots;
+    signal0() {}
 
-        signal0()
-        {}
+    signal0(const this_type &s) : base_type(s) {}
 
-        signal0(const this_type& s)
-            : base_type(s)
-        {}
+    ~signal0() { base_type::disconnect_all(); }
 
-        ~signal0()
-        {
-                base_type::disconnect_all();
+    template<class desttype>
+    void connect(desttype *pclass, void (desttype::*pmemfun)())
+    {
+        lock_block<mt_policy> lock(this);
+
+        _connection0<desttype, mt_policy> *conn = new _connection0<desttype, mt_policy>(pclass, pmemfun);
+
+        m_connected_slots.push_back(conn);
+        pclass->signal_connect(this);
+    }
+
+    void SIGSLOT_EMIT()
+    {
+        lock_block<mt_policy> lock(this);
+
+        typename connections_list::const_iterator itNext, it = m_connected_slots.begin();
+        typename connections_list::const_iterator itEnd = m_connected_slots.end();
+
+        while (it != itEnd) {
+            itNext = it;
+            ++itNext;
+
+            (*it)->SIGSLOT_EMIT();
+
+            it = itNext;
         }
+    }
 
-        template<class desttype>
-        void connect(desttype* pclass, void (desttype::*pmemfun)())
-        {
-                lock_block<mt_policy> lock(this);
-
-                _connection0<desttype, mt_policy>* conn =
-                        new _connection0<desttype, mt_policy>(pclass, pmemfun);
-
-                m_connected_slots.push_back(conn);
-                pclass->signal_connect(this);
-        }
-
-        void SIGSLOT_EMIT()
-        {
-                lock_block<mt_policy> lock(this);
-
-                typename connections_list::const_iterator itNext, it = m_connected_slots.begin();
-                typename connections_list::const_iterator itEnd = m_connected_slots.end();
-
-                while(it != itEnd)
-                {
-                        itNext = it;
-                        ++itNext;
-
-                        (*it)->SIGSLOT_EMIT();
-
-                        it = itNext;
-                }
-        }
-
-        void operator()()
-        {
-                SIGSLOT_EMIT();
-        }
+    void operator()() { SIGSLOT_EMIT(); }
 };
 
 template<class arg1_type, class mt_policy = SIGSLOT_DEFAULT_MT_POLICY>
-class signal1 : public _signal_base_middle<std::list<_connection_base1<arg1_type, mt_policy>*>, mt_policy>
-{
+class signal1 : public _signal_base_middle<std::list<_connection_base1<arg1_type, mt_policy> *>, mt_policy> {
 public:
+    typedef signal1<arg1_type, mt_policy> this_type;
+    typedef std::list<_connection_base1<arg1_type, mt_policy> *> connections_list;
+    typedef _signal_base_middle<connections_list, mt_policy> base_type;
 
-        typedef signal1<arg1_type, mt_policy> this_type;
-        typedef std::list<_connection_base1<arg1_type, mt_policy>*> connections_list;
-        typedef _signal_base_middle<connections_list, mt_policy> base_type;
+    using base_type::m_connected_slots;
 
-        using base_type::m_connected_slots;
+    signal1() {}
 
-        signal1()
-        {}
+    signal1(const this_type &s) : base_type(s) {}
 
-        signal1(const this_type& s)
-            : base_type(s)
-        {}
+    ~signal1() { base_type::disconnect_all(); }
 
-        ~signal1()
-        {
-                base_type::disconnect_all();
+    template<class desttype>
+    void connect(desttype *pclass, void (desttype::*pmemfun)(arg1_type))
+    {
+        lock_block<mt_policy> lock(this);
+        _connection1<desttype, arg1_type, mt_policy> *conn =
+            new _connection1<desttype, arg1_type, mt_policy>(pclass, pmemfun);
+        m_connected_slots.push_back(conn);
+        pclass->signal_connect(this);
+    }
+
+    void SIGSLOT_EMIT(arg1_type a1)
+    {
+        lock_block<mt_policy> lock(this);
+        typename connections_list::const_iterator itNext, it = m_connected_slots.begin();
+        typename connections_list::const_iterator itEnd = m_connected_slots.end();
+
+        while (it != itEnd) {
+            itNext = it;
+            ++itNext;
+
+            (*it)->SIGSLOT_EMIT(a1);
+
+            it = itNext;
         }
+    }
 
-        template<class desttype>
-        void connect(desttype* pclass, void (desttype::*pmemfun)(arg1_type))
-        {
-                lock_block<mt_policy> lock(this);
-                _connection1<desttype, arg1_type, mt_policy>* conn =
-                        new _connection1<desttype, arg1_type, mt_policy>(pclass, pmemfun);
-                m_connected_slots.push_back(conn);
-                pclass->signal_connect(this);
-        }
-
-        void SIGSLOT_EMIT(arg1_type a1)
-        {
-                lock_block<mt_policy> lock(this);
-                typename connections_list::const_iterator itNext, it = m_connected_slots.begin();
-                typename connections_list::const_iterator itEnd = m_connected_slots.end();
-
-                while(it != itEnd)
-                {
-                        itNext = it;
-                        ++itNext;
-
-                        (*it)->SIGSLOT_EMIT(a1);
-
-                        it = itNext;
-                }
-        }
-
-        void operator()(arg1_type a1)
-        {
-                SIGSLOT_EMIT(a1);
-        }
+    void operator()(arg1_type a1) { SIGSLOT_EMIT(a1); }
 };
 
 template<class arg1_type, class arg2_type, class mt_policy = SIGSLOT_DEFAULT_MT_POLICY>
-class signal2 : public _signal_base_middle<std::list<_connection_base2<arg1_type, arg2_type, mt_policy>*>, mt_policy>
-{
+class signal2 : public _signal_base_middle<std::list<_connection_base2<arg1_type, arg2_type, mt_policy> *>, mt_policy> {
 public:
+    typedef signal2<arg1_type, arg2_type, mt_policy> this_type;
+    typedef std::list<_connection_base2<arg1_type, arg2_type, mt_policy> *> connections_list;
+    typedef _signal_base_middle<connections_list, mt_policy> base_type;
 
-        typedef signal2<arg1_type, arg2_type, mt_policy> this_type;
-        typedef std::list<_connection_base2<arg1_type, arg2_type, mt_policy>*> connections_list;
-        typedef _signal_base_middle<connections_list, mt_policy> base_type;
+    using base_type::m_connected_slots;
 
-        using base_type::m_connected_slots;
+    signal2() {}
 
-        signal2()
-        {}
+    signal2(const this_type &s) : base_type(s) {}
 
-        signal2(const this_type& s)
-            : base_type(s)
-        {}
+    ~signal2() { base_type::disconnect_all(); }
 
-        ~signal2()
-        {
-                base_type::disconnect_all();
+    template<class desttype>
+    void connect(desttype *pclass, void (desttype::*pmemfun)(arg1_type, arg2_type))
+    {
+        lock_block<mt_policy> lock(this);
+        _connection2<desttype, arg1_type, arg2_type, mt_policy> *conn =
+            new _connection2<desttype, arg1_type, arg2_type, mt_policy>(pclass, pmemfun);
+        m_connected_slots.push_back(conn);
+        pclass->signal_connect(this);
+    }
+
+    void SIGSLOT_EMIT(arg1_type a1, arg2_type a2)
+    {
+        lock_block<mt_policy> lock(this);
+        typename connections_list::const_iterator itNext, it = m_connected_slots.begin();
+        typename connections_list::const_iterator itEnd = m_connected_slots.end();
+
+        while (it != itEnd) {
+            itNext = it;
+            ++itNext;
+
+            (*it)->SIGSLOT_EMIT(a1, a2);
+
+            it = itNext;
         }
+    }
 
-        template<class desttype>
-        void connect(desttype* pclass, void (desttype::*pmemfun)(arg1_type,
-                                                                 arg2_type))
-        {
-                lock_block<mt_policy> lock(this);
-                _connection2<desttype, arg1_type, arg2_type, mt_policy>* conn = new
-                        _connection2<desttype, arg1_type, arg2_type, mt_policy>(pclass, pmemfun);
-                m_connected_slots.push_back(conn);
-                pclass->signal_connect(this);
-        }
-
-        void SIGSLOT_EMIT(arg1_type a1, arg2_type a2)
-        {
-                lock_block<mt_policy> lock(this);
-                typename connections_list::const_iterator itNext, it = m_connected_slots.begin();
-                typename connections_list::const_iterator itEnd = m_connected_slots.end();
-
-                while(it != itEnd)
-                {
-                        itNext = it;
-                        ++itNext;
-
-                        (*it)->SIGSLOT_EMIT(a1, a2);
-
-                        it = itNext;
-                }
-        }
-
-        void operator()(arg1_type a1, arg2_type a2)
-        {
-                SIGSLOT_EMIT(a1, a2);
-        }
+    void operator()(arg1_type a1, arg2_type a2) { SIGSLOT_EMIT(a1, a2); }
 };
 
 template<class arg1_type, class arg2_type, class arg3_type, class mt_policy = SIGSLOT_DEFAULT_MT_POLICY>
-class signal3 : public _signal_base_middle<std::list<_connection_base3<arg1_type, arg2_type, arg3_type, mt_policy>*>, mt_policy>
-{
+class signal3 : public _signal_base_middle<std::list<_connection_base3<arg1_type, arg2_type, arg3_type, mt_policy> *>,
+                                           mt_policy> {
 public:
+    typedef signal3<arg1_type, arg2_type, arg3_type, mt_policy> this_type;
+    typedef std::list<_connection_base3<arg1_type, arg2_type, arg3_type, mt_policy> *> connections_list;
+    typedef _signal_base_middle<connections_list, mt_policy> base_type;
 
-        typedef signal3<arg1_type, arg2_type, arg3_type, mt_policy> this_type;
-        typedef std::list<_connection_base3<arg1_type, arg2_type, arg3_type, mt_policy>*> connections_list;
-        typedef _signal_base_middle<connections_list, mt_policy> base_type;
+    using base_type::m_connected_slots;
 
-        using base_type::m_connected_slots;
+    signal3() {}
 
-        signal3()
-        {}
+    signal3(const this_type &s) : base_type(s) {}
 
-        signal3(const this_type& s)
-            : base_type(s)
-        {}
+    ~signal3() { base_type::disconnect_all(); }
 
-        ~signal3()
-        {
-                base_type::disconnect_all();
+    template<class desttype>
+    void connect(desttype *pclass, void (desttype::*pmemfun)(arg1_type, arg2_type, arg3_type))
+    {
+        lock_block<mt_policy> lock(this);
+        _connection3<desttype, arg1_type, arg2_type, arg3_type, mt_policy> *conn =
+            new _connection3<desttype, arg1_type, arg2_type, arg3_type, mt_policy>(pclass, pmemfun);
+        m_connected_slots.push_back(conn);
+        pclass->signal_connect(this);
+    }
+
+    void SIGSLOT_EMIT(arg1_type a1, arg2_type a2, arg3_type a3)
+    {
+        lock_block<mt_policy> lock(this);
+        typename connections_list::const_iterator itNext, it = m_connected_slots.begin();
+        typename connections_list::const_iterator itEnd = m_connected_slots.end();
+
+        while (it != itEnd) {
+            itNext = it;
+            ++itNext;
+
+            (*it)->SIGSLOT_EMIT(a1, a2, a3);
+
+            it = itNext;
         }
+    }
 
-        template<class desttype>
-        void connect(desttype* pclass, void (desttype::*pmemfun)(arg1_type,
-                                                                 arg2_type, arg3_type))
-        {
-                lock_block<mt_policy> lock(this);
-                _connection3<desttype, arg1_type, arg2_type, arg3_type, mt_policy>* conn =
-                        new _connection3<desttype, arg1_type, arg2_type, arg3_type, mt_policy>(pclass,
-                                                                                               pmemfun);
-                m_connected_slots.push_back(conn);
-                pclass->signal_connect(this);
-        }
-
-        void SIGSLOT_EMIT(arg1_type a1, arg2_type a2, arg3_type a3)
-        {
-                lock_block<mt_policy> lock(this);
-                typename connections_list::const_iterator itNext, it = m_connected_slots.begin();
-                typename connections_list::const_iterator itEnd = m_connected_slots.end();
-
-                while(it != itEnd)
-                {
-                        itNext = it;
-                        ++itNext;
-
-                        (*it)->SIGSLOT_EMIT(a1, a2, a3);
-
-                        it = itNext;
-                }
-        }
-
-        void operator()(arg1_type a1, arg2_type a2, arg3_type a3)
-        {
-                SIGSLOT_EMIT(a1, a2, a3);
-        }
+    void operator()(arg1_type a1, arg2_type a2, arg3_type a3) { SIGSLOT_EMIT(a1, a2, a3); }
 };
 
-template<class arg1_type, class arg2_type, class arg3_type, class arg4_type, class mt_policy = SIGSLOT_DEFAULT_MT_POLICY>
-class signal4 : public _signal_base_middle<std::list<_connection_base4<arg1_type, arg2_type, arg3_type, arg4_type, mt_policy>*>, mt_policy>
-{
+template<class arg1_type,
+         class arg2_type,
+         class arg3_type,
+         class arg4_type,
+         class mt_policy = SIGSLOT_DEFAULT_MT_POLICY>
+class signal4
+    : public _signal_base_middle<std::list<_connection_base4<arg1_type, arg2_type, arg3_type, arg4_type, mt_policy> *>,
+                                 mt_policy> {
 public:
+    typedef signal4<arg1_type, arg2_type, arg3_type, arg4_type, mt_policy> this_type;
+    typedef std::list<_connection_base4<arg1_type, arg2_type, arg3_type, arg4_type, mt_policy> *> connections_list;
+    typedef _signal_base_middle<connections_list, mt_policy> base_type;
 
-        typedef signal4<arg1_type, arg2_type, arg3_type, arg4_type, mt_policy> this_type;
-        typedef std::list<_connection_base4<arg1_type, arg2_type, arg3_type, arg4_type, mt_policy>*> connections_list;
-        typedef _signal_base_middle<connections_list, mt_policy> base_type;
+    using base_type::m_connected_slots;
 
-        using base_type::m_connected_slots;
+    signal4() {}
 
-        signal4()
-        {}
+    signal4(const this_type &s) : base_type(s) {}
 
-        signal4(const this_type& s)
-            : base_type(s)
-        {}
+    ~signal4() { base_type::disconnect_all(); }
 
-        ~signal4()
-        {
-                base_type::disconnect_all();
+    template<class desttype>
+    void connect(desttype *pclass, void (desttype::*pmemfun)(arg1_type, arg2_type, arg3_type, arg4_type))
+    {
+        lock_block<mt_policy> lock(this);
+        _connection4<desttype, arg1_type, arg2_type, arg3_type, arg4_type, mt_policy> *conn =
+            new _connection4<desttype, arg1_type, arg2_type, arg3_type, arg4_type, mt_policy>(pclass, pmemfun);
+        m_connected_slots.push_back(conn);
+        pclass->signal_connect(this);
+    }
+
+    void SIGSLOT_EMIT(arg1_type a1, arg2_type a2, arg3_type a3, arg4_type a4)
+    {
+        lock_block<mt_policy> lock(this);
+        typename connections_list::const_iterator itNext, it = m_connected_slots.begin();
+        typename connections_list::const_iterator itEnd = m_connected_slots.end();
+
+        while (it != itEnd) {
+            itNext = it;
+            ++itNext;
+
+            (*it)->SIGSLOT_EMIT(a1, a2, a3, a4);
+
+            it = itNext;
         }
+    }
 
-        template<class desttype>
-        void connect(desttype* pclass, void (desttype::*pmemfun)(arg1_type,
-                                                                 arg2_type, arg3_type, arg4_type))
-        {
-                lock_block<mt_policy> lock(this);
-                _connection4<desttype, arg1_type, arg2_type, arg3_type, arg4_type, mt_policy>*
-                        conn = new _connection4<desttype, arg1_type, arg2_type, arg3_type,
-                                                arg4_type, mt_policy>(pclass, pmemfun);
-                m_connected_slots.push_back(conn);
-                pclass->signal_connect(this);
-        }
-
-        void SIGSLOT_EMIT(arg1_type a1, arg2_type a2, arg3_type a3, arg4_type a4)
-        {
-                lock_block<mt_policy> lock(this);
-                typename connections_list::const_iterator itNext, it = m_connected_slots.begin();
-                typename connections_list::const_iterator itEnd = m_connected_slots.end();
-
-                while(it != itEnd)
-                {
-                        itNext = it;
-                        ++itNext;
-
-                        (*it)->SIGSLOT_EMIT(a1, a2, a3, a4);
-
-                        it = itNext;
-                }
-        }
-
-        void operator()(arg1_type a1, arg2_type a2, arg3_type a3, arg4_type a4)
-        {
-                SIGSLOT_EMIT(a1, a2, a3, a4);
-        }
+    void operator()(arg1_type a1, arg2_type a2, arg3_type a3, arg4_type a4) { SIGSLOT_EMIT(a1, a2, a3, a4); }
 };
 
-template<class arg1_type, class arg2_type, class arg3_type, class arg4_type,
-         class arg5_type, class mt_policy = SIGSLOT_DEFAULT_MT_POLICY>
-class signal5 : public _signal_base_middle<std::list<_connection_base5<arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, mt_policy>*>, mt_policy>
-{
+template<class arg1_type,
+         class arg2_type,
+         class arg3_type,
+         class arg4_type,
+         class arg5_type,
+         class mt_policy = SIGSLOT_DEFAULT_MT_POLICY>
+class signal5 : public _signal_base_middle<
+                    std::list<_connection_base5<arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, mt_policy> *>,
+                    mt_policy> {
 public:
+    typedef signal5<arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, mt_policy> this_type;
+    typedef std::list<_connection_base5<arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, mt_policy> *>
+        connections_list;
+    typedef _signal_base_middle<connections_list, mt_policy> base_type;
 
-        typedef signal5<arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, mt_policy> this_type;
-        typedef std::list<_connection_base5<arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, mt_policy>*> connections_list;
-        typedef _signal_base_middle<connections_list, mt_policy> base_type;
+    using base_type::m_connected_slots;
 
-        using base_type::m_connected_slots;
+    signal5() {}
 
-        signal5()
-        {}
+    signal5(const this_type &s) : base_type(s) {}
 
-        signal5(const this_type& s)
-            : base_type(s)
-        {}
+    ~signal5() { base_type::disconnect_all(); }
 
-        ~signal5()
-        {
-                base_type::disconnect_all();
+    template<class desttype>
+    void connect(desttype *pclass, void (desttype::*pmemfun)(arg1_type, arg2_type, arg3_type, arg4_type, arg5_type))
+    {
+        lock_block<mt_policy> lock(this);
+        _connection5<desttype, arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, mt_policy> *conn =
+            new _connection5<desttype, arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, mt_policy>(
+                pclass, pmemfun);
+        m_connected_slots.push_back(conn);
+        pclass->signal_connect(this);
+    }
+
+    void SIGSLOT_EMIT(arg1_type a1, arg2_type a2, arg3_type a3, arg4_type a4, arg5_type a5)
+    {
+        lock_block<mt_policy> lock(this);
+        typename connections_list::const_iterator itNext, it = m_connected_slots.begin();
+        typename connections_list::const_iterator itEnd = m_connected_slots.end();
+
+        while (it != itEnd) {
+            itNext = it;
+            ++itNext;
+
+            (*it)->SIGSLOT_EMIT(a1, a2, a3, a4, a5);
+
+            it = itNext;
         }
+    }
 
-        template<class desttype>
-        void connect(desttype* pclass, void (desttype::*pmemfun)(arg1_type,
-                                                                 arg2_type, arg3_type, arg4_type, arg5_type))
-        {
-                lock_block<mt_policy> lock(this);
-                _connection5<desttype, arg1_type, arg2_type, arg3_type, arg4_type,
-                             arg5_type, mt_policy>* conn = new _connection5<desttype, arg1_type, arg2_type,
-                                                                            arg3_type, arg4_type, arg5_type, mt_policy>(pclass, pmemfun);
-                m_connected_slots.push_back(conn);
-                pclass->signal_connect(this);
-        }
-
-        void SIGSLOT_EMIT(arg1_type a1, arg2_type a2, arg3_type a3, arg4_type a4,
-                          arg5_type a5)
-        {
-                lock_block<mt_policy> lock(this);
-                typename connections_list::const_iterator itNext, it = m_connected_slots.begin();
-                typename connections_list::const_iterator itEnd = m_connected_slots.end();
-
-                while(it != itEnd)
-                {
-                        itNext = it;
-                        ++itNext;
-
-                        (*it)->SIGSLOT_EMIT(a1, a2, a3, a4, a5);
-
-                        it = itNext;
-                }
-        }
-
-        void operator()(arg1_type a1, arg2_type a2, arg3_type a3, arg4_type a4,
-                        arg5_type a5)
-        {
-                SIGSLOT_EMIT(a1, a2, a3, a4, a5);
-        }
+    void operator()(arg1_type a1, arg2_type a2, arg3_type a3, arg4_type a4, arg5_type a5)
+    {
+        SIGSLOT_EMIT(a1, a2, a3, a4, a5);
+    }
 };
 
-
-template<class arg1_type, class arg2_type, class arg3_type, class arg4_type,
-         class arg5_type, class arg6_type, class mt_policy = SIGSLOT_DEFAULT_MT_POLICY>
-class signal6 : public _signal_base_middle<std::list<_connection_base6<arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, arg6_type, mt_policy>*>, mt_policy>
-{
+template<class arg1_type,
+         class arg2_type,
+         class arg3_type,
+         class arg4_type,
+         class arg5_type,
+         class arg6_type,
+         class mt_policy = SIGSLOT_DEFAULT_MT_POLICY>
+class signal6
+    : public _signal_base_middle<
+          std::list<_connection_base6<arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, arg6_type, mt_policy> *>,
+          mt_policy> {
 public:
+    typedef signal6<arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, arg6_type, mt_policy> this_type;
+    typedef std::list<_connection_base6<arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, arg6_type, mt_policy> *>
+        connections_list;
+    typedef _signal_base_middle<connections_list, mt_policy> base_type;
 
-        typedef signal6<arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, arg6_type, mt_policy> this_type;
-        typedef std::list<_connection_base6<arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, arg6_type, mt_policy>*> connections_list;
-        typedef _signal_base_middle<connections_list, mt_policy> base_type;
+    using base_type::m_connected_slots;
 
-        using base_type::m_connected_slots;
+    signal6() {}
 
-        signal6()
-        {}
+    signal6(const this_type &s) : base_type(s) {}
 
-        signal6(const this_type& s)
-            : base_type(s)
-        {}
+    ~signal6() { base_type::disconnect_all(); }
 
-        ~signal6()
-        {
-                base_type::disconnect_all();
+    template<class desttype>
+    void connect(desttype *pclass,
+                 void (desttype::*pmemfun)(arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, arg6_type))
+    {
+        lock_block<mt_policy> lock(this);
+        _connection6<desttype, arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, arg6_type, mt_policy> *conn =
+            new _connection6<desttype, arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, arg6_type, mt_policy>(
+                pclass, pmemfun);
+        m_connected_slots.push_back(conn);
+        pclass->signal_connect(this);
+    }
+
+    void SIGSLOT_EMIT(arg1_type a1, arg2_type a2, arg3_type a3, arg4_type a4, arg5_type a5, arg6_type a6)
+    {
+        lock_block<mt_policy> lock(this);
+        typename connections_list::const_iterator itNext, it = m_connected_slots.begin();
+        typename connections_list::const_iterator itEnd = m_connected_slots.end();
+
+        while (it != itEnd) {
+            itNext = it;
+            ++itNext;
+
+            (*it)->SIGSLOT_EMIT(a1, a2, a3, a4, a5, a6);
+
+            it = itNext;
         }
+    }
 
-        template<class desttype>
-        void connect(desttype* pclass, void (desttype::*pmemfun)(arg1_type,
-                                                                 arg2_type, arg3_type, arg4_type, arg5_type, arg6_type))
-        {
-                lock_block<mt_policy> lock(this);
-                _connection6<desttype, arg1_type, arg2_type, arg3_type, arg4_type,
-                             arg5_type, arg6_type, mt_policy>* conn =
-                        new _connection6<desttype, arg1_type, arg2_type, arg3_type,
-                                         arg4_type, arg5_type, arg6_type, mt_policy>(pclass, pmemfun);
-                m_connected_slots.push_back(conn);
-                pclass->signal_connect(this);
-        }
-
-        void SIGSLOT_EMIT(arg1_type a1, arg2_type a2, arg3_type a3, arg4_type a4,
-                          arg5_type a5, arg6_type a6)
-        {
-                lock_block<mt_policy> lock(this);
-                typename connections_list::const_iterator itNext, it = m_connected_slots.begin();
-                typename connections_list::const_iterator itEnd = m_connected_slots.end();
-
-                while(it != itEnd)
-                {
-                        itNext = it;
-                        ++itNext;
-
-                        (*it)->SIGSLOT_EMIT(a1, a2, a3, a4, a5, a6);
-
-                        it = itNext;
-                }
-        }
-
-        void operator()(arg1_type a1, arg2_type a2, arg3_type a3, arg4_type a4,
-                        arg5_type a5, arg6_type a6)
-        {
-                SIGSLOT_EMIT(a1, a2, a3, a4, a5, a6);
-        }
+    void operator()(arg1_type a1, arg2_type a2, arg3_type a3, arg4_type a4, arg5_type a5, arg6_type a6)
+    {
+        SIGSLOT_EMIT(a1, a2, a3, a4, a5, a6);
+    }
 };
 
-template<class arg1_type, class arg2_type, class arg3_type, class arg4_type,
-         class arg5_type, class arg6_type, class arg7_type, class mt_policy = SIGSLOT_DEFAULT_MT_POLICY>
-class signal7 : public _signal_base_middle<std::list<_connection_base7<arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, arg6_type, arg7_type, mt_policy>*>, mt_policy>
-{
+template<class arg1_type,
+         class arg2_type,
+         class arg3_type,
+         class arg4_type,
+         class arg5_type,
+         class arg6_type,
+         class arg7_type,
+         class mt_policy = SIGSLOT_DEFAULT_MT_POLICY>
+class signal7
+    : public _signal_base_middle<
+          std::list<
+              _connection_base7<arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, arg6_type, arg7_type, mt_policy>
+                  *>,
+          mt_policy> {
 public:
+    typedef signal7<arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, arg6_type, arg7_type, mt_policy> this_type;
+    typedef std::list<
+        _connection_base7<arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, arg6_type, arg7_type, mt_policy> *>
+        connections_list;
+    typedef _signal_base_middle<connections_list, mt_policy> base_type;
 
-        typedef signal7<arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, arg6_type, arg7_type, mt_policy> this_type;
-        typedef std::list<_connection_base7<arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, arg6_type, arg7_type, mt_policy>*> connections_list;
-        typedef _signal_base_middle<connections_list, mt_policy> base_type;
+    using base_type::m_connected_slots;
 
-        using base_type::m_connected_slots;
+    signal7() {}
 
-        signal7()
-        {}
+    signal7(const this_type &s) : base_type(s) {}
 
-        signal7(const this_type& s)
-            : base_type(s)
-        {}
+    ~signal7() { base_type::disconnect_all(); }
 
-        ~signal7()
-        {
-                base_type::disconnect_all();
+    template<class desttype>
+    void connect(desttype *pclass,
+                 void (desttype::*pmemfun)(arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, arg6_type, arg7_type))
+    {
+        lock_block<mt_policy> lock(this);
+        _connection7<desttype, arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, arg6_type, arg7_type, mt_policy>
+            *conn = new _connection7<desttype, arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, arg6_type,
+                                     arg7_type, mt_policy>(pclass, pmemfun);
+        m_connected_slots.push_back(conn);
+        pclass->signal_connect(this);
+    }
+
+    void SIGSLOT_EMIT(arg1_type a1, arg2_type a2, arg3_type a3, arg4_type a4, arg5_type a5, arg6_type a6, arg7_type a7)
+    {
+        lock_block<mt_policy> lock(this);
+        typename connections_list::const_iterator itNext, it = m_connected_slots.begin();
+        typename connections_list::const_iterator itEnd = m_connected_slots.end();
+
+        while (it != itEnd) {
+            itNext = it;
+            ++itNext;
+
+            (*it)->SIGSLOT_EMIT(a1, a2, a3, a4, a5, a6, a7);
+
+            it = itNext;
         }
+    }
 
-        template<class desttype>
-        void connect(desttype* pclass, void (desttype::*pmemfun)(arg1_type,
-                                                                 arg2_type, arg3_type, arg4_type, arg5_type, arg6_type,
-                                                                 arg7_type))
-        {
-                lock_block<mt_policy> lock(this);
-                _connection7<desttype, arg1_type, arg2_type, arg3_type, arg4_type,
-                             arg5_type, arg6_type, arg7_type, mt_policy>* conn =
-                        new _connection7<desttype, arg1_type, arg2_type, arg3_type,
-                                         arg4_type, arg5_type, arg6_type, arg7_type, mt_policy>(pclass, pmemfun);
-                m_connected_slots.push_back(conn);
-                pclass->signal_connect(this);
-        }
-
-        void SIGSLOT_EMIT(arg1_type a1, arg2_type a2, arg3_type a3, arg4_type a4,
-                          arg5_type a5, arg6_type a6, arg7_type a7)
-        {
-                lock_block<mt_policy> lock(this);
-                typename connections_list::const_iterator itNext, it = m_connected_slots.begin();
-                typename connections_list::const_iterator itEnd = m_connected_slots.end();
-
-                while(it != itEnd)
-                {
-                        itNext = it;
-                        ++itNext;
-
-                        (*it)->SIGSLOT_EMIT(a1, a2, a3, a4, a5, a6, a7);
-
-                        it = itNext;
-                }
-        }
-
-        void operator()(arg1_type a1, arg2_type a2, arg3_type a3, arg4_type a4,
-                        arg5_type a5, arg6_type a6, arg7_type a7)
-        {
-                SIGSLOT_EMIT(a1, a2, a3, a4, a5, a6, a7);
-        }
+    void operator()(arg1_type a1, arg2_type a2, arg3_type a3, arg4_type a4, arg5_type a5, arg6_type a6, arg7_type a7)
+    {
+        SIGSLOT_EMIT(a1, a2, a3, a4, a5, a6, a7);
+    }
 };
 
-template<class arg1_type, class arg2_type, class arg3_type, class arg4_type,
-         class arg5_type, class arg6_type, class arg7_type, class arg8_type, class mt_policy = SIGSLOT_DEFAULT_MT_POLICY>
-class signal8 : public _signal_base_middle<std::list<_connection_base8<arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, arg6_type, arg7_type, arg8_type, mt_policy>*>, mt_policy>
-{
+template<class arg1_type,
+         class arg2_type,
+         class arg3_type,
+         class arg4_type,
+         class arg5_type,
+         class arg6_type,
+         class arg7_type,
+         class arg8_type,
+         class mt_policy = SIGSLOT_DEFAULT_MT_POLICY>
+class signal8
+    : public _signal_base_middle<std::list<_connection_base8<arg1_type,
+                                                             arg2_type,
+                                                             arg3_type,
+                                                             arg4_type,
+                                                             arg5_type,
+                                                             arg6_type,
+                                                             arg7_type,
+                                                             arg8_type,
+                                                             mt_policy> *>,
+                                 mt_policy> {
 public:
+    typedef signal8<arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, arg6_type, arg7_type, arg8_type, mt_policy>
+        this_type;
+    typedef std::list<_connection_base8<arg1_type,
+                                        arg2_type,
+                                        arg3_type,
+                                        arg4_type,
+                                        arg5_type,
+                                        arg6_type,
+                                        arg7_type,
+                                        arg8_type,
+                                        mt_policy> *>
+        connections_list;
+    typedef _signal_base_middle<connections_list, mt_policy> base_type;
 
-        typedef signal8<arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, arg6_type, arg7_type, arg8_type, mt_policy> this_type;
-        typedef std::list<_connection_base8<arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, arg6_type, arg7_type, arg8_type, mt_policy>*> connections_list;
-        typedef _signal_base_middle<connections_list, mt_policy> base_type;
+    using base_type::m_connected_slots;
 
-        using base_type::m_connected_slots;
+    signal8() {}
 
-        signal8()
-        {}
+    signal8(const this_type &s) : base_type(s) {}
 
-        signal8(const this_type& s)
-            : base_type(s)
-        {}
+    ~signal8() { base_type::disconnect_all(); }
 
-        ~signal8()
-        {
-                base_type::disconnect_all();
+    template<class desttype>
+    void connect(
+        desttype *pclass,
+        void (
+            desttype::*pmemfun)(arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, arg6_type, arg7_type, arg8_type))
+    {
+        lock_block<mt_policy> lock(this);
+        _connection8<desttype, arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, arg6_type, arg7_type, arg8_type,
+                     mt_policy> *conn =
+            new _connection8<desttype, arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, arg6_type, arg7_type,
+                             arg8_type, mt_policy>(pclass, pmemfun);
+        m_connected_slots.push_back(conn);
+        pclass->signal_connect(this);
+    }
+
+    void SIGSLOT_EMIT(arg1_type a1,
+                      arg2_type a2,
+                      arg3_type a3,
+                      arg4_type a4,
+                      arg5_type a5,
+                      arg6_type a6,
+                      arg7_type a7,
+                      arg8_type a8)
+    {
+        lock_block<mt_policy> lock(this);
+        typename connections_list::const_iterator itNext, it = m_connected_slots.begin();
+        typename connections_list::const_iterator itEnd = m_connected_slots.end();
+
+        while (it != itEnd) {
+            itNext = it;
+            ++itNext;
+
+            (*it)->SIGSLOT_EMIT(a1, a2, a3, a4, a5, a6, a7, a8);
+
+            it = itNext;
         }
+    }
 
-        template<class desttype>
-        void connect(desttype* pclass, void (desttype::*pmemfun)(arg1_type,
-                                                                 arg2_type, arg3_type, arg4_type, arg5_type, arg6_type,
-                                                                 arg7_type, arg8_type))
-        {
-                lock_block<mt_policy> lock(this);
-                _connection8<desttype, arg1_type, arg2_type, arg3_type, arg4_type,
-                             arg5_type, arg6_type, arg7_type, arg8_type, mt_policy>* conn =
-                        new _connection8<desttype, arg1_type, arg2_type, arg3_type,
-                                         arg4_type, arg5_type, arg6_type, arg7_type,
-                                         arg8_type, mt_policy>(pclass, pmemfun);
-                m_connected_slots.push_back(conn);
-                pclass->signal_connect(this);
-        }
-
-        void SIGSLOT_EMIT(arg1_type a1, arg2_type a2, arg3_type a3, arg4_type a4,
-                          arg5_type a5, arg6_type a6, arg7_type a7, arg8_type a8)
-        {
-                lock_block<mt_policy> lock(this);
-                typename connections_list::const_iterator itNext, it = m_connected_slots.begin();
-                typename connections_list::const_iterator itEnd = m_connected_slots.end();
-
-                while(it != itEnd)
-                {
-                        itNext = it;
-                        ++itNext;
-
-                        (*it)->SIGSLOT_EMIT(a1, a2, a3, a4, a5, a6, a7, a8);
-
-                        it = itNext;
-                }
-        }
-
-        void operator()(arg1_type a1, arg2_type a2, arg3_type a3, arg4_type a4,
-                        arg5_type a5, arg6_type a6, arg7_type a7, arg8_type a8)
-        {
-                SIGSLOT_EMIT(a1, a2, a3, a4, a5, a6, a7, a8);
-        }
+    void operator()(arg1_type a1,
+                    arg2_type a2,
+                    arg3_type a3,
+                    arg4_type a4,
+                    arg5_type a5,
+                    arg6_type a6,
+                    arg7_type a7,
+                    arg8_type a8)
+    {
+        SIGSLOT_EMIT(a1, a2, a3, a4, a5, a6, a7, a8);
+    }
 };
 
-namespace impl
-{
+namespace impl {
 
 struct empty {};
 
-} // namespace impl
+}// namespace impl
 
 // signal can be used instead of the numbered signalN classes.
 // For example:
@@ -1609,74 +1495,64 @@ struct empty {};
 // instead of
 //
 //     sigslot::signal2<int, double> signal;
-template<typename A1 = impl::empty, typename A2 = impl::empty,
-         typename A3 = impl::empty, typename A4 = impl::empty,
-         typename A5 = impl::empty, typename A6 = impl::empty,
-         typename A7 = impl::empty, typename A8 = impl::empty>
+template<typename A1 = impl::empty,
+         typename A2 = impl::empty,
+         typename A3 = impl::empty,
+         typename A4 = impl::empty,
+         typename A5 = impl::empty,
+         typename A6 = impl::empty,
+         typename A7 = impl::empty,
+         typename A8 = impl::empty>
 struct signal;
 
 template<>
-struct signal<>: public signal0<>
-{};
+struct signal<> : public signal0<> {};
 
 template<typename A1>
-struct signal<A1>: public signal1<A1>
-{};
+struct signal<A1> : public signal1<A1> {};
 
 template<typename A1, typename A2>
-struct signal<A1, A2>: public signal2<A1, A2>
-{};
+struct signal<A1, A2> : public signal2<A1, A2> {};
 
 template<typename A1, typename A2, typename A3>
-struct signal<A1, A2, A3>: public signal3<A1, A2, A3>
-{};
+struct signal<A1, A2, A3> : public signal3<A1, A2, A3> {};
 
 template<typename A1, typename A2, typename A3, typename A4>
-struct signal<A1, A2, A3, A4>: public signal4<A1, A2, A3, A4>
-{};
+struct signal<A1, A2, A3, A4> : public signal4<A1, A2, A3, A4> {};
 
 template<typename A1, typename A2, typename A3, typename A4, typename A5>
-struct signal<A1, A2, A3, A4, A5>: public signal5<A1, A2, A3, A4, A5>
-{};
+struct signal<A1, A2, A3, A4, A5> : public signal5<A1, A2, A3, A4, A5> {};
 
-template<typename A1, typename A2, typename A3, typename A4, typename A5,
-         typename A6>
-struct signal<A1, A2, A3, A4, A5, A6>: public signal6<A1, A2, A3, A4, A5, A6>
-{};
+template<typename A1, typename A2, typename A3, typename A4, typename A5, typename A6>
+struct signal<A1, A2, A3, A4, A5, A6> : public signal6<A1, A2, A3, A4, A5, A6> {};
 
-template<typename A1, typename A2, typename A3, typename A4, typename A5,
-         typename A6, typename A7>
-struct signal<A1, A2, A3, A4, A5, A6, A7>:
-    public signal7<A1, A2, A3, A4, A5, A6, A7>
-{};
+template<typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7>
+struct signal<A1, A2, A3, A4, A5, A6, A7> : public signal7<A1, A2, A3, A4, A5, A6, A7> {};
 
-template<typename A1, typename A2, typename A3, typename A4, typename A5,
-         typename A6, typename A7, typename A8>
-struct signal: public signal8<A1, A2, A3, A4, A5, A6, A7, A8>
-{};
+template<typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8>
+struct signal : public signal8<A1, A2, A3, A4, A5, A6, A7, A8> {};
 
 // Some convenience methods for signal handling.
 template<typename Derived>
-struct has_signals
-{
-        virtual ~has_signals() {}
+struct has_signals {
+    virtual ~has_signals() {}
 
-        // Connect a signal to a slot on the specified destination object.
-        template<typename Signal, typename Dst, typename Sig>
-        static inline void connect(Signal &signal, Dst *dst, Sig memfun)
-        {
-                signal.connect(dst, memfun);
-        }
+    // Connect a signal to a slot on the specified destination object.
+    template<typename Signal, typename Dst, typename Sig>
+    static inline void connect(Signal &signal, Dst *dst, Sig memfun)
+    {
+        signal.connect(dst, memfun);
+    }
 
-        // Connect a signal to a slot on 'this'.
-        template<typename Signal, typename Sig>
-        inline void connect(Signal &signal, Sig memfun)
-        {
-                Derived* dst = static_cast<Derived*>(this);
-                connect(signal, dst, memfun);
-        }
+    // Connect a signal to a slot on 'this'.
+    template<typename Signal, typename Sig>
+    inline void connect(Signal &signal, Sig memfun)
+    {
+        Derived *dst = static_cast<Derived *>(this);
+        connect(signal, dst, memfun);
+    }
 };
 
-}; // namespace sigslot
+};// namespace sigslot
 
-#endif // __SIGSLOT_H__
\ No newline at end of file
+#endif// __SIGSLOT_H__
\ No newline at end of file
diff --git a/tile/testing/bm_main.h b/tile/testing/bm_main.h
index 7b739fa..7acb2a5 100644
--- a/tile/testing/bm_main.h
+++ b/tile/testing/bm_main.h
@@ -8,11 +8,9 @@ namespace tile {
 namespace testing {
 int InitAndRunAllBenchmarks(int *argc, char **argv);
 
-#define TILE_BENCHMARK_MAIN                                                    \
-  int main(int argc, char **argv) {                                            \
-    return ::tile::testing::InitAndRunAllBenchmarks(&argc, argv);              \
-  }
-} // namespace testing
-} // namespace tile
+#define TILE_BENCHMARK_MAIN                                                                                            \
+    int main(int argc, char **argv) { return ::tile::testing::InitAndRunAllBenchmarks(&argc, argv); }
+}// namespace testing
+}// namespace tile
 
-#endif // TILE_TESTING_BM_MAIN_H
+#endif// TILE_TESTING_BM_MAIN_H
diff --git a/tile/testing/internal/random_string.cc b/tile/testing/internal/random_string.cc
index cd3d1df..70963a9 100644
--- a/tile/testing/internal/random_string.cc
+++ b/tile/testing/internal/random_string.cc
@@ -1,9 +1,11 @@
 #include "tile/testing/internal/random_string.h"
+
 namespace tile {
-namespace testing {} // namespace testing
-                     //
+namespace testing {}// namespace testing
+                    //
+
 constexpr PoolType PoolTraits<testing::CachedString>::kType;
 constexpr std::size_t PoolTraits<testing::CachedString>::kLowWaterMark;
 constexpr std::size_t PoolTraits<testing::CachedString>::kHighWaterMark;
 constexpr std::chrono::seconds PoolTraits<testing::CachedString>::kMaxIdle;
-} // namespace tile
+}// namespace tile
diff --git a/tile/testing/internal/random_string.h b/tile/testing/internal/random_string.h
index 7a06924..cb19ec0 100644
--- a/tile/testing/internal/random_string.h
+++ b/tile/testing/internal/random_string.h
@@ -6,57 +6,58 @@ namespace tile {
 
 namespace testing {
 struct CachedString {
-  std::string str;
+    std::string str;
 };
-} // namespace testing
+}// namespace testing
 
-template <> struct PoolTraits<testing::CachedString> {
-  static constexpr auto kType = PoolType::ThreadLocal;
+template<>
+struct PoolTraits<testing::CachedString> {
+    static constexpr auto kType                 = PoolType::ThreadLocal;
 
-  static constexpr std::size_t kLowWaterMark = 10;
-  static constexpr std::size_t kHighWaterMark = 10000;
-  static constexpr auto kMaxIdle = std::chrono::seconds(10);
+    static constexpr std::size_t kLowWaterMark  = 10;
+    static constexpr std::size_t kHighWaterMark = 10000;
+    static constexpr auto kMaxIdle              = std::chrono::seconds(10);
 };
 
 namespace testing {
 
-template <int min_val = 0, int max_val = 255>
-inline void RandomString(std::string *str, std::size_t min_len = 10000,
-                         std::size_t max_len = 100000) {
-  TILE_CHECK_LE(min_len, max_len);
+template<int min_val = 0, int max_val = 255>
+inline void
+RandomString(std::string *str, std::size_t min_len = 10000, std::size_t max_len = 100000)
+{
+    TILE_CHECK_LE(min_len, max_len);
 
-  str->resize(Random(min_len, max_len));
-  for (auto &&e : *str) {
-    e = Random(0, 255);
-  }
+    str->resize(Random(min_len, max_len));
+    for (auto &&e : *str) { e = Random(0, 255); }
 }
 
-inline std::string RandomString(std::size_t min_len = 10000,
-                                std::size_t max_len = 100000) {
-  TILE_CHECK_LE(min_len, max_len);
-  TILE_CHECK_GT(min_len, 0);
-  std::string result(Random(min_len, max_len), 0);
-  RandomString(&result);
-  return result;
-}
-
-inline PooledPtr<CachedString> GetCachedString(std::size_t len = -1) {
-  auto ptr = object_pool::Get<CachedString>();
-  if (len != static_cast<std::size_t>(-1)) {
-    ptr->str.resize(len);
-  }
-  return ptr;
+inline std::string
+RandomString(std::size_t min_len = 10000, std::size_t max_len = 100000)
+{
+    TILE_CHECK_LE(min_len, max_len);
+    TILE_CHECK_GT(min_len, 0);
+    std::string result(Random(min_len, max_len), 0);
+    RandomString(&result);
+    return result;
 }
 
 inline PooledPtr<CachedString>
-GetCachedRandomString(std::size_t min_len = 100000,
-                      std::size_t max_len = 100000) {
-  auto ptr = object_pool::Get<CachedString>();
-  const auto len = ptr->str.size();
-  ptr->str.resize(Random(min_len, max_len));
-  RandomString(&ptr->str);
-  return ptr;
+GetCachedString(std::size_t len = -1)
+{
+    auto ptr = object_pool::Get<CachedString>();
+    if (len != static_cast<std::size_t>(-1)) { ptr->str.resize(len); }
+    return ptr;
 }
 
-} // namespace testing
-} // namespace tile
+inline PooledPtr<CachedString>
+GetCachedRandomString(std::size_t min_len = 100000, std::size_t max_len = 100000)
+{
+    auto ptr       = object_pool::Get<CachedString>();
+    const auto len = ptr->str.size();
+    ptr->str.resize(Random(min_len, max_len));
+    RandomString(&ptr->str);
+    return ptr;
+}
+
+}// namespace testing
+}// namespace tile
diff --git a/tile/testing/main.cc b/tile/testing/main.cc
index 69ffa25..1632746 100644
--- a/tile/testing/main.cc
+++ b/tile/testing/main.cc
@@ -8,17 +8,19 @@
 namespace tile {
 namespace testing {
 
-int InitAndRunAllTests(int *argc, char **argv) {
-  ::testing::InitGoogleTest(argc, argv);
+int
+InitAndRunAllTests(int *argc, char **argv)
+{
+    ::testing::InitGoogleTest(argc, argv);
 
-  // if (gflags::GetCommandLineFlagInfoOrDie("logtostderr").is_default) {
-  //   FLAGS_logtostderr = true;
-  // }
+    // if (gflags::GetCommandLineFlagInfoOrDie("logtostderr").is_default) {
+    //   FLAGS_logtostderr = true;
+    // }
 
-  return Start(*argc, argv, [](int, char **) { return ::RUN_ALL_TESTS(); });
+    return Start(*argc, argv, [](int, char **) { return ::RUN_ALL_TESTS(); });
 }
 
-} // namespace testing
-} // namespace tile
+}// namespace testing
+}// namespace tile
 
 TILE_TEST_MAIN
diff --git a/tile/testing/main.h b/tile/testing/main.h
index 5e2dd93..bf2b52d 100644
--- a/tile/testing/main.h
+++ b/tile/testing/main.h
@@ -9,11 +9,9 @@ namespace tile {
 namespace testing {
 int InitAndRunAllTests(int *argc, char **argv);
 
-#define TILE_TEST_MAIN                                                         \
-  int main(int argc, char **argv) {                                            \
-    return ::tile::testing::InitAndRunAllTests(&argc, argv);                   \
-  }
-} // namespace testing
-} // namespace tile
+#define TILE_TEST_MAIN                                                                                                 \
+    int main(int argc, char **argv) { return ::tile::testing::InitAndRunAllTests(&argc, argv); }
+}// namespace testing
+}// namespace tile
 
-#endif // TILE_TESTING_MAIN_H
+#endif// TILE_TESTING_MAIN_H
diff --git a/tile/tile.h b/tile/tile.h
index 3d89de1..7d72a4c 100644
--- a/tile/tile.h
+++ b/tile/tile.h
@@ -49,4 +49,4 @@
 // Tile Init
 #include "tile/init.h"
 
-#endif // TILE_TILE_H
+#endif// TILE_TILE_H

From 30576240a24061fa59e87d0ac5dee9f911250cee Mon Sep 17 00:00:00 2001
From: tqcq <99722391+tqcq@users.noreply.github.com>
Date: Fri, 23 Aug 2024 21:42:20 +0800
Subject: [PATCH 10/25] fix install cmake for android

---
 .gitea/workflows/android.yml | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/.gitea/workflows/android.yml b/.gitea/workflows/android.yml
index 4ba1529..b6c4e6e 100644
--- a/.gitea/workflows/android.yml
+++ b/.gitea/workflows/android.yml
@@ -36,6 +36,10 @@ jobs:
     - uses: actions/checkout@v4
       with: 
         submodules: true
+    - name: install-tools
+      run: |
+        apt-get update -y
+        apt-get install -y cmake make
 
     - name: armeabi-v7a
       run: |

From fa04f9c23a2407309888f09e8c494290a30b1b87 Mon Sep 17 00:00:00 2001
From: tqcq <99722391+tqcq@users.noreply.github.com>
Date: Mon, 2 Sep 2024 13:44:40 +0800
Subject: [PATCH 11/25] feat merge master

---
 tile/base/expected.h                    |   4 +-
 tile/base/exposed_var.h                 |   3 +-
 tile/base/internal/logging.cc           | 624 +++++++++++++-----------
 tile/base/internal/logging.h            | 233 +++++----
 tile/base/internal/logging_glog.cc      | 290 ++++++-----
 tile/base/internal/logging_test.cc      |  84 ++--
 tile/base/logging/basic_file_sink.cc    |  55 ++-
 tile/base/logging/basic_file_sink.h     |  33 +-
 tile/base/logging/console_sink.cc       |  43 +-
 tile/base/logging/console_sink.h        |  26 +-
 tile/base/logging/splitter_sink.cc      | 102 ++--
 tile/base/logging/splitter_sink.h       |  41 +-
 tile/base/logging/splitter_sink_test.cc |  82 ++--
 tile/init.cc                            |  33 +-
 tile/testing/bm_main.cc                 |  34 +-
 15 files changed, 958 insertions(+), 729 deletions(-)

diff --git a/tile/base/expected.h b/tile/base/expected.h
index eae217c..1c24faa 100644
--- a/tile/base/expected.h
+++ b/tile/base/expected.h
@@ -2128,8 +2128,8 @@ nsel_DISABLE_MSVC_WARNINGS(26409)
                 : make_unexpected(detail::invoke(std::forward<F>(f), std::move(error())));
         }
 #endif
-#endif// nsel_P2505R >= 3
-        // unwrap()
+#endif// nsel_P2505R >= 3                                                                                              \
+      // unwrap()
 
         //  template <class U, class E>
         //  constexpr expected<U,E> expected<expected<U,E>,E>::unwrap() const&;
diff --git a/tile/base/exposed_var.h b/tile/base/exposed_var.h
index 19917bc..4621b4f 100644
--- a/tile/base/exposed_var.h
+++ b/tile/base/exposed_var.h
@@ -174,9 +174,8 @@ private:
             {"1s", 1}
         };
         for (auto &&item : m) {}
+        return result;
     }
-    return result;
-  }
 
     void LinkToParent(Slice rel_path, ExposedVarGroup *parent)
     {
diff --git a/tile/base/internal/logging.cc b/tile/base/internal/logging.cc
index ce7c21b..da17c4c 100644
--- a/tile/base/internal/logging.cc
+++ b/tile/base/internal/logging.cc
@@ -16,7 +16,7 @@ GetProviers()
     static std::vector<PrefixAppender *> providers;
     return &providers;
 }
-} // namespace
+}// namespace
 
 namespace details {
 std::string
@@ -24,10 +24,12 @@ DescribeFormatArguments(const std::vector<std::string> &args)
 {
     return fmt::format("{}", fmt::join(args.begin(), args.end(), ", "));
 }
-} // namespace details
+}// namespace details
 
-void InstallPrefixProvider(PrefixAppender *writer) {
-  GetProviers()->push_back(writer);
+void
+InstallPrefixProvider(PrefixAppender *writer)
+{
+    GetProviers()->push_back(writer);
 }
 
 void
@@ -39,9 +41,9 @@ WritePrefixTo(std::string *to)
         if (to->size() != was) { to->push_back(' '); }
     }
 }
-} // namespace logging
-} // namespace internal
-} // namespace tile
+}// namespace logging
+}// namespace internal
+}// namespace tile
 
 namespace tile {
 static std::mutex g_sink_mutex;
@@ -53,226 +55,273 @@ std::mutex g_log_mutex;
 
 class OStreamWrapper : public std::streambuf {
 public:
-  OStreamWrapper(std::ostream &ostream) : ostream_(ostream) {}
+    OStreamWrapper(std::ostream &ostream) : ostream_(ostream) {}
 
-  int_type overflow(int_type c) override { return c; }
+    int_type overflow(int_type c) override { return c; }
 
 private:
-  std::ostream &ostream_;
+    std::ostream &ostream_;
 };
 
-bool VLogIsOn(int n) { return true; }
+bool
+VLogIsOn(int n)
+{
+    return true;
+}
 
 class LogMessage::Impl {
 public:
-  Impl(const char *file, int line)
-      : stream_(message_text_, LogMessage::kMaxLogMessageLen, 0) {
-    Init(file, line, TILE_INFO, &LogMessage::Impl::SendToLog);
-  }
-  Impl(const char *file, int line, LogSeverity severity)
-      : stream_(message_text_, LogMessage::kMaxLogMessageLen, 0) {
-    Init(file, line, severity, &LogMessage::Impl::SendToLog);
-  }
-  Impl(const char *file, int line, LogSeverity severity, LogSink *sink,
-       bool also_send_to_log)
-      : stream_(message_text_, LogMessage::kMaxLogMessageLen, 0) {
-    Init(file, line, severity,
-         also_send_to_log ? &LogMessage::Impl::SendToSinkAndLog
-                          : &LogMessage::Impl::SendToSink);
-    sink_ = sink;
-  }
-  ~Impl() { Flush(); }
-  std::ostream &stream() { return stream_; }
-  void Flush() {
-    if (has_been_flushed_) {
-      return;
-    }
-
-    num_chars_to_log_ = stream_.pcount();
-    const bool append_newline = message_text_[num_chars_to_log_ - 1] != '\n';
-    char original_final_char = '\0';
-
-    if (append_newline) {
-      original_final_char = message_text_[num_chars_to_log_];
-      message_text_[num_chars_to_log_++] = '\n';
-    }
-    message_text_[num_chars_to_log_] = '\0';
-
+    Impl(const char *file, int line) : stream_(message_text_, LogMessage::kMaxLogMessageLen, 0)
     {
-      std::lock_guard<std::mutex> _{g_log_mutex};
-      (this->*(send_method_))();
-      ++g_num_messages[severity_];
-      WaitForSinks();
-      if (sink_) {
-        sink_->Flush();
-      }
+        Init(file, line, TILE_INFO, &LogMessage::Impl::SendToLog);
     }
 
-    if (append_newline) {
-      message_text_[num_chars_to_log_ - 1] = original_final_char;
+    Impl(const char *file, int line, LogSeverity severity) : stream_(message_text_, LogMessage::kMaxLogMessageLen, 0)
+    {
+        Init(file, line, severity, &LogMessage::Impl::SendToLog);
     }
 
-    if (preserved_errno_ != 0) {
-      errno = preserved_errno_;
+    Impl(const char *file, int line, LogSeverity severity, LogSink *sink, bool also_send_to_log)
+        : stream_(message_text_, LogMessage::kMaxLogMessageLen, 0)
+    {
+        Init(file, line, severity,
+             also_send_to_log ? &LogMessage::Impl::SendToSinkAndLog : &LogMessage::Impl::SendToSink);
+        sink_ = sink;
     }
-    has_been_flushed_ = true;
 
-    if (severity_ == TILE_FATAL) {
-      assert(false);
+    ~Impl() { Flush(); }
+
+    std::ostream &stream() { return stream_; }
+
+    void Flush()
+    {
+        if (has_been_flushed_) { return; }
+
+        num_chars_to_log_         = stream_.pcount();
+        const bool append_newline = message_text_[num_chars_to_log_ - 1] != '\n';
+        char original_final_char  = '\0';
+
+        if (append_newline) {
+            original_final_char                = message_text_[num_chars_to_log_];
+            message_text_[num_chars_to_log_++] = '\n';
+        }
+        message_text_[num_chars_to_log_] = '\0';
+
+        {
+            std::lock_guard<std::mutex> _{g_log_mutex};
+            (this->*(send_method_))();
+            ++g_num_messages[severity_];
+            WaitForSinks();
+            if (sink_) { sink_->Flush(); }
+        }
+
+        if (append_newline) { message_text_[num_chars_to_log_ - 1] = original_final_char; }
+
+        if (preserved_errno_ != 0) { errno = preserved_errno_; }
+        has_been_flushed_ = true;
+
+        if (severity_ == TILE_FATAL) { assert(false); }
     }
-  }
 
-  LogSeverity severity() const noexcept { return severity_; }
-  int line() const noexcept { return line_; }
-  const char *fullname() const noexcept { return file_; }
-  const char *basename() const noexcept { return file_; }
-  const LogMessageTime &time() const noexcept { return time_; }
-  int preserved_errno() const { return preserved_errno_; }
+    LogSeverity severity() const noexcept { return severity_; }
+
+    int line() const noexcept { return line_; }
+
+    const char *fullname() const noexcept { return file_; }
+
+    const char *basename() const noexcept { return file_; }
+
+    const LogMessageTime &time() const noexcept { return time_; }
+
+    int preserved_errno() const { return preserved_errno_; }
 
 private:
-  void Init(const char *file, int line, LogSeverity severity,
-            void (LogMessage::Impl::*send_method)()) {
-    has_been_flushed_ = false;
-    file_ = file;
-    line_ = line;
-    severity_ = severity;
-    send_method_ = send_method;
-    sink_ = nullptr;
-    const auto now = std::chrono::system_clock::now();
-    time_ = LogMessageTime(now);
-    thread_id_ = std::this_thread::get_id();
-    preserved_errno_ = errno;
-  }
+    void Init(const char *file, int line, LogSeverity severity, void (LogMessage::Impl::*send_method)())
+    {
+        has_been_flushed_ = false;
+        file_             = file;
+        line_             = line;
+        severity_         = severity;
+        send_method_      = send_method;
+        sink_             = nullptr;
+        const auto now    = std::chrono::system_clock::now();
+        time_             = LogMessageTime(now);
+        thread_id_        = std::this_thread::get_id();
+        preserved_errno_  = errno;
+    }
 
-  void SendToSink() {
-    if (sink_) {
-      sink_->Send(severity_, fullname(), basename(), line(), time(),
-                  message_text_ + num_prefix_chars_,
-                  num_chars_to_log_ - num_prefix_chars_);
+    void SendToSink()
+    {
+        if (sink_) {
+            sink_->Send(severity_, fullname(), basename(), line(), time(), message_text_ + num_prefix_chars_,
+                        num_chars_to_log_ - num_prefix_chars_ - 1);
+        }
     }
-  }
-  void SendToLog() {
-    if (g_sink_count.load(std::memory_order_relaxed) == 0) {
-      ColoredWriteToStdout(severity_, message_text_ + num_prefix_chars_,
-                           num_chars_to_log_ - num_chars_to_log_);
+
+    void SendToLog()
+    {
+        if (g_sink_count.load(std::memory_order_relaxed) == 0) {
+            ColoredWriteToStdout(severity_, message_text_ + num_prefix_chars_, num_chars_to_log_ - num_chars_to_log_);
+        }
+        LogToSinks(severity_, fullname(), basename(), line(), time(), message_text_ + num_prefix_chars_,
+                   num_chars_to_log_ - num_prefix_chars_ - 1);
+    }
+
+    void SendToSinkAndLog()
+    {
+        SendToSink();
+        SendToLog();
     }
-    LogToSinks(severity_, fullname(), basename(), line(), time(),
-               message_text_ + num_prefix_chars_,
-               num_chars_to_log_ - num_prefix_chars_);
-  }
-  void SendToSinkAndLog() {
-    SendToSink();
-    SendToLog();
-  }
 
 private:
-  char message_text_[LogMessage::kMaxLogMessageLen + 1];
-  LogMessage::LogStream stream_;
+    char message_text_[LogMessage::kMaxLogMessageLen + 1];
+    LogMessage::LogStream stream_;
 
-  bool has_been_flushed_;
+    bool has_been_flushed_;
 
-  const char *file_;
-  int line_;
-  LogSeverity severity_;
-  void (LogMessage::Impl::*send_method_)();
+    const char *file_;
+    int line_;
+    LogSeverity severity_;
+    void (LogMessage::Impl::*send_method_)();
 
-  LogSink *sink_;
-  LogMessageTime time_;
-  std::thread::id thread_id_;
-  int preserved_errno_;
+    LogSink *sink_;
+    LogMessageTime time_;
+    std::thread::id thread_id_;
+    int preserved_errno_;
 
-  size_t num_prefix_chars_;
-  size_t num_chars_to_log_;
+    size_t num_prefix_chars_;
+    size_t num_chars_to_log_;
 };
 
-LogMessage::LogMessage(const char *file, int line)
-    : impl_(new Impl(file, line)) {}
-LogMessage::LogMessage(const char *file, int line, LogSeverity severity)
-    : impl_(new Impl(file, line, severity)) {}
-LogMessage::LogMessage(const char *file, int line, LogSeverity severity,
-                       LogSink *sink, bool also_send_to_log)
-    : impl_(new Impl(file, line, severity, sink, also_send_to_log)) {}
+LogMessage::LogMessage(const char *file, int line) : impl_(new Impl(file, line)) {}
+
+LogMessage::LogMessage(const char *file, int line, LogSeverity severity) : impl_(new Impl(file, line, severity)) {}
+
+LogMessage::LogMessage(const char *file, int line, LogSeverity severity, LogSink *sink, bool also_send_to_log)
+    : impl_(new Impl(file, line, severity, sink, also_send_to_log))
+{}
 
 LogMessage::~LogMessage() {}
 
-std::ostream &LogMessage::stream() { return impl_->stream(); }
-void LogMessage::Flush() { impl_->Flush(); }
-
-LogSeverity LogMessage::severity() const noexcept { return impl_->severity(); }
-int LogMessage::line() const noexcept { return impl_->line(); }
-const char *LogMessage::fullname() const noexcept { return impl_->fullname(); }
-const char *LogMessage::basename() const noexcept { return impl_->basename(); }
-const LogMessageTime &LogMessage::time() const noexcept {
-  return impl_->time();
+std::ostream &
+LogMessage::stream()
+{
+    return impl_->stream();
 }
-int LogMessage::preserved_errno() const { return impl_->preserved_errno(); }
 
-LogMessageFatal::LogMessageFatal(const char *file, int line)
-    : LogMessage(file, line, TILE_FATAL) {}
+void
+LogMessage::Flush()
+{
+    impl_->Flush();
+}
+
+LogSeverity
+LogMessage::severity() const noexcept
+{
+    return impl_->severity();
+}
+
+int
+LogMessage::line() const noexcept
+{
+    return impl_->line();
+}
+
+const char *
+LogMessage::fullname() const noexcept
+{
+    return impl_->fullname();
+}
+
+const char *
+LogMessage::basename() const noexcept
+{
+    return impl_->basename();
+}
+
+const LogMessageTime &
+LogMessage::time() const noexcept
+{
+    return impl_->time();
+}
+
+int
+LogMessage::preserved_errno() const
+{
+    return impl_->preserved_errno();
+}
+
+LogMessageFatal::LogMessageFatal(const char *file, int line) : LogMessage(file, line, TILE_FATAL) {}
 
 LogMessageFatal::~LogMessageFatal() {}
 
-std::ostream &LogMessageFatal::stream() { return LogMessage::stream(); }
+std::ostream &
+LogMessageFatal::stream()
+{
+    return LogMessage::stream();
+}
 
 LogMessageTime::LogMessageTime() : time_struct_(), timestamp_(0), usecs_(0), gmtoffset_(0) {}
 
-LogMessageTime::LogMessageTime(std::tm t) : use_localtime_(true) {
-  std::time_t timestamp = std::mktime(&t);
-  init(t, timestamp, 0);
+LogMessageTime::LogMessageTime(std::tm t) : use_localtime_(true)
+{
+    std::time_t timestamp = std::mktime(&t);
+    init(t, timestamp, 0);
 }
 
-LogMessageTime::LogMessageTime(std::time_t timestamp, WallTime now)
-    : use_localtime_(false) {
-  std::tm t;
-  if (use_localtime_) {
-    localtime_r(&timestamp, &t);
-  } else {
-    gmtime_r(&timestamp, &t);
-  }
+LogMessageTime::LogMessageTime(std::time_t timestamp, WallTime now) : use_localtime_(false)
+{
+    std::tm t;
+    if (use_localtime_) {
+        localtime_r(&timestamp, &t);
+    } else {
+        gmtime_r(&timestamp, &t);
+    }
 
-  init(t, timestamp, now);
-}
-LogMessageTime::LogMessageTime(std::chrono::system_clock::time_point tp)
-    : use_localtime_(false) {
-  std::time_t timestamp = std::chrono::system_clock::to_time_t(tp);
-  std::tm t;
-  if (use_localtime_) {
-    localtime_r(&timestamp, &t);
-  } else {
-    gmtime_r(&timestamp, &t);
-  }
-
-  init(t, timestamp, 0);
-  usecs_ = std::chrono::duration_cast<std::chrono::microseconds>(
-               tp.time_since_epoch())
-               .count() %
-           1000000;
+    init(t, timestamp, now);
 }
 
-void LogMessageTime::init(const std::tm &t, std::time_t timestamp,
-                          WallTime now) {
-  time_struct_ = t;
-  timestamp_ = timestamp;
-  if (now < timestamp) {
-    usecs_ = 0;
-  } else {
-    usecs_ = static_cast<std::int32_t>((now - timestamp) * 1000000) % 1000000;
-  }
+LogMessageTime::LogMessageTime(std::chrono::system_clock::time_point tp) : use_localtime_(false)
+{
+    std::time_t timestamp = std::chrono::system_clock::to_time_t(tp);
+    std::tm t;
+    if (use_localtime_) {
+        localtime_r(&timestamp, &t);
+    } else {
+        gmtime_r(&timestamp, &t);
+    }
+
+    init(t, timestamp, 0);
+    usecs_ = std::chrono::duration_cast<std::chrono::microseconds>(tp.time_since_epoch()).count() % 1000000;
+}
+
+void
+LogMessageTime::init(const std::tm &t, std::time_t timestamp, WallTime now)
+{
+    time_struct_ = t;
+    timestamp_   = timestamp;
+    if (now < timestamp) {
+        usecs_ = 0;
+    } else {
+        usecs_ = static_cast<std::int32_t>((now - timestamp) * 1000000) % 1000000;
+    }
 
     CalcGmtOffset();
 }
 
-void LogMessageTime::CalcGmtOffset() {
-  std::tm gmt_struct;
-  int isDst = 0;
-  if (true) {
-    localtime_r(&timestamp_, &gmt_struct);
-    isDst = gmt_struct.tm_isdst;
-    gmt_struct = time_struct_;
-  } else {
-    isDst = time_struct_.tm_isdst;
-    gmtime_r(&timestamp_, &gmt_struct);
-  }
+void
+LogMessageTime::CalcGmtOffset()
+{
+    std::tm gmt_struct;
+    int isDst = 0;
+    if (true) {
+        localtime_r(&timestamp_, &gmt_struct);
+        isDst      = gmt_struct.tm_isdst;
+        gmt_struct = time_struct_;
+    } else {
+        isDst = time_struct_.tm_isdst;
+        gmtime_r(&timestamp_, &gmt_struct);
+    }
 
     time_t gmt_sec       = mktime(&gmt_struct);
     const long hour_secs = 3600;
@@ -282,14 +331,15 @@ void LogMessageTime::CalcGmtOffset() {
 }
 
 LogSink::~LogSink() {}
-bool LogSink::ShouldLog(LogSeverity severity) { return true; }
-void LogSink::Send(LogSeverity severity, const char *full_filename,
-                   const char *base_filename, int line,
-                   const LogMessageTime &logmsgtime, const char *message,
-                   size_t message_len) {
+
+bool
+LogSink::ShouldLog(LogSeverity severity)
+{
+    return true;
+}
 
 void
-LogSink::send(LogSeverity severity,
+LogSink::Send(LogSeverity severity,
               const char *full_filename,
               const char *base_filename,
               int line,
@@ -300,104 +350,130 @@ LogSink::send(LogSeverity severity,
 
     // do nothing
 }
-void LogSink::Flush() {}
 
-std::string LogSink::ToString(LogSeverity severity, const char *file,
-                              const char *base_filename, int line,
-                              const LogMessageTime &logmsgtime,
-                              const char *message, size_t message_len) {
-  std::stringstream ss;
-  char date_time[64];
-  sprintf(date_time, "%4d-%02d-%02dT%02d:%02d:%02d.%06d",
-          logmsgtime.year() + 1900, logmsgtime.month(), logmsgtime.day(),
-          logmsgtime.hour(), logmsgtime.min(), logmsgtime.sec(),
-          logmsgtime.usec());
+void
+LogSink::Flush()
+{}
 
-  ss << date_time;
+std::string
+LogSink::ToString(LogSeverity severity,
+                  const char *file,
+                  const char *base_filename,
+                  int line,
+                  const LogMessageTime &logmsgtime,
+                  const char *message,
+                  size_t message_len)
+{
+    std::stringstream ss;
+    char date_time[64];
+    sprintf(date_time, "%4d-%02d-%02dT%02d:%02d:%02d.%06d", logmsgtime.year() + 1900, logmsgtime.month(),
+            logmsgtime.day(), logmsgtime.hour(), logmsgtime.min(), logmsgtime.sec(), logmsgtime.usec());
 
-  if (logmsgtime.gmtoff() != 0) {
-    auto hour = logmsgtime.gmtoff() / 3600;
-    auto min = std::abs(logmsgtime.gmtoff() % 3600) / 60;
-    sprintf(date_time, "%+03ld:%02ld", hour, min);
     ss << date_time;
-  } else if (!logmsgtime.use_localtime()) {
-    ss << "Z";
-  }
-  ss << " " << GetLogSeverityName(severity)[0] << " ";
-  ss << base_filename << ":" << line << " ";
 
-  // return google::LogSink::ToString(severity, file, line, logmsgtime.tm(),
-  //                                  message, message_len);
-
-  ss.write(message, message_len);
-  return ss.str();
-}
-
-static void ColoredWriteToStderrOrStdout(FILE *output, LogSeverity severity,
-                                         const char *message, size_t len) {
-  fwrite(message, len, 1, output);
-  fflush(output);
-}
-
-void ColoredWriteToStdout(LogSeverity severity, const char *message,
-                          size_t len) {
-  FILE *output = stdout;
-  if (severity >= TILE_FATAL) {
-    output = stderr;
-  }
-  ColoredWriteToStderrOrStdout(output, severity, message, len);
-}
-void ColoredWriteToStderr(LogSeverity severity, const char *message,
-                          size_t len) {
-  ColoredWriteToStderrOrStdout(stderr, severity, message, len);
-}
-
-void AddLogSink(LogSink::Ptr dest) {
-  std::lock_guard<std::mutex> _(g_sink_mutex);
-  g_sinks.insert(dest);
-  g_sink_count.fetch_add(1);
-}
-
-void RemoveLogSink(LogSink::Ptr dest) {
-  std::lock_guard<std::mutex> _(g_sink_mutex);
-  g_sinks.erase(dest);
-  g_sink_count.fetch_sub(1);
-}
-
-void SetStderrLogging(LogSeverity min_severity) {}
-void LogToStderr() {}
-void LogToSinks(LogSeverity severity, const char *full_filename,
-                const char *base_filename, int line, const LogMessageTime &time,
-                const char *message, size_t message_len) {
-  std::lock_guard<std::mutex> _(g_sink_mutex);
-  for (auto &&sink : g_sinks) {
-    if (sink->ShouldLog(severity)) {
-      sink->Send(severity, full_filename, base_filename, line, time, message,
-                 message_len);
+    if (logmsgtime.gmtoff() != 0) {
+        auto hour = logmsgtime.gmtoff() / 3600;
+        auto min  = std::abs(logmsgtime.gmtoff() % 3600) / 60;
+        sprintf(date_time, "%+03ld:%02ld", hour, min);
+        ss << date_time;
+    } else if (!logmsgtime.use_localtime()) {
+        ss << "Z";
     }
-  }
-}
-void WaitForSinks() {
-  std::lock_guard<std::mutex> _(g_sink_mutex);
-  for (auto &&sink : g_sinks) {
-    sink->Flush();
-  }
+    ss << " " << GetLogSeverityName(severity)[0] << " ";
+    ss << base_filename << ":" << line << " ";
+
+    // return google::LogSink::ToString(severity, file, line, logmsgtime.tm(),
+    //                                  message, message_len);
+
+    ss.write(message, message_len);
+    return ss.str();
 }
 
-const char *GetLogSeverityName(LogSeverity severity) {
-  const static std::map<LogSeverity, const char *> severity_names = {
-      {TILE_INFO, "INFO"},
-      {TILE_WARNING, "WARNING"},
-      {TILE_ERROR, "ERROR"},
-      {TILE_FATAL, "FATAL"},
-  };
-
-  auto iter = severity_names.find(severity);
-  if (iter != severity_names.end()) {
-    return iter->second;
-  } else {
-    return "UNKNOWN";
-  }
+static void
+ColoredWriteToStderrOrStdout(FILE *output, LogSeverity severity, const char *message, size_t len)
+{
+    fwrite(message, len, 1, output);
+    fflush(output);
 }
 
-} // namespace tile
+void
+ColoredWriteToStdout(LogSeverity severity, const char *message, size_t len)
+{
+    FILE *output = stdout;
+    if (severity >= TILE_FATAL) { output = stderr; }
+    ColoredWriteToStderrOrStdout(output, severity, message, len);
+}
+
+void
+ColoredWriteToStderr(LogSeverity severity, const char *message, size_t len)
+{
+    ColoredWriteToStderrOrStdout(stderr, severity, message, len);
+}
+
+void
+AddLogSink(LogSink::Ptr dest)
+{
+    std::lock_guard<std::mutex> _(g_sink_mutex);
+    g_sinks.insert(dest);
+    g_sink_count.fetch_add(1);
+}
+
+void
+RemoveLogSink(LogSink::Ptr dest)
+{
+    std::lock_guard<std::mutex> _(g_sink_mutex);
+    g_sinks.erase(dest);
+    g_sink_count.fetch_sub(1);
+}
+
+void
+SetStderrLogging(LogSeverity min_severity)
+{}
+
+void
+LogToStderr()
+{}
+
+void
+LogToSinks(LogSeverity severity,
+           const char *full_filename,
+           const char *base_filename,
+           int line,
+           const LogMessageTime &time,
+           const char *message,
+           size_t message_len)
+{
+    std::lock_guard<std::mutex> _(g_sink_mutex);
+    for (auto &&sink : g_sinks) {
+        if (sink->ShouldLog(severity)) {
+            sink->Send(severity, full_filename, base_filename, line, time, message, message_len);
+        }
+    }
+}
+
+void
+WaitForSinks()
+{
+    std::lock_guard<std::mutex> _(g_sink_mutex);
+    for (auto &&sink : g_sinks) { sink->Flush(); }
+}
+
+const char *
+GetLogSeverityName(LogSeverity severity)
+{
+    const static std::map<LogSeverity, const char *> severity_names = {
+        {TILE_INFO,    "INFO"   },
+        {TILE_WARNING, "WARNING"},
+        {TILE_ERROR,   "ERROR"  },
+        {TILE_FATAL,   "FATAL"  },
+    };
+
+    auto iter = severity_names.find(severity);
+    if (iter != severity_names.end()) {
+        return iter->second;
+    } else {
+        return "UNKNOWN";
+    }
+}
+
+}// namespace tile
diff --git a/tile/base/internal/logging.h b/tile/base/internal/logging.h
index 95a8e0c..5bcc717 100644
--- a/tile/base/internal/logging.h
+++ b/tile/base/internal/logging.h
@@ -21,84 +21,93 @@ namespace tile {
 // typedef int LogSeverity;
 // const int TILE_INFO = 0, TILE_WARNING = 1, TILE_ERROR = 2, TILE_FATAL = 3;
 enum LogSeverity {
-  TILE_INFO = 0,
-  TILE_WARNING = 1,
-  TILE_ERROR = 2,
-  TILE_FATAL = 3,
-  TILE_MAX_LOG_SEVERITY = TILE_FATAL
+    TILE_INFO             = 0,
+    TILE_WARNING          = 1,
+    TILE_ERROR            = 2,
+    TILE_FATAL            = 3,
+    TILE_MAX_LOG_SEVERITY = TILE_FATAL
 };
 
 bool VLogIsOn(int n);
 
 class LogStreamBuf : public std::streambuf {
 public:
-  LogStreamBuf(char *buf, int len) { setp(buf, buf + len - 2); }
+    LogStreamBuf(char *buf, int len) { setp(buf, buf + len - 2); }
 
-  int_type overflow(int_type ch) { return ch; }
-  size_t pcount() const { return static_cast<size_t>(pptr() - pbase()); }
-  char *pbase() const { return std::streambuf::pbase(); }
+    int_type overflow(int_type ch) { return ch; }
+
+    size_t pcount() const { return static_cast<size_t>(pptr() - pbase()); }
+
+    char *pbase() const { return std::streambuf::pbase(); }
 };
 
 class LogSink;
 class LogMessageTime;
+
 class LogMessage {
 public:
-  class LogStream : public std::ostream {
-  public:
-    LogStream(char *buf, int len, int64_t ctr)
-        : std::ostream(nullptr), streambuf_(buf, len), ctr_(ctr), self_(this) {
-      rdbuf(&streambuf_);
-    }
+    class LogStream : public std::ostream {
+    public:
+        LogStream(char *buf, int len, int64_t ctr) : std::ostream(nullptr), streambuf_(buf, len), ctr_(ctr), self_(this)
+        {
+            rdbuf(&streambuf_);
+        }
 
-    LogStream(LogStream &other) noexcept
-        : std::ostream(nullptr), streambuf_(std::move(other.streambuf_)),
-          ctr_(internal::Exchange(other.ctr_, 0)), self_(this) {
-      rdbuf(&streambuf_);
-    }
+        LogStream(LogStream &other) noexcept
+            : std::ostream(nullptr),
+              streambuf_(std::move(other.streambuf_)),
+              ctr_(internal::Exchange(other.ctr_, 0)),
+              self_(this)
+        {
+            rdbuf(&streambuf_);
+        }
 
-    LogStream &operator=(LogStream &&other) noexcept {
-      streambuf_ = std::move(other.streambuf_);
-      ctr_ = internal::Exchange(other.ctr_, 0);
-      self_ = this;
-      rdbuf(&streambuf_);
-      return *this;
-    }
+        LogStream &operator=(LogStream &&other) noexcept
+        {
+            streambuf_ = std::move(other.streambuf_);
+            ctr_       = internal::Exchange(other.ctr_, 0);
+            self_      = this;
+            rdbuf(&streambuf_);
+            return *this;
+        }
 
-    int64_t ctr() const { return ctr_; }
-    void set_ctr(int64_t ctr) { ctr_ = ctr; }
+        int64_t ctr() const { return ctr_; }
 
-    LogStream *self() { return self_; }
+        void set_ctr(int64_t ctr) { ctr_ = ctr; }
 
-    size_t pcount() const { return streambuf_.pcount(); }
-    char *pbase() const { return streambuf_.pbase(); }
-    char *str() const { return pbase(); }
+        LogStream *self() { return self_; }
 
-    LogStream(const LogStream &) = delete;
-    LogStream &operator=(const LogStream &) = delete;
+        size_t pcount() const { return streambuf_.pcount(); }
 
-  private:
-    LogStreamBuf streambuf_;
-    int64_t ctr_;
-    LogStream *self_;
-  };
+        char *pbase() const { return streambuf_.pbase(); }
+
+        char *str() const { return pbase(); }
+
+        LogStream(const LogStream &)            = delete;
+        LogStream &operator=(const LogStream &) = delete;
+
+    private:
+        LogStreamBuf streambuf_;
+        int64_t ctr_;
+        LogStream *self_;
+    };
 
 public:
-  static const size_t kMaxLogMessageLen = 30000;
-  LogMessage(const char *file, int line);
-  LogMessage(const char *file, int line, LogSeverity severity);
-  LogMessage(const char *file, int line, LogSeverity severity, LogSink *sink,
-             bool also_send_to_log = true);
+    static const size_t kMaxLogMessageLen = 30000;
+    LogMessage(const char *file, int line);
+    LogMessage(const char *file, int line, LogSeverity severity);
+    LogMessage(const char *file, int line, LogSeverity severity, LogSink *sink, bool also_send_to_log = true);
 
-  ~LogMessage();
-  std::ostream &stream();
-  void Flush();
+    ~LogMessage();
+    std::ostream &stream();
+    void Flush();
 
-  LogSeverity severity() const noexcept;
-  int line() const noexcept;
-  const char *fullname() const noexcept;
-  const char *basename() const noexcept;
-  const LogMessageTime &time() const noexcept;
-  int preserved_errno() const;
+    LogSeverity severity() const noexcept;
+    int line() const noexcept;
+    const char *fullname() const noexcept;
+    const char *basename() const noexcept;
+    const LogMessageTime &time() const noexcept;
+    int preserved_errno() const;
 
 private:
     class Impl;
@@ -107,9 +116,9 @@ private:
 
 class LogMessageFatal : public LogMessage {
 public:
-  LogMessageFatal(const char *file, int line);
-  ~LogMessageFatal();
-  std::ostream &stream();
+    LogMessageFatal(const char *file, int line);
+    ~LogMessageFatal();
+    std::ostream &stream();
 };
 
 class LogMessageVoidify {
@@ -550,66 +559,88 @@ FormatLog(const char *file, int line, Ts &&...args) noexcept
 
 namespace tile {
 typedef double WallTime;
-struct LogMessageTime {
-  LogMessageTime();
-  LogMessageTime(std::tm t);
-  LogMessageTime(std::time_t timestamp, WallTime now);
-  LogMessageTime(std::chrono::system_clock::time_point tp);
 
-  const time_t &timestamp() const { return timestamp_; }
-  const int &sec() const { return time_struct_.tm_sec; }
-  const int32_t &usec() const { return usecs_; }
-  const int &(min)() const { return time_struct_.tm_min; }
-  const int &hour() const { return time_struct_.tm_hour; }
-  const int &day() const { return time_struct_.tm_mday; }
-  const int &month() const { return time_struct_.tm_mon; }
-  const int &year() const { return time_struct_.tm_year; }
-  const int &dayOfWeek() const { return time_struct_.tm_wday; }
-  const int &dayInYear() const { return time_struct_.tm_yday; }
-  const int &dst() const { return time_struct_.tm_isdst; }
-  const long int &gmtoff() const { return gmtoffset_; }
-  const std::tm &tm() const { return time_struct_; }
-  const bool use_localtime() const { return use_localtime_; }
+struct LogMessageTime {
+    LogMessageTime();
+    LogMessageTime(std::tm t);
+    LogMessageTime(std::time_t timestamp, WallTime now);
+    LogMessageTime(std::chrono::system_clock::time_point tp);
+
+    const time_t &timestamp() const { return timestamp_; }
+
+    const int &sec() const { return time_struct_.tm_sec; }
+
+    const int32_t &usec() const { return usecs_; }
+
+    const int &(min) () const { return time_struct_.tm_min; }
+
+    const int &hour() const { return time_struct_.tm_hour; }
+
+    const int &day() const { return time_struct_.tm_mday; }
+
+    const int &month() const { return time_struct_.tm_mon; }
+
+    const int &year() const { return time_struct_.tm_year; }
+
+    const int &dayOfWeek() const { return time_struct_.tm_wday; }
+
+    const int &dayInYear() const { return time_struct_.tm_yday; }
+
+    const int &dst() const { return time_struct_.tm_isdst; }
+
+    const long int &gmtoff() const { return gmtoffset_; }
+
+    const std::tm &tm() const { return time_struct_; }
+
+    const bool use_localtime() const { return use_localtime_; }
 
 private:
-  void init(const std::tm &t, std::time_t timestamp, WallTime now);
-  std::tm time_struct_; // Time of creation of LogMessage
-  time_t timestamp_;    // Time of creation of LogMessage in seconds
-  int32_t usecs_;       // Time of creation of LogMessage - microseconds part
-  long int gmtoffset_;
-  bool use_localtime_;
+    void init(const std::tm &t, std::time_t timestamp, WallTime now);
+    std::tm time_struct_;// Time of creation of LogMessage
+    time_t timestamp_;   // Time of creation of LogMessage in seconds
+    int32_t usecs_;      // Time of creation of LogMessage - microseconds part
+    long int gmtoffset_;
+    bool use_localtime_;
 
     void CalcGmtOffset();
 };
 
 class LogSink {
 public:
-  using Ptr = std::shared_ptr<LogSink>;
+    using Ptr = std::shared_ptr<LogSink>;
 
-  virtual ~LogSink();
-  virtual bool ShouldLog(LogSeverity severity);
-  virtual void Send(LogSeverity severity, const char *full_filename,
-                    const char *base_filename, int line,
-                    const LogMessageTime &logmsgtime, const char *message,
-                    size_t message_len);
-  virtual void Flush();
-  std::string ToString(LogSeverity severity, const char *file,
-                       const char *base_file, int line,
-                       const LogMessageTime &logmsgtime, const char *message,
-                       size_t message_len);
+    virtual ~LogSink();
+    virtual bool ShouldLog(LogSeverity severity);
+    virtual void Send(LogSeverity severity,
+                      const char *full_filename,
+                      const char *base_filename,
+                      int line,
+                      const LogMessageTime &logmsgtime,
+                      const char *message,
+                      size_t message_len);
+    virtual void Flush();
+    std::string ToString(LogSeverity severity,
+                         const char *file,
+                         const char *base_file,
+                         int line,
+                         const LogMessageTime &logmsgtime,
+                         const char *message,
+                         size_t message_len);
 };
 
-void ColoredWriteToStdout(LogSeverity severity, const char *message,
-                          size_t len);
-void ColoredWriteToStderr(LogSeverity severity, const char *message,
-                          size_t len);
+void ColoredWriteToStdout(LogSeverity severity, const char *message, size_t len);
+void ColoredWriteToStderr(LogSeverity severity, const char *message, size_t len);
 void AddLogSink(LogSink::Ptr dest);
 void RemoveLogSink(LogSink::Ptr dest);
 void SetStderrLogging(LogSeverity min_severity);
 void LogToStderr();
-void LogToSinks(LogSeverity severity, const char *full_filename,
-                const char *base_filename, int line, const LogMessageTime &time,
-                const char *message, size_t message_len);
+void LogToSinks(LogSeverity severity,
+                const char *full_filename,
+                const char *base_filename,
+                int line,
+                const LogMessageTime &time,
+                const char *message,
+                size_t message_len);
 void WaitForSinks();
 const char *GetLogSeverityName(LogSeverity severity);
 
diff --git a/tile/base/internal/logging_glog.cc b/tile/base/internal/logging_glog.cc
index 746bbf4..5e05c06 100644
--- a/tile/base/internal/logging_glog.cc
+++ b/tile/base/internal/logging_glog.cc
@@ -6,182 +6,244 @@
 #include <mutex>
 
 namespace tile {
-bool VLogIsOn(int n) { return true; }
+bool
+VLogIsOn(int n)
+{
+    return true;
+}
+
 class LogMessage::Impl {
 public:
-  Impl(const char *file, int line, int severity) : lm_(file, line, severity) {}
-  std::ostream &stream() { return lm_.stream(); }
+    Impl(const char *file, int line, int severity) : lm_(file, line, severity) {}
+
+    std::ostream &stream() { return lm_.stream(); }
 
 private:
-  google::LogMessage lm_;
+    google::LogMessage lm_;
 };
 
 class LogMessageFatal::Impl {
 public:
-  Impl(const char *file, int line) : lm_(file, line) {}
-  std::ostream &stream() { return lm_.stream(); }
+    Impl(const char *file, int line) : lm_(file, line) {}
+
+    std::ostream &stream() { return lm_.stream(); }
 
 private:
-  google::LogMessageFatal lm_;
+    google::LogMessageFatal lm_;
 };
 
-LogMessage::LogMessage(const char *file, int line, int severity)
-    : impl_(new Impl(file, line, severity)) {}
+LogMessage::LogMessage(const char *file, int line, int severity) : impl_(new Impl(file, line, severity)) {}
+
 LogMessage::~LogMessage() = default;
-std::ostream &LogMessage::stream() { return impl_->stream(); }
 
-LogMessageFatal::LogMessageFatal(const char *file, int line)
-    : impl_(new Impl(file, line)) {}
+std::ostream &
+LogMessage::stream()
+{
+    return impl_->stream();
+}
+
+LogMessageFatal::LogMessageFatal(const char *file, int line) : impl_(new Impl(file, line)) {}
+
 LogMessageFatal::~LogMessageFatal() = default;
-std::ostream &LogMessageFatal::stream() { return impl_->stream(); }
 
-} // namespace tile
+std::ostream &
+LogMessageFatal::stream()
+{
+    return impl_->stream();
+}
+
+}// namespace tile
 
 namespace tile {
 namespace internal {
 namespace logging {
 namespace {
-std::vector<PrefixAppender *> *GetProviers() {
-  static std::vector<PrefixAppender *> providers;
-  return &providers;
+std::vector<PrefixAppender *> *
+GetProviers()
+{
+    static std::vector<PrefixAppender *> providers;
+    return &providers;
 }
-} // namespace
+}// namespace
+
 namespace details {
-std::string DescribeFormatArguments(const std::vector<std::string> &args) {
-  return fmt::format("{}", fmt::join(args.begin(), args.end(), ", "));
+std::string
+DescribeFormatArguments(const std::vector<std::string> &args)
+{
+    return fmt::format("{}", fmt::join(args.begin(), args.end(), ", "));
 }
 
-} // namespace details
-void InstallPrefixProvider(PrefixAppender *writer) {
-  GetProviers()->push_back(writer);
+}// namespace details
+
+void
+InstallPrefixProvider(PrefixAppender *writer)
+{
+    GetProviers()->push_back(writer);
 }
-void WritePrefixTo(std::string *to) {
-  for (auto &&appender : *GetProviers()) {
-    auto was = to->size();
-    appender(to);
-    if (to->size() != was) {
-      to->push_back(' ');
+
+void
+WritePrefixTo(std::string *to)
+{
+    for (auto &&appender : *GetProviers()) {
+        auto was = to->size();
+        appender(to);
+        if (to->size() != was) { to->push_back(' '); }
     }
-  }
 }
-} // namespace logging
-} // namespace internal
-} // namespace tile
+}// namespace logging
+}// namespace internal
+}// namespace tile
+
 namespace tile {
 
-LogMessageTime::LogMessageTime()
-    : time_struct_(), timestamp_(0), usecs_(0), gmtoffset_(0) {}
+LogMessageTime::LogMessageTime() : time_struct_(), timestamp_(0), usecs_(0), gmtoffset_(0) {}
 
-LogMessageTime::LogMessageTime(std::tm t) {
-  std::time_t timestamp = std::mktime(&t);
-  init(t, timestamp, 0);
+LogMessageTime::LogMessageTime(std::tm t)
+{
+    std::time_t timestamp = std::mktime(&t);
+    init(t, timestamp, 0);
 }
 
-LogMessageTime::LogMessageTime(std::time_t timestamp, WallTime now) {
-  std::tm t;
-  if (FLAGS_log_utc_time)
-    gmtime_r(&timestamp, &t);
-  else
-    localtime_r(&timestamp, &t);
-  init(t, timestamp, now);
+LogMessageTime::LogMessageTime(std::time_t timestamp, WallTime now)
+{
+    std::tm t;
+    if (FLAGS_log_utc_time)
+        gmtime_r(&timestamp, &t);
+    else
+        localtime_r(&timestamp, &t);
+    init(t, timestamp, now);
 }
 
-void LogMessageTime::init(const std::tm &t, std::time_t timestamp,
-                          WallTime now) {
-  time_struct_ = t;
-  timestamp_ = timestamp;
-  usecs_ = static_cast<std::int32_t>((now - timestamp) * 1000000);
+void
+LogMessageTime::init(const std::tm &t, std::time_t timestamp, WallTime now)
+{
+    time_struct_ = t;
+    timestamp_   = timestamp;
+    usecs_       = static_cast<std::int32_t>((now - timestamp) * 1000000);
 
-  CalcGmtOffset();
+    CalcGmtOffset();
 }
 
-void LogMessageTime::CalcGmtOffset() {
-  std::tm gmt_struct;
-  int isDst = 0;
-  if (FLAGS_log_utc_time) {
-    localtime_r(&timestamp_, &gmt_struct);
-    isDst = gmt_struct.tm_isdst;
-    gmt_struct = time_struct_;
-  } else {
-    isDst = time_struct_.tm_isdst;
-    gmtime_r(&timestamp_, &gmt_struct);
-  }
+void
+LogMessageTime::CalcGmtOffset()
+{
+    std::tm gmt_struct;
+    int isDst = 0;
+    if (FLAGS_log_utc_time) {
+        localtime_r(&timestamp_, &gmt_struct);
+        isDst      = gmt_struct.tm_isdst;
+        gmt_struct = time_struct_;
+    } else {
+        isDst = time_struct_.tm_isdst;
+        gmtime_r(&timestamp_, &gmt_struct);
+    }
 
-  time_t gmt_sec = mktime(&gmt_struct);
-  const long hour_secs = 3600;
-  // If the Daylight Saving Time(isDst) is active subtract an hour from the
-  // current timestamp.
-  gmtoffset_ =
-      static_cast<long int>(timestamp_ - gmt_sec + (isDst ? hour_secs : 0));
+    time_t gmt_sec       = mktime(&gmt_struct);
+    const long hour_secs = 3600;
+    // If the Daylight Saving Time(isDst) is active subtract an hour from the
+    // current timestamp.
+    gmtoffset_ = static_cast<long int>(timestamp_ - gmt_sec + (isDst ? hour_secs : 0));
 }
 
 LogSink::~LogSink() {}
-void LogSink::send(LogSeverity severity, const char *full_filename,
-                   const char *base_filename, int line,
-                   const LogMessageTime &logmsgtime, const char *message,
-                   size_t message_len) {
 
-  // do nothing
+void
+LogSink::send(LogSeverity severity,
+              const char *full_filename,
+              const char *base_filename,
+              int line,
+              const LogMessageTime &logmsgtime,
+              const char *message,
+              size_t message_len)
+{
+
+    // do nothing
 }
-void LogSink::WaitTillSent() {}
-std::string LogSink::ToString(LogSeverity severity, const char *file, int line,
-                              const LogMessageTime &logmsgtime,
-                              const char *message, size_t message_len) {
-  return google::LogSink::ToString(severity, file, line, logmsgtime.tm(),
-                                   message, message_len);
+
+void
+LogSink::WaitTillSent()
+{}
+
+std::string
+LogSink::ToString(LogSeverity severity,
+                  const char *file,
+                  int line,
+                  const LogMessageTime &logmsgtime,
+                  const char *message,
+                  size_t message_len)
+{
+    return google::LogSink::ToString(severity, file, line, logmsgtime.tm(), message, message_len);
 }
 
 class LogSinkWrapper : public google::LogSink {
 public:
-  LogSinkWrapper(tile::LogSink *dest) : dest_(dest) {}
-  ~LogSinkWrapper() override {}
-  void send(LogSeverity severity, const char *full_filename,
-            const char *base_filename, int line,
-            const google::LogMessageTime &logmsgtime, const char *message,
-            size_t message_len) override {
-    dest_->send(severity, full_filename, base_filename, line, logmsgtime.tm(),
-                message, message_len);
-  }
+    LogSinkWrapper(tile::LogSink *dest) : dest_(dest) {}
 
-  void WaitTillSent() override { dest_->WaitTillSent(); }
+    ~LogSinkWrapper() override {}
+
+    void send(LogSeverity severity,
+              const char *full_filename,
+              const char *base_filename,
+              int line,
+              const google::LogMessageTime &logmsgtime,
+              const char *message,
+              size_t message_len) override
+    {
+        dest_->send(severity, full_filename, base_filename, line, logmsgtime.tm(), message, message_len);
+    }
+
+    void WaitTillSent() override { dest_->WaitTillSent(); }
 
 private:
-  tile::LogSink *dest_;
+    tile::LogSink *dest_;
 };
 
 struct LogSinkPair {
-  struct LogSinWrapper *wrapper;
-  LogSink *sink;
+    struct LogSinWrapper *wrapper;
+    LogSink *sink;
 };
 
 static std::map<LogSink *, LogSinkWrapper *> sink_registry;
 static std::mutex sink_registry_mutex;
 
-void AddLogSink(LogSink *dest) {
-  std::lock_guard<std::mutex> lock(sink_registry_mutex);
-  if (sink_registry.find(dest) != sink_registry.end()) {
-    return;
-  }
+void
+AddLogSink(LogSink *dest)
+{
+    std::lock_guard<std::mutex> lock(sink_registry_mutex);
+    if (sink_registry.find(dest) != sink_registry.end()) { return; }
 
-  auto wrapper = new LogSinkWrapper(dest);
-  sink_registry[dest] = wrapper;
-  google::AddLogSink(wrapper);
+    auto wrapper        = new LogSinkWrapper(dest);
+    sink_registry[dest] = wrapper;
+    google::AddLogSink(wrapper);
 }
 
-void RemoveLogSink(LogSink *dest) {
-  std::lock_guard<std::mutex> lock(sink_registry_mutex);
-  auto iter = sink_registry.find(dest);
-  if (iter != sink_registry.end()) {
-    google::RemoveLogSink(iter->second);
-    sink_registry.erase(iter);
-    delete iter->second;
-  }
+void
+RemoveLogSink(LogSink *dest)
+{
+    std::lock_guard<std::mutex> lock(sink_registry_mutex);
+    auto iter = sink_registry.find(dest);
+    if (iter != sink_registry.end()) {
+        google::RemoveLogSink(iter->second);
+        sink_registry.erase(iter);
+        delete iter->second;
+    }
 }
-void SetStderrLogging(LogSeverity min_severity) {
-  google::SetStderrLogging(min_severity);
+
+void
+SetStderrLogging(LogSeverity min_severity)
+{
+    google::SetStderrLogging(min_severity);
 }
-void LogToStderr() { google::LogToStderr(); }
-const char *GetLogSeverityName(LogSeverity severity) {
-  return google::GetLogSeverityName(severity);
+
+void
+LogToStderr()
+{
+    google::LogToStderr();
 }
-} // namespace tile
+
+const char *
+GetLogSeverityName(LogSeverity severity)
+{
+    return google::GetLogSeverityName(severity);
+}
+}// namespace tile
diff --git a/tile/base/internal/logging_test.cc b/tile/base/internal/logging_test.cc
index 20d23f1..6592036 100644
--- a/tile/base/internal/logging_test.cc
+++ b/tile/base/internal/logging_test.cc
@@ -9,17 +9,31 @@
 #include <thread>
 
 struct AwesomeLogSink : public tile::LogSink {
-  virtual void Send(tile::LogSeverity severity, const char *full_filename,
-                    const char *base_filename, int line,
-                    const tile::LogMessageTime &logmsgtime, const char *message,
-                    size_t message_len) override {
-    msgs.emplace_back(std::string(message, message_len));
-  }
-  std::vector<std::string> msgs;
+    static std::shared_ptr<AwesomeLogSink> Create() { return std::make_shared<AwesomeLogSink>(); }
+
+    virtual void Send(tile::LogSeverity severity,
+                      const char *full_filename,
+                      const char *base_filename,
+                      int line,
+                      const tile::LogMessageTime &logmsgtime,
+                      const char *message,
+                      size_t message_len) override
+    {
+        msgs.emplace_back(std::string(message, message_len));
+    }
+
+    std::vector<std::string> msgs;
 };
 
 std::string my_prefix, my_prefix2;
 
+void
+ResetLogPrefix()
+{
+    my_prefix.clear();
+    my_prefix2.clear();
+}
+
 void
 WriteLoggingPrefix(std::string *s)
 {
@@ -32,26 +46,26 @@ WriteLoggingPrefix2(std::string *s)
     *s += my_prefix2;
 }
 
-TEST(Logging, Prefix) {
-  auto sink = std::make_shared<AwesomeLogSink>();
-  tile::AddLogSink(sink);
-  tile::ScopedDeferred defered([&] { tile::RemoveLogSink(sink); });
+TEST(Logging, Prefix)
+{
+    auto sink = std::make_shared<AwesomeLogSink>();
+    tile::AddLogSink(sink);
+    tile::ScopedDeferred defered([&] { tile::RemoveLogSink(sink); });
 
-  TILE_LOG_INFO("something");
+    TILE_LOG_INFO("something");
 
-  my_prefix = "[prefix]";
-  TILE_LOG_INFO("something");
+    my_prefix = "[prefix]";
+    TILE_LOG_INFO("something");
 
-  my_prefix = "[prefix1]";
-  TILE_LOG_INFO("something");
+    my_prefix = "[prefix1]";
+    TILE_LOG_INFO("something");
 
-  my_prefix2 = "[prefix2]";
-  TILE_LOG_INFO("something");
+    my_prefix2 = "[prefix2]";
+    TILE_LOG_INFO("something");
 
-  ASSERT_THAT(sink->msgs,
-              ::testing::ElementsAre("something", "[prefix] something",
-                                     "[prefix1] something",
-                                     "[prefix1] [prefix2] something"));
+    ASSERT_THAT(sink->msgs,
+                ::testing::ElementsAre(
+                    "something", "[prefix] something", "[prefix1] something", "[prefix1] [prefix2] something"));
 }
 
 TEST(Logging, CHECK)
@@ -65,39 +79,21 @@ TEST(Logging, CHECK)
     ASSERT_DEATH(([] { TILE_CHECK_NE(1, 1, "CHECK_NE"); }()), "CHECK_NE");
 }
 
-TEST(Logging, Prefix)
-{
-    AwesomeLogSink sink;
-    tile::AddLogSink(&sink);
-    tile::ScopedDeferred defered([&] { tile::RemoveLogSink(&sink); });
-
-  auto sink = std::make_shared<AwesomeLogSink>();
-  tile::AddLogSink(sink);
-  tile::ScopedDeferred defered([&] { tile::RemoveLogSink(sink); });
-  for (int i = 0; i < 30; i++) {
-    TILE_LOG_INFO_EVERY_SECOND("something");
-    std::this_thread::sleep_for(std::chrono::milliseconds(100));
-  }
-
-  ASSERT_THAT(sink->msgs,
-              ::testing::ElementsAre("something", "something", "something"));
-}
-
 TEST(Logging, DontPanicOnFormatFailure) { TILE_LOG_INFO("Don't panic!{}{}", 1); }
 
 TEST(Logging, EverySecond)
 {
     ResetLogPrefix();
 
-    AwesomeLogSink sink;
-    tile::AddLogSink(&sink);
-    tile::ScopedDeferred defered([&] { tile::RemoveLogSink(&sink); });
+    auto sink = AwesomeLogSink::Create();
+    tile::AddLogSink(sink);
+    tile::ScopedDeferred defered([&] { tile::RemoveLogSink(sink); });
     for (int i = 0; i < 30; i++) {
         TILE_LOG_INFO_EVERY_SECOND("something");
         std::this_thread::sleep_for(std::chrono::milliseconds(100));
     }
 
-    ASSERT_THAT(sink.msgs, ::testing::ElementsAre("something", "something", "something"));
+    ASSERT_THAT(sink->msgs, ::testing::ElementsAre("something", "something", "something"));
 }
 
 TEST(Logging, Enum)
diff --git a/tile/base/logging/basic_file_sink.cc b/tile/base/logging/basic_file_sink.cc
index ca0fe05..38d5210 100644
--- a/tile/base/logging/basic_file_sink.cc
+++ b/tile/base/logging/basic_file_sink.cc
@@ -1,24 +1,47 @@
 #include "tile/base/logging/basic_file_sink.h"
 
 namespace tile {
-BasicFileSink::Ptr BasicFileSink::Create(const std::string &filepath) {
-  auto sink = std::shared_ptr<BasicFileSink>(new BasicFileSink());
-  sink->set_filepath(filepath);
-  return sink;
+BasicFileSink::Ptr
+BasicFileSink::Create(const std::string &filepath)
+{
+    auto sink = std::shared_ptr<BasicFileSink>(new BasicFileSink());
+    sink->set_filepath(filepath);
+    return sink;
 }
+
 BasicFileSink::BasicFileSink() {}
+
 BasicFileSink::~BasicFileSink() {}
-void BasicFileSink::Send(LogSeverity severity, const char *full_filename,
-                         const char *base_filename, int line,
-                         const LogMessageTime &logmsgtime, const char *message,
-                         size_t message_len) {
-  TILE_CHECK(!filepath_.empty(), "filepath is empty");
-  ofs_ << std::string(message, message_len) << std::endl;
+
+void
+BasicFileSink::Send(LogSeverity severity,
+                    const char *full_filename,
+                    const char *base_filename,
+                    int line,
+                    const LogMessageTime &logmsgtime,
+                    const char *message,
+                    size_t message_len)
+{
+    TILE_CHECK(!filepath_.empty(), "filepath is empty");
+    ofs_ << std::string(message, message_len) << std::endl;
 }
-std::string BasicFileSink::filepath() const { return filepath_; }
-void BasicFileSink::set_filepath(const std::string &filepath) {
-  filepath_ = filepath;
-  ofs_.open(filepath, std::ios::out | std::ios::app);
+
+std::string
+BasicFileSink::filepath() const
+{
+    return filepath_;
 }
-void BasicFileSink::Flush() { ofs_.flush(); }
-} // namespace tile
+
+void
+BasicFileSink::set_filepath(const std::string &filepath)
+{
+    filepath_ = filepath;
+    ofs_.open(filepath, std::ios::out | std::ios::app);
+}
+
+void
+BasicFileSink::Flush()
+{
+    ofs_.flush();
+}
+}// namespace tile
diff --git a/tile/base/logging/basic_file_sink.h b/tile/base/logging/basic_file_sink.h
index 66a8d28..b0d4d18 100644
--- a/tile/base/logging/basic_file_sink.h
+++ b/tile/base/logging/basic_file_sink.h
@@ -10,27 +10,30 @@
 namespace tile {
 class BasicFileSink : public LogSink {
 public:
-  using Ptr = std::shared_ptr<BasicFileSink>;
-  static Ptr Create(const std::string &filepath);
+    using Ptr = std::shared_ptr<BasicFileSink>;
+    static Ptr Create(const std::string &filepath);
 
-  ~BasicFileSink() override;
-  void Send(LogSeverity severity, const char *full_filename,
-            const char *base_filename, int line,
-            const LogMessageTime &logmsgtime, const char *message,
-            size_t message_len) override;
-  void Flush() override;
+    ~BasicFileSink() override;
+    void Send(LogSeverity severity,
+              const char *full_filename,
+              const char *base_filename,
+              int line,
+              const LogMessageTime &logmsgtime,
+              const char *message,
+              size_t message_len) override;
+    void Flush() override;
 
-  std::string filepath() const;
-  void set_filepath(const std::string &filepath);
+    std::string filepath() const;
+    void set_filepath(const std::string &filepath);
 
 protected:
-  BasicFileSink();
+    BasicFileSink();
 
 private:
-  std::string filepath_;
-  std::ofstream ofs_;
+    std::string filepath_;
+    std::ofstream ofs_;
 };
 
-} // namespace tile
+}// namespace tile
 
-#endif // TILE_BASE_LOGGING_BASIC_FILE_SINK_H
+#endif// TILE_BASE_LOGGING_BASIC_FILE_SINK_H
diff --git a/tile/base/logging/console_sink.cc b/tile/base/logging/console_sink.cc
index d274d38..c1f353f 100644
--- a/tile/base/logging/console_sink.cc
+++ b/tile/base/logging/console_sink.cc
@@ -1,32 +1,39 @@
 #include "tile/base/logging/console_sink.h"
 
 #include <stdio.h>
+
 namespace tile {
 
-ConsoleSink::Ptr ConsoleSink::Create() {
-  return std::shared_ptr<ConsoleSink>(new ConsoleSink());
+ConsoleSink::Ptr
+ConsoleSink::Create()
+{
+    return std::shared_ptr<ConsoleSink>(new ConsoleSink());
 }
 
 ConsoleSink::~ConsoleSink() {}
 
-void ConsoleSink::Send(LogSeverity severity, const char *full_filename,
-                       const char *base_filename, int line,
-                       const LogMessageTime &logmsgtime, const char *message,
-                       size_t message_len) {
-  auto msg = ToString(severity, full_filename, base_filename, line, logmsgtime,
-                      message, message_len);
-  while (!msg.empty() && msg.back() == '\n') {
-    msg.pop_back();
-  }
-  if (severity >= TILE_FATAL) {
-    fprintf(stderr, "%s\n", msg.c_str());
-  } else {
-    fprintf(stdout, "%s\n", msg.c_str());
-  }
+void
+ConsoleSink::Send(LogSeverity severity,
+                  const char *full_filename,
+                  const char *base_filename,
+                  int line,
+                  const LogMessageTime &logmsgtime,
+                  const char *message,
+                  size_t message_len)
+{
+    auto msg = ToString(severity, full_filename, base_filename, line, logmsgtime, message, message_len);
+    while (!msg.empty() && msg.back() == '\n') { msg.pop_back(); }
+    if (severity >= TILE_FATAL) {
+        fprintf(stderr, "%s\n", msg.c_str());
+    } else {
+        fprintf(stdout, "%s\n", msg.c_str());
+    }
 }
 
-void ConsoleSink::Flush() {}
+void
+ConsoleSink::Flush()
+{}
 
 ConsoleSink::ConsoleSink() {}
 
-} // namespace tile
+}// namespace tile
diff --git a/tile/base/logging/console_sink.h b/tile/base/logging/console_sink.h
index 332930a..73d7c39 100644
--- a/tile/base/logging/console_sink.h
+++ b/tile/base/logging/console_sink.h
@@ -4,22 +4,26 @@
 #pragma once
 
 #include "tile/base/internal/logging.h"
+
 namespace tile {
 class ConsoleSink : public LogSink {
 public:
-  using Ptr = std::shared_ptr<ConsoleSink>;
-  static Ptr Create();
+    using Ptr = std::shared_ptr<ConsoleSink>;
+    static Ptr Create();
 
-  ~ConsoleSink() override;
-  void Send(LogSeverity severity, const char *full_filename,
-            const char *base_filename, int line,
-            const LogMessageTime &logmsgtime, const char *message,
-            size_t message_len) override;
-  void Flush() override;
+    ~ConsoleSink() override;
+    void Send(LogSeverity severity,
+              const char *full_filename,
+              const char *base_filename,
+              int line,
+              const LogMessageTime &logmsgtime,
+              const char *message,
+              size_t message_len) override;
+    void Flush() override;
 
 protected:
-  ConsoleSink();
+    ConsoleSink();
 };
-} // namespace tile
+}// namespace tile
 
-#endif // TILE_BASE_LOGGING_CONSOLE_SINK_H
+#endif// TILE_BASE_LOGGING_CONSOLE_SINK_H
diff --git a/tile/base/logging/splitter_sink.cc b/tile/base/logging/splitter_sink.cc
index e658d94..d56f0ec 100644
--- a/tile/base/logging/splitter_sink.cc
+++ b/tile/base/logging/splitter_sink.cc
@@ -2,62 +2,78 @@
 #include <cassert>
 
 namespace tile {
-std::shared_ptr<SplitterSink> SplitterSink::Create() {
-  return std::shared_ptr<SplitterSink>(new SplitterSink());
+std::shared_ptr<SplitterSink>
+SplitterSink::Create()
+{
+    return std::shared_ptr<SplitterSink>(new SplitterSink());
 }
 
-std::shared_ptr<SplitterSink> SplitterSink::Create(
-    std::initializer_list<std::shared_ptr<LogSink>> init_list) {
-  auto sink = Create();
-  for (auto &s : init_list) {
-    sink->AddSink(s);
-  }
-  return sink;
+std::shared_ptr<SplitterSink>
+SplitterSink::Create(std::initializer_list<std::shared_ptr<LogSink>> init_list)
+{
+    auto sink = Create();
+    for (auto &s : init_list) { sink->AddSink(s); }
+    return sink;
 }
 
 SplitterSink::SplitterSink() {}
+
 SplitterSink::~SplitterSink() {}
-void SplitterSink::Send(LogSeverity severity, const char *full_filename,
-                        const char *base_filename, int line,
-                        const LogMessageTime &logmsgtime, const char *message,
-                        size_t message_len) {
-  assert(!doing_ && "SplitterSink::send() should not be called recursively");
-  std::lock_guard<std::mutex> _(sinks_mutex_);
-  doing_ = true;
-  for (auto &sink : sinks_) {
-    sink->Send(severity, full_filename, base_filename, line, logmsgtime,
-               message, message_len);
-  }
-  doing_ = false;
+
+void
+SplitterSink::Send(LogSeverity severity,
+                   const char *full_filename,
+                   const char *base_filename,
+                   int line,
+                   const LogMessageTime &logmsgtime,
+                   const char *message,
+                   size_t message_len)
+{
+    assert(!doing_ && "SplitterSink::send() should not be called recursively");
+    std::lock_guard<std::mutex> _(sinks_mutex_);
+    doing_ = true;
+    for (auto &sink : sinks_) {
+        sink->Send(severity, full_filename, base_filename, line, logmsgtime, message, message_len);
+    }
+    doing_ = false;
 }
 
-void SplitterSink::Flush() {
-  assert(!doing_ && "SplitterSink::send() should not be called recursively");
-  std::lock_guard<std::mutex> _(sinks_mutex_);
-  doing_ = true;
-  for (auto &sink : sinks_) {
-    sink->Flush();
-  }
-  doing_ = false;
+void
+SplitterSink::Flush()
+{
+    assert(!doing_ && "SplitterSink::send() should not be called recursively");
+    std::lock_guard<std::mutex> _(sinks_mutex_);
+    doing_ = true;
+    for (auto &sink : sinks_) { sink->Flush(); }
+    doing_ = false;
 }
 
-void SplitterSink::AddSink(std::shared_ptr<LogSink> sink) {
-  std::lock_guard<std::mutex> _(sinks_mutex_);
-  sinks_.insert(sink);
+void
+SplitterSink::AddSink(std::shared_ptr<LogSink> sink)
+{
+    std::lock_guard<std::mutex> _(sinks_mutex_);
+    sinks_.insert(sink);
 }
 
-void SplitterSink::RemoveSink(std::shared_ptr<LogSink> sink) {
-  std::lock_guard<std::mutex> _(sinks_mutex_);
-  sinks_.erase(sink);
+void
+SplitterSink::RemoveSink(std::shared_ptr<LogSink> sink)
+{
+    std::lock_guard<std::mutex> _(sinks_mutex_);
+    sinks_.erase(sink);
 }
 
-void SplitterSink::ClearSinks() {
-  std::lock_guard<std::mutex> _(sinks_mutex_);
-  sinks_.clear();
-}
-std::set<LogSink::Ptr> SplitterSink::sinks() {
-  std::lock_guard<std::mutex> _(sinks_mutex_);
-  return sinks_;
+void
+SplitterSink::ClearSinks()
+{
+    std::lock_guard<std::mutex> _(sinks_mutex_);
+    sinks_.clear();
 }
 
-} // namespace tile
+std::set<LogSink::Ptr>
+SplitterSink::sinks()
+{
+    std::lock_guard<std::mutex> _(sinks_mutex_);
+    return sinks_;
+}
+
+}// namespace tile
diff --git a/tile/base/logging/splitter_sink.h b/tile/base/logging/splitter_sink.h
index 082c29a..58b45e8 100644
--- a/tile/base/logging/splitter_sink.h
+++ b/tile/base/logging/splitter_sink.h
@@ -10,31 +10,34 @@
 namespace tile {
 class SplitterSink : public LogSink {
 public:
-  using Ptr = std::shared_ptr<SplitterSink>;
-  static Ptr Create();
-  static Ptr Create(std::initializer_list<std::shared_ptr<LogSink>> init_list);
+    using Ptr = std::shared_ptr<SplitterSink>;
+    static Ptr Create();
+    static Ptr Create(std::initializer_list<std::shared_ptr<LogSink>> init_list);
 
-  ~SplitterSink() override;
+    ~SplitterSink() override;
 
-  void Send(LogSeverity severity, const char *full_filename,
-            const char *base_filename, int line,
-            const LogMessageTime &logmsgtime, const char *message,
-            size_t message_len) override;
-  void Flush() override;
+    void Send(LogSeverity severity,
+              const char *full_filename,
+              const char *base_filename,
+              int line,
+              const LogMessageTime &logmsgtime,
+              const char *message,
+              size_t message_len) override;
+    void Flush() override;
 
-  void AddSink(std::shared_ptr<LogSink> sink);
-  void RemoveSink(std::shared_ptr<LogSink> sink);
-  void ClearSinks();
-  std::set<LogSink::Ptr> sinks();
+    void AddSink(std::shared_ptr<LogSink> sink);
+    void RemoveSink(std::shared_ptr<LogSink> sink);
+    void ClearSinks();
+    std::set<LogSink::Ptr> sinks();
 
 protected:
-  SplitterSink();
+    SplitterSink();
 
 private:
-  std::set<std::shared_ptr<LogSink>> sinks_;
-  std::mutex sinks_mutex_;
-  bool doing_ = false;
+    std::set<std::shared_ptr<LogSink>> sinks_;
+    std::mutex sinks_mutex_;
+    bool doing_ = false;
 };
-} // namespace tile
+}// namespace tile
 
-#endif // TILE_BASE_LOGGING_SPLITTER_SINK_H
+#endif// TILE_BASE_LOGGING_SPLITTER_SINK_H
diff --git a/tile/base/logging/splitter_sink_test.cc b/tile/base/logging/splitter_sink_test.cc
index 87af503..1728026 100644
--- a/tile/base/logging/splitter_sink_test.cc
+++ b/tile/base/logging/splitter_sink_test.cc
@@ -4,53 +4,57 @@
 namespace tile {
 class SimpleSink : public LogSink {
 public:
-  using Ptr = std::shared_ptr<SimpleSink>;
-  static Ptr Create() { return std::shared_ptr<SimpleSink>(new SimpleSink()); }
-  void Send(LogSeverity severity, const char *full_filename,
-            const char *base_filename, int line,
-            const LogMessageTime &logmsgtime, const char *message,
-            size_t message_len) override {
-    message_ = std::string(message, message_len);
-  }
-  void Flush() override {}
-  std::string message_;
+    using Ptr = std::shared_ptr<SimpleSink>;
+
+    static Ptr Create() { return std::shared_ptr<SimpleSink>(new SimpleSink()); }
+
+    void Send(LogSeverity severity,
+              const char *full_filename,
+              const char *base_filename,
+              int line,
+              const LogMessageTime &logmsgtime,
+              const char *message,
+              size_t message_len) override
+    {
+        message_ = std::string(message, message_len);
+    }
+
+    void Flush() override {}
+
+    std::string message_;
 };
 
-TEST(SplitterSink, One) {
-  auto sink = SimpleSink::Create();
-  auto splitter = SplitterSink::Create({sink});
-  splitter->Send(LogSeverity::TILE_INFO, nullptr, nullptr, 0, LogMessageTime(),
-                 "message", 7);
-  ASSERT_EQ(sink->message_, "message");
+TEST(SplitterSink, One)
+{
+    auto sink     = SimpleSink::Create();
+    auto splitter = SplitterSink::Create({sink});
+    splitter->Send(LogSeverity::TILE_INFO, nullptr, nullptr, 0, LogMessageTime(), "message", 7);
+    ASSERT_EQ(sink->message_, "message");
 }
 
-TEST(SplitterSink, Two) {
-  auto sink1 = SimpleSink::Create();
-  auto sink2 = SimpleSink::Create();
-  auto splitter = SplitterSink::Create({sink1, sink2});
-  splitter->Send(LogSeverity::TILE_INFO, nullptr, nullptr, 0, LogMessageTime(),
-                 "message", 7);
-  ASSERT_EQ(sink1->message_, "message");
-  ASSERT_EQ(sink2->message_, "message");
+TEST(SplitterSink, Two)
+{
+    auto sink1    = SimpleSink::Create();
+    auto sink2    = SimpleSink::Create();
+    auto splitter = SplitterSink::Create({sink1, sink2});
+    splitter->Send(LogSeverity::TILE_INFO, nullptr, nullptr, 0, LogMessageTime(), "message", 7);
+    ASSERT_EQ(sink1->message_, "message");
+    ASSERT_EQ(sink2->message_, "message");
 }
 
-TEST(SplitterSink, Multi) {
-  auto splitter = SplitterSink::Create();
-  for (int i = 0; i < 100; i++) {
-    splitter->AddSink(SimpleSink::Create());
-  }
+TEST(SplitterSink, Multi)
+{
+    auto splitter = SplitterSink::Create();
+    for (int i = 0; i < 100; i++) { splitter->AddSink(SimpleSink::Create()); }
 
-  for (int i = 0; i < 100; i++) {
-    std::stringstream ss;
-    ss << "message" << i;
-    auto msg = ss.str();
-    splitter->Send(LogSeverity::TILE_INFO, nullptr, nullptr, 0,
-                   LogMessageTime(), msg.data(), msg.size());
+    for (int i = 0; i < 100; i++) {
+        std::stringstream ss;
+        ss << "message" << i;
+        auto msg = ss.str();
+        splitter->Send(LogSeverity::TILE_INFO, nullptr, nullptr, 0, LogMessageTime(), msg.data(), msg.size());
 
-    for (auto &sink : splitter->sinks()) {
-      ASSERT_EQ(std::static_pointer_cast<SimpleSink>(sink)->message_, msg);
+        for (auto &sink : splitter->sinks()) { ASSERT_EQ(std::static_pointer_cast<SimpleSink>(sink)->message_, msg); }
     }
-  }
 }
 
-} // namespace tile
+}// namespace tile
diff --git a/tile/init.cc b/tile/init.cc
index af6ee5f..4a72e2c 100644
--- a/tile/init.cc
+++ b/tile/init.cc
@@ -32,12 +32,14 @@ namespace {
 
 std::atomic<bool> g_quit_siganl{false};
 
-void QuitSignalHandler(int sig) {
-  auto old = g_quit_siganl.exchange(true, std::memory_order_relaxed);
-  if (old && FLAGS_tile_abort_on_double_quit_signal) {
-    // TODO: Add TILE_RAW_LOG
-    // RAW_LOG(FATAL, "Double quit signal received. Crashing the program");
-  }
+void
+QuitSignalHandler(int sig)
+{
+    auto old = g_quit_siganl.exchange(true, std::memory_order_relaxed);
+    if (old && FLAGS_tile_abort_on_double_quit_signal) {
+        // TODO: Add TILE_RAW_LOG
+        // RAW_LOG(FATAL, "Double quit signal received. Crashing the program");
+    }
 }
 
 void
@@ -52,22 +54,23 @@ InstallQuitSignalHandler()
 }
 }// namespace
 
-int Start(int argc, char **argv, std::function<int(int, char **)> cb,
-          bool single_thread, bool enable_crash_catch) {
-  if (enable_crash_catch) {
-    // TODO: Add InstallFailureSignalHandler
-    // google::InstallFailureSignalHandler();
-  }
+int
+Start(int argc, char **argv, std::function<int(int, char **)> cb, bool single_thread, bool enable_crash_catch)
+{
+    if (enable_crash_catch) {
+        // TODO: Add InstallFailureSignalHandler
+        // google::InstallFailureSignalHandler();
+    }
 
     // Init gflags
     gflags::SetVersionString(TILE_VERSION);
     gflags::ParseCommandLineFlags(&argc, &argv, true);
     detail::ApplyFlagOverrider();
 
-  AddLogSink(ConsoleSink::Create());
+    AddLogSink(ConsoleSink::Create());
 
-  // TODO: Add Init log level
-  // google::InitGoogleLogging(argv[0]);
+    // TODO: Add Init log level
+    // google::InitGoogleLogging(argv[0]);
 
     TILE_LOG_INFO("Tile started. version: {}", TILE_VERSION);
 
diff --git a/tile/testing/bm_main.cc b/tile/testing/bm_main.cc
index a322e97..33fc952 100644
--- a/tile/testing/bm_main.cc
+++ b/tile/testing/bm_main.cc
@@ -10,27 +10,29 @@ namespace tile {
 namespace testing {
 
 namespace {
-int StartBenchmark(int argc, char **argv) {
-  ::benchmark::Initialize(&argc, argv);
-  if (::benchmark::ReportUnrecognizedArguments(argc, argv)) {
-    return 1;
-  }
-  ::benchmark::RunSpecifiedBenchmarks();
-  ::benchmark::Shutdown();
-  return 0;
+int
+StartBenchmark(int argc, char **argv)
+{
+    ::benchmark::Initialize(&argc, argv);
+    if (::benchmark::ReportUnrecognizedArguments(argc, argv)) { return 1; }
+    ::benchmark::RunSpecifiedBenchmarks();
+    ::benchmark::Shutdown();
+    return 0;
 }
-} // namespace
+}// namespace
 
-int InitAndRunAllBenchmarks(int *argc, char **argv) {
+int
+InitAndRunAllBenchmarks(int *argc, char **argv)
+{
 
-  // if (gflags::GetCommandLineFlagInfoOrDie("logtostderr").is_default) {
-  //   FLAGS_logtostderr = true;
-  // }
+    // if (gflags::GetCommandLineFlagInfoOrDie("logtostderr").is_default) {
+    //   FLAGS_logtostderr = true;
+    // }
 
-  return Start(*argc, argv, StartBenchmark, true);
+    return Start(*argc, argv, StartBenchmark, true);
 }
 
-} // namespace testing
-} // namespace tile
+}// namespace testing
+}// namespace tile
 
 TILE_BENCHMARK_MAIN

From 25998dde64b81b1fb879683a5ff5d9c657b5c08a Mon Sep 17 00:00:00 2001
From: tqcq <99722391+tqcq@users.noreply.github.com>
Date: Mon, 2 Sep 2024 16:06:42 +0800
Subject: [PATCH 12/25] feat static libgcc libstdc++

---
 CMakeLists.txt | 60 +++++++++++++++++++++++++++-----------------------
 1 file changed, 32 insertions(+), 28 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 4a03f8b..51d2a33 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -19,6 +19,10 @@ set(CMAKE_CXX_EXTENSIONS OFF)
 
 set(CMAKE_POSITION_INDEPENDENT_CODE ON)
 
+# add static libgcc and libstdc++ for static linking
+set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -static-libgcc -static-libstdc++")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -static-libgcc -static-libstdc++")
+
 option(TILE_BUILD_TESTS "Build tests" OFF)
 option(TILE_BUILD_BENCHMARKS "Build tests" OFF)
 option(TILE_WITH_OPENSSL "Build with openssl" OFF)
@@ -34,34 +38,34 @@ if(NOT CMAKE_BUILD_TYPE)
     set(CMAKE_BUILD_TYPE "Release")
 endif()
 
-if(CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
-  # set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -gz")
-  # set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -gz")
-  # set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -static") set(CMAKE_C_FLAGS
-  # "${CMAKE_CXX_FLAGS} -static") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}
-  # -fsanitize=address ") set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fsanitize=address
-  # ")
-
-  set(WHOLE_ARCHIVE_PREFIX "-Wl,-force_load")
-  # set(NO_WHOLE_ARCHIVE_PREFIX "")
-elseif(CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang")
-  # set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -gz")
-  # set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -gz")
-  # set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -static") set(CMAKE_C_FLAGS
-  # "${CMAKE_CXX_FLAGS} -static")
-
-  set(WHOLE_ARCHIVE_PREFIX "-Wl,-force_load,")
-  # set(NO_WHOLE_ARCHIVE_PREFIX "")
-elseif(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -gz")
-  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -gz")
-  # set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -static-libgcc -static-libstdc++")
-  # set(CMAKE_C_FLAGS "${CMAKE_CXX_FLAGS} -static-libgcc -static-libstdc++")
-
-  set(STATIC_BINARY_FLAGS "-static-libgcc -static-libstdc++")
-  set(WHOLE_ARCHIVE_PREFIX "-Wl,--whole-archive")
-  set(WHOLE_ARCHIVE_SUFFIX "-Wl,--no-whole-archive")
-endif()
+# if(CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
+#   # set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -gz")
+#   # set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -gz")
+#   # set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -static") set(CMAKE_C_FLAGS
+#   # "${CMAKE_CXX_FLAGS} -static") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}
+#   # -fsanitize=address ") set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fsanitize=address
+#   # ")
+#
+#   set(WHOLE_ARCHIVE_PREFIX "-Wl,-force_load")
+#   # set(NO_WHOLE_ARCHIVE_PREFIX "")
+# elseif(CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang")
+#   # set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -gz")
+#   # set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -gz")
+#   # set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -static") set(CMAKE_C_FLAGS
+#   # "${CMAKE_CXX_FLAGS} -static")
+#
+#   set(WHOLE_ARCHIVE_PREFIX "-Wl,-force_load,")
+#   # set(NO_WHOLE_ARCHIVE_PREFIX "")
+# elseif(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+#   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -gz")
+#   set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -gz")
+#   # set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -static-libgcc -static-libstdc++")
+#   # set(CMAKE_C_FLAGS "${CMAKE_CXX_FLAGS} -static-libgcc -static-libstdc++")
+#
+#   set(STATIC_BINARY_FLAGS "-static-libgcc -static-libstdc++")
+#   set(WHOLE_ARCHIVE_PREFIX "-Wl,--whole-archive")
+#   set(WHOLE_ARCHIVE_SUFFIX "-Wl,--no-whole-archive")
+# endif()
 
 # extern int getifaddrs(struct ifaddrs **ifap); extern void freeifaddrs(struct
 # ifaddrs *ifa);

From f03d0bd931771344263ceabb80e21bdb2502dd18 Mon Sep 17 00:00:00 2001
From: tqcq <99722391+tqcq@users.noreply.github.com>
Date: Tue, 10 Sep 2024 11:25:57 +0800
Subject: [PATCH 13/25] fix spell

---
 tile/base/logging.h  | 1 +
 tile/io/descriptor.h | 2 +-
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/tile/base/logging.h b/tile/base/logging.h
index 885501c..5de2cdc 100644
--- a/tile/base/logging.h
+++ b/tile/base/logging.h
@@ -5,6 +5,7 @@
 
 #include "tile/base/internal/logging.h"
 #include "tile/base/logging/basic_file_sink.h"
+#include "tile/base/logging/console_sink.h"
 #include "tile/base/logging/splitter_sink.h"
 
 // #define TILE_VLOG(n, ...)
diff --git a/tile/io/descriptor.h b/tile/io/descriptor.h
index e50d8a3..2249567 100644
--- a/tile/io/descriptor.h
+++ b/tile/io/descriptor.h
@@ -63,7 +63,7 @@ private:
 
     bool Enabled() const { return read_mostly_.enabled; }
 
-    void FireEvents(int mas, std::uint64_t polled_at);
+    void FireEvents(int mask, std::uint64_t polled_at);
     void FireReadEvent(std::uint64_t fired_at);
     void FireWriteEvent(std::uint64_t fired_at);
     void FireErrorEvent(std::uint64_t fired_at);

From 748262d48bbce6ef0dcc664360e8adc386bc3a5a Mon Sep 17 00:00:00 2001
From: tqcq <99722391+tqcq@users.noreply.github.com>
Date: Sat, 28 Sep 2024 19:11:32 +0800
Subject: [PATCH 14/25] fix miss cmake

---
 .gitea/workflows/linux-arm-gcc.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.gitea/workflows/linux-arm-gcc.yml b/.gitea/workflows/linux-arm-gcc.yml
index 3b5cc01..5f10a39 100644
--- a/.gitea/workflows/linux-arm-gcc.yml
+++ b/.gitea/workflows/linux-arm-gcc.yml
@@ -39,7 +39,7 @@ jobs:
       - name: install-tools
         run: |
           sudo apt-get update -y
-          sudo apt-get install -y g++-arm-linux-gnueabi qemu-user-binfmt
+          sudo apt-get install -y cmake g++-arm-linux-gnueabi qemu-user-binfmt
       - name: configure
         run: |
           mkdir build && cd build

From eda5a202861e5f56ded0ecda53d7784fbf3d7897 Mon Sep 17 00:00:00 2001
From: tqcq <99722391+tqcq@users.noreply.github.com>
Date: Sun, 29 Sep 2024 09:09:18 +0800
Subject: [PATCH 15/25] fix(toml_configuration): fix RemoveRaw delete all tree

---
 CMakeLists.txt                              |     2 +
 third_party/README.md                       |     3 +
 third_party/header_only/toml.hpp            | 17241 ++++++++++++++++++
 tile/base/config/json_configuration_test.cc |    10 +-
 tile/base/config/toml_configuration.cc      |   219 +
 tile/base/config/toml_configuration.h       |    40 +
 tile/base/config/toml_configuration_test.cc |    71 +
 tile/base/slice.h                           |     4 +-
 8 files changed, 17581 insertions(+), 9 deletions(-)
 create mode 100644 third_party/README.md
 create mode 100644 third_party/header_only/toml.hpp
 create mode 100644 tile/base/config/toml_configuration.cc
 create mode 100644 tile/base/config/toml_configuration.h
 create mode 100644 tile/base/config/toml_configuration_test.cc

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 51d2a33..80a5fb2 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -219,6 +219,7 @@ set(TILE_SRCS
     "tile/base/config/ini_file_configuration.cc"
     "tile/base/config/json_configuration.cc"
     "tile/base/config/layered_configuration.cc"
+    "tile/base/config/toml_configuration.cc"
 )
 
 if((NOT TILE_HAVE_GETIFADDRS) OR (NOT TILE_HAVE_FREEIFADDRS))
@@ -243,6 +244,7 @@ target_include_directories(
          "${CMAKE_CURRENT_SOURCE_DIR}"
          ${THIRD_PARTY_INCLUDE_DIRS}
          RPIVATE
+         "${CMAKE_CURRENT_SOURCE_DIR}/third_party/header_only/"
          "${CMAKE_CURRENT_BINARY_DIR}/third_party/gflags/include")
 
 target_link_libraries(
diff --git a/third_party/README.md b/third_party/README.md
new file mode 100644
index 0000000..6b79838
--- /dev/null
+++ b/third_party/README.md
@@ -0,0 +1,3 @@
+# Library
+
+- [toml11](https://github.com/ToruNiina/toml11/archive/refs/tags/v4.2.0.tar.gz)
diff --git a/third_party/header_only/toml.hpp b/third_party/header_only/toml.hpp
new file mode 100644
index 0000000..afdaf5b
--- /dev/null
+++ b/third_party/header_only/toml.hpp
@@ -0,0 +1,17241 @@
+#ifndef TOML11_VERSION_HPP
+#define TOML11_VERSION_HPP
+
+#define TOML11_VERSION_MAJOR 4
+#define TOML11_VERSION_MINOR 2
+#define TOML11_VERSION_PATCH 0
+
+#ifndef __cplusplus
+#    error "__cplusplus is not defined"
+#endif
+
+// Since MSVC does not define `__cplusplus` correctly unless you pass
+// `/Zc:__cplusplus` when compiling, the workaround macros are added.
+//
+// The value of `__cplusplus` macro is defined in the C++ standard spec, but
+// MSVC ignores the value, maybe because of backward compatibility. Instead,
+// MSVC defines _MSVC_LANG that has the same value as __cplusplus defined in
+// the C++ standard. So we check if _MSVC_LANG is defined before using `__cplusplus`.
+//
+// FYI: https://docs.microsoft.com/en-us/cpp/build/reference/zc-cplusplus?view=msvc-170
+//      https://docs.microsoft.com/en-us/cpp/preprocessor/predefined-macros?view=msvc-170
+//
+
+#if defined(_MSVC_LANG) && defined(_MSC_VER) && 190024210 <= _MSC_FULL_VER
+#  define TOML11_CPLUSPLUS_STANDARD_VERSION _MSVC_LANG
+#else
+#  define TOML11_CPLUSPLUS_STANDARD_VERSION __cplusplus
+#endif
+
+#if TOML11_CPLUSPLUS_STANDARD_VERSION < 201103L
+#    error "toml11 requires C++11 or later."
+#endif
+
+#if ! defined(__has_include)
+#  define __has_include(x) 0
+#endif
+
+#if ! defined(__has_cpp_attribute)
+#  define __has_cpp_attribute(x) 0
+#endif
+
+#if ! defined(__has_builtin)
+#  define __has_builtin(x) 0
+#endif
+
+// hard to remember
+
+#ifndef TOML11_CXX14_VALUE
+#define TOML11_CXX14_VALUE 201402L
+#endif//TOML11_CXX14_VALUE
+
+#ifndef TOML11_CXX17_VALUE
+#define TOML11_CXX17_VALUE 201703L
+#endif//TOML11_CXX17_VALUE
+
+#ifndef TOML11_CXX20_VALUE
+#define TOML11_CXX20_VALUE 202002L
+#endif//TOML11_CXX20_VALUE
+
+#if defined(__cpp_char8_t)
+#  if __cpp_char8_t >= 201811L
+#    define TOML11_HAS_CHAR8_T 1
+#  endif
+#endif
+
+#if TOML11_CPLUSPLUS_STANDARD_VERSION >= TOML11_CXX17_VALUE
+#  if __has_include(<string_view>)
+#    define TOML11_HAS_STRING_VIEW 1
+#  endif
+#endif
+
+#ifndef TOML11_DISABLE_STD_FILESYSTEM
+#  if TOML11_CPLUSPLUS_STANDARD_VERSION >= TOML11_CXX17_VALUE
+#    if __has_include(<filesystem>)
+#      define TOML11_HAS_FILESYSTEM 1
+#    endif
+#  endif
+#endif
+
+#if TOML11_CPLUSPLUS_STANDARD_VERSION >= TOML11_CXX17_VALUE
+#  if __has_include(<optional>)
+#    define TOML11_HAS_OPTIONAL 1
+#  endif
+#endif
+
+#if defined(TOML11_COMPILE_SOURCES)
+#  define TOML11_INLINE
+#else
+#  define TOML11_INLINE inline
+#endif
+
+namespace toml
+{
+
+inline const char* license_notice() noexcept
+{
+    return R"(The MIT License (MIT)
+
+Copyright (c) 2017-now Toru Niina
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.)";
+}
+
+} // toml
+#endif // TOML11_VERSION_HPP
+#ifndef TOML11_FORMAT_HPP
+#define TOML11_FORMAT_HPP
+
+#ifndef TOML11_FORMAT_FWD_HPP
+#define TOML11_FORMAT_FWD_HPP
+
+#include <iosfwd>
+#include <string>
+#include <utility>
+
+#include <cstddef>
+#include <cstdint>
+
+namespace toml
+{
+
+// toml types with serialization info
+
+enum class indent_char : std::uint8_t
+{
+    space, // use space
+    tab,   // use tab
+    none   // no indent
+};
+
+std::ostream& operator<<(std::ostream& os, const indent_char& c);
+std::string to_string(const indent_char c);
+
+// ----------------------------------------------------------------------------
+// boolean
+
+struct boolean_format_info
+{
+    // nothing, for now
+};
+
+inline bool operator==(const boolean_format_info&, const boolean_format_info&) noexcept
+{
+    return true;
+}
+inline bool operator!=(const boolean_format_info&, const boolean_format_info&) noexcept
+{
+    return false;
+}
+
+// ----------------------------------------------------------------------------
+// integer
+
+enum class integer_format : std::uint8_t
+{
+    dec = 0,
+    bin = 1,
+    oct = 2,
+    hex = 3,
+};
+
+std::ostream& operator<<(std::ostream& os, const integer_format f);
+std::string to_string(const integer_format);
+
+struct integer_format_info
+{
+    integer_format fmt = integer_format::dec;
+    bool        uppercase = true; // hex with uppercase
+    std::size_t width     = 0;    // minimal width (may exceed)
+    std::size_t spacer    = 0;    // position of `_` (if 0, no spacer)
+    std::string suffix    = "";   // _suffix (library extension)
+};
+
+bool operator==(const integer_format_info&, const integer_format_info&) noexcept;
+bool operator!=(const integer_format_info&, const integer_format_info&) noexcept;
+
+// ----------------------------------------------------------------------------
+// floating
+
+enum class floating_format : std::uint8_t
+{
+    defaultfloat = 0,
+    fixed        = 1, // does not include exponential part
+    scientific   = 2, // always include exponential part
+    hex          = 3  // hexfloat extension
+};
+
+std::ostream& operator<<(std::ostream& os, const floating_format f);
+std::string to_string(const floating_format);
+
+struct floating_format_info
+{
+    floating_format fmt = floating_format::defaultfloat;
+    std::size_t prec  = 0;        // precision (if 0, use the default)
+    std::string suffix = "";      // 1.0e+2_suffix (library extension)
+};
+
+bool operator==(const floating_format_info&, const floating_format_info&) noexcept;
+bool operator!=(const floating_format_info&, const floating_format_info&) noexcept;
+
+// ----------------------------------------------------------------------------
+// string
+
+enum class string_format : std::uint8_t
+{
+    basic             = 0,
+    literal           = 1,
+    multiline_basic   = 2,
+    multiline_literal = 3
+};
+
+std::ostream& operator<<(std::ostream& os, const string_format f);
+std::string to_string(const string_format);
+
+struct string_format_info
+{
+    string_format fmt = string_format::basic;
+    bool start_with_newline    = false;
+};
+
+bool operator==(const string_format_info&, const string_format_info&) noexcept;
+bool operator!=(const string_format_info&, const string_format_info&) noexcept;
+
+// ----------------------------------------------------------------------------
+// datetime
+
+enum class datetime_delimiter_kind : std::uint8_t
+{
+    upper_T = 0,
+    lower_t = 1,
+    space   = 2,
+};
+std::ostream& operator<<(std::ostream& os, const datetime_delimiter_kind d);
+std::string to_string(const datetime_delimiter_kind);
+
+struct offset_datetime_format_info
+{
+    datetime_delimiter_kind delimiter = datetime_delimiter_kind::upper_T;
+    bool has_seconds = true;
+    std::size_t subsecond_precision = 6; // [us]
+};
+
+bool operator==(const offset_datetime_format_info&, const offset_datetime_format_info&) noexcept;
+bool operator!=(const offset_datetime_format_info&, const offset_datetime_format_info&) noexcept;
+
+struct local_datetime_format_info
+{
+    datetime_delimiter_kind delimiter = datetime_delimiter_kind::upper_T;
+    bool has_seconds = true;
+    std::size_t subsecond_precision = 6; // [us]
+};
+
+bool operator==(const local_datetime_format_info&, const local_datetime_format_info&) noexcept;
+bool operator!=(const local_datetime_format_info&, const local_datetime_format_info&) noexcept;
+
+struct local_date_format_info
+{
+    // nothing, for now
+};
+
+bool operator==(const local_date_format_info&, const local_date_format_info&) noexcept;
+bool operator!=(const local_date_format_info&, const local_date_format_info&) noexcept;
+
+struct local_time_format_info
+{
+    bool has_seconds = true;
+    std::size_t subsecond_precision = 6; // [us]
+};
+
+bool operator==(const local_time_format_info&, const local_time_format_info&) noexcept;
+bool operator!=(const local_time_format_info&, const local_time_format_info&) noexcept;
+
+// ----------------------------------------------------------------------------
+// array
+
+enum class array_format : std::uint8_t
+{
+    default_format  = 0,
+    oneline         = 1,
+    multiline       = 2,
+    array_of_tables = 3 // [[format.in.this.way]]
+};
+
+std::ostream& operator<<(std::ostream& os, const array_format f);
+std::string to_string(const array_format);
+
+struct array_format_info
+{
+    array_format fmt            = array_format::default_format;
+    indent_char  indent_type    = indent_char::space;
+    std::int32_t body_indent    = 4; // indent in case of multiline
+    std::int32_t closing_indent = 0; // indent of `]`
+};
+
+bool operator==(const array_format_info&, const array_format_info&) noexcept;
+bool operator!=(const array_format_info&, const array_format_info&) noexcept;
+
+// ----------------------------------------------------------------------------
+// table
+
+enum class table_format : std::uint8_t
+{
+    multiline         = 0, // [foo] \n bar = "baz"
+    oneline           = 1, // foo = {bar = "baz"}
+    dotted            = 2, // foo.bar = "baz"
+    multiline_oneline = 3, // foo = { \n bar = "baz" \n }
+    implicit          = 4  // [x] defined by [x.y.z]. skip in serializer.
+};
+
+std::ostream& operator<<(std::ostream& os, const table_format f);
+std::string to_string(const table_format);
+
+struct table_format_info
+{
+    table_format fmt = table_format::multiline;
+    indent_char  indent_type    = indent_char::space;
+    std::int32_t body_indent    = 0; // indent of values
+    std::int32_t name_indent    = 0; // indent of [table]
+    std::int32_t closing_indent = 0; // in case of {inline-table}
+};
+
+bool operator==(const table_format_info&, const table_format_info&) noexcept;
+bool operator!=(const table_format_info&, const table_format_info&) noexcept;
+
+// ----------------------------------------------------------------------------
+// wrapper
+
+namespace detail
+{
+template<typename T, typename F>
+struct value_with_format
+{
+    using value_type  = T;
+    using format_type = F;
+
+    value_with_format()  = default;
+    ~value_with_format() = default;
+    value_with_format(const value_with_format&) = default;
+    value_with_format(value_with_format&&)      = default;
+    value_with_format& operator=(const value_with_format&) = default;
+    value_with_format& operator=(value_with_format&&)      = default;
+
+    value_with_format(value_type v, format_type f)
+        : value{std::move(v)}, format{std::move(f)}
+    {}
+
+    template<typename U>
+    value_with_format(value_with_format<U, format_type> other)
+        : value{std::move(other.value)}, format{std::move(other.format)}
+    {}
+
+    value_type  value;
+    format_type format;
+};
+} // detail
+
+} // namespace toml
+#endif // TOML11_FORMAT_FWD_HPP
+
+#if ! defined(TOML11_COMPILE_SOURCES)
+#ifndef TOML11_FORMAT_IMPL_HPP
+#define TOML11_FORMAT_IMPL_HPP
+
+
+#include <ostream>
+#include <sstream>
+
+namespace toml
+{
+
+// toml types with serialization info
+
+TOML11_INLINE std::ostream& operator<<(std::ostream& os, const indent_char& c)
+{
+    switch(c)
+    {
+        case indent_char::space:         {os << "space"        ; break;}
+        case indent_char::tab:           {os << "tab"          ; break;}
+        case indent_char::none:          {os << "none"         ; break;}
+        default:
+        {
+            os << "unknown indent char: " << static_cast<std::uint8_t>(c);
+        }
+    }
+    return os;
+}
+
+TOML11_INLINE std::string to_string(const indent_char c)
+{
+    std::ostringstream oss;
+    oss << c;
+    return oss.str();
+}
+
+// ----------------------------------------------------------------------------
+// boolean
+
+// ----------------------------------------------------------------------------
+// integer
+
+TOML11_INLINE std::ostream& operator<<(std::ostream& os, const integer_format f)
+{
+    switch(f)
+    {
+        case integer_format::dec: {os << "dec"; break;}
+        case integer_format::bin: {os << "bin"; break;}
+        case integer_format::oct: {os << "oct"; break;}
+        case integer_format::hex: {os << "hex"; break;}
+        default:
+        {
+            os << "unknown integer_format: " << static_cast<std::uint8_t>(f);
+            break;
+        }
+    }
+    return os;
+}
+TOML11_INLINE std::string to_string(const integer_format c)
+{
+    std::ostringstream oss;
+    oss << c;
+    return oss.str();
+}
+
+
+TOML11_INLINE bool operator==(const integer_format_info& lhs, const integer_format_info& rhs) noexcept
+{
+    return lhs.fmt       == rhs.fmt    &&
+           lhs.uppercase == rhs.uppercase &&
+           lhs.width     == rhs.width  &&
+           lhs.spacer    == rhs.spacer &&
+           lhs.suffix    == rhs.suffix ;
+}
+TOML11_INLINE bool operator!=(const integer_format_info& lhs, const integer_format_info& rhs) noexcept
+{
+    return !(lhs == rhs);
+}
+
+// ----------------------------------------------------------------------------
+// floating
+
+TOML11_INLINE std::ostream& operator<<(std::ostream& os, const floating_format f)
+{
+    switch(f)
+    {
+        case floating_format::defaultfloat: {os << "defaultfloat"; break;}
+        case floating_format::fixed       : {os << "fixed"       ; break;}
+        case floating_format::scientific  : {os << "scientific"  ; break;}
+        case floating_format::hex         : {os << "hex"         ; break;}
+        default:
+        {
+            os << "unknown floating_format: " << static_cast<std::uint8_t>(f);
+            break;
+        }
+    }
+    return os;
+}
+TOML11_INLINE std::string to_string(const floating_format c)
+{
+    std::ostringstream oss;
+    oss << c;
+    return oss.str();
+}
+
+TOML11_INLINE bool operator==(const floating_format_info& lhs, const floating_format_info& rhs) noexcept
+{
+    return lhs.fmt          == rhs.fmt          &&
+           lhs.prec         == rhs.prec         &&
+           lhs.suffix       == rhs.suffix       ;
+}
+TOML11_INLINE bool operator!=(const floating_format_info& lhs, const floating_format_info& rhs) noexcept
+{
+    return !(lhs == rhs);
+}
+
+// ----------------------------------------------------------------------------
+// string
+
+TOML11_INLINE std::ostream& operator<<(std::ostream& os, const string_format f)
+{
+    switch(f)
+    {
+        case string_format::basic            : {os << "basic"            ; break;}
+        case string_format::literal          : {os << "literal"          ; break;}
+        case string_format::multiline_basic  : {os << "multiline_basic"  ; break;}
+        case string_format::multiline_literal: {os << "multiline_literal"; break;}
+        default:
+        {
+            os << "unknown string_format: " << static_cast<std::uint8_t>(f);
+            break;
+        }
+    }
+    return os;
+}
+TOML11_INLINE std::string to_string(const string_format c)
+{
+    std::ostringstream oss;
+    oss << c;
+    return oss.str();
+}
+
+TOML11_INLINE bool operator==(const string_format_info& lhs, const string_format_info& rhs) noexcept
+{
+    return lhs.fmt                == rhs.fmt                &&
+           lhs.start_with_newline == rhs.start_with_newline ;
+}
+TOML11_INLINE bool operator!=(const string_format_info& lhs, const string_format_info& rhs) noexcept
+{
+    return !(lhs == rhs);
+}
+// ----------------------------------------------------------------------------
+// datetime
+
+TOML11_INLINE std::ostream& operator<<(std::ostream& os, const datetime_delimiter_kind d)
+{
+    switch(d)
+    {
+        case datetime_delimiter_kind::upper_T: { os << "upper_T, "; break; }
+        case datetime_delimiter_kind::lower_t: { os << "lower_t, "; break; }
+        case datetime_delimiter_kind::space:   { os << "space, ";   break; }
+        default:
+        {
+            os << "unknown datetime delimiter: " << static_cast<std::uint8_t>(d);
+            break;
+        }
+    }
+    return os;
+}
+TOML11_INLINE std::string to_string(const datetime_delimiter_kind c)
+{
+    std::ostringstream oss;
+    oss << c;
+    return oss.str();
+}
+
+TOML11_INLINE bool operator==(const offset_datetime_format_info& lhs, const offset_datetime_format_info& rhs) noexcept
+{
+    return lhs.delimiter           == rhs.delimiter   &&
+           lhs.has_seconds         == rhs.has_seconds &&
+           lhs.subsecond_precision == rhs.subsecond_precision ;
+}
+TOML11_INLINE bool operator!=(const offset_datetime_format_info& lhs, const offset_datetime_format_info& rhs) noexcept
+{
+    return !(lhs == rhs);
+}
+
+TOML11_INLINE bool operator==(const local_datetime_format_info& lhs, const local_datetime_format_info& rhs) noexcept
+{
+    return lhs.delimiter           == rhs.delimiter   &&
+           lhs.has_seconds         == rhs.has_seconds &&
+           lhs.subsecond_precision == rhs.subsecond_precision ;
+}
+TOML11_INLINE bool operator!=(const local_datetime_format_info& lhs, const local_datetime_format_info& rhs) noexcept
+{
+    return !(lhs == rhs);
+}
+
+TOML11_INLINE bool operator==(const local_date_format_info&, const local_date_format_info&) noexcept
+{
+    return true;
+}
+TOML11_INLINE bool operator!=(const local_date_format_info& lhs, const local_date_format_info& rhs) noexcept
+{
+    return !(lhs == rhs);
+}
+
+TOML11_INLINE bool operator==(const local_time_format_info& lhs, const local_time_format_info& rhs) noexcept
+{
+    return lhs.has_seconds         == rhs.has_seconds         &&
+           lhs.subsecond_precision == rhs.subsecond_precision ;
+}
+TOML11_INLINE bool operator!=(const local_time_format_info& lhs, const local_time_format_info& rhs) noexcept
+{
+    return !(lhs == rhs);
+}
+
+// ----------------------------------------------------------------------------
+// array
+
+TOML11_INLINE std::ostream& operator<<(std::ostream& os, const array_format f)
+{
+    switch(f)
+    {
+        case array_format::default_format : {os << "default_format" ; break;}
+        case array_format::oneline        : {os << "oneline"        ; break;}
+        case array_format::multiline      : {os << "multiline"      ; break;}
+        case array_format::array_of_tables: {os << "array_of_tables"; break;}
+        default:
+        {
+            os << "unknown array_format: " << static_cast<std::uint8_t>(f);
+            break;
+        }
+    }
+    return os;
+}
+TOML11_INLINE std::string to_string(const array_format c)
+{
+    std::ostringstream oss;
+    oss << c;
+    return oss.str();
+}
+
+TOML11_INLINE bool operator==(const array_format_info& lhs, const array_format_info& rhs) noexcept
+{
+    return lhs.fmt            == rhs.fmt            &&
+           lhs.indent_type    == rhs.indent_type    &&
+           lhs.body_indent    == rhs.body_indent    &&
+           lhs.closing_indent == rhs.closing_indent ;
+}
+TOML11_INLINE bool operator!=(const array_format_info& lhs, const array_format_info& rhs) noexcept
+{
+    return !(lhs == rhs);
+}
+
+// ----------------------------------------------------------------------------
+// table
+
+TOML11_INLINE std::ostream& operator<<(std::ostream& os, const table_format f)
+{
+    switch(f)
+    {
+        case table_format::multiline        : {os << "multiline"        ; break;}
+        case table_format::oneline          : {os << "oneline"          ; break;}
+        case table_format::dotted           : {os << "dotted"           ; break;}
+        case table_format::multiline_oneline: {os << "multiline_oneline"; break;}
+        case table_format::implicit         : {os << "implicit"         ; break;}
+        default:
+        {
+            os << "unknown table_format: " << static_cast<std::uint8_t>(f);
+            break;
+        }
+    }
+    return os;
+}
+TOML11_INLINE std::string to_string(const table_format c)
+{
+    std::ostringstream oss;
+    oss << c;
+    return oss.str();
+}
+
+TOML11_INLINE bool operator==(const table_format_info& lhs, const table_format_info& rhs) noexcept
+{
+    return lhs.fmt                == rhs.fmt              &&
+           lhs.indent_type        == rhs.indent_type      &&
+           lhs.body_indent        == rhs.body_indent      &&
+           lhs.name_indent        == rhs.name_indent      &&
+           lhs.closing_indent     == rhs.closing_indent   ;
+}
+TOML11_INLINE bool operator!=(const table_format_info& lhs, const table_format_info& rhs) noexcept
+{
+    return !(lhs == rhs);
+}
+
+} // namespace toml
+#endif // TOML11_FORMAT_IMPL_HPP
+#endif
+
+#endif// TOML11_FORMAT_HPP
+#ifndef TOML11_DATETIME_HPP
+#define TOML11_DATETIME_HPP
+
+#ifndef TOML11_DATETIME_FWD_HPP
+#define TOML11_DATETIME_FWD_HPP
+
+#include <chrono>
+#include <iosfwd>
+#include <string>
+
+#include <cstdint>
+#include <cstdlib>
+#include <ctime>
+
+namespace toml
+{
+
+enum class month_t : std::uint8_t
+{
+    Jan =  0,
+    Feb =  1,
+    Mar =  2,
+    Apr =  3,
+    May =  4,
+    Jun =  5,
+    Jul =  6,
+    Aug =  7,
+    Sep =  8,
+    Oct =  9,
+    Nov = 10,
+    Dec = 11
+};
+
+// ----------------------------------------------------------------------------
+
+struct local_date
+{
+    std::int16_t year{0};   // A.D. (like, 2018)
+    std::uint8_t month{0};  // [0, 11]
+    std::uint8_t day{0};    // [1, 31]
+
+    local_date(int y, month_t m, int d)
+        : year {static_cast<std::int16_t>(y)},
+          month{static_cast<std::uint8_t>(m)},
+          day  {static_cast<std::uint8_t>(d)}
+    {}
+
+    explicit local_date(const std::tm& t)
+        : year {static_cast<std::int16_t>(t.tm_year + 1900)},
+          month{static_cast<std::uint8_t>(t.tm_mon)},
+          day  {static_cast<std::uint8_t>(t.tm_mday)}
+    {}
+
+    explicit local_date(const std::chrono::system_clock::time_point& tp);
+    explicit local_date(const std::time_t t);
+
+    operator std::chrono::system_clock::time_point() const;
+    operator std::time_t() const;
+
+    local_date() = default;
+    ~local_date() = default;
+    local_date(local_date const&) = default;
+    local_date(local_date&&)      = default;
+    local_date& operator=(local_date const&) = default;
+    local_date& operator=(local_date&&)      = default;
+};
+bool operator==(const local_date& lhs, const local_date& rhs);
+bool operator!=(const local_date& lhs, const local_date& rhs);
+bool operator< (const local_date& lhs, const local_date& rhs);
+bool operator<=(const local_date& lhs, const local_date& rhs);
+bool operator> (const local_date& lhs, const local_date& rhs);
+bool operator>=(const local_date& lhs, const local_date& rhs);
+
+std::ostream& operator<<(std::ostream& os, const local_date& date);
+std::string to_string(const local_date& date);
+
+// -----------------------------------------------------------------------------
+
+struct local_time
+{
+    std::uint8_t  hour{0};        // [0, 23]
+    std::uint8_t  minute{0};      // [0, 59]
+    std::uint8_t  second{0};      // [0, 60]
+    std::uint16_t millisecond{0}; // [0, 999]
+    std::uint16_t microsecond{0}; // [0, 999]
+    std::uint16_t nanosecond{0};  // [0, 999]
+
+    local_time(int h, int m, int s,
+               int ms = 0, int us = 0, int ns = 0)
+        : hour  {static_cast<std::uint8_t>(h)},
+          minute{static_cast<std::uint8_t>(m)},
+          second{static_cast<std::uint8_t>(s)},
+          millisecond{static_cast<std::uint16_t>(ms)},
+          microsecond{static_cast<std::uint16_t>(us)},
+          nanosecond {static_cast<std::uint16_t>(ns)}
+    {}
+
+    explicit local_time(const std::tm& t)
+        : hour  {static_cast<std::uint8_t>(t.tm_hour)},
+          minute{static_cast<std::uint8_t>(t.tm_min )},
+          second{static_cast<std::uint8_t>(t.tm_sec )},
+          millisecond{0}, microsecond{0}, nanosecond{0}
+    {}
+
+    template<typename Rep, typename Period>
+    explicit local_time(const std::chrono::duration<Rep, Period>& t)
+    {
+        const auto h = std::chrono::duration_cast<std::chrono::hours>(t);
+        this->hour = static_cast<std::uint8_t>(h.count());
+        const auto t2 = t - h;
+        const auto m = std::chrono::duration_cast<std::chrono::minutes>(t2);
+        this->minute = static_cast<std::uint8_t>(m.count());
+        const auto t3 = t2 - m;
+        const auto s = std::chrono::duration_cast<std::chrono::seconds>(t3);
+        this->second = static_cast<std::uint8_t>(s.count());
+        const auto t4 = t3 - s;
+        const auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(t4);
+        this->millisecond = static_cast<std::uint16_t>(ms.count());
+        const auto t5 = t4 - ms;
+        const auto us = std::chrono::duration_cast<std::chrono::microseconds>(t5);
+        this->microsecond = static_cast<std::uint16_t>(us.count());
+        const auto t6 = t5 - us;
+        const auto ns = std::chrono::duration_cast<std::chrono::nanoseconds>(t6);
+        this->nanosecond = static_cast<std::uint16_t>(ns.count());
+    }
+
+    operator std::chrono::nanoseconds() const;
+
+    local_time() = default;
+    ~local_time() = default;
+    local_time(local_time const&) = default;
+    local_time(local_time&&)      = default;
+    local_time& operator=(local_time const&) = default;
+    local_time& operator=(local_time&&)      = default;
+};
+
+bool operator==(const local_time& lhs, const local_time& rhs);
+bool operator!=(const local_time& lhs, const local_time& rhs);
+bool operator< (const local_time& lhs, const local_time& rhs);
+bool operator<=(const local_time& lhs, const local_time& rhs);
+bool operator> (const local_time& lhs, const local_time& rhs);
+bool operator>=(const local_time& lhs, const local_time& rhs);
+
+std::ostream& operator<<(std::ostream& os, const local_time& time);
+std::string to_string(const local_time& time);
+
+// ----------------------------------------------------------------------------
+
+struct time_offset
+{
+    std::int8_t hour{0};   // [-12, 12]
+    std::int8_t minute{0}; // [-59, 59]
+
+    time_offset(int h, int m)
+        : hour  {static_cast<std::int8_t>(h)},
+          minute{static_cast<std::int8_t>(m)}
+    {}
+
+    operator std::chrono::minutes() const;
+
+    time_offset() = default;
+    ~time_offset() = default;
+    time_offset(time_offset const&) = default;
+    time_offset(time_offset&&)      = default;
+    time_offset& operator=(time_offset const&) = default;
+    time_offset& operator=(time_offset&&)      = default;
+};
+
+bool operator==(const time_offset& lhs, const time_offset& rhs);
+bool operator!=(const time_offset& lhs, const time_offset& rhs);
+bool operator< (const time_offset& lhs, const time_offset& rhs);
+bool operator<=(const time_offset& lhs, const time_offset& rhs);
+bool operator> (const time_offset& lhs, const time_offset& rhs);
+bool operator>=(const time_offset& lhs, const time_offset& rhs);
+
+std::ostream& operator<<(std::ostream& os, const time_offset& offset);
+
+std::string to_string(const time_offset& offset);
+
+// -----------------------------------------------------------------------------
+
+struct local_datetime
+{
+    local_date date{};
+    local_time time{};
+
+    local_datetime(local_date d, local_time t): date{d}, time{t} {}
+
+    explicit local_datetime(const std::tm& t): date{t}, time{t}{}
+
+    explicit local_datetime(const std::chrono::system_clock::time_point& tp);
+    explicit local_datetime(const std::time_t t);
+
+    operator std::chrono::system_clock::time_point() const;
+    operator std::time_t() const;
+
+    local_datetime() = default;
+    ~local_datetime() = default;
+    local_datetime(local_datetime const&) = default;
+    local_datetime(local_datetime&&)      = default;
+    local_datetime& operator=(local_datetime const&) = default;
+    local_datetime& operator=(local_datetime&&)      = default;
+};
+
+bool operator==(const local_datetime& lhs, const local_datetime& rhs);
+bool operator!=(const local_datetime& lhs, const local_datetime& rhs);
+bool operator< (const local_datetime& lhs, const local_datetime& rhs);
+bool operator<=(const local_datetime& lhs, const local_datetime& rhs);
+bool operator> (const local_datetime& lhs, const local_datetime& rhs);
+bool operator>=(const local_datetime& lhs, const local_datetime& rhs);
+
+std::ostream& operator<<(std::ostream& os, const local_datetime& dt);
+
+std::string to_string(const local_datetime& dt);
+
+// -----------------------------------------------------------------------------
+
+struct offset_datetime
+{
+    local_date  date{};
+    local_time  time{};
+    time_offset offset{};
+
+    offset_datetime(local_date d, local_time t, time_offset o)
+        : date{d}, time{t}, offset{o}
+    {}
+    offset_datetime(const local_datetime& dt, time_offset o)
+        : date{dt.date}, time{dt.time}, offset{o}
+    {}
+    // use the current local timezone offset
+    explicit offset_datetime(const local_datetime& ld);
+    explicit offset_datetime(const std::chrono::system_clock::time_point& tp);
+    explicit offset_datetime(const std::time_t& t);
+    explicit offset_datetime(const std::tm& t);
+
+    operator std::chrono::system_clock::time_point() const;
+
+    operator std::time_t() const;
+
+    offset_datetime() = default;
+    ~offset_datetime() = default;
+    offset_datetime(offset_datetime const&) = default;
+    offset_datetime(offset_datetime&&)      = default;
+    offset_datetime& operator=(offset_datetime const&) = default;
+    offset_datetime& operator=(offset_datetime&&)      = default;
+
+  private:
+
+    static time_offset get_local_offset(const std::time_t* tp);
+};
+
+bool operator==(const offset_datetime& lhs, const offset_datetime& rhs);
+bool operator!=(const offset_datetime& lhs, const offset_datetime& rhs);
+bool operator< (const offset_datetime& lhs, const offset_datetime& rhs);
+bool operator<=(const offset_datetime& lhs, const offset_datetime& rhs);
+bool operator> (const offset_datetime& lhs, const offset_datetime& rhs);
+bool operator>=(const offset_datetime& lhs, const offset_datetime& rhs);
+
+std::ostream& operator<<(std::ostream& os, const offset_datetime& dt);
+
+std::string to_string(const offset_datetime& dt);
+
+}//toml
+#endif // TOML11_DATETIME_FWD_HPP
+
+#if ! defined(TOML11_COMPILE_SOURCES)
+#ifndef TOML11_DATETIME_IMPL_HPP
+#define TOML11_DATETIME_IMPL_HPP
+
+
+#include <array>
+#include <iomanip>
+#include <ostream>
+#include <sstream>
+#include <tuple>
+
+#include <cstdlib>
+#include <ctime>
+
+namespace toml
+{
+
+// To avoid non-threadsafe std::localtime. In C11 (not C++11!), localtime_s is
+// provided in the absolutely same purpose, but C++11 is actually not compatible
+// with C11. We need to dispatch the function depending on the OS.
+namespace detail
+{
+// TODO: find more sophisticated way to handle this
+#if defined(_MSC_VER)
+TOML11_INLINE std::tm localtime_s(const std::time_t* src)
+{
+    std::tm dst;
+    const auto result = ::localtime_s(&dst, src);
+    if (result) { throw std::runtime_error("localtime_s failed."); }
+    return dst;
+}
+TOML11_INLINE std::tm gmtime_s(const std::time_t* src)
+{
+    std::tm dst;
+    const auto result = ::gmtime_s(&dst, src);
+    if (result) { throw std::runtime_error("gmtime_s failed."); }
+    return dst;
+}
+#elif (defined(_POSIX_C_SOURCE) && _POSIX_C_SOURCE >= 1) || defined(_XOPEN_SOURCE) || defined(_BSD_SOURCE) || defined(_SVID_SOURCE) || defined(_POSIX_SOURCE)
+TOML11_INLINE std::tm localtime_s(const std::time_t* src)
+{
+    std::tm dst;
+    const auto result = ::localtime_r(src, &dst);
+    if (!result) { throw std::runtime_error("localtime_r failed."); }
+    return dst;
+}
+TOML11_INLINE std::tm gmtime_s(const std::time_t* src)
+{
+    std::tm dst;
+    const auto result = ::gmtime_r(src, &dst);
+    if (!result) { throw std::runtime_error("gmtime_r failed."); }
+    return dst;
+}
+#else // fallback. not threadsafe
+TOML11_INLINE std::tm localtime_s(const std::time_t* src)
+{
+    const auto result = std::localtime(src);
+    if (!result) { throw std::runtime_error("localtime failed."); }
+    return *result;
+}
+TOML11_INLINE std::tm gmtime_s(const std::time_t* src)
+{
+    const auto result = std::gmtime(src);
+    if (!result) { throw std::runtime_error("gmtime failed."); }
+    return *result;
+}
+#endif
+} // detail
+
+// ----------------------------------------------------------------------------
+
+TOML11_INLINE local_date::local_date(const std::chrono::system_clock::time_point& tp)
+{
+    const auto t    = std::chrono::system_clock::to_time_t(tp);
+    const auto time = detail::localtime_s(&t);
+    *this = local_date(time);
+}
+
+TOML11_INLINE local_date::local_date(const std::time_t t)
+    : local_date{std::chrono::system_clock::from_time_t(t)}
+{}
+
+TOML11_INLINE local_date::operator std::chrono::system_clock::time_point() const
+{
+    // std::mktime returns date as local time zone. no conversion needed
+    std::tm t;
+    t.tm_sec   = 0;
+    t.tm_min   = 0;
+    t.tm_hour  = 0;
+    t.tm_mday  = static_cast<int>(this->day);
+    t.tm_mon   = static_cast<int>(this->month);
+    t.tm_year  = static_cast<int>(this->year) - 1900;
+    t.tm_wday  = 0; // the value will be ignored
+    t.tm_yday  = 0; // the value will be ignored
+    t.tm_isdst = -1;
+    return std::chrono::system_clock::from_time_t(std::mktime(&t));
+}
+
+TOML11_INLINE local_date::operator std::time_t() const
+{
+    return std::chrono::system_clock::to_time_t(
+            std::chrono::system_clock::time_point(*this));
+}
+
+TOML11_INLINE bool operator==(const local_date& lhs, const local_date& rhs)
+{
+    return std::make_tuple(lhs.year, lhs.month, lhs.day) ==
+           std::make_tuple(rhs.year, rhs.month, rhs.day);
+}
+TOML11_INLINE bool operator!=(const local_date& lhs, const local_date& rhs)
+{
+    return !(lhs == rhs);
+}
+TOML11_INLINE bool operator< (const local_date& lhs, const local_date& rhs)
+{
+    return std::make_tuple(lhs.year, lhs.month, lhs.day) <
+           std::make_tuple(rhs.year, rhs.month, rhs.day);
+}
+TOML11_INLINE bool operator<=(const local_date& lhs, const local_date& rhs)
+{
+    return (lhs < rhs) || (lhs == rhs);
+}
+TOML11_INLINE bool operator> (const local_date& lhs, const local_date& rhs)
+{
+    return !(lhs <= rhs);
+}
+TOML11_INLINE bool operator>=(const local_date& lhs, const local_date& rhs)
+{
+    return !(lhs < rhs);
+}
+
+TOML11_INLINE std::ostream& operator<<(std::ostream& os, const local_date& date)
+{
+    os << std::setfill('0') << std::setw(4) << static_cast<int>(date.year )     << '-';
+    os << std::setfill('0') << std::setw(2) << static_cast<int>(date.month) + 1 << '-';
+    os << std::setfill('0') << std::setw(2) << static_cast<int>(date.day  )    ;
+    return os;
+}
+
+TOML11_INLINE std::string to_string(const local_date& date)
+{
+    std::ostringstream oss;
+    oss.imbue(std::locale::classic());
+    oss << date;
+    return oss.str();
+}
+
+// -----------------------------------------------------------------------------
+
+TOML11_INLINE local_time::operator std::chrono::nanoseconds() const
+{
+    return std::chrono::nanoseconds (this->nanosecond)  +
+           std::chrono::microseconds(this->microsecond) +
+           std::chrono::milliseconds(this->millisecond) +
+           std::chrono::seconds(this->second) +
+           std::chrono::minutes(this->minute) +
+           std::chrono::hours(this->hour);
+}
+
+TOML11_INLINE bool operator==(const local_time& lhs, const local_time& rhs)
+{
+    return std::make_tuple(lhs.hour, lhs.minute, lhs.second, lhs.millisecond, lhs.microsecond, lhs.nanosecond) ==
+           std::make_tuple(rhs.hour, rhs.minute, rhs.second, rhs.millisecond, rhs.microsecond, rhs.nanosecond);
+}
+TOML11_INLINE bool operator!=(const local_time& lhs, const local_time& rhs)
+{
+    return !(lhs == rhs);
+}
+TOML11_INLINE bool operator< (const local_time& lhs, const local_time& rhs)
+{
+    return std::make_tuple(lhs.hour, lhs.minute, lhs.second, lhs.millisecond, lhs.microsecond, lhs.nanosecond) <
+           std::make_tuple(rhs.hour, rhs.minute, rhs.second, rhs.millisecond, rhs.microsecond, rhs.nanosecond);
+}
+TOML11_INLINE bool operator<=(const local_time& lhs, const local_time& rhs)
+{
+    return (lhs < rhs) || (lhs == rhs);
+}
+TOML11_INLINE bool operator> (const local_time& lhs, const local_time& rhs)
+{
+    return !(lhs <= rhs);
+}
+TOML11_INLINE bool operator>=(const local_time& lhs, const local_time& rhs)
+{
+    return !(lhs < rhs);
+}
+
+TOML11_INLINE std::ostream& operator<<(std::ostream& os, const local_time& time)
+{
+    os << std::setfill('0') << std::setw(2) << static_cast<int>(time.hour  ) << ':';
+    os << std::setfill('0') << std::setw(2) << static_cast<int>(time.minute) << ':';
+    os << std::setfill('0') << std::setw(2) << static_cast<int>(time.second);
+    if(time.millisecond != 0 || time.microsecond != 0 || time.nanosecond != 0)
+    {
+        os << '.';
+        os << std::setfill('0') << std::setw(3) << static_cast<int>(time.millisecond);
+        if(time.microsecond != 0 || time.nanosecond != 0)
+        {
+            os << std::setfill('0') << std::setw(3) << static_cast<int>(time.microsecond);
+            if(time.nanosecond != 0)
+            {
+                os << std::setfill('0') << std::setw(3) << static_cast<int>(time.nanosecond);
+            }
+        }
+    }
+    return os;
+}
+
+TOML11_INLINE std::string to_string(const local_time& time)
+{
+    std::ostringstream oss;
+    oss.imbue(std::locale::classic());
+    oss << time;
+    return oss.str();
+}
+
+// ----------------------------------------------------------------------------
+
+TOML11_INLINE time_offset::operator std::chrono::minutes() const
+{
+    return std::chrono::minutes(this->minute) +
+           std::chrono::hours(this->hour);
+}
+
+TOML11_INLINE bool operator==(const time_offset& lhs, const time_offset& rhs)
+{
+    return std::make_tuple(lhs.hour, lhs.minute) ==
+           std::make_tuple(rhs.hour, rhs.minute);
+}
+TOML11_INLINE bool operator!=(const time_offset& lhs, const time_offset& rhs)
+{
+    return !(lhs == rhs);
+}
+TOML11_INLINE bool operator< (const time_offset& lhs, const time_offset& rhs)
+{
+    return std::make_tuple(lhs.hour, lhs.minute) <
+           std::make_tuple(rhs.hour, rhs.minute);
+}
+TOML11_INLINE bool operator<=(const time_offset& lhs, const time_offset& rhs)
+{
+    return (lhs < rhs) || (lhs == rhs);
+}
+TOML11_INLINE bool operator> (const time_offset& lhs, const time_offset& rhs)
+{
+    return !(lhs <= rhs);
+}
+TOML11_INLINE bool operator>=(const time_offset& lhs, const time_offset& rhs)
+{
+    return !(lhs < rhs);
+}
+
+TOML11_INLINE std::ostream& operator<<(std::ostream& os, const time_offset& offset)
+{
+    if(offset.hour == 0 && offset.minute == 0)
+    {
+        os << 'Z';
+        return os;
+    }
+    int minute = static_cast<int>(offset.hour) * 60 + offset.minute;
+    if(minute < 0){os << '-'; minute = std::abs(minute);} else {os << '+';}
+    os << std::setfill('0') << std::setw(2) << minute / 60 << ':';
+    os << std::setfill('0') << std::setw(2) << minute % 60;
+    return os;
+}
+
+TOML11_INLINE std::string to_string(const time_offset& offset)
+{
+    std::ostringstream oss;
+    oss.imbue(std::locale::classic());
+    oss << offset;
+    return oss.str();
+}
+
+// -----------------------------------------------------------------------------
+
+TOML11_INLINE local_datetime::local_datetime(const std::chrono::system_clock::time_point& tp)
+{
+    const auto t = std::chrono::system_clock::to_time_t(tp);
+    std::tm ltime = detail::localtime_s(&t);
+
+    this->date = local_date(ltime);
+    this->time = local_time(ltime);
+
+    // std::tm lacks subsecond information, so diff between tp and tm
+    // can be used to get millisecond & microsecond information.
+    const auto t_diff = tp -
+        std::chrono::system_clock::from_time_t(std::mktime(&ltime));
+    this->time.millisecond = static_cast<std::uint16_t>(
+      std::chrono::duration_cast<std::chrono::milliseconds>(t_diff).count());
+    this->time.microsecond = static_cast<std::uint16_t>(
+      std::chrono::duration_cast<std::chrono::microseconds>(t_diff).count());
+    this->time.nanosecond = static_cast<std::uint16_t>(
+      std::chrono::duration_cast<std::chrono::nanoseconds >(t_diff).count());
+}
+
+TOML11_INLINE local_datetime::local_datetime(const std::time_t t)
+    : local_datetime{std::chrono::system_clock::from_time_t(t)}
+{}
+
+TOML11_INLINE local_datetime::operator std::chrono::system_clock::time_point() const
+{
+    using internal_duration =
+        typename std::chrono::system_clock::time_point::duration;
+
+    // Normally DST begins at A.M. 3 or 4. If we re-use conversion operator
+    // of local_date and local_time independently, the conversion fails if
+    // it is the day when DST begins or ends. Since local_date considers the
+    // time is 00:00 A.M. and local_time does not consider DST because it
+    // does not have any date information. We need to consider both date and
+    // time information at the same time to convert it correctly.
+
+    std::tm t;
+    t.tm_sec   = static_cast<int>(this->time.second);
+    t.tm_min   = static_cast<int>(this->time.minute);
+    t.tm_hour  = static_cast<int>(this->time.hour);
+    t.tm_mday  = static_cast<int>(this->date.day);
+    t.tm_mon   = static_cast<int>(this->date.month);
+    t.tm_year  = static_cast<int>(this->date.year) - 1900;
+    t.tm_wday  = 0; // the value will be ignored
+    t.tm_yday  = 0; // the value will be ignored
+    t.tm_isdst = -1;
+
+    // std::mktime returns date as local time zone. no conversion needed
+    auto dt = std::chrono::system_clock::from_time_t(std::mktime(&t));
+    dt += std::chrono::duration_cast<internal_duration>(
+            std::chrono::milliseconds(this->time.millisecond) +
+            std::chrono::microseconds(this->time.microsecond) +
+            std::chrono::nanoseconds (this->time.nanosecond));
+    return dt;
+}
+
+TOML11_INLINE local_datetime::operator std::time_t() const
+{
+    return std::chrono::system_clock::to_time_t(
+            std::chrono::system_clock::time_point(*this));
+}
+
+TOML11_INLINE bool operator==(const local_datetime& lhs, const local_datetime& rhs)
+{
+    return std::make_tuple(lhs.date, lhs.time) ==
+           std::make_tuple(rhs.date, rhs.time);
+}
+TOML11_INLINE bool operator!=(const local_datetime& lhs, const local_datetime& rhs)
+{
+    return !(lhs == rhs);
+}
+TOML11_INLINE bool operator< (const local_datetime& lhs, const local_datetime& rhs)
+{
+    return std::make_tuple(lhs.date, lhs.time) <
+           std::make_tuple(rhs.date, rhs.time);
+}
+TOML11_INLINE bool operator<=(const local_datetime& lhs, const local_datetime& rhs)
+{
+    return (lhs < rhs) || (lhs == rhs);
+}
+TOML11_INLINE bool operator> (const local_datetime& lhs, const local_datetime& rhs)
+{
+    return !(lhs <= rhs);
+}
+TOML11_INLINE bool operator>=(const local_datetime& lhs, const local_datetime& rhs)
+{
+    return !(lhs < rhs);
+}
+
+TOML11_INLINE std::ostream& operator<<(std::ostream& os, const local_datetime& dt)
+{
+    os << dt.date << 'T' << dt.time;
+    return os;
+}
+
+TOML11_INLINE std::string to_string(const local_datetime& dt)
+{
+    std::ostringstream oss;
+    oss.imbue(std::locale::classic());
+    oss << dt;
+    return oss.str();
+}
+
+// -----------------------------------------------------------------------------
+
+
+TOML11_INLINE offset_datetime::offset_datetime(const local_datetime& ld)
+    : date{ld.date}, time{ld.time}, offset{get_local_offset(nullptr)}
+      // use the current local timezone offset
+{}
+TOML11_INLINE offset_datetime::offset_datetime(const std::chrono::system_clock::time_point& tp)
+    : offset{0, 0} // use gmtime
+{
+    const auto timet = std::chrono::system_clock::to_time_t(tp);
+    const auto tm    = detail::gmtime_s(&timet);
+    this->date = local_date(tm);
+    this->time = local_time(tm);
+}
+TOML11_INLINE offset_datetime::offset_datetime(const std::time_t& t)
+    : offset{0, 0} // use gmtime
+{
+    const auto tm    = detail::gmtime_s(&t);
+    this->date = local_date(tm);
+    this->time = local_time(tm);
+}
+TOML11_INLINE offset_datetime::offset_datetime(const std::tm& t)
+    : offset{0, 0} // assume gmtime
+{
+    this->date = local_date(t);
+    this->time = local_time(t);
+}
+
+TOML11_INLINE offset_datetime::operator std::chrono::system_clock::time_point() const
+{
+    // get date-time
+    using internal_duration =
+        typename std::chrono::system_clock::time_point::duration;
+
+    // first, convert it to local date-time information in the same way as
+    // local_datetime does. later we will use time_t to adjust time offset.
+    std::tm t;
+    t.tm_sec   = static_cast<int>(this->time.second);
+    t.tm_min   = static_cast<int>(this->time.minute);
+    t.tm_hour  = static_cast<int>(this->time.hour);
+    t.tm_mday  = static_cast<int>(this->date.day);
+    t.tm_mon   = static_cast<int>(this->date.month);
+    t.tm_year  = static_cast<int>(this->date.year) - 1900;
+    t.tm_wday  = 0; // the value will be ignored
+    t.tm_yday  = 0; // the value will be ignored
+    t.tm_isdst = -1;
+    const std::time_t tp_loc = std::mktime(std::addressof(t));
+
+    auto tp = std::chrono::system_clock::from_time_t(tp_loc);
+    tp += std::chrono::duration_cast<internal_duration>(
+            std::chrono::milliseconds(this->time.millisecond) +
+            std::chrono::microseconds(this->time.microsecond) +
+            std::chrono::nanoseconds (this->time.nanosecond));
+
+    // Since mktime uses local time zone, it should be corrected.
+    // `12:00:00+09:00` means `03:00:00Z`. So mktime returns `03:00:00Z` if
+    // we are in `+09:00` timezone. To represent `12:00:00Z` there, we need
+    // to add `+09:00` to `03:00:00Z`.
+    //    Here, it uses the time_t converted from date-time info to handle
+    // daylight saving time.
+    const auto ofs = get_local_offset(std::addressof(tp_loc));
+    tp += std::chrono::hours  (ofs.hour);
+    tp += std::chrono::minutes(ofs.minute);
+
+    // We got `12:00:00Z` by correcting local timezone applied by mktime.
+    // Then we will apply the offset. Let's say `12:00:00-08:00` is given.
+    // And now, we have `12:00:00Z`. `12:00:00-08:00` means `20:00:00Z`.
+    // So we need to subtract the offset.
+    tp -= std::chrono::minutes(this->offset);
+    return tp;
+}
+
+TOML11_INLINE offset_datetime::operator std::time_t() const
+{
+    return std::chrono::system_clock::to_time_t(
+            std::chrono::system_clock::time_point(*this));
+}
+
+TOML11_INLINE time_offset offset_datetime::get_local_offset(const std::time_t* tp)
+{
+    // get local timezone with the same date-time information as mktime
+    const auto t = detail::localtime_s(tp);
+
+    std::array<char, 6> buf;
+    const auto result = std::strftime(buf.data(), 6, "%z", &t); // +hhmm\0
+    if(result != 5)
+    {
+        throw std::runtime_error("toml::offset_datetime: cannot obtain "
+                                 "timezone information of current env");
+    }
+    const int ofs = std::atoi(buf.data());
+    const int ofs_h = ofs / 100;
+    const int ofs_m = ofs - (ofs_h * 100);
+    return time_offset(ofs_h, ofs_m);
+}
+
+TOML11_INLINE bool operator==(const offset_datetime& lhs, const offset_datetime& rhs)
+{
+    return std::make_tuple(lhs.date, lhs.time, lhs.offset) ==
+           std::make_tuple(rhs.date, rhs.time, rhs.offset);
+}
+TOML11_INLINE bool operator!=(const offset_datetime& lhs, const offset_datetime& rhs)
+{
+    return !(lhs == rhs);
+}
+TOML11_INLINE bool operator< (const offset_datetime& lhs, const offset_datetime& rhs)
+{
+    return std::make_tuple(lhs.date, lhs.time, lhs.offset) <
+           std::make_tuple(rhs.date, rhs.time, rhs.offset);
+}
+TOML11_INLINE bool operator<=(const offset_datetime& lhs, const offset_datetime& rhs)
+{
+    return (lhs < rhs) || (lhs == rhs);
+}
+TOML11_INLINE bool operator> (const offset_datetime& lhs, const offset_datetime& rhs)
+{
+    return !(lhs <= rhs);
+}
+TOML11_INLINE bool operator>=(const offset_datetime& lhs, const offset_datetime& rhs)
+{
+    return !(lhs < rhs);
+}
+
+TOML11_INLINE std::ostream& operator<<(std::ostream& os, const offset_datetime& dt)
+{
+    os << dt.date << 'T' << dt.time << dt.offset;
+    return os;
+}
+
+TOML11_INLINE std::string to_string(const offset_datetime& dt)
+{
+    std::ostringstream oss;
+    oss.imbue(std::locale::classic());
+    oss << dt;
+    return oss.str();
+}
+
+}//toml
+#endif // TOML11_DATETIME_IMPL_HPP
+#endif
+
+#endif // TOML11_DATETIME_HPP
+#ifndef TOML11_COMPAT_HPP
+#define TOML11_COMPAT_HPP
+
+
+#include <algorithm>
+#include <iterator>
+#include <memory>
+#include <string>
+#include <type_traits>
+
+#include <cassert>
+
+#if TOML11_CPLUSPLUS_STANDARD_VERSION >= TOML11_CXX20_VALUE
+#  if __has_include(<bit>)
+#    include <bit>
+#  endif
+#endif
+
+#include <cstring>
+
+// ----------------------------------------------------------------------------
+
+#if TOML11_CPLUSPLUS_STANDARD_VERSION >= TOML11_CXX14_VALUE
+#  if __has_cpp_attribute(deprecated)
+#    define TOML11_HAS_ATTR_DEPRECATED 1
+#  endif
+#endif
+
+#if defined(TOML11_HAS_ATTR_DEPRECATED)
+#  define TOML11_DEPRECATED(msg) [[deprecated(msg)]]
+#elif defined(__GNUC__)
+#  define TOML11_DEPRECATED(msg) __attribute__((deprecated(msg)))
+#elif defined(_MSC_VER)
+#  define TOML11_DEPRECATED(msg) __declspec(deprecated(msg))
+#else
+#  define TOML11_DEPRECATED(msg)
+#endif
+
+// ----------------------------------------------------------------------------
+
+#if defined(__cpp_if_constexpr)
+#  if __cpp_if_constexpr >= 201606L
+#    define TOML11_HAS_CONSTEXPR_IF 1
+#  endif
+#endif
+
+#if defined(TOML11_HAS_CONSTEXPR_IF)
+#  define TOML11_CONSTEXPR_IF if constexpr
+#else
+#  define TOML11_CONSTEXPR_IF if
+#endif
+
+// ----------------------------------------------------------------------------
+
+#if TOML11_CPLUSPLUS_STANDARD_VERSION >= TOML11_CXX14_VALUE
+#  if defined(__cpp_lib_make_unique)
+#    if __cpp_lib_make_unique >= 201304L
+#      define TOML11_HAS_STD_MAKE_UNIQUE 1
+#    endif
+#  endif
+#endif
+
+namespace toml
+{
+namespace cxx
+{
+
+#if defined(TOML11_HAS_STD_MAKE_UNIQUE)
+
+using std::make_unique;
+
+#else
+
+template<typename T, typename ... Ts>
+std::unique_ptr<T> make_unique(Ts&& ... args)
+{
+    return std::unique_ptr<T>(new T(std::forward<Ts>(args)...));
+}
+
+#endif // TOML11_HAS_STD_MAKE_UNIQUE
+
+} // cxx
+} // toml
+
+// ---------------------------------------------------------------------------
+
+#if TOML11_CPLUSPLUS_STANDARD_VERSION >= TOML11_CXX14_VALUE
+#  if defined(__cpp_lib_make_reverse_iterator)
+#    if __cpp_lib_make_reverse_iterator >= 201402L
+#      define TOML11_HAS_STD_MAKE_REVERSE_ITERATOR 1
+#    endif
+#  endif
+#endif
+
+namespace toml
+{
+namespace cxx
+{
+# if defined(TOML11_HAS_STD_MAKE_REVERSE_ITERATOR)
+
+using std::make_reverse_iterator;
+
+#else
+
+template<typename Iterator>
+std::reverse_iterator<Iterator> make_reverse_iterator(Iterator iter)
+{
+    return std::reverse_iterator<Iterator>(iter);
+}
+
+#endif // TOML11_HAS_STD_MAKE_REVERSE_ITERATOR
+
+} // cxx
+} // toml
+
+// ---------------------------------------------------------------------------
+
+#if TOML11_CPLUSPLUS_STANDARD_VERSION >= TOML11_CXX20_VALUE
+#  if defined(__cpp_lib_clamp)
+#    if __cpp_lib_clamp >= 201603L
+#      define TOML11_HAS_STD_CLAMP 1
+#    endif
+#  endif
+#endif
+
+namespace toml
+{
+namespace cxx
+{
+#if defined(TOML11_HAS_STD_CLAMP)
+
+using std::clamp;
+
+#else
+
+template<typename T>
+T clamp(const T& x, const T& low, const T& high) noexcept
+{
+    assert(low <= high);
+    return (std::min)((std::max)(x, low), high);
+}
+
+#endif // TOML11_HAS_STD_CLAMP
+
+} // cxx
+} // toml
+
+// ---------------------------------------------------------------------------
+
+#if TOML11_CPLUSPLUS_STANDARD_VERSION >= TOML11_CXX20_VALUE
+#  if defined(__cpp_lib_bit_cast)
+#    if __cpp_lib_bit_cast >= 201806L
+#      define TOML11_HAS_STD_BIT_CAST 1
+#    endif
+#  endif
+#endif
+
+namespace toml
+{
+namespace cxx
+{
+#if defined(TOML11_HAS_STD_BIT_CAST)
+
+using std::bit_cast;
+
+#else
+
+template<typename U, typename T>
+U bit_cast(const T& x) noexcept
+{
+    static_assert(sizeof(T) == sizeof(U), "");
+    static_assert(std::is_default_constructible<T>::value, "");
+
+    U z;
+    std::memcpy(reinterpret_cast<char*>(std::addressof(z)),
+                reinterpret_cast<const char*>(std::addressof(x)),
+                sizeof(T));
+
+    return z;
+}
+
+#endif // TOML11_HAS_STD_BIT_CAST
+
+} // cxx
+} // toml
+
+// ---------------------------------------------------------------------------
+// C++20 remove_cvref_t
+
+#if TOML11_CPLUSPLUS_STANDARD_VERSION >= TOML11_CXX20_VALUE
+#  if defined(__cpp_lib_remove_cvref)
+#    if __cpp_lib_remove_cvref >= 201711L
+#      define TOML11_HAS_STD_REMOVE_CVREF 1
+#    endif
+#  endif
+#endif
+
+namespace toml
+{
+namespace cxx
+{
+#if defined(TOML11_HAS_STD_REMOVE_CVREF)
+
+using std::remove_cvref;
+using std::remove_cvref_t;
+
+#else
+
+template<typename T>
+struct remove_cvref
+{
+    using type = typename std::remove_cv<
+        typename std::remove_reference<T>::type>::type;
+};
+
+template<typename T>
+using remove_cvref_t = typename remove_cvref<T>::type;
+
+#endif // TOML11_HAS_STD_REMOVE_CVREF
+
+} // cxx
+} // toml
+
+// ---------------------------------------------------------------------------
+// C++17 and/or/not
+
+#if TOML11_CPLUSPLUS_STANDARD_VERSION >= TOML11_CXX17_VALUE
+#  if defined(__cpp_lib_logical_traits)
+#    if __cpp_lib_logical_traits >= 201510L
+#      define TOML11_HAS_STD_CONJUNCTION 1
+#    endif
+#  endif
+#endif
+
+namespace toml
+{
+namespace cxx
+{
+#if defined(TOML11_HAS_STD_CONJUNCTION)
+
+using std::conjunction;
+using std::disjunction;
+using std::negation;
+
+#else
+
+template<typename ...> struct conjunction : std::true_type{};
+template<typename T>   struct conjunction<T> : T{};
+template<typename T, typename ... Ts>
+struct conjunction<T, Ts...> :
+    std::conditional<static_cast<bool>(T::value), conjunction<Ts...>, T>::type
+{};
+
+template<typename ...> struct disjunction : std::false_type{};
+template<typename T>   struct disjunction<T> : T {};
+template<typename T, typename ... Ts>
+struct disjunction<T, Ts...> :
+    std::conditional<static_cast<bool>(T::value), T, disjunction<Ts...>>::type
+{};
+
+template<typename T>
+struct negation : std::integral_constant<bool, !static_cast<bool>(T::value)>{};
+
+#endif // TOML11_HAS_STD_CONJUNCTION
+
+} // cxx
+} // toml
+
+// ---------------------------------------------------------------------------
+// C++14 index_sequence
+
+#if TOML11_CPLUSPLUS_STANDARD_VERSION >= TOML11_CXX14_VALUE
+#  if defined(__cpp_lib_integer_sequence)
+#    if __cpp_lib_integer_sequence >= 201304L
+#      define TOML11_HAS_STD_INTEGER_SEQUENCE 1
+#    endif
+#  endif
+#endif
+
+namespace toml
+{
+namespace cxx
+{
+#if defined(TOML11_HAS_STD_INTEGER_SEQUENCE)
+
+using std::index_sequence;
+using std::make_index_sequence;
+
+#else
+
+template<std::size_t ... Ns> struct index_sequence{};
+
+template<bool B, std::size_t N, typename T>
+struct double_index_sequence;
+
+template<std::size_t N, std::size_t ... Is>
+struct double_index_sequence<true, N, index_sequence<Is...>>
+{
+    using type = index_sequence<Is..., (Is+N)..., N*2>;
+};
+template<std::size_t N, std::size_t ... Is>
+struct double_index_sequence<false, N, index_sequence<Is...>>
+{
+    using type = index_sequence<Is..., (Is+N)...>;
+};
+
+template<std::size_t N>
+struct index_sequence_maker
+{
+    using type = typename double_index_sequence<
+            N % 2 == 1, N/2, typename index_sequence_maker<N/2>::type
+        >::type;
+};
+template<>
+struct index_sequence_maker<0>
+{
+    using type = index_sequence<>;
+};
+
+template<std::size_t N>
+using make_index_sequence = typename index_sequence_maker<N>::type;
+
+#endif // TOML11_HAS_STD_INTEGER_SEQUENCE
+
+} // cxx
+} // toml
+
+// ---------------------------------------------------------------------------
+// C++14 enable_if_t
+
+#if TOML11_CPLUSPLUS_STANDARD_VERSION >= TOML11_CXX14_VALUE
+#  if defined(__cpp_lib_transformation_trait_aliases)
+#    if __cpp_lib_transformation_trait_aliases >= 201304L
+#      define TOML11_HAS_STD_ENABLE_IF_T 1
+#    endif
+#  endif
+#endif
+
+namespace toml
+{
+namespace cxx
+{
+#if defined(TOML11_HAS_STD_ENABLE_IF_T)
+
+using std::enable_if_t;
+
+#else
+
+template<bool B, typename T>
+using enable_if_t = typename std::enable_if<B, T>::type;
+
+#endif // TOML11_HAS_STD_ENABLE_IF_T
+
+} // cxx
+} // toml
+
+// ---------------------------------------------------------------------------
+// return_type_of_t
+
+#if TOML11_CPLUSPLUS_STANDARD_VERSION >= TOML11_CXX17_VALUE
+#  if defined(__cpp_lib_is_invocable)
+#    if __cpp_lib_is_invocable >= 201703
+#      define TOML11_HAS_STD_INVOKE_RESULT 1
+#    endif
+#  endif
+#endif
+
+namespace toml
+{
+namespace cxx
+{
+#if defined(TOML11_HAS_STD_INVOKE_RESULT)
+
+template<typename F, typename ... Args>
+using return_type_of_t = std::invoke_result_t<F, Args...>;
+
+#else
+
+// result_of is deprecated after C++17
+template<typename F, typename ... Args>
+using return_type_of_t = typename std::result_of<F(Args...)>::type;
+
+#endif // TOML11_HAS_STD_INVOKE_RESULT
+
+} // cxx
+} // toml
+
+// ----------------------------------------------------------------------------
+// (subset of) source_location
+
+#if TOML11_CPLUSPLUS_STANDARD_VERSION >= 202002L
+#  if __has_include(<source_location>)
+#    define TOML11_HAS_STD_SOURCE_LOCATION
+#  endif // has_include
+#endif // c++20
+
+#if ! defined(TOML11_HAS_STD_SOURCE_LOCATION)
+#  if defined(__GNUC__) && ! defined(__clang__)
+#    if TOML11_CPLUSPLUS_STANDARD_VERSION >= TOML11_CXX14_VALUE
+#      if __has_include(<experimental/source_location>)
+#        define TOML11_HAS_EXPERIMENTAL_SOURCE_LOCATION
+#      endif
+#    endif
+#  endif // GNU g++
+#endif // not TOML11_HAS_STD_SOURCE_LOCATION
+
+#if ! defined(TOML11_HAS_STD_SOURCE_LOCATION) && ! defined(TOML11_HAS_EXPERIMENTAL_SOURCE_LOCATION)
+#  if defined(__GNUC__) && ! defined(__clang__)
+#    if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 9))
+#      define TOML11_HAS_BUILTIN_FILE_LINE 1
+#      define TOML11_BUILTIN_LINE_TYPE int
+#    endif
+#  elif defined(__clang__) // clang 9.0.0 implements builtin_FILE/LINE
+#    if __has_builtin(__builtin_FILE) && __has_builtin(__builtin_LINE)
+#      define TOML11_HAS_BUILTIN_FILE_LINE 1
+#      define TOML11_BUILTIN_LINE_TYPE unsigned int
+#    endif
+#  elif defined(_MSVC_LANG) && defined(_MSC_VER)
+#    if _MSC_VER > 1926
+#      define TOML11_HAS_BUILTIN_FILE_LINE 1
+#      define TOML11_BUILTIN_LINE_TYPE int
+#    endif
+#  endif
+#endif
+
+#if defined(TOML11_HAS_STD_SOURCE_LOCATION)
+#include <source_location>
+namespace toml
+{
+namespace cxx
+{
+using source_location = std::source_location;
+
+inline std::string to_string(const source_location& loc)
+{
+    return std::string(" at line ") + std::to_string(loc.line()) +
+           std::string(" in file ") + std::string(loc.file_name());
+}
+} // cxx
+} // toml
+#elif defined(TOML11_HAS_EXPERIMENTAL_SOURCE_LOCATION)
+#include <experimental/source_location>
+namespace toml
+{
+namespace cxx
+{
+using source_location = std::experimental::source_location;
+
+inline std::string to_string(const source_location& loc)
+{
+    return std::string(" at line ") + std::to_string(loc.line()) +
+           std::string(" in file ") + std::string(loc.file_name());
+}
+} // cxx
+} // toml
+#elif defined(TOML11_HAS_BUILTIN_FILE_LINE)
+namespace toml
+{
+namespace cxx
+{
+struct source_location
+{
+    using line_type = TOML11_BUILTIN_LINE_TYPE;
+    static source_location current(const line_type line = __builtin_LINE(),
+                                   const char*     file = __builtin_FILE())
+    {
+        return source_location(line, file);
+    }
+
+    source_location(const line_type line, const char* file)
+        : line_(line), file_name_(file)
+    {}
+
+    line_type   line()      const noexcept {return line_;}
+    const char* file_name() const noexcept {return file_name_;}
+
+  private:
+
+    line_type   line_;
+    const char* file_name_;
+};
+
+inline std::string to_string(const source_location& loc)
+{
+    return std::string(" at line ") + std::to_string(loc.line()) +
+           std::string(" in file ") + std::string(loc.file_name());
+}
+} // cxx
+} // toml
+#else // no builtin
+namespace toml
+{
+namespace cxx
+{
+struct source_location
+{
+    static source_location current() { return source_location{}; }
+};
+
+inline std::string to_string(const source_location&)
+{
+    return std::string("");
+}
+} // cxx
+} // toml
+#endif // TOML11_HAS_STD_SOURCE_LOCATION
+
+// ----------------------------------------------------------------------------
+// (subset of) optional
+
+#if TOML11_CPLUSPLUS_STANDARD_VERSION >= TOML11_CXX17_VALUE
+#  if __has_include(<optional>)
+#    include <optional>
+#  endif // has_include(optional)
+#endif // C++17
+
+#if TOML11_CPLUSPLUS_STANDARD_VERSION >= TOML11_CXX17_VALUE
+#  if defined(__cpp_lib_optional)
+#    if __cpp_lib_optional >= 201606L
+#      define TOML11_HAS_STD_OPTIONAL 1
+#    endif
+#  endif
+#endif
+
+#if defined(TOML11_HAS_STD_OPTIONAL)
+
+namespace toml
+{
+namespace cxx
+{
+using std::optional;
+
+inline std::nullopt_t make_nullopt() {return std::nullopt;}
+
+template<typename charT, typename traitsT>
+std::basic_ostream<charT, traitsT>&
+operator<<(std::basic_ostream<charT, traitsT>& os, const std::nullopt_t&)
+{
+    os << "nullopt";
+    return os;
+}
+
+} // cxx
+} // toml
+
+#else // TOML11_HAS_STD_OPTIONAL
+
+namespace toml
+{
+namespace cxx
+{
+
+struct nullopt_t{};
+inline nullopt_t make_nullopt() {return nullopt_t{};}
+
+inline bool operator==(const nullopt_t&, const nullopt_t&) noexcept {return true;}
+inline bool operator!=(const nullopt_t&, const nullopt_t&) noexcept {return false;}
+inline bool operator< (const nullopt_t&, const nullopt_t&) noexcept {return false;}
+inline bool operator<=(const nullopt_t&, const nullopt_t&) noexcept {return true;}
+inline bool operator> (const nullopt_t&, const nullopt_t&) noexcept {return false;}
+inline bool operator>=(const nullopt_t&, const nullopt_t&) noexcept {return true;}
+
+template<typename charT, typename traitsT>
+std::basic_ostream<charT, traitsT>&
+operator<<(std::basic_ostream<charT, traitsT>& os, const nullopt_t&)
+{
+    os << "nullopt";
+    return os;
+}
+
+template<typename T>
+class optional
+{
+  public:
+
+    using value_type = T;
+
+  public:
+
+    optional() noexcept : has_value_(false), null_('\0') {}
+    optional(nullopt_t) noexcept : has_value_(false), null_('\0') {}
+
+    optional(const T& x): has_value_(true), value_(x) {}
+    optional(T&& x): has_value_(true), value_(std::move(x)) {}
+
+    template<typename U, enable_if_t<std::is_constructible<T, U>::value, std::nullptr_t> = nullptr>
+    explicit optional(U&& x): has_value_(true), value_(std::forward<U>(x)) {}
+
+    optional(const optional& rhs): has_value_(rhs.has_value_)
+    {
+        if(rhs.has_value_)
+        {
+            this->assigner(rhs.value_);
+        }
+    }
+    optional(optional&& rhs): has_value_(rhs.has_value_)
+    {
+        if(this->has_value_)
+        {
+            this->assigner(std::move(rhs.value_));
+        }
+    }
+
+    optional& operator=(const optional& rhs)
+    {
+        if(this == std::addressof(rhs)) {return *this;}
+
+        this->cleanup();
+        this->has_value_ = rhs.has_value_;
+        if(this->has_value_)
+        {
+            this->assigner(rhs.value_);
+        }
+        return *this;
+    }
+    optional& operator=(optional&& rhs)
+    {
+        if(this == std::addressof(rhs)) {return *this;}
+
+        this->cleanup();
+        this->has_value_ = rhs.has_value_;
+        if(this->has_value_)
+        {
+            this->assigner(std::move(rhs.value_));
+        }
+        return *this;
+    }
+
+    template<typename U, enable_if_t<conjunction<
+        negation<std::is_same<T, U>>, std::is_constructible<T, U>
+        >::value, std::nullptr_t> = nullptr>
+    explicit optional(const optional<U>& rhs): has_value_(rhs.has_value_), null_('\0')
+    {
+        if(rhs.has_value_)
+        {
+            this->assigner(rhs.value_);
+        }
+    }
+    template<typename U, enable_if_t<conjunction<
+        negation<std::is_same<T, U>>, std::is_constructible<T, U>
+        >::value, std::nullptr_t> = nullptr>
+    explicit optional(optional<U>&& rhs): has_value_(rhs.has_value_), null_('\0')
+    {
+        if(this->has_value_)
+        {
+            this->assigner(std::move(rhs.value_));
+        }
+    }
+
+    template<typename U, enable_if_t<conjunction<
+        negation<std::is_same<T, U>>, std::is_constructible<T, U>
+        >::value, std::nullptr_t> = nullptr>
+    optional& operator=(const optional<U>& rhs)
+    {
+        if(this == std::addressof(rhs)) {return *this;}
+
+        this->cleanup();
+        this->has_value_ = rhs.has_value_;
+        if(this->has_value_)
+        {
+            this->assigner(rhs.value_);
+        }
+        return *this;
+    }
+
+    template<typename U, enable_if_t<conjunction<
+        negation<std::is_same<T, U>>, std::is_constructible<T, U>
+        >::value, std::nullptr_t> = nullptr>
+    optional& operator=(optional<U>&& rhs)
+    {
+        if(this == std::addressof(rhs)) {return *this;}
+
+        this->cleanup();
+        this->has_value_ = rhs.has_value_;
+        if(this->has_value_)
+        {
+            this->assigner(std::move(rhs.value_));
+        }
+        return *this;
+    }
+    ~optional() noexcept
+    {
+        this->cleanup();
+    }
+
+    explicit operator bool() const noexcept
+    {
+        return has_value_;
+    }
+
+    bool has_value() const noexcept {return has_value_;}
+
+    value_type const& value(source_location loc = source_location::current()) const
+    {
+        if( ! this->has_value_)
+        {
+            throw std::runtime_error("optional::value(): bad_unwrap" + to_string(loc));
+        }
+        return this->value_;
+    }
+    value_type& value(source_location loc = source_location::current())
+    {
+        if( ! this->has_value_)
+        {
+            throw std::runtime_error("optional::value(): bad_unwrap" + to_string(loc));
+        }
+        return this->value_;
+    }
+
+    value_type const& value_or(const value_type& opt) const
+    {
+        if(this->has_value_) {return this->value_;} else {return opt;}
+    }
+    value_type& value_or(value_type& opt)
+    {
+        if(this->has_value_) {return this->value_;} else {return opt;}
+    }
+
+  private:
+
+    void cleanup() noexcept
+    {
+        if(this->has_value_)
+        {
+            value_.~T();
+        }
+    }
+
+    template<typename U>
+    void assigner(U&& x)
+    {
+        const auto tmp = ::new(std::addressof(this->value_)) value_type(std::forward<U>(x));
+        assert(tmp == std::addressof(this->value_));
+        (void)tmp;
+    }
+
+  private:
+
+    bool has_value_;
+    union
+    {
+        char null_;
+        T    value_;
+    };
+};
+} // cxx
+} // toml
+#endif // TOML11_HAS_STD_OPTIONAL
+
+#endif // TOML11_COMPAT_HPP
+#ifndef TOML11_VALUE_T_HPP
+#define TOML11_VALUE_T_HPP
+
+#ifndef TOML11_VALUE_T_FWD_HPP
+#define TOML11_VALUE_T_FWD_HPP
+
+
+#include <iosfwd>
+#include <string>
+#include <type_traits>
+
+#include <cstdint>
+
+namespace toml
+{
+
+// forward decl
+template<typename TypeConfig>
+class basic_value;
+
+// ----------------------------------------------------------------------------
+// enum representing toml types
+
+enum class value_t : std::uint8_t
+{
+    empty           =  0,
+    boolean         =  1,
+    integer         =  2,
+    floating        =  3,
+    string          =  4,
+    offset_datetime =  5,
+    local_datetime  =  6,
+    local_date      =  7,
+    local_time      =  8,
+    array           =  9,
+    table           = 10
+};
+
+std::ostream& operator<<(std::ostream& os, value_t t);
+std::string to_string(value_t t);
+
+
+// ----------------------------------------------------------------------------
+// meta functions for internal use
+
+namespace detail
+{
+
+template<value_t V>
+using value_t_constant = std::integral_constant<value_t, V>;
+
+template<typename T, typename Value>
+struct type_to_enum : value_t_constant<value_t::empty> {};
+
+template<typename V> struct type_to_enum<typename V::boolean_type        , V> : value_t_constant<value_t::boolean        > {};
+template<typename V> struct type_to_enum<typename V::integer_type        , V> : value_t_constant<value_t::integer        > {};
+template<typename V> struct type_to_enum<typename V::floating_type       , V> : value_t_constant<value_t::floating       > {};
+template<typename V> struct type_to_enum<typename V::string_type         , V> : value_t_constant<value_t::string         > {};
+template<typename V> struct type_to_enum<typename V::offset_datetime_type, V> : value_t_constant<value_t::offset_datetime> {};
+template<typename V> struct type_to_enum<typename V::local_datetime_type , V> : value_t_constant<value_t::local_datetime > {};
+template<typename V> struct type_to_enum<typename V::local_date_type     , V> : value_t_constant<value_t::local_date     > {};
+template<typename V> struct type_to_enum<typename V::local_time_type     , V> : value_t_constant<value_t::local_time     > {};
+template<typename V> struct type_to_enum<typename V::array_type          , V> : value_t_constant<value_t::array          > {};
+template<typename V> struct type_to_enum<typename V::table_type          , V> : value_t_constant<value_t::table          > {};
+
+template<value_t V, typename Value>
+struct enum_to_type { using type = void; };
+
+template<typename V> struct enum_to_type<value_t::boolean        , V> { using type = typename V::boolean_type        ; };
+template<typename V> struct enum_to_type<value_t::integer        , V> { using type = typename V::integer_type        ; };
+template<typename V> struct enum_to_type<value_t::floating       , V> { using type = typename V::floating_type       ; };
+template<typename V> struct enum_to_type<value_t::string         , V> { using type = typename V::string_type         ; };
+template<typename V> struct enum_to_type<value_t::offset_datetime, V> { using type = typename V::offset_datetime_type; };
+template<typename V> struct enum_to_type<value_t::local_datetime , V> { using type = typename V::local_datetime_type ; };
+template<typename V> struct enum_to_type<value_t::local_date     , V> { using type = typename V::local_date_type     ; };
+template<typename V> struct enum_to_type<value_t::local_time     , V> { using type = typename V::local_time_type     ; };
+template<typename V> struct enum_to_type<value_t::array          , V> { using type = typename V::array_type          ; };
+template<typename V> struct enum_to_type<value_t::table          , V> { using type = typename V::table_type          ; };
+
+template<value_t V, typename Value>
+using enum_to_type_t = typename enum_to_type<V, Value>::type;
+
+template<value_t V>
+struct enum_to_fmt_type { using type = void; };
+
+template<> struct enum_to_fmt_type<value_t::boolean        > { using type = boolean_format_info        ; };
+template<> struct enum_to_fmt_type<value_t::integer        > { using type = integer_format_info        ; };
+template<> struct enum_to_fmt_type<value_t::floating       > { using type = floating_format_info       ; };
+template<> struct enum_to_fmt_type<value_t::string         > { using type = string_format_info         ; };
+template<> struct enum_to_fmt_type<value_t::offset_datetime> { using type = offset_datetime_format_info; };
+template<> struct enum_to_fmt_type<value_t::local_datetime > { using type = local_datetime_format_info ; };
+template<> struct enum_to_fmt_type<value_t::local_date     > { using type = local_date_format_info     ; };
+template<> struct enum_to_fmt_type<value_t::local_time     > { using type = local_time_format_info     ; };
+template<> struct enum_to_fmt_type<value_t::array          > { using type = array_format_info          ; };
+template<> struct enum_to_fmt_type<value_t::table          > { using type = table_format_info          ; };
+
+template<value_t V>
+using enum_to_fmt_type_t = typename enum_to_fmt_type<V>::type;
+
+template<typename T, typename Value>
+struct is_exact_toml_type0 : cxx::disjunction<
+    std::is_same<T, typename Value::boolean_type        >,
+    std::is_same<T, typename Value::integer_type        >,
+    std::is_same<T, typename Value::floating_type       >,
+    std::is_same<T, typename Value::string_type         >,
+    std::is_same<T, typename Value::offset_datetime_type>,
+    std::is_same<T, typename Value::local_datetime_type >,
+    std::is_same<T, typename Value::local_date_type     >,
+    std::is_same<T, typename Value::local_time_type     >,
+    std::is_same<T, typename Value::array_type          >,
+    std::is_same<T, typename Value::table_type          >
+    >{};
+template<typename T, typename V> struct is_exact_toml_type: is_exact_toml_type0<cxx::remove_cvref_t<T>, V> {};
+template<typename T, typename V> struct is_not_toml_type : cxx::negation<is_exact_toml_type<T, V>> {};
+
+} // namespace detail
+} // namespace toml
+#endif // TOML11_VALUE_T_FWD_HPP
+
+#if ! defined(TOML11_COMPILE_SOURCES)
+#ifndef TOML11_VALUE_T_IMPL_HPP
+#define TOML11_VALUE_T_IMPL_HPP
+
+
+#include <ostream>
+#include <sstream>
+#include <string>
+
+namespace toml
+{
+
+TOML11_INLINE std::ostream& operator<<(std::ostream& os, value_t t)
+{
+    switch(t)
+    {
+        case value_t::boolean         : os << "boolean";         return os;
+        case value_t::integer         : os << "integer";         return os;
+        case value_t::floating        : os << "floating";        return os;
+        case value_t::string          : os << "string";          return os;
+        case value_t::offset_datetime : os << "offset_datetime"; return os;
+        case value_t::local_datetime  : os << "local_datetime";  return os;
+        case value_t::local_date      : os << "local_date";      return os;
+        case value_t::local_time      : os << "local_time";      return os;
+        case value_t::array           : os << "array";           return os;
+        case value_t::table           : os << "table";           return os;
+        case value_t::empty           : os << "empty";           return os;
+        default                       : os << "unknown";         return os;
+    }
+}
+
+TOML11_INLINE std::string to_string(value_t t)
+{
+    std::ostringstream oss;
+    oss << t;
+    return oss.str();
+}
+
+} // namespace toml
+#endif // TOML11_VALUE_T_IMPL_HPP
+#endif
+
+#endif // TOML11_VALUE_T_HPP
+#ifndef TOML11_STORAGE_HPP
+#define TOML11_STORAGE_HPP
+
+
+namespace toml
+{
+namespace detail
+{
+
+// It owns a pointer to T. It does deep-copy when copied.
+// This struct is introduced to implement a recursive type.
+//
+// `toml::value` contains `std::vector<toml::value>` to represent a toml array.
+// But, in the definition of `toml::value`, `toml::value` is still incomplete.
+// `std::vector` of an incomplete type is not allowed in C++11 (it is allowed
+// after C++17). To avoid this, we need to use a pointer to `toml::value`, like
+// `std::vector<std::unique_ptr<toml::value>>`. Although `std::unique_ptr` is
+// noncopyable, we want to make `toml::value` copyable. `storage` is introduced
+// to resolve those problems.
+template<typename T>
+struct storage
+{
+    using value_type = T;
+
+    explicit storage(value_type v): ptr_(cxx::make_unique<T>(std::move(v))) {}
+    ~storage() = default;
+
+    storage(const storage& rhs): ptr_(cxx::make_unique<T>(*rhs.ptr_)) {}
+    storage& operator=(const storage& rhs)
+    {
+        this->ptr_ = cxx::make_unique<T>(*rhs.ptr_);
+        return *this;
+    }
+
+    storage(storage&&) = default;
+    storage& operator=(storage&&) = default;
+
+    bool is_ok() const noexcept {return static_cast<bool>(ptr_);}
+
+    value_type& get() const noexcept {return *ptr_;}
+
+  private:
+    std::unique_ptr<value_type> ptr_;
+};
+
+} // detail
+} // toml
+#endif // TOML11_STORAGE_HPP
+#ifndef TOML11_COMMENTS_HPP
+#define TOML11_COMMENTS_HPP
+
+#ifndef TOML11_COMMENTS_FWD_HPP
+#define TOML11_COMMENTS_FWD_HPP
+
+// to use __has_builtin
+
+#include <exception>
+#include <initializer_list>
+#include <iterator>
+#include <stdexcept>
+#include <string>
+#include <type_traits>
+#include <utility>
+#include <vector>
+#include <ostream>
+
+// This file provides mainly two classes, `preserve_comments` and `discard_comments`.
+// Those two are a container that have the same interface as `std::vector<std::string>`
+// but bahaves in the opposite way. `preserve_comments` is just the same as
+// `std::vector<std::string>` and each `std::string` corresponds to a comment line.
+// Conversely, `discard_comments` discards all the strings and ignores everything
+// assigned in it. `discard_comments` is always empty and you will encounter an
+// error whenever you access to the element.
+namespace toml
+{
+class discard_comments; // forward decl
+
+class preserve_comments
+{
+  public:
+    // `container_type` is not provided in discard_comments.
+    // do not use this inner-type in a generic code.
+    using container_type         = std::vector<std::string>;
+
+    using size_type              = container_type::size_type;
+    using difference_type        = container_type::difference_type;
+    using value_type             = container_type::value_type;
+    using reference              = container_type::reference;
+    using const_reference        = container_type::const_reference;
+    using pointer                = container_type::pointer;
+    using const_pointer          = container_type::const_pointer;
+    using iterator               = container_type::iterator;
+    using const_iterator         = container_type::const_iterator;
+    using reverse_iterator       = container_type::reverse_iterator;
+    using const_reverse_iterator = container_type::const_reverse_iterator;
+
+  public:
+
+    preserve_comments()  = default;
+    ~preserve_comments() = default;
+    preserve_comments(preserve_comments const&) = default;
+    preserve_comments(preserve_comments &&)     = default;
+    preserve_comments& operator=(preserve_comments const&) = default;
+    preserve_comments& operator=(preserve_comments &&)     = default;
+
+    explicit preserve_comments(const std::vector<std::string>& c): comments(c){}
+    explicit preserve_comments(std::vector<std::string>&& c)
+        : comments(std::move(c))
+    {}
+    preserve_comments& operator=(const std::vector<std::string>& c)
+    {
+        comments = c;
+        return *this;
+    }
+    preserve_comments& operator=(std::vector<std::string>&& c)
+    {
+        comments = std::move(c);
+        return *this;
+    }
+
+    explicit preserve_comments(const discard_comments&) {}
+
+    explicit preserve_comments(size_type n): comments(n) {}
+    preserve_comments(size_type n, const std::string& x): comments(n, x) {}
+    preserve_comments(std::initializer_list<std::string> x): comments(x) {}
+    template<typename InputIterator>
+    preserve_comments(InputIterator first, InputIterator last)
+        : comments(first, last)
+    {}
+
+    template<typename InputIterator>
+    void assign(InputIterator first, InputIterator last) {comments.assign(first, last);}
+    void assign(std::initializer_list<std::string> ini)  {comments.assign(ini);}
+    void assign(size_type n, const std::string& val)     {comments.assign(n, val);}
+
+    // Related to the issue #97.
+    //
+    // `std::vector::insert` and `std::vector::erase` in the STL implementation
+    // included in GCC 4.8.5 takes `std::vector::iterator` instead of
+    // `std::vector::const_iterator`. It causes compilation error in GCC 4.8.5.
+#if defined(__GNUC__) && defined(__GNUC_MINOR__) && defined(__GNUC_PATCHLEVEL__) && !defined(__clang__)
+#  if (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) <= 40805
+#    define TOML11_WORKAROUND_GCC_4_8_X_STANDARD_LIBRARY_IMPLEMENTATION
+#  endif
+#endif
+
+#ifdef TOML11_WORKAROUND_GCC_4_8_X_STANDARD_LIBRARY_IMPLEMENTATION
+    iterator insert(iterator p, const std::string& x)
+    {
+        return comments.insert(p, x);
+    }
+    iterator insert(iterator p, std::string&&      x)
+    {
+        return comments.insert(p, std::move(x));
+    }
+    void insert(iterator p, size_type n, const std::string& x)
+    {
+        return comments.insert(p, n, x);
+    }
+    template<typename InputIterator>
+    void insert(iterator p, InputIterator first, InputIterator last)
+    {
+        return comments.insert(p, first, last);
+    }
+    void insert(iterator p, std::initializer_list<std::string> ini)
+    {
+        return comments.insert(p, ini);
+    }
+
+    template<typename ... Ts>
+    iterator emplace(iterator p, Ts&& ... args)
+    {
+        return comments.emplace(p, std::forward<Ts>(args)...);
+    }
+
+    iterator erase(iterator pos) {return comments.erase(pos);}
+    iterator erase(iterator first, iterator last)
+    {
+        return comments.erase(first, last);
+    }
+#else
+    iterator insert(const_iterator p, const std::string& x)
+    {
+        return comments.insert(p, x);
+    }
+    iterator insert(const_iterator p, std::string&&      x)
+    {
+        return comments.insert(p, std::move(x));
+    }
+    iterator insert(const_iterator p, size_type n, const std::string& x)
+    {
+        return comments.insert(p, n, x);
+    }
+    template<typename InputIterator>
+    iterator insert(const_iterator p, InputIterator first, InputIterator last)
+    {
+        return comments.insert(p, first, last);
+    }
+    iterator insert(const_iterator p, std::initializer_list<std::string> ini)
+    {
+        return comments.insert(p, ini);
+    }
+
+    template<typename ... Ts>
+    iterator emplace(const_iterator p, Ts&& ... args)
+    {
+        return comments.emplace(p, std::forward<Ts>(args)...);
+    }
+
+    iterator erase(const_iterator pos) {return comments.erase(pos);}
+    iterator erase(const_iterator first, const_iterator last)
+    {
+        return comments.erase(first, last);
+    }
+#endif
+
+    void swap(preserve_comments& other) {comments.swap(other.comments);}
+
+    void push_back(const std::string& v) {comments.push_back(v);}
+    void push_back(std::string&&      v) {comments.push_back(std::move(v));}
+    void pop_back()                      {comments.pop_back();}
+
+    template<typename ... Ts>
+    void emplace_back(Ts&& ... args) {comments.emplace_back(std::forward<Ts>(args)...);}
+
+    void clear() {comments.clear();}
+
+    size_type size()     const noexcept {return comments.size();}
+    size_type max_size() const noexcept {return comments.max_size();}
+    size_type capacity() const noexcept {return comments.capacity();}
+    bool      empty()    const noexcept {return comments.empty();}
+
+    void reserve(size_type n)                      {comments.reserve(n);}
+    void resize(size_type n)                       {comments.resize(n);}
+    void resize(size_type n, const std::string& c) {comments.resize(n, c);}
+    void shrink_to_fit()                           {comments.shrink_to_fit();}
+
+    reference       operator[](const size_type n)       noexcept {return comments[n];}
+    const_reference operator[](const size_type n) const noexcept {return comments[n];}
+    reference       at(const size_type n)       {return comments.at(n);}
+    const_reference at(const size_type n) const {return comments.at(n);}
+    reference       front()       noexcept {return comments.front();}
+    const_reference front() const noexcept {return comments.front();}
+    reference       back()        noexcept {return comments.back();}
+    const_reference back()  const noexcept {return comments.back();}
+
+    pointer         data()        noexcept {return comments.data();}
+    const_pointer   data()  const noexcept {return comments.data();}
+
+    iterator       begin()        noexcept {return comments.begin();}
+    iterator       end()          noexcept {return comments.end();}
+    const_iterator begin()  const noexcept {return comments.begin();}
+    const_iterator end()    const noexcept {return comments.end();}
+    const_iterator cbegin() const noexcept {return comments.cbegin();}
+    const_iterator cend()   const noexcept {return comments.cend();}
+
+    reverse_iterator       rbegin()        noexcept {return comments.rbegin();}
+    reverse_iterator       rend()          noexcept {return comments.rend();}
+    const_reverse_iterator rbegin()  const noexcept {return comments.rbegin();}
+    const_reverse_iterator rend()    const noexcept {return comments.rend();}
+    const_reverse_iterator crbegin() const noexcept {return comments.crbegin();}
+    const_reverse_iterator crend()   const noexcept {return comments.crend();}
+
+    friend bool operator==(const preserve_comments&, const preserve_comments&);
+    friend bool operator!=(const preserve_comments&, const preserve_comments&);
+    friend bool operator< (const preserve_comments&, const preserve_comments&);
+    friend bool operator<=(const preserve_comments&, const preserve_comments&);
+    friend bool operator> (const preserve_comments&, const preserve_comments&);
+    friend bool operator>=(const preserve_comments&, const preserve_comments&);
+
+    friend void swap(preserve_comments&, std::vector<std::string>&);
+    friend void swap(std::vector<std::string>&, preserve_comments&);
+
+  private:
+
+    container_type comments;
+};
+
+bool operator==(const preserve_comments& lhs, const preserve_comments& rhs);
+bool operator!=(const preserve_comments& lhs, const preserve_comments& rhs);
+bool operator< (const preserve_comments& lhs, const preserve_comments& rhs);
+bool operator<=(const preserve_comments& lhs, const preserve_comments& rhs);
+bool operator> (const preserve_comments& lhs, const preserve_comments& rhs);
+bool operator>=(const preserve_comments& lhs, const preserve_comments& rhs);
+
+void swap(preserve_comments& lhs, preserve_comments& rhs);
+void swap(preserve_comments& lhs, std::vector<std::string>& rhs);
+void swap(std::vector<std::string>& lhs, preserve_comments& rhs);
+
+std::ostream& operator<<(std::ostream& os, const preserve_comments& com);
+
+namespace detail
+{
+
+// To provide the same interface with `preserve_comments`, `discard_comments`
+// should have an iterator. But it does not contain anything, so we need to
+// add an iterator that points nothing.
+//
+// It always points null, so DO NOT unwrap this iterator. It always crashes
+// your program.
+template<typename T, bool is_const>
+struct empty_iterator
+{
+    using value_type        = T;
+    using reference_type    = typename std::conditional<is_const, T const&, T&>::type;
+    using pointer_type      = typename std::conditional<is_const, T const*, T*>::type;
+    using difference_type   = std::ptrdiff_t;
+    using iterator_category = std::random_access_iterator_tag;
+
+    empty_iterator()  = default;
+    ~empty_iterator() = default;
+    empty_iterator(empty_iterator const&) = default;
+    empty_iterator(empty_iterator &&)     = default;
+    empty_iterator& operator=(empty_iterator const&) = default;
+    empty_iterator& operator=(empty_iterator &&)     = default;
+
+    // DO NOT call these operators.
+    reference_type operator*()  const noexcept {std::terminate();}
+    pointer_type   operator->() const noexcept {return nullptr;}
+    reference_type operator[](difference_type) const noexcept {return this->operator*();}
+
+    // These operators do nothing.
+    empty_iterator& operator++()    noexcept {return *this;}
+    empty_iterator  operator++(int) noexcept {return *this;}
+    empty_iterator& operator--()    noexcept {return *this;}
+    empty_iterator  operator--(int) noexcept {return *this;}
+
+    empty_iterator& operator+=(difference_type) noexcept {return *this;}
+    empty_iterator& operator-=(difference_type) noexcept {return *this;}
+
+    empty_iterator  operator+(difference_type) const noexcept {return *this;}
+    empty_iterator  operator-(difference_type) const noexcept {return *this;}
+};
+
+template<typename T, bool C>
+bool operator==(const empty_iterator<T, C>&, const empty_iterator<T, C>&) noexcept {return true;}
+template<typename T, bool C>
+bool operator!=(const empty_iterator<T, C>&, const empty_iterator<T, C>&) noexcept {return false;}
+template<typename T, bool C>
+bool operator< (const empty_iterator<T, C>&, const empty_iterator<T, C>&) noexcept {return false;}
+template<typename T, bool C>
+bool operator<=(const empty_iterator<T, C>&, const empty_iterator<T, C>&) noexcept {return true;}
+template<typename T, bool C>
+bool operator> (const empty_iterator<T, C>&, const empty_iterator<T, C>&) noexcept {return false;}
+template<typename T, bool C>
+bool operator>=(const empty_iterator<T, C>&, const empty_iterator<T, C>&) noexcept {return true;}
+
+template<typename T, bool C>
+typename empty_iterator<T, C>::difference_type
+operator-(const empty_iterator<T, C>&, const empty_iterator<T, C>&) noexcept {return 0;}
+
+template<typename T, bool C>
+empty_iterator<T, C>
+operator+(typename empty_iterator<T, C>::difference_type, const empty_iterator<T, C>& rhs) noexcept {return rhs;}
+template<typename T, bool C>
+empty_iterator<T, C>
+operator+(const empty_iterator<T, C>& lhs, typename empty_iterator<T, C>::difference_type) noexcept {return lhs;}
+
+} // detail
+
+// The default comment type. It discards all the comments. It requires only one
+// byte to contain, so the memory footprint is smaller than preserve_comments.
+//
+// It just ignores `push_back`, `insert`, `erase`, and any other modifications.
+// IT always returns size() == 0, the iterator taken by `begin()` is always the
+// same as that of `end()`, and accessing through `operator[]` or iterators
+// always causes a segmentation fault. DO NOT access to the element of this.
+//
+// Why this is chose as the default type is because the last version (2.x.y)
+// does not contain any comments in a value. To minimize the impact on the
+// efficiency, this is chosen as a default.
+//
+// To reduce the memory footprint, later we can try empty base optimization (EBO).
+class discard_comments
+{
+  public:
+    using size_type              = std::size_t;
+    using difference_type        = std::ptrdiff_t;
+    using value_type             = std::string;
+    using reference              = std::string&;
+    using const_reference        = std::string const&;
+    using pointer                = std::string*;
+    using const_pointer          = std::string const*;
+    using iterator               = detail::empty_iterator<std::string, false>;
+    using const_iterator         = detail::empty_iterator<std::string, true>;
+    using reverse_iterator       = detail::empty_iterator<std::string, false>;
+    using const_reverse_iterator = detail::empty_iterator<std::string, true>;
+
+  public:
+    discard_comments() = default;
+    ~discard_comments() = default;
+    discard_comments(discard_comments const&) = default;
+    discard_comments(discard_comments &&)     = default;
+    discard_comments& operator=(discard_comments const&) = default;
+    discard_comments& operator=(discard_comments &&)     = default;
+
+    explicit discard_comments(const std::vector<std::string>&) noexcept {}
+    explicit discard_comments(std::vector<std::string>&&)      noexcept {}
+    discard_comments& operator=(const std::vector<std::string>&) noexcept {return *this;}
+    discard_comments& operator=(std::vector<std::string>&&)      noexcept {return *this;}
+
+    explicit discard_comments(const preserve_comments&)        noexcept {}
+
+    explicit discard_comments(size_type) noexcept {}
+    discard_comments(size_type, const std::string&) noexcept {}
+    discard_comments(std::initializer_list<std::string>) noexcept {}
+    template<typename InputIterator>
+    discard_comments(InputIterator, InputIterator) noexcept {}
+
+    template<typename InputIterator>
+    void assign(InputIterator, InputIterator)       noexcept {}
+    void assign(std::initializer_list<std::string>) noexcept {}
+    void assign(size_type, const std::string&)      noexcept {}
+
+    iterator insert(const_iterator, const std::string&)                 {return iterator{};}
+    iterator insert(const_iterator, std::string&&)                      {return iterator{};}
+    iterator insert(const_iterator, size_type, const std::string&)      {return iterator{};}
+    template<typename InputIterator>
+    iterator insert(const_iterator, InputIterator, InputIterator)       {return iterator{};}
+    iterator insert(const_iterator, std::initializer_list<std::string>) {return iterator{};}
+
+    template<typename ... Ts>
+    iterator emplace(const_iterator, Ts&& ...)     {return iterator{};}
+    iterator erase(const_iterator)                 {return iterator{};}
+    iterator erase(const_iterator, const_iterator) {return iterator{};}
+
+    void swap(discard_comments&) {return;}
+
+    void push_back(const std::string&) {return;}
+    void push_back(std::string&&     ) {return;}
+    void pop_back()                    {return;}
+
+    template<typename ... Ts>
+    void emplace_back(Ts&& ...) {return;}
+
+    void clear() {return;}
+
+    size_type size()     const noexcept {return 0;}
+    size_type max_size() const noexcept {return 0;}
+    size_type capacity() const noexcept {return 0;}
+    bool      empty()    const noexcept {return true;}
+
+    void reserve(size_type)                    {return;}
+    void resize(size_type)                     {return;}
+    void resize(size_type, const std::string&) {return;}
+    void shrink_to_fit()                       {return;}
+
+    // DO NOT access to the element of this container. This container is always
+    // empty, so accessing through operator[], front/back, data causes address
+    // error.
+
+    reference       operator[](const size_type)       noexcept {never_call("toml::discard_comment::operator[]");}
+    const_reference operator[](const size_type) const noexcept {never_call("toml::discard_comment::operator[]");}
+    reference       at(const size_type)       {throw std::out_of_range("toml::discard_comment is always empty.");}
+    const_reference at(const size_type) const {throw std::out_of_range("toml::discard_comment is always empty.");}
+    reference       front()       noexcept {never_call("toml::discard_comment::front");}
+    const_reference front() const noexcept {never_call("toml::discard_comment::front");}
+    reference       back()        noexcept {never_call("toml::discard_comment::back");}
+    const_reference back()  const noexcept {never_call("toml::discard_comment::back");}
+
+    pointer         data()        noexcept {return nullptr;}
+    const_pointer   data()  const noexcept {return nullptr;}
+
+    iterator       begin()        noexcept {return iterator{};}
+    iterator       end()          noexcept {return iterator{};}
+    const_iterator begin()  const noexcept {return const_iterator{};}
+    const_iterator end()    const noexcept {return const_iterator{};}
+    const_iterator cbegin() const noexcept {return const_iterator{};}
+    const_iterator cend()   const noexcept {return const_iterator{};}
+
+    reverse_iterator       rbegin()        noexcept {return iterator{};}
+    reverse_iterator       rend()          noexcept {return iterator{};}
+    const_reverse_iterator rbegin()  const noexcept {return const_iterator{};}
+    const_reverse_iterator rend()    const noexcept {return const_iterator{};}
+    const_reverse_iterator crbegin() const noexcept {return const_iterator{};}
+    const_reverse_iterator crend()   const noexcept {return const_iterator{};}
+
+  private:
+
+    [[noreturn]] static void never_call(const char *const this_function)
+    {
+#if __has_builtin(__builtin_unreachable)
+        __builtin_unreachable();
+#endif
+        throw std::logic_error{this_function};
+    }
+};
+
+inline bool operator==(const discard_comments&, const discard_comments&) noexcept {return true;}
+inline bool operator!=(const discard_comments&, const discard_comments&) noexcept {return false;}
+inline bool operator< (const discard_comments&, const discard_comments&) noexcept {return false;}
+inline bool operator<=(const discard_comments&, const discard_comments&) noexcept {return true;}
+inline bool operator> (const discard_comments&, const discard_comments&) noexcept {return false;}
+inline bool operator>=(const discard_comments&, const discard_comments&) noexcept {return true;}
+
+inline void swap(const discard_comments&, const discard_comments&) noexcept {return;}
+
+inline std::ostream& operator<<(std::ostream& os, const discard_comments&) {return os;}
+
+} // toml11
+#endif // TOML11_COMMENTS_FWD_HPP
+
+#if ! defined(TOML11_COMPILE_SOURCES)
+#ifndef TOML11_COMMENTS_IMPL_HPP
+#define TOML11_COMMENTS_IMPL_HPP
+
+
+namespace toml
+{
+
+TOML11_INLINE bool operator==(const preserve_comments& lhs, const preserve_comments& rhs) {return lhs.comments == rhs.comments;}
+TOML11_INLINE bool operator!=(const preserve_comments& lhs, const preserve_comments& rhs) {return lhs.comments != rhs.comments;}
+TOML11_INLINE bool operator< (const preserve_comments& lhs, const preserve_comments& rhs) {return lhs.comments <  rhs.comments;}
+TOML11_INLINE bool operator<=(const preserve_comments& lhs, const preserve_comments& rhs) {return lhs.comments <= rhs.comments;}
+TOML11_INLINE bool operator> (const preserve_comments& lhs, const preserve_comments& rhs) {return lhs.comments >  rhs.comments;}
+TOML11_INLINE bool operator>=(const preserve_comments& lhs, const preserve_comments& rhs) {return lhs.comments >= rhs.comments;}
+
+TOML11_INLINE void swap(preserve_comments& lhs, preserve_comments& rhs)
+{
+    lhs.swap(rhs);
+    return;
+}
+TOML11_INLINE void swap(preserve_comments& lhs, std::vector<std::string>& rhs)
+{
+    lhs.comments.swap(rhs);
+    return;
+}
+TOML11_INLINE void swap(std::vector<std::string>& lhs, preserve_comments& rhs)
+{
+    lhs.swap(rhs.comments);
+    return;
+}
+
+TOML11_INLINE std::ostream& operator<<(std::ostream& os, const preserve_comments& com)
+{
+    for(const auto& c : com)
+    {
+        if(c.front() != '#')
+        {
+            os << '#';
+        }
+        os << c << '\n';
+    }
+    return os;
+}
+
+} // toml11
+#endif // TOML11_COMMENTS_IMPL_HPP
+#endif
+
+#endif // TOML11_COMMENTS_HPP
+#ifndef TOML11_COLOR_HPP
+#define TOML11_COLOR_HPP
+
+#ifndef TOML11_COLOR_FWD_HPP
+#define TOML11_COLOR_FWD_HPP
+
+#include <iosfwd>
+
+#ifdef TOML11_COLORIZE_ERROR_MESSAGE
+#define TOML11_ERROR_MESSAGE_COLORIZED true
+#else
+#define TOML11_ERROR_MESSAGE_COLORIZED false
+#endif
+
+#ifdef TOML11_USE_THREAD_LOCAL_COLORIZATION
+#define TOML11_THREAD_LOCAL_COLORIZATION thread_local
+#else
+#define TOML11_THREAD_LOCAL_COLORIZATION
+#endif
+
+namespace toml
+{
+namespace color
+{
+// put ANSI escape sequence to ostream
+inline namespace ansi
+{
+namespace detail
+{
+
+// Control color mode globally
+class color_mode
+{
+  public:
+
+    void enable() noexcept
+    {
+        should_color_ = true;
+    }
+    void disable() noexcept
+    {
+        should_color_ = false;
+    }
+    bool should_color() const noexcept
+    {
+        return should_color_;
+    }
+
+  private:
+
+    bool should_color_ = TOML11_ERROR_MESSAGE_COLORIZED;
+};
+
+inline color_mode& color_status() noexcept
+{
+    static TOML11_THREAD_LOCAL_COLORIZATION color_mode status;
+    return status;
+}
+
+} // detail
+
+std::ostream& reset  (std::ostream& os);
+std::ostream& bold   (std::ostream& os);
+std::ostream& grey   (std::ostream& os);
+std::ostream& gray   (std::ostream& os);
+std::ostream& red    (std::ostream& os);
+std::ostream& green  (std::ostream& os);
+std::ostream& yellow (std::ostream& os);
+std::ostream& blue   (std::ostream& os);
+std::ostream& magenta(std::ostream& os);
+std::ostream& cyan   (std::ostream& os);
+std::ostream& white  (std::ostream& os);
+
+} // ansi
+
+inline void enable()
+{
+    return detail::color_status().enable();
+}
+inline void disable()
+{
+    return detail::color_status().disable();
+}
+inline bool should_color()
+{
+    return detail::color_status().should_color();
+}
+
+} // color
+} // toml
+#endif // TOML11_COLOR_FWD_HPP
+
+#if ! defined(TOML11_COMPILE_SOURCES)
+#ifndef TOML11_COLOR_IMPL_HPP
+#define TOML11_COLOR_IMPL_HPP
+
+
+#include <ostream>
+
+namespace toml
+{
+namespace color
+{
+// put ANSI escape sequence to ostream
+inline namespace ansi
+{
+
+TOML11_INLINE std::ostream& reset(std::ostream& os)
+{
+    if(detail::color_status().should_color()) {os << "\033[00m";}
+    return os;
+}
+TOML11_INLINE std::ostream& bold(std::ostream& os)
+{
+    if(detail::color_status().should_color()) {os << "\033[01m";}
+    return os;
+}
+TOML11_INLINE std::ostream& grey(std::ostream& os)
+{
+    if(detail::color_status().should_color()) {os << "\033[30m";}
+    return os;
+}
+TOML11_INLINE std::ostream& gray(std::ostream& os)
+{
+    if(detail::color_status().should_color()) {os << "\033[30m";}
+    return os;
+}
+TOML11_INLINE std::ostream& red(std::ostream& os)
+{
+    if(detail::color_status().should_color()) {os << "\033[31m";}
+    return os;
+}
+TOML11_INLINE std::ostream& green(std::ostream& os)
+{
+    if(detail::color_status().should_color()) {os << "\033[32m";}
+    return os;
+}
+TOML11_INLINE std::ostream& yellow(std::ostream& os)
+{
+    if(detail::color_status().should_color()) {os << "\033[33m";}
+    return os;
+}
+TOML11_INLINE std::ostream& blue(std::ostream& os)
+{
+    if(detail::color_status().should_color()) {os << "\033[34m";}
+    return os;
+}
+TOML11_INLINE std::ostream& magenta(std::ostream& os)
+{
+    if(detail::color_status().should_color()) {os << "\033[35m";}
+    return os;
+}
+TOML11_INLINE std::ostream& cyan   (std::ostream& os)
+{
+    if(detail::color_status().should_color()) {os << "\033[36m";}
+    return os;
+}
+TOML11_INLINE std::ostream& white  (std::ostream& os)
+{
+    if(detail::color_status().should_color()) {os << "\033[37m";}
+    return os;
+}
+
+} // ansi
+} // color
+} // toml
+#endif // TOML11_COLOR_IMPL_HPP
+#endif
+
+#endif // TOML11_COLOR_HPP
+#ifndef TOML11_SPEC_HPP
+#define TOML11_SPEC_HPP
+
+#include <ostream>
+#include <sstream>
+
+#include <cstdint>
+
+namespace toml
+{
+
+struct semantic_version
+{
+    constexpr semantic_version(std::uint32_t mjr, std::uint32_t mnr, std::uint32_t p) noexcept
+        : major{mjr}, minor{mnr}, patch{p}
+    {}
+
+    std::uint32_t major;
+    std::uint32_t minor;
+    std::uint32_t patch;
+};
+
+constexpr inline semantic_version
+make_semver(std::uint32_t mjr, std::uint32_t mnr, std::uint32_t p) noexcept
+{
+    return semantic_version(mjr, mnr, p);
+}
+
+constexpr inline bool
+operator==(const semantic_version& lhs, const semantic_version& rhs) noexcept
+{
+    return lhs.major == rhs.major &&
+           lhs.minor == rhs.minor &&
+           lhs.patch == rhs.patch;
+}
+constexpr inline bool
+operator!=(const semantic_version& lhs, const semantic_version& rhs) noexcept
+{
+    return !(lhs == rhs);
+}
+constexpr inline bool
+operator<(const semantic_version& lhs, const semantic_version& rhs) noexcept
+{
+    return lhs.major < rhs.major ||
+           (lhs.major == rhs.major && lhs.minor < rhs.minor) ||
+           (lhs.major == rhs.major && lhs.minor == rhs.minor && lhs.patch < rhs.patch);
+}
+constexpr inline bool
+operator>(const semantic_version& lhs, const semantic_version& rhs) noexcept
+{
+    return rhs < lhs;
+}
+constexpr inline bool
+operator<=(const semantic_version& lhs, const semantic_version& rhs) noexcept
+{
+    return !(lhs > rhs);
+}
+constexpr inline bool
+operator>=(const semantic_version& lhs, const semantic_version& rhs) noexcept
+{
+    return !(lhs < rhs);
+}
+
+inline std::ostream& operator<<(std::ostream& os, const semantic_version& v)
+{
+    os << v.major << '.' << v.minor << '.' << v.patch;
+    return os;
+}
+
+inline std::string to_string(const semantic_version& v)
+{
+    std::ostringstream oss;
+    oss << v;
+    return oss.str();
+}
+
+struct spec
+{
+    constexpr static spec default_version() noexcept
+    {
+        return spec::v(1, 0, 0);
+    }
+
+    constexpr static spec v(std::uint32_t mjr, std::uint32_t mnr, std::uint32_t p) noexcept
+    {
+        return spec(make_semver(mjr, mnr, p));
+    }
+
+    constexpr explicit spec(const semantic_version& semver) noexcept
+        : version{semver},
+          v1_1_0_allow_control_characters_in_comments {semantic_version{1, 1, 0} <= semver},
+          v1_1_0_allow_newlines_in_inline_tables      {semantic_version{1, 1, 0} <= semver},
+          v1_1_0_allow_trailing_comma_in_inline_tables{semantic_version{1, 1, 0} <= semver},
+          v1_1_0_allow_non_english_in_bare_keys       {semantic_version{1, 1, 0} <= semver},
+          v1_1_0_add_escape_sequence_e                {semantic_version{1, 1, 0} <= semver},
+          v1_1_0_add_escape_sequence_x                {semantic_version{1, 1, 0} <= semver},
+          v1_1_0_make_seconds_optional                {semantic_version{1, 1, 0} <= semver},
+          ext_hex_float {false},
+          ext_num_suffix{false},
+          ext_null_value{false}
+    {}
+
+    semantic_version version; // toml version
+
+    // diff from v1.0.0 -> v1.1.0
+    bool v1_1_0_allow_control_characters_in_comments;
+    bool v1_1_0_allow_newlines_in_inline_tables;
+    bool v1_1_0_allow_trailing_comma_in_inline_tables;
+    bool v1_1_0_allow_non_english_in_bare_keys;
+    bool v1_1_0_add_escape_sequence_e;
+    bool v1_1_0_add_escape_sequence_x;
+    bool v1_1_0_make_seconds_optional;
+
+    // library extensions
+    bool ext_hex_float;  // allow hex float (in C++ style)
+    bool ext_num_suffix; // allow number suffix (in C++ style)
+    bool ext_null_value; // allow `null` as a value
+};
+
+} // namespace toml
+#endif // TOML11_SPEC_HPP
+#ifndef TOML11_ORDERED_MAP_HPP
+#define TOML11_ORDERED_MAP_HPP
+
+#include <algorithm>
+#include <stdexcept>
+#include <utility>
+#include <vector>
+
+namespace toml
+{
+
+namespace detail
+{
+template<typename Cmp>
+struct ordered_map_ebo_container
+{
+    Cmp cmp_; // empty base optimization for empty Cmp type
+};
+} // detail
+
+template<typename Key, typename Val, typename Cmp = std::equal_to<Key>,
+         typename Allocator = std::allocator<std::pair<Key, Val>>>
+class ordered_map : detail::ordered_map_ebo_container<Cmp>
+{
+  public:
+    using key_type    = Key;
+    using mapped_type = Val;
+    using value_type  = std::pair<Key, Val>;
+
+    using key_compare    = Cmp;
+    using allocator_type = Allocator;
+
+    using container_type  = std::vector<value_type, Allocator>;
+    using reference       = typename container_type::reference;
+    using pointer         = typename container_type::pointer;
+    using const_reference = typename container_type::const_reference;
+    using const_pointer   = typename container_type::const_pointer;
+    using iterator        = typename container_type::iterator;
+    using const_iterator  = typename container_type::const_iterator;
+    using size_type       = typename container_type::size_type;
+    using difference_type = typename container_type::difference_type;
+
+  private:
+
+    using ebo_base = detail::ordered_map_ebo_container<Cmp>;
+
+  public:
+
+    ordered_map() = default;
+    ~ordered_map() = default;
+    ordered_map(const ordered_map&) = default;
+    ordered_map(ordered_map&&)      = default;
+    ordered_map& operator=(const ordered_map&) = default;
+    ordered_map& operator=(ordered_map&&)      = default;
+
+    ordered_map(const ordered_map& other, const Allocator& alloc)
+        : container_(other.container_, alloc)
+    {}
+    ordered_map(ordered_map&& other, const Allocator& alloc)
+        : container_(std::move(other.container_), alloc)
+    {}
+
+    explicit ordered_map(const Cmp& cmp, const Allocator& alloc = Allocator())
+        : ebo_base{cmp}, container_(alloc)
+    {}
+    explicit ordered_map(const Allocator& alloc)
+        : container_(alloc)
+    {}
+
+    template<typename InputIterator>
+    ordered_map(InputIterator first, InputIterator last, const Cmp& cmp = Cmp(), const Allocator& alloc = Allocator())
+        : ebo_base{cmp}, container_(first, last, alloc)
+    {}
+    template<typename InputIterator>
+    ordered_map(InputIterator first, InputIterator last, const Allocator& alloc)
+        : container_(first, last, alloc)
+    {}
+
+    ordered_map(std::initializer_list<value_type> v, const Cmp& cmp = Cmp(), const Allocator& alloc = Allocator())
+        : ebo_base{cmp}, container_(std::move(v), alloc)
+    {}
+    ordered_map(std::initializer_list<value_type> v, const Allocator& alloc)
+        : container_(std::move(v), alloc)
+    {}
+    ordered_map& operator=(std::initializer_list<value_type> v)
+    {
+        this->container_ = std::move(v);
+        return *this;
+    }
+
+    iterator       begin()        noexcept {return container_.begin();}
+    iterator       end()          noexcept {return container_.end();}
+    const_iterator begin()  const noexcept {return container_.begin();}
+    const_iterator end()    const noexcept {return container_.end();}
+    const_iterator cbegin() const noexcept {return container_.cbegin();}
+    const_iterator cend()   const noexcept {return container_.cend();}
+
+    bool        empty()    const noexcept {return container_.empty();}
+    std::size_t size()     const noexcept {return container_.size();}
+    std::size_t max_size() const noexcept {return container_.max_size();}
+
+    void clear() {container_.clear();}
+
+    void push_back(const value_type& v)
+    {
+        if(this->contains(v.first))
+        {
+            throw std::out_of_range("ordered_map: value already exists");
+        }
+        container_.push_back(v);
+    }
+    void push_back(value_type&& v)
+    {
+        if(this->contains(v.first))
+        {
+            throw std::out_of_range("ordered_map: value already exists");
+        }
+        container_.push_back(std::move(v));
+    }
+    void emplace_back(key_type k, mapped_type v)
+    {
+        if(this->contains(k))
+        {
+            throw std::out_of_range("ordered_map: value already exists");
+        }
+        container_.emplace_back(std::move(k), std::move(v));
+    }
+    void pop_back()  {container_.pop_back();}
+
+    void insert(value_type kv)
+    {
+        if(this->contains(kv.first))
+        {
+            throw std::out_of_range("ordered_map: value already exists");
+        }
+        container_.push_back(std::move(kv));
+    }
+    void emplace(key_type k, mapped_type v)
+    {
+        if(this->contains(k))
+        {
+            throw std::out_of_range("ordered_map: value already exists");
+        }
+        container_.emplace_back(std::move(k), std::move(v));
+    }
+
+    std::size_t count(const key_type& key) const
+    {
+        if(this->find(key) != this->end())
+        {
+            return 1;
+        }
+        else
+        {
+            return 0;
+        }
+    }
+    bool contains(const key_type& key) const
+    {
+        return this->find(key) != this->end();
+    }
+    iterator find(const key_type& key) noexcept
+    {
+        return std::find_if(this->begin(), this->end(),
+            [&key, this](const value_type& v) {return this->cmp_(v.first, key);});
+    }
+    const_iterator find(const key_type& key) const noexcept
+    {
+        return std::find_if(this->begin(), this->end(),
+            [&key, this](const value_type& v) {return this->cmp_(v.first, key);});
+    }
+
+    mapped_type&       at(const key_type& k)
+    {
+        const auto iter = this->find(k);
+        if(iter == this->end())
+        {
+            throw std::out_of_range("ordered_map: no such element");
+        }
+        return iter->second;
+    }
+    mapped_type const& at(const key_type& k) const
+    {
+        const auto iter = this->find(k);
+        if(iter == this->end())
+        {
+            throw std::out_of_range("ordered_map: no such element");
+        }
+        return iter->second;
+    }
+
+    mapped_type& operator[](const key_type& k)
+    {
+        const auto iter = this->find(k);
+        if(iter == this->end())
+        {
+            this->container_.emplace_back(k, mapped_type{});
+            return this->container_.back().second;
+        }
+        return iter->second;
+    }
+
+    mapped_type const& operator[](const key_type& k) const
+    {
+        const auto iter = this->find(k);
+        if(iter == this->end())
+        {
+            throw std::out_of_range("ordered_map: no such element");
+        }
+        return iter->second;
+    }
+
+    key_compare key_comp() const {return this->cmp_;}
+
+    void swap(ordered_map& other)
+    {
+        container_.swap(other.container_);
+    }
+
+  private:
+
+    container_type container_;
+};
+
+template<typename K, typename V, typename C, typename A>
+bool operator==(const ordered_map<K,V,C,A>& lhs, const ordered_map<K,V,C,A>& rhs)
+{
+    return lhs.size() == rhs.size() && std::equal(lhs.begin(), lhs.end(), rhs.begin());
+}
+template<typename K, typename V, typename C, typename A>
+bool operator!=(const ordered_map<K,V,C,A>& lhs, const ordered_map<K,V,C,A>& rhs)
+{
+    return !(lhs == rhs);
+}
+template<typename K, typename V, typename C, typename A>
+bool operator<(const ordered_map<K,V,C,A>& lhs, const ordered_map<K,V,C,A>& rhs)
+{
+    return std::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end());
+}
+template<typename K, typename V, typename C, typename A>
+bool operator>(const ordered_map<K,V,C,A>& lhs, const ordered_map<K,V,C,A>& rhs)
+{
+    return rhs < lhs;
+}
+template<typename K, typename V, typename C, typename A>
+bool operator<=(const ordered_map<K,V,C,A>& lhs, const ordered_map<K,V,C,A>& rhs)
+{
+    return !(lhs > rhs);
+}
+template<typename K, typename V, typename C, typename A>
+bool operator>=(const ordered_map<K,V,C,A>& lhs, const ordered_map<K,V,C,A>& rhs)
+{
+    return !(lhs < rhs);
+}
+
+template<typename K, typename V, typename C, typename A>
+void swap(ordered_map<K,V,C,A>& lhs, ordered_map<K,V,C,A>& rhs)
+{
+    lhs.swap(rhs);
+    return;
+}
+
+
+} // toml
+#endif // TOML11_ORDERED_MAP_HPP
+#ifndef TOML11_INTO_HPP
+#define TOML11_INTO_HPP
+
+namespace toml
+{
+
+template<typename T>
+struct into;
+// {
+//     static toml::value into_toml(const T& user_defined_type)
+//     {
+//         // User-defined conversions ...
+//     }
+// };
+
+} // toml
+#endif // TOML11_INTO_HPP
+#ifndef TOML11_FROM_HPP
+#define TOML11_FROM_HPP
+
+namespace toml
+{
+
+template<typename T>
+struct from;
+// {
+//     static T from_toml(const toml::value& v)
+//     {
+//         // User-defined conversions ...
+//     }
+// };
+
+} // toml
+#endif // TOML11_FROM_HPP
+#ifndef TOML11_TRAITS_HPP
+#define TOML11_TRAITS_HPP
+
+
+#include <array>
+#include <chrono>
+#include <forward_list>
+#include <string>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+
+#if defined(TOML11_HAS_STRING_VIEW)
+#include <string_view>
+#endif
+
+namespace toml
+{
+template<typename TypeConcig>
+class basic_value;
+
+namespace detail
+{
+// ---------------------------------------------------------------------------
+// check whether type T is a kind of container/map class
+
+struct has_iterator_impl
+{
+    template<typename T> static std::true_type  check(typename T::iterator*);
+    template<typename T> static std::false_type check(...);
+};
+struct has_value_type_impl
+{
+    template<typename T> static std::true_type  check(typename T::value_type*);
+    template<typename T> static std::false_type check(...);
+};
+struct has_key_type_impl
+{
+    template<typename T> static std::true_type  check(typename T::key_type*);
+    template<typename T> static std::false_type check(...);
+};
+struct has_mapped_type_impl
+{
+    template<typename T> static std::true_type  check(typename T::mapped_type*);
+    template<typename T> static std::false_type check(...);
+};
+struct has_reserve_method_impl
+{
+    template<typename T> static std::false_type check(...);
+    template<typename T> static std::true_type  check(
+        decltype(std::declval<T>().reserve(std::declval<std::size_t>()))*);
+};
+struct has_push_back_method_impl
+{
+    template<typename T> static std::false_type check(...);
+    template<typename T> static std::true_type  check(
+        decltype(std::declval<T>().push_back(std::declval<typename T::value_type>()))*);
+};
+struct is_comparable_impl
+{
+    template<typename T> static std::false_type check(...);
+    template<typename T> static std::true_type  check(
+        decltype(std::declval<T>() < std::declval<T>())*);
+};
+
+struct has_from_toml_method_impl
+{
+    template<typename T, typename TC>
+    static std::true_type  check(
+        decltype(std::declval<T>().from_toml(std::declval<::toml::basic_value<TC>>()))*);
+
+    template<typename T, typename TC>
+    static std::false_type check(...);
+};
+struct has_into_toml_method_impl
+{
+    template<typename T>
+    static std::true_type  check(decltype(std::declval<T>().into_toml())*);
+    template<typename T>
+    static std::false_type check(...);
+};
+
+struct has_template_into_toml_method_impl
+{
+    template<typename T, typename TypeConfig>
+    static std::true_type  check(decltype(std::declval<T>().template into_toml<TypeConfig>())*);
+    template<typename T, typename TypeConfig>
+    static std::false_type check(...);
+};
+
+struct has_specialized_from_impl
+{
+    template<typename T>
+    static std::false_type check(...);
+    template<typename T, std::size_t S = sizeof(::toml::from<T>)>
+    static std::true_type check(::toml::from<T>*);
+};
+struct has_specialized_into_impl
+{
+    template<typename T>
+    static std::false_type check(...);
+    template<typename T, std::size_t S = sizeof(::toml::into<T>)>
+    static std::true_type check(::toml::into<T>*);
+};
+
+
+/// Intel C++ compiler can not use decltype in parent class declaration, here
+/// is a hack to work around it. https://stackoverflow.com/a/23953090/4692076
+#ifdef __INTEL_COMPILER
+#define decltype(...) std::enable_if<true, decltype(__VA_ARGS__)>::type
+#endif
+
+template<typename T>
+struct has_iterator: decltype(has_iterator_impl::check<T>(nullptr)){};
+template<typename T>
+struct has_value_type: decltype(has_value_type_impl::check<T>(nullptr)){};
+template<typename T>
+struct has_key_type: decltype(has_key_type_impl::check<T>(nullptr)){};
+template<typename T>
+struct has_mapped_type: decltype(has_mapped_type_impl::check<T>(nullptr)){};
+template<typename T>
+struct has_reserve_method: decltype(has_reserve_method_impl::check<T>(nullptr)){};
+template<typename T>
+struct has_push_back_method: decltype(has_push_back_method_impl::check<T>(nullptr)){};
+template<typename T>
+struct is_comparable: decltype(is_comparable_impl::check<T>(nullptr)){};
+
+template<typename T, typename TC>
+struct has_from_toml_method: decltype(has_from_toml_method_impl::check<T, TC>(nullptr)){};
+
+template<typename T>
+struct has_into_toml_method: decltype(has_into_toml_method_impl::check<T>(nullptr)){};
+
+template<typename T, typename TypeConfig>
+struct has_template_into_toml_method: decltype(has_template_into_toml_method_impl::check<T, TypeConfig>(nullptr)){};
+
+template<typename T>
+struct has_specialized_from: decltype(has_specialized_from_impl::check<T>(nullptr)){};
+template<typename T>
+struct has_specialized_into: decltype(has_specialized_into_impl::check<T>(nullptr)){};
+
+#ifdef __INTEL_COMPILER
+#undef decltype
+#endif
+
+// ---------------------------------------------------------------------------
+// type checkers
+
+template<typename T> struct is_std_pair_impl : std::false_type{};
+template<typename T1, typename T2>
+struct is_std_pair_impl<std::pair<T1, T2>> : std::true_type{};
+template<typename T>
+using is_std_pair = is_std_pair_impl<cxx::remove_cvref_t<T>>;
+
+template<typename T> struct is_std_tuple_impl : std::false_type{};
+template<typename ... Ts>
+struct is_std_tuple_impl<std::tuple<Ts...>> : std::true_type{};
+template<typename T>
+using is_std_tuple = is_std_tuple_impl<cxx::remove_cvref_t<T>>;
+
+template<typename T> struct is_std_array_impl : std::false_type{};
+template<typename T, std::size_t N>
+struct is_std_array_impl<std::array<T, N>> : std::true_type{};
+template<typename T>
+using is_std_array = is_std_array_impl<cxx::remove_cvref_t<T>>;
+
+template<typename T> struct is_std_forward_list_impl : std::false_type{};
+template<typename T>
+struct is_std_forward_list_impl<std::forward_list<T>> : std::true_type{};
+template<typename T>
+using is_std_forward_list = is_std_forward_list_impl<cxx::remove_cvref_t<T>>;
+
+template<typename T> struct is_std_basic_string_impl : std::false_type{};
+template<typename C, typename T, typename A>
+struct is_std_basic_string_impl<std::basic_string<C, T, A>> : std::true_type{};
+template<typename T>
+using is_std_basic_string = is_std_basic_string_impl<cxx::remove_cvref_t<T>>;
+
+template<typename T> struct is_1byte_std_basic_string_impl : std::false_type{};
+template<typename C, typename T, typename A>
+struct is_1byte_std_basic_string_impl<std::basic_string<C, T, A>>
+    : std::integral_constant<bool, sizeof(C) == sizeof(char)> {};
+template<typename T>
+using is_1byte_std_basic_string = is_std_basic_string_impl<cxx::remove_cvref_t<T>>;
+
+#if defined(TOML11_HAS_STRING_VIEW)
+template<typename T> struct is_std_basic_string_view_impl : std::false_type{};
+template<typename C, typename T>
+struct is_std_basic_string_view_impl<std::basic_string_view<C, T>> : std::true_type{};
+template<typename T>
+using is_std_basic_string_view = is_std_basic_string_view_impl<cxx::remove_cvref_t<T>>;
+
+template<typename V, typename S>
+struct is_string_view_of : std::false_type {};
+template<typename C, typename T>
+struct is_string_view_of<std::basic_string_view<C, T>, std::basic_string<C, T>> : std::true_type {};
+#endif
+
+template<typename T> struct is_chrono_duration_impl: std::false_type{};
+template<typename Rep, typename Period>
+struct is_chrono_duration_impl<std::chrono::duration<Rep, Period>>: std::true_type{};
+template<typename T>
+using is_chrono_duration = is_chrono_duration_impl<cxx::remove_cvref_t<T>>;
+
+template<typename T>
+struct is_map_impl : cxx::conjunction< // map satisfies all the following conditions
+    has_iterator<T>,         // has T::iterator
+    has_value_type<T>,       // has T::value_type
+    has_key_type<T>,         // has T::key_type
+    has_mapped_type<T>       // has T::mapped_type
+    >{};
+template<typename T>
+using is_map = is_map_impl<cxx::remove_cvref_t<T>>;
+
+template<typename T>
+struct is_container_impl : cxx::conjunction<
+    cxx::negation<is_map<T>>,                         // not a map
+    cxx::negation<std::is_same<T, std::string>>,      // not a std::string
+#ifdef TOML11_HAS_STRING_VIEW
+    cxx::negation<std::is_same<T, std::string_view>>, // not a std::string_view
+#endif
+    has_iterator<T>,                             // has T::iterator
+    has_value_type<T>                            // has T::value_type
+    >{};
+template<typename T>
+using is_container = is_container_impl<cxx::remove_cvref_t<T>>;
+
+template<typename T>
+struct is_basic_value_impl: std::false_type{};
+template<typename TC>
+struct is_basic_value_impl<::toml::basic_value<TC>>: std::true_type{};
+template<typename T>
+using is_basic_value = is_basic_value_impl<cxx::remove_cvref_t<T>>;
+
+}// detail
+}//toml
+#endif // TOML11_TRAITS_HPP
+#ifndef TOML11_EXCEPTION_HPP
+#define TOML11_EXCEPTION_HPP
+
+#include <exception>
+
+namespace toml
+{
+
+struct exception : public std::exception
+{
+  public:
+    virtual ~exception() noexcept override = default;
+    virtual const char* what() const noexcept override {return "";}
+};
+
+} // toml
+#endif // TOMl11_EXCEPTION_HPP
+#ifndef TOML11_RESULT_HPP
+#define TOML11_RESULT_HPP
+
+
+#include <ostream>
+#include <string>
+#include <type_traits>
+#include <utility>
+
+#include <cassert>
+
+namespace toml
+{
+
+struct bad_result_access final : public ::toml::exception
+{
+  public:
+    explicit bad_result_access(std::string what_arg)
+        : what_(std::move(what_arg))
+    {}
+    ~bad_result_access() noexcept override = default;
+    const char* what() const noexcept override {return what_.c_str();}
+
+  private:
+    std::string what_;
+};
+
+// -----------------------------------------------------------------------------
+
+template<typename T>
+struct success
+{
+    static_assert( ! std::is_same<T, void>::value, "");
+
+    using value_type = T;
+
+    explicit success(value_type v)
+        noexcept(std::is_nothrow_move_constructible<value_type>::value)
+        : value(std::move(v))
+    {}
+
+    template<typename U, cxx::enable_if_t<
+        std::is_convertible<cxx::remove_cvref_t<U>, T>::value,
+        std::nullptr_t> = nullptr>
+    explicit success(U&& v): value(std::forward<U>(v)) {}
+
+    template<typename U>
+    explicit success(success<U> v): value(std::move(v.value)) {}
+
+    ~success() = default;
+    success(const success&) = default;
+    success(success&&)      = default;
+    success& operator=(const success&) = default;
+    success& operator=(success&&)      = default;
+
+    value_type&       get()       noexcept {return value;}
+    value_type const& get() const noexcept {return value;}
+
+  private:
+
+    value_type value;
+};
+
+template<typename T>
+struct success<std::reference_wrapper<T>>
+{
+    static_assert( ! std::is_same<T, void>::value, "");
+
+    using value_type = T;
+
+    explicit success(std::reference_wrapper<value_type> v) noexcept
+        : value(std::move(v))
+    {}
+
+    ~success() = default;
+    success(const success&) = default;
+    success(success&&)      = default;
+    success& operator=(const success&) = default;
+    success& operator=(success&&)      = default;
+
+    value_type&       get()       noexcept {return value.get();}
+    value_type const& get() const noexcept {return value.get();}
+
+  private:
+
+    std::reference_wrapper<value_type> value;
+};
+
+template<typename T>
+success<typename std::decay<T>::type> ok(T&& v)
+{
+    return success<typename std::decay<T>::type>(std::forward<T>(v));
+}
+template<std::size_t N>
+success<std::string> ok(const char (&literal)[N])
+{
+    return success<std::string>(std::string(literal));
+}
+
+// -----------------------------------------------------------------------------
+
+template<typename T>
+struct failure
+{
+    using value_type = T;
+
+    explicit failure(value_type v)
+        noexcept(std::is_nothrow_move_constructible<value_type>::value)
+        : value(std::move(v))
+    {}
+
+    template<typename U, cxx::enable_if_t<
+        std::is_convertible<cxx::remove_cvref_t<U>, T>::value,
+        std::nullptr_t> = nullptr>
+    explicit failure(U&& v): value(std::forward<U>(v)) {}
+
+    template<typename U>
+    explicit failure(failure<U> v): value(std::move(v.value)) {}
+
+    ~failure() = default;
+    failure(const failure&) = default;
+    failure(failure&&)      = default;
+    failure& operator=(const failure&) = default;
+    failure& operator=(failure&&)      = default;
+
+    value_type&       get()       noexcept {return value;}
+    value_type const& get() const noexcept {return value;}
+
+  private:
+
+    value_type value;
+};
+
+template<typename T>
+struct failure<std::reference_wrapper<T>>
+{
+    using value_type = T;
+
+    explicit failure(std::reference_wrapper<value_type> v) noexcept
+        : value(std::move(v))
+    {}
+
+    ~failure() = default;
+    failure(const failure&) = default;
+    failure(failure&&)      = default;
+    failure& operator=(const failure&) = default;
+    failure& operator=(failure&&)      = default;
+
+    value_type&       get()       noexcept {return value.get();}
+    value_type const& get() const noexcept {return value.get();}
+
+  private:
+
+    std::reference_wrapper<value_type> value;
+};
+
+template<typename T>
+failure<typename std::decay<T>::type> err(T&& v)
+{
+    return failure<typename std::decay<T>::type>(std::forward<T>(v));
+}
+
+template<std::size_t N>
+failure<std::string> err(const char (&literal)[N])
+{
+    return failure<std::string>(std::string(literal));
+}
+
+/* ============================================================================
+ *                  _ _
+ *  _ _ ___ ____  _| | |_
+ * | '_/ -_|_-< || | |  _|
+ * |_| \___/__/\_,_|_|\__|
+ */
+
+template<typename T, typename E>
+struct result
+{
+    using success_type = success<T>;
+    using failure_type = failure<E>;
+    using value_type = typename success_type::value_type;
+    using error_type = typename failure_type::value_type;
+
+    result(success_type s): is_ok_(true),  succ_(std::move(s)) {}
+    result(failure_type f): is_ok_(false), fail_(std::move(f)) {}
+
+    template<typename U, cxx::enable_if_t<cxx::conjunction<
+            cxx::negation<std::is_same<cxx::remove_cvref_t<U>, value_type>>,
+            std::is_convertible<cxx::remove_cvref_t<U>, value_type>
+        >::value, std::nullptr_t> = nullptr>
+    result(success<U> s): is_ok_(true),  succ_(std::move(s.value)) {}
+
+    template<typename U, cxx::enable_if_t<cxx::conjunction<
+            cxx::negation<std::is_same<cxx::remove_cvref_t<U>, error_type>>,
+            std::is_convertible<cxx::remove_cvref_t<U>, error_type>
+        >::value, std::nullptr_t> = nullptr>
+    result(failure<U> f): is_ok_(false), fail_(std::move(f.value)) {}
+
+    result& operator=(success_type s)
+    {
+        this->cleanup();
+        this->is_ok_ = true;
+        auto tmp = ::new(std::addressof(this->succ_)) success_type(std::move(s));
+        assert(tmp == std::addressof(this->succ_));
+        (void)tmp;
+        return *this;
+    }
+    result& operator=(failure_type f)
+    {
+        this->cleanup();
+        this->is_ok_ = false;
+        auto tmp = ::new(std::addressof(this->fail_)) failure_type(std::move(f));
+        assert(tmp == std::addressof(this->fail_));
+        (void)tmp;
+        return *this;
+    }
+
+    template<typename U>
+    result& operator=(success<U> s)
+    {
+        this->cleanup();
+        this->is_ok_ = true;
+        auto tmp = ::new(std::addressof(this->succ_)) success_type(std::move(s.value));
+        assert(tmp == std::addressof(this->succ_));
+        (void)tmp;
+        return *this;
+    }
+    template<typename U>
+    result& operator=(failure<U> f)
+    {
+        this->cleanup();
+        this->is_ok_ = false;
+        auto tmp = ::new(std::addressof(this->fail_)) failure_type(std::move(f.value));
+        assert(tmp == std::addressof(this->fail_));
+        (void)tmp;
+        return *this;
+    }
+
+    ~result() noexcept {this->cleanup();}
+
+    result(const result& other): is_ok_(other.is_ok())
+    {
+        if(other.is_ok())
+        {
+            auto tmp = ::new(std::addressof(this->succ_)) success_type(other.succ_);
+            assert(tmp == std::addressof(this->succ_));
+            (void)tmp;
+        }
+        else
+        {
+            auto tmp = ::new(std::addressof(this->fail_)) failure_type(other.fail_);
+            assert(tmp == std::addressof(this->fail_));
+            (void)tmp;
+        }
+    }
+    result(result&& other): is_ok_(other.is_ok())
+    {
+        if(other.is_ok())
+        {
+            auto tmp = ::new(std::addressof(this->succ_)) success_type(std::move(other.succ_));
+            assert(tmp == std::addressof(this->succ_));
+            (void)tmp;
+        }
+        else
+        {
+            auto tmp = ::new(std::addressof(this->fail_)) failure_type(std::move(other.fail_));
+            assert(tmp == std::addressof(this->fail_));
+            (void)tmp;
+        }
+    }
+
+    result& operator=(const result& other)
+    {
+        this->cleanup();
+        if(other.is_ok())
+        {
+            auto tmp = ::new(std::addressof(this->succ_)) success_type(other.succ_);
+            assert(tmp == std::addressof(this->succ_));
+            (void)tmp;
+        }
+        else
+        {
+            auto tmp = ::new(std::addressof(this->fail_)) failure_type(other.fail_);
+            assert(tmp == std::addressof(this->fail_));
+            (void)tmp;
+        }
+        is_ok_ = other.is_ok();
+        return *this;
+    }
+    result& operator=(result&& other)
+    {
+        this->cleanup();
+        if(other.is_ok())
+        {
+            auto tmp = ::new(std::addressof(this->succ_)) success_type(std::move(other.succ_));
+            assert(tmp == std::addressof(this->succ_));
+            (void)tmp;
+        }
+        else
+        {
+            auto tmp = ::new(std::addressof(this->fail_)) failure_type(std::move(other.fail_));
+            assert(tmp == std::addressof(this->fail_));
+            (void)tmp;
+        }
+        is_ok_ = other.is_ok();
+        return *this;
+    }
+
+    template<typename U, typename F, cxx::enable_if_t<cxx::conjunction<
+            cxx::negation<std::is_same<cxx::remove_cvref_t<U>, value_type>>,
+            cxx::negation<std::is_same<cxx::remove_cvref_t<F>, error_type>>,
+            std::is_convertible<cxx::remove_cvref_t<U>, value_type>,
+            std::is_convertible<cxx::remove_cvref_t<F>, error_type>
+        >::value, std::nullptr_t> = nullptr>
+    result(result<U, F> other): is_ok_(other.is_ok())
+    {
+        if(other.is_ok())
+        {
+            auto tmp = ::new(std::addressof(this->succ_)) success_type(std::move(other.as_ok()));
+            assert(tmp == std::addressof(this->succ_));
+            (void)tmp;
+        }
+        else
+        {
+            auto tmp = ::new(std::addressof(this->fail_)) failure_type(std::move(other.as_err()));
+            assert(tmp == std::addressof(this->fail_));
+            (void)tmp;
+        }
+    }
+
+    template<typename U, typename F, cxx::enable_if_t<cxx::conjunction<
+            cxx::negation<std::is_same<cxx::remove_cvref_t<U>, value_type>>,
+            cxx::negation<std::is_same<cxx::remove_cvref_t<F>, error_type>>,
+            std::is_convertible<cxx::remove_cvref_t<U>, value_type>,
+            std::is_convertible<cxx::remove_cvref_t<F>, error_type>
+        >::value, std::nullptr_t> = nullptr>
+    result& operator=(result<U, F> other)
+    {
+        this->cleanup();
+        if(other.is_ok())
+        {
+            auto tmp = ::new(std::addressof(this->succ_)) success_type(std::move(other.as_ok()));
+            assert(tmp == std::addressof(this->succ_));
+            (void)tmp;
+        }
+        else
+        {
+            auto tmp = ::new(std::addressof(this->fail_)) failure_type(std::move(other.as_err()));
+            assert(tmp == std::addressof(this->fail_));
+            (void)tmp;
+        }
+        is_ok_ = other.is_ok();
+        return *this;
+    }
+
+    bool is_ok()  const noexcept {return is_ok_;}
+    bool is_err() const noexcept {return !is_ok_;}
+
+    explicit operator bool() const noexcept {return is_ok_;}
+
+    value_type& unwrap(cxx::source_location loc = cxx::source_location::current())
+    {
+        if(this->is_err())
+        {
+            throw bad_result_access("toml::result: bad unwrap" + cxx::to_string(loc));
+        }
+        return this->succ_.get();
+    }
+    value_type const& unwrap(cxx::source_location loc = cxx::source_location::current()) const
+    {
+        if(this->is_err())
+        {
+            throw bad_result_access("toml::result: bad unwrap" + cxx::to_string(loc));
+        }
+        return this->succ_.get();
+    }
+
+    value_type& unwrap_or(value_type& opt) noexcept
+    {
+        if(this->is_err()) {return opt;}
+        return this->succ_.get();
+    }
+    value_type const& unwrap_or(value_type const& opt) const noexcept
+    {
+        if(this->is_err()) {return opt;}
+        return this->succ_.get();
+    }
+
+    error_type& unwrap_err(cxx::source_location loc = cxx::source_location::current())
+    {
+        if(this->is_ok())
+        {
+            throw bad_result_access("toml::result: bad unwrap_err" + cxx::to_string(loc));
+        }
+        return this->fail_.get();
+    }
+    error_type const& unwrap_err(cxx::source_location loc = cxx::source_location::current()) const
+    {
+        if(this->is_ok())
+        {
+            throw bad_result_access("toml::result: bad unwrap_err" + cxx::to_string(loc));
+        }
+        return this->fail_.get();
+    }
+
+    value_type& as_ok() noexcept
+    {
+        assert(this->is_ok());
+        return this->succ_.get();
+    }
+    value_type const& as_ok() const noexcept
+    {
+        assert(this->is_ok());
+        return this->succ_.get();
+    }
+
+    error_type& as_err() noexcept
+    {
+        assert(this->is_err());
+        return this->fail_.get();
+    }
+    error_type const& as_err() const noexcept
+    {
+        assert(this->is_err());
+        return this->fail_.get();
+    }
+
+  private:
+
+    void cleanup() noexcept
+    {
+#if defined(__GNUC__) && ! defined(__clang__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wduplicated-branches"
+#endif
+
+        if(this->is_ok_) {this->succ_.~success_type();}
+        else             {this->fail_.~failure_type();}
+
+#if defined(__GNUC__) && ! defined(__clang__)
+#pragma GCC diagnostic pop
+#endif
+        return;
+    }
+
+  private:
+
+    bool      is_ok_;
+    union
+    {
+        success_type succ_;
+        failure_type fail_;
+    };
+};
+
+// ----------------------------------------------------------------------------
+
+namespace detail
+{
+struct none_t {};
+inline bool operator==(const none_t&, const none_t&) noexcept {return true;}
+inline bool operator!=(const none_t&, const none_t&) noexcept {return false;}
+inline bool operator< (const none_t&, const none_t&) noexcept {return false;}
+inline bool operator<=(const none_t&, const none_t&) noexcept {return true;}
+inline bool operator> (const none_t&, const none_t&) noexcept {return false;}
+inline bool operator>=(const none_t&, const none_t&) noexcept {return true;}
+inline std::ostream& operator<<(std::ostream& os, const none_t&)
+{
+    os << "none";
+    return os;
+}
+} // detail
+
+inline success<detail::none_t> ok() noexcept
+{
+    return success<detail::none_t>(detail::none_t{});
+}
+inline failure<detail::none_t> err() noexcept
+{
+    return failure<detail::none_t>(detail::none_t{});
+}
+
+} // toml
+#endif // TOML11_RESULT_HPP
+#ifndef TOML11_UTILITY_HPP
+#define TOML11_UTILITY_HPP
+
+
+#include <array>
+#include <sstream>
+
+#include <cassert>
+#include <cctype>
+#include <cstring>
+
+namespace toml
+{
+namespace detail
+{
+
+// to output character in an error message.
+inline std::string show_char(const int c)
+{
+    using char_type = unsigned char;
+    if(std::isgraph(c))
+    {
+        return std::string(1, static_cast<char>(c));
+    }
+    else
+    {
+        std::array<char, 5> buf;
+        buf.fill('\0');
+        const auto r = std::snprintf(buf.data(), buf.size(), "0x%02x", c & 0xFF);
+        assert(r == static_cast<int>(buf.size()) - 1);
+        (void) r; // Unused variable warning
+        auto in_hex = std::string(buf.data());
+        switch(c)
+        {
+            case char_type('\0'):   {in_hex += "(NUL)";             break;}
+            case char_type(' ') :   {in_hex += "(SPACE)";           break;}
+            case char_type('\n'):   {in_hex += "(LINE FEED)";       break;}
+            case char_type('\r'):   {in_hex += "(CARRIAGE RETURN)"; break;}
+            case char_type('\t'):   {in_hex += "(TAB)";             break;}
+            case char_type('\v'):   {in_hex += "(VERTICAL TAB)";    break;}
+            case char_type('\f'):   {in_hex += "(FORM FEED)";       break;}
+            case char_type('\x1B'): {in_hex += "(ESCAPE)";          break;}
+            default: break;
+        }
+        return in_hex;
+    }
+}
+
+// ---------------------------------------------------------------------------
+
+template<typename Container>
+void try_reserve_impl(Container& container, std::size_t N, std::true_type)
+{
+    container.reserve(N);
+    return;
+}
+template<typename Container>
+void try_reserve_impl(Container&, std::size_t, std::false_type) noexcept
+{
+    return;
+}
+
+template<typename Container>
+void try_reserve(Container& container, std::size_t N)
+{
+    try_reserve_impl(container, N, has_reserve_method<Container>{});
+    return;
+}
+
+// ---------------------------------------------------------------------------
+
+template<typename T>
+result<T, none_t> from_string(const std::string& str)
+{
+    T v;
+    std::istringstream iss(str);
+    iss >> v;
+    if(iss.fail())
+    {
+        return err();
+    }
+    return ok(v);
+}
+
+// ---------------------------------------------------------------------------
+
+// helper function to avoid std::string(0, 'c') or std::string(iter, iter)
+template<typename Iterator>
+std::string make_string(Iterator first, Iterator last)
+{
+    if(first == last) {return "";}
+    return std::string(first, last);
+}
+inline std::string make_string(std::size_t len, char c)
+{
+    if(len == 0) {return "";}
+    return std::string(len, c);
+}
+
+// ---------------------------------------------------------------------------
+
+template<typename Char,  typename Traits, typename Alloc,
+         typename Char2, typename Traits2, typename Alloc2>
+struct string_conv_impl
+{
+    static_assert(sizeof(Char)  == sizeof(char), "");
+    static_assert(sizeof(Char2) == sizeof(char), "");
+
+    static std::basic_string<Char, Traits, Alloc> invoke(std::basic_string<Char2, Traits2, Alloc2> s)
+    {
+        std::basic_string<Char, Traits, Alloc> retval;
+        std::transform(s.begin(), s.end(), std::back_inserter(retval),
+            [](const Char2 c) {return static_cast<Char>(c);});
+        return retval;
+    }
+    template<std::size_t N>
+    static std::basic_string<Char, Traits, Alloc> invoke(const Char2 (&s)[N])
+    {
+        std::basic_string<Char, Traits, Alloc> retval;
+        // "string literal" has null-char at the end. to skip it, we use prev.
+        std::transform(std::begin(s), std::prev(std::end(s)), std::back_inserter(retval),
+            [](const Char2 c) {return static_cast<Char>(c);});
+        return retval;
+    }
+};
+
+template<typename Char,  typename Traits, typename Alloc>
+struct string_conv_impl<Char, Traits, Alloc, Char, Traits, Alloc>
+{
+    static_assert(sizeof(Char) == sizeof(char), "");
+
+    static std::basic_string<Char, Traits, Alloc> invoke(std::basic_string<Char, Traits, Alloc> s)
+    {
+        return s;
+    }
+    template<std::size_t N>
+    static std::basic_string<Char, Traits, Alloc> invoke(const Char (&s)[N])
+    {
+        return std::basic_string<Char, Traits, Alloc>(s);
+    }
+};
+
+template<typename S, typename Char2, typename Traits2, typename Alloc2>
+cxx::enable_if_t<is_std_basic_string<S>::value, S>
+string_conv(std::basic_string<Char2, Traits2, Alloc2> s)
+{
+    using C = typename S::value_type;
+    using T = typename S::traits_type;
+    using A = typename S::allocator_type;
+    return string_conv_impl<C, T, A, Char2, Traits2, Alloc2>::invoke(std::move(s));
+}
+template<typename S, std::size_t N>
+cxx::enable_if_t<is_std_basic_string<S>::value, S>
+string_conv(const char (&s)[N])
+{
+    using C = typename S::value_type;
+    using T = typename S::traits_type;
+    using A = typename S::allocator_type;
+    using C2 = char;
+    using T2 = std::char_traits<C2>;
+    using A2 = std::allocator<C2>;
+
+    return string_conv_impl<C, T, A, C2, T2, A2>::template invoke<N>(s);
+}
+
+} // namespace detail
+} // namespace toml
+#endif // TOML11_UTILITY_HPP
+#ifndef TOML11_LOCATION_HPP
+#define TOML11_LOCATION_HPP
+
+#ifndef TOML11_LOCATION_FWD_HPP
+#define TOML11_LOCATION_FWD_HPP
+
+
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace toml
+{
+namespace detail
+{
+
+class region; // fwd decl
+
+//
+// To represent where we are reading in the parse functions.
+// Since it "points" somewhere in the input stream, the length is always 1.
+//
+class location
+{
+  public:
+
+    using char_type       = unsigned char; // must be unsigned
+    using container_type  = std::vector<char_type>;
+    using difference_type = typename container_type::difference_type; // to suppress sign-conversion warning
+    using source_ptr      = std::shared_ptr<const container_type>;
+
+  public:
+
+    location(source_ptr src, std::string src_name)
+        : source_(std::move(src)), source_name_(std::move(src_name)),
+          location_(0), line_number_(1)
+    {}
+
+    location(const location&) = default;
+    location(location&&)      = default;
+    location& operator=(const location&) = default;
+    location& operator=(location&&)      = default;
+    ~location() = default;
+
+    void advance(std::size_t n = 1) noexcept;
+    void retrace(std::size_t n = 1) noexcept;
+
+    bool is_ok() const noexcept { return static_cast<bool>(this->source_); }
+
+    bool eof() const noexcept;
+    char_type current() const;
+
+    char_type peek();
+
+    std::size_t get_location() const noexcept
+    {
+        return this->location_;
+    }
+    void set_location(const std::size_t loc) noexcept;
+
+    std::size_t line_number() const noexcept
+    {
+        return this->line_number_;
+    }
+    std::string get_line() const;
+    std::size_t column_number() const noexcept;
+
+    source_ptr const&  source()      const noexcept {return this->source_;}
+    std::string const& source_name() const noexcept {return this->source_name_;}
+
+  private:
+
+    void advance_line_number(const std::size_t n);
+    void retrace_line_number(const std::size_t n);
+
+  private:
+
+    friend region;
+
+  private:
+
+    source_ptr  source_;
+    std::string source_name_;
+    std::size_t location_; // std::vector<>::difference_type is signed
+    std::size_t line_number_;
+};
+
+bool operator==(const location& lhs, const location& rhs) noexcept;
+bool operator!=(const location& lhs, const location& rhs);
+
+location prev(const location& loc);
+location next(const location& loc);
+location make_temporary_location(const std::string& str) noexcept;
+
+template<typename F>
+result<location, none_t>
+find_if(const location& first, const location& last, const F& func) noexcept
+{
+    if(first.source() != last.source())             { return err(); }
+    if(first.get_location() >= last.get_location()) { return err(); }
+
+    auto loc = first;
+    while(loc.get_location() != last.get_location())
+    {
+        if(func(loc.current()))
+        {
+            return ok(loc);
+        }
+        loc.advance();
+    }
+    return err();
+}
+
+template<typename F>
+result<location, none_t>
+rfind_if(location first, const location& last, const F& func)
+{
+    if(first.source() != last.source())             { return err(); }
+    if(first.get_location() >= last.get_location()) { return err(); }
+
+    auto loc = last;
+    while(loc.get_location() != first.get_location())
+    {
+        if(func(loc.current()))
+        {
+            return ok(loc);
+        }
+        loc.retrace();
+    }
+    if(func(first.current()))
+    {
+        return ok(first);
+    }
+    return err();
+}
+
+result<location, none_t> find(const location& first, const location& last,
+                              const location::char_type val);
+result<location, none_t> rfind(const location& first, const location& last,
+                               const location::char_type val);
+
+std::size_t count(const location& first, const location& last,
+                  const location::char_type& c);
+
+} // detail
+} // toml
+#endif // TOML11_LOCATION_FWD_HPP
+
+#if ! defined(TOML11_COMPILE_SOURCES)
+#ifndef TOML11_LOCATION_IMPL_HPP
+#define TOML11_LOCATION_IMPL_HPP
+
+
+namespace toml
+{
+namespace detail
+{
+
+TOML11_INLINE void location::advance(std::size_t n) noexcept
+{
+    assert(this->is_ok());
+    if(this->location_ + n < this->source_->size())
+    {
+        this->advance_line_number(n);
+        this->location_ += n;
+    }
+    else
+    {
+        this->advance_line_number(this->source_->size() - this->location_);
+        this->location_ = this->source_->size();
+    }
+}
+TOML11_INLINE void location::retrace(std::size_t n) noexcept
+{
+    assert(this->is_ok());
+    if(this->location_ < n)
+    {
+        this->location_ = 0;
+        this->line_number_ = 1;
+    }
+    else
+    {
+        this->retrace_line_number(n);
+        this->location_ -= n;
+    }
+}
+
+TOML11_INLINE bool location::eof() const noexcept
+{
+    assert(this->is_ok());
+    return this->location_ >= this->source_->size();
+}
+TOML11_INLINE location::char_type location::current() const
+{
+    assert(this->is_ok());
+    if(this->eof()) {return '\0';}
+
+    assert(this->location_ < this->source_->size());
+    return this->source_->at(this->location_);
+}
+
+TOML11_INLINE location::char_type location::peek()
+{
+    assert(this->is_ok());
+    if(this->location_ >= this->source_->size())
+    {
+        return '\0';
+    }
+    else
+    {
+        return this->source_->at(this->location_ + 1);
+    }
+}
+
+TOML11_INLINE void location::set_location(const std::size_t loc) noexcept
+{
+    if(this->location_ == loc)
+    {
+        return ;
+    }
+
+    if(loc == 0)
+    {
+        this->line_number_ = 1;
+    }
+    else if(this->location_ < loc)
+    {
+        const auto d = loc - this->location_;
+        this->advance_line_number(d);
+    }
+    else
+    {
+        const auto d = this->location_ - loc;
+        this->retrace_line_number(d);
+    }
+    this->location_ = loc;
+}
+
+TOML11_INLINE std::string location::get_line() const
+{
+    assert(this->is_ok());
+    const auto iter = std::next(this->source_->cbegin(), static_cast<difference_type>(this->location_));
+    const auto riter = cxx::make_reverse_iterator(iter);
+
+    const auto prev = std::find(riter, this->source_->crend(), char_type('\n'));
+    const auto next = std::find(iter,  this->source_->cend(),  char_type('\n'));
+
+    return make_string(std::next(prev.base()), next);
+}
+TOML11_INLINE std::size_t location::column_number() const noexcept
+{
+    assert(this->is_ok());
+    const auto iter  = std::next(this->source_->cbegin(), static_cast<difference_type>(this->location_));
+    const auto riter = cxx::make_reverse_iterator(iter);
+    const auto prev  = std::find(riter, this->source_->crend(), char_type('\n'));
+
+    assert(prev.base() <= iter);
+    return static_cast<std::size_t>(std::distance(prev.base(), iter) + 1); // 1-origin
+}
+
+
+TOML11_INLINE void location::advance_line_number(const std::size_t n)
+{
+    assert(this->is_ok());
+    assert(this->location_ + n <= this->source_->size());
+
+    const auto iter = this->source_->cbegin();
+    this->line_number_ += static_cast<std::size_t>(std::count(
+        std::next(iter, static_cast<difference_type>(this->location_)),
+        std::next(iter, static_cast<difference_type>(this->location_ + n)),
+        char_type('\n')));
+
+    return;
+}
+TOML11_INLINE void location::retrace_line_number(const std::size_t n)
+{
+    assert(this->is_ok());
+    assert(n <= this->location_); // loc - n >= 0
+
+    const auto iter = this->source_->cbegin();
+    const auto dline_num = static_cast<std::size_t>(std::count(
+        std::next(iter, static_cast<difference_type>(this->location_ - n)),
+        std::next(iter, static_cast<difference_type>(this->location_)),
+        char_type('\n')));
+
+    if(this->line_number_ <= dline_num)
+    {
+        this->line_number_ = 1;
+    }
+    else
+    {
+        this->line_number_ -= dline_num;
+    }
+    return;
+}
+
+TOML11_INLINE bool operator==(const location& lhs, const location& rhs) noexcept
+{
+    if( ! lhs.is_ok() || ! rhs.is_ok())
+    {
+        return (!lhs.is_ok()) && (!rhs.is_ok());
+    }
+    return lhs.source()       == rhs.source()      &&
+           lhs.source_name()  == rhs.source_name() &&
+           lhs.get_location() == rhs.get_location();
+}
+TOML11_INLINE bool operator!=(const location& lhs, const location& rhs)
+{
+    return !(lhs == rhs);
+}
+
+TOML11_INLINE location prev(const location& loc)
+{
+    location p(loc);
+    p.retrace(1);
+    return p;
+}
+TOML11_INLINE location next(const location& loc)
+{
+    location p(loc);
+    p.advance(1);
+    return p;
+}
+
+TOML11_INLINE location make_temporary_location(const std::string& str) noexcept
+{
+    location::container_type cont(str.size());
+    std::transform(str.begin(), str.end(), cont.begin(),
+        [](const std::string::value_type& c) {
+            return cxx::bit_cast<location::char_type>(c);
+        });
+    return location(std::make_shared<const location::container_type>(
+            std::move(cont)), "internal temporary");
+}
+
+TOML11_INLINE result<location, none_t>
+find(const location& first, const location& last, const location::char_type val)
+{
+    return find_if(first, last, [val](const location::char_type c) {
+            return c == val;
+        });
+}
+TOML11_INLINE result<location, none_t>
+rfind(const location& first, const location& last, const location::char_type val)
+{
+    return rfind_if(first, last, [val](const location::char_type c) {
+            return c == val;
+        });
+}
+
+TOML11_INLINE std::size_t
+count(const location& first, const location& last, const location::char_type& c)
+{
+    if(first.source() != last.source())             { return 0; }
+    if(first.get_location() >= last.get_location()) { return 0; }
+
+    auto loc = first;
+    std::size_t num = 0;
+    while(loc.get_location() != last.get_location())
+    {
+        if(loc.current() == c)
+        {
+            num += 1;
+        }
+        loc.advance();
+    }
+    return num;
+}
+
+} // detail
+} // toml
+#endif // TOML11_LOCATION_HPP
+#endif
+
+#endif // TOML11_LOCATION_HPP
+#ifndef TOML11_REGION_HPP
+#define TOML11_REGION_HPP
+
+#ifndef TOML11_REGION_FWD_HPP
+#define TOML11_REGION_FWD_HPP
+
+
+#include <string>
+#include <vector>
+
+#include <cassert>
+
+namespace toml
+{
+namespace detail
+{
+
+//
+// To represent where is a toml::value defined, or where does an error occur.
+// Stored in toml::value. source_location will be constructed based on this.
+//
+class region
+{
+  public:
+
+    using char_type       = location::char_type;
+    using container_type  = location::container_type;
+    using difference_type = location::difference_type;
+    using source_ptr      = location::source_ptr;
+
+    using iterator       = typename container_type::iterator;
+    using const_iterator = typename container_type::const_iterator;
+
+  public:
+
+    // a value that is constructed manually does not have input stream info
+    region()
+        : source_(nullptr), source_name_(""), length_(0),
+          first_(0), first_line_(0), first_column_(0), last_(0), last_line_(0),
+          last_column_(0)
+    {}
+
+    // a value defined in [first, last).
+    // Those source must be the same. Instread, `region` does not make sense.
+    region(const location& first, const location& last);
+
+    // shorthand of [loc, loc+1)
+    explicit region(const location& loc);
+
+    ~region() = default;
+    region(const region&) = default;
+    region(region&&)      = default;
+    region& operator=(const region&) = default;
+    region& operator=(region&&)      = default;
+
+    bool is_ok() const noexcept { return static_cast<bool>(this->source_); }
+
+    operator bool() const noexcept { return this->is_ok(); }
+
+    std::size_t length() const noexcept {return this->length_;}
+
+    std::size_t first_line_number() const noexcept
+    {
+        return this->first_line_;
+    }
+    std::size_t first_column_number() const noexcept
+    {
+        return this->first_column_;
+    }
+    std::size_t last_line_number() const noexcept
+    {
+        return this->last_line_;
+    }
+    std::size_t last_column_number() const noexcept
+    {
+        return this->last_column_;
+    }
+
+    char_type at(std::size_t i) const;
+
+    const_iterator begin() const noexcept;
+    const_iterator end() const noexcept;
+    const_iterator cbegin() const noexcept;
+    const_iterator cend() const noexcept;
+
+    std::string as_string() const;
+    std::vector<std::string> as_lines() const;
+
+    source_ptr const&  source()      const noexcept {return this->source_;}
+    std::string const& source_name() const noexcept {return this->source_name_;}
+
+  private:
+
+    source_ptr  source_;
+    std::string source_name_;
+    std::size_t length_;
+    std::size_t first_;
+    std::size_t first_line_;
+    std::size_t first_column_;
+    std::size_t last_;
+    std::size_t last_line_;
+    std::size_t last_column_;
+};
+
+} // namespace detail
+} // namespace toml
+#endif // TOML11_REGION_FWD_HPP
+
+#if ! defined(TOML11_COMPILE_SOURCES)
+#ifndef TOML11_REGION_IMPL_HPP
+#define TOML11_REGION_IMPL_HPP
+
+
+#include <algorithm>
+#include <iterator>
+#include <string>
+#include <sstream>
+#include <vector>
+#include <cassert>
+
+namespace toml
+{
+namespace detail
+{
+
+// a value defined in [first, last).
+// Those source must be the same. Instread, `region` does not make sense.
+TOML11_INLINE region::region(const location& first, const location& last)
+    : source_(first.source()), source_name_(first.source_name()),
+      length_(last.get_location() - first.get_location()),
+      first_(first.get_location()),
+      first_line_(first.line_number()),
+      first_column_(first.column_number()),
+      last_(last.get_location()),
+      last_line_(last.line_number()),
+      last_column_(last.column_number())
+{
+    assert(first.source()      == last.source());
+    assert(first.source_name() == last.source_name());
+}
+
+    // shorthand of [loc, loc+1)
+TOML11_INLINE region::region(const location& loc)
+    : source_(loc.source()), source_name_(loc.source_name()), length_(0),
+      first_line_(0), first_column_(0), last_line_(0), last_column_(0)
+{
+    // if the file ends with LF, the resulting region points no char.
+    if(loc.eof())
+    {
+        if(loc.get_location() == 0)
+        {
+            this->length_       = 0;
+            this->first_        = 0;
+            this->first_line_   = 0;
+            this->first_column_ = 0;
+            this->last_         = 0;
+            this->last_line_    = 0;
+            this->last_column_  = 0;
+        }
+        else
+        {
+            const auto first = prev(loc);
+            this->first_        = first.get_location();
+            this->first_line_   = first.line_number();
+            this->first_column_ = first.column_number();
+            this->last_         = loc.get_location();
+            this->last_line_    = loc.line_number();
+            this->last_column_  = loc.column_number();
+            this->length_       = 1;
+        }
+    }
+    else
+    {
+        this->first_        = loc.get_location();
+        this->first_line_   = loc.line_number();
+        this->first_column_ = loc.column_number();
+        this->last_         = loc.get_location() + 1;
+        this->last_line_    = loc.line_number();
+        this->last_column_  = loc.column_number() + 1;
+        this->length_       = 1;
+    }
+}
+
+TOML11_INLINE region::char_type region::at(std::size_t i) const
+{
+    if(this->last_ <= this->first_ + i)
+    {
+        throw std::out_of_range("range::at: index " + std::to_string(i) +
+                " exceeds length " + std::to_string(this->length_));
+    }
+    const auto iter = std::next(this->source_->cbegin(),
+            static_cast<difference_type>(this->first_ + i));
+    return *iter;
+}
+
+TOML11_INLINE region::const_iterator region::begin() const noexcept
+{
+    return std::next(this->source_->cbegin(),
+            static_cast<difference_type>(this->first_));
+}
+TOML11_INLINE region::const_iterator region::end() const noexcept
+{
+    return std::next(this->source_->cbegin(),
+            static_cast<difference_type>(this->last_));
+}
+TOML11_INLINE region::const_iterator region::cbegin() const noexcept
+{
+    return std::next(this->source_->cbegin(),
+            static_cast<difference_type>(this->first_));
+}
+TOML11_INLINE region::const_iterator region::cend() const noexcept
+{
+    return std::next(this->source_->cbegin(),
+            static_cast<difference_type>(this->last_));
+}
+
+TOML11_INLINE std::string region::as_string() const
+{
+    if(this->is_ok())
+    {
+        const auto begin = std::next(this->source_->cbegin(), static_cast<difference_type>(this->first_));
+        const auto end   = std::next(this->source_->cbegin(), static_cast<difference_type>(this->last_ ));
+        return ::toml::detail::make_string(begin, end);
+    }
+    else
+    {
+        return std::string("");
+    }
+}
+
+TOML11_INLINE std::vector<std::string> region::as_lines() const
+{
+    assert(this->is_ok());
+    if(this->length_ == 0)
+    {
+        return std::vector<std::string>{""};
+    }
+
+    // Consider the following toml file
+    // ```
+    // array = [
+    // ] # comment
+    // ```
+    // and the region represnets
+    // ```
+    //         [
+    // ]
+    // ```
+    // but we want to show the following.
+    // ```
+    // array = [
+    // ] # comment
+    // ```
+    // So we need to find LFs before `begin` and after `end`.
+    //
+    // But, if region ends with LF, it should not include the next line.
+    // ```
+    // a = 42
+    //     ^^^- with the last LF
+    // ```
+    // So we start from `end-1` when looking for LF.
+
+    const auto begin_idx = static_cast<difference_type>(this->first_);
+    const auto end_idx   = static_cast<difference_type>(this->last_) - 1;
+
+    // length_ != 0, so begin < end. then begin <= end-1
+    assert(begin_idx <= end_idx);
+
+    const auto begin = std::next(this->source_->cbegin(), begin_idx);
+    const auto end   = std::next(this->source_->cbegin(), end_idx);
+
+    const auto line_begin = std::find(cxx::make_reverse_iterator(begin), this->source_->crend(), char_type('\n')).base();
+    const auto line_end   = std::find(end, this->source_->cend(), char_type('\n'));
+
+    const auto reg_lines = make_string(line_begin, line_end);
+
+    if(reg_lines == "") // the region is an empty line that only contains LF
+    {
+        return std::vector<std::string>{""};
+    }
+
+    std::istringstream iss(reg_lines);
+
+    std::vector<std::string> lines;
+    std::string line;
+    while(std::getline(iss, line))
+    {
+        lines.push_back(line);
+    }
+    return lines;
+}
+
+} // namespace detail
+} // namespace toml
+#endif // TOML11_REGION_IMPL_HPP
+#endif
+
+#endif // TOML11_REGION_HPP
+#ifndef TOML11_SOURCE_LOCATION_HPP
+#define TOML11_SOURCE_LOCATION_HPP
+
+#ifndef TOML11_SOURCE_LOCATION_FWD_HPP
+#define TOML11_SOURCE_LOCATION_FWD_HPP
+
+
+#include <sstream>
+#include <string>
+#include <vector>
+
+namespace toml
+{
+
+// A struct to contain location in a toml file.
+struct source_location
+{
+  public:
+
+    explicit source_location(const detail::region& r);
+    ~source_location() = default;
+    source_location(source_location const&) = default;
+    source_location(source_location &&)     = default;
+    source_location& operator=(source_location const&) = default;
+    source_location& operator=(source_location &&)     = default;
+
+    bool is_ok() const noexcept {return this->is_ok_;}
+    std::size_t length() const noexcept {return this->length_;}
+
+    std::size_t first_line_number()   const noexcept {return this->first_line_;}
+    std::size_t first_column_number() const noexcept {return this->first_column_;}
+    std::size_t last_line_number()    const noexcept {return this->last_line_;}
+    std::size_t last_column_number()  const noexcept {return this->last_column_;}
+
+    std::string const& file_name()  const noexcept {return this->file_name_;}
+
+    std::size_t num_lines() const noexcept {return this->line_str_.size();}
+
+    std::string const& first_line() const;
+    std::string const& last_line() const;
+
+    std::vector<std::string> const& lines() const noexcept {return line_str_;}
+
+  private:
+
+    bool        is_ok_;
+    std::size_t first_line_;
+    std::size_t first_column_;
+    std::size_t last_line_;
+    std::size_t last_column_;
+    std::size_t length_;
+    std::string file_name_;
+    std::vector<std::string> line_str_;
+};
+
+namespace detail
+{
+
+std::size_t integer_width_base10(std::size_t i) noexcept;
+
+inline std::size_t line_width() noexcept {return 0;}
+
+template<typename ... Ts>
+std::size_t line_width(const source_location& loc, const std::string& /*msg*/,
+        const Ts& ... tail) noexcept
+{
+    return (std::max)(
+            integer_width_base10(loc.last_line_number()), line_width(tail...));
+}
+
+std::ostringstream&
+format_filename(std::ostringstream& oss, const source_location& loc);
+
+std::ostringstream&
+format_empty_line(std::ostringstream& oss, const std::size_t lnw);
+
+std::ostringstream& format_line(std::ostringstream& oss,
+    const std::size_t lnw, const std::size_t linenum, const std::string& line);
+
+std::ostringstream& format_underline(std::ostringstream& oss,
+        const std::size_t lnw, const std::size_t col, const std::size_t len,
+        const std::string& msg);
+
+std::string format_location_impl(const std::size_t lnw,
+    const std::string& prev_fname,
+    const source_location& loc, const std::string& msg);
+
+inline std::string format_location_rec(const std::size_t, const std::string&)
+{
+    return "";
+}
+
+template<typename ... Ts>
+std::string format_location_rec(const std::size_t lnw,
+        const std::string& prev_fname,
+        const source_location& loc, const std::string& msg,
+        const Ts& ... tail)
+{
+    return format_location_impl(lnw, prev_fname, loc, msg) +
+           format_location_rec(lnw, loc.file_name(), tail...);
+}
+
+} // namespace detail
+
+// format a location info without title
+template<typename ... Ts>
+std::string format_location(
+        const source_location& loc, const std::string& msg, const Ts& ... tail)
+{
+    const auto lnw = detail::line_width(loc, msg, tail...);
+
+    const std::string f(""); // at the 1st iteration, no prev_filename is given
+    return detail::format_location_rec(lnw, f, loc, msg, tail...);
+}
+
+} // toml
+#endif // TOML11_SOURCE_LOCATION_FWD_HPP
+
+#if ! defined(TOML11_COMPILE_SOURCES)
+#ifndef TOML11_SOURCE_LOCATION_IMPL_HPP
+#define TOML11_SOURCE_LOCATION_IMPL_HPP
+
+
+
+#include <iomanip>
+#include <sstream>
+#include <string>
+#include <vector>
+
+#include <cctype>
+
+namespace toml
+{
+
+TOML11_INLINE source_location::source_location(const detail::region& r)
+    : is_ok_(false),
+      first_line_(1),
+      first_column_(1),
+      last_line_(1),
+      last_column_(1),
+      length_(0),
+      file_name_("unknown file")
+{
+    if(r.is_ok())
+    {
+        this->is_ok_        = true;
+        this->file_name_    = r.source_name();
+        this->first_line_   = r.first_line_number();
+        this->first_column_ = r.first_column_number();
+        this->last_line_    = r.last_line_number();
+        this->last_column_  = r.last_column_number();
+        this->length_       = r.length();
+        this->line_str_     = r.as_lines();
+    }
+}
+
+TOML11_INLINE std::string const& source_location::first_line() const
+{
+    if(this->line_str_.size() == 0)
+    {
+        throw std::out_of_range("toml::source_location::first_line: `lines` is empty");
+    }
+    return this->line_str_.front();
+}
+TOML11_INLINE std::string const& source_location::last_line() const
+{
+    if(this->line_str_.size() == 0)
+    {
+        throw std::out_of_range("toml::source_location::first_line: `lines` is empty");
+    }
+    return this->line_str_.back();
+}
+
+namespace detail
+{
+
+TOML11_INLINE std::size_t integer_width_base10(std::size_t i) noexcept
+{
+    std::size_t width = 0;
+    while(i != 0)
+    {
+        i /= 10;
+        width += 1;
+    }
+    return width;
+}
+
+TOML11_INLINE std::ostringstream&
+format_filename(std::ostringstream& oss, const source_location& loc)
+{
+    // --> example.toml
+    oss << color::bold << color::blue << " --> " << color::reset
+        << color::bold << loc.file_name() << '\n' << color::reset;
+    return oss;
+}
+
+TOML11_INLINE std::ostringstream& format_empty_line(std::ostringstream& oss,
+        const std::size_t lnw)
+{
+    //    |
+    oss << detail::make_string(lnw + 1, ' ')
+        << color::bold << color::blue << " |\n"  << color::reset;
+    return oss;
+}
+
+TOML11_INLINE std::ostringstream& format_line(std::ostringstream& oss,
+    const std::size_t lnw, const std::size_t linenum, const std::string& line)
+{
+    // 10 | key = "value"
+    oss << ' ' << color::bold << color::blue
+        << std::setw(static_cast<int>(lnw))
+        << std::right << linenum << " | "  << color::reset;
+    for(const char c : line)
+    {
+        if(std::isgraph(c) || c == ' ')
+        {
+            oss << c;
+        }
+        else
+        {
+            oss << show_char(c);
+        }
+    }
+    oss << '\n';
+    return oss;
+}
+TOML11_INLINE std::ostringstream& format_underline(std::ostringstream& oss,
+        const std::size_t lnw, const std::size_t col, const std::size_t len,
+        const std::string& msg)
+{
+    //    |       ^^^^^^^-- this part
+    oss << make_string(lnw + 1, ' ')
+        << color::bold << color::blue << " | " << color::reset;
+
+    oss << make_string(col-1 /*1-origin*/, ' ')
+        << color::bold << color::red
+        << make_string(len, '^') << "-- "
+        << color::reset << msg << '\n';
+
+    return oss;
+}
+
+TOML11_INLINE std::string format_location_impl(const std::size_t lnw,
+    const std::string& prev_fname,
+    const source_location& loc, const std::string& msg)
+{
+    std::ostringstream oss;
+
+    if(loc.file_name() != prev_fname)
+    {
+        format_filename(oss, loc);
+        if( ! loc.lines().empty())
+        {
+            format_empty_line(oss, lnw);
+        }
+    }
+
+    if(loc.lines().size() == 1)
+    {
+        // when column points LF, it exceeds the size of the first line.
+        std::size_t underline_limit = 1;
+        if(loc.first_line().size() < loc.first_column_number())
+        {
+            underline_limit = 1;
+        }
+        else
+        {
+            underline_limit = loc.first_line().size() - loc.first_column_number() + 1;
+        }
+        const auto underline_len = (std::min)(underline_limit, loc.length());
+
+        format_line(oss, lnw, loc.first_line_number(), loc.first_line());
+        format_underline(oss, lnw, loc.first_column_number(), underline_len, msg);
+    }
+    else if(loc.lines().size() == 2)
+    {
+        const auto first_underline_len =
+            loc.first_line().size() - loc.first_column_number() + 1;
+        format_line(oss, lnw, loc.first_line_number(), loc.first_line());
+        format_underline(oss, lnw, loc.first_column_number(),
+                first_underline_len, "");
+
+        format_line(oss, lnw, loc.last_line_number(), loc.last_line());
+        format_underline(oss, lnw, 1, loc.last_column_number(), msg);
+    }
+    else if(loc.lines().size() > 2)
+    {
+        const auto first_underline_len =
+            loc.first_line().size() - loc.first_column_number() + 1;
+        format_line(oss, lnw, loc.first_line_number(), loc.first_line());
+        format_underline(oss, lnw, loc.first_column_number(),
+                first_underline_len, "and");
+
+        if(loc.lines().size() == 3)
+        {
+            format_line(oss, lnw, loc.first_line_number()+1, loc.lines().at(1));
+            format_underline(oss, lnw, 1, loc.lines().at(1).size(), "and");
+        }
+        else
+        {
+            format_line(oss, lnw, loc.first_line_number()+1, " ...");
+            format_empty_line(oss, lnw);
+        }
+        format_line(oss, lnw, loc.last_line_number(), loc.last_line());
+        format_underline(oss, lnw, 1, loc.last_column_number(), msg);
+    }
+    // if loc is empty, do nothing.
+    return oss.str();
+}
+
+} // namespace detail
+} // toml
+#endif // TOML11_SOURCE_LOCATION_IMPL_HPP
+#endif
+
+#endif // TOML11_SOURCE_LOCATION_HPP
+#ifndef TOML11_ERROR_INFO_HPP
+#define TOML11_ERROR_INFO_HPP
+
+#ifndef TOML11_ERROR_INFO_FWD_HPP
+#define TOML11_ERROR_INFO_FWD_HPP
+
+
+namespace toml
+{
+
+// error info returned from parser.
+struct error_info
+{
+    error_info(std::string t, source_location l, std::string m, std::string s = "")
+        : title_(std::move(t)), locations_{std::make_pair(std::move(l), std::move(m))},
+          suffix_(std::move(s))
+    {}
+
+    error_info(std::string t, std::vector<std::pair<source_location, std::string>> l,
+               std::string s = "")
+        : title_(std::move(t)), locations_(std::move(l)), suffix_(std::move(s))
+    {}
+
+    std::string const& title() const noexcept {return title_;}
+    std::string &      title()       noexcept {return title_;}
+
+    std::vector<std::pair<source_location, std::string>> const&
+    locations() const noexcept {return locations_;}
+
+    void add_locations(source_location loc, std::string msg) noexcept
+    {
+        locations_.emplace_back(std::move(loc), std::move(msg));
+    }
+
+    std::string const& suffix() const noexcept {return suffix_;}
+    std::string &      suffix()       noexcept {return suffix_;}
+
+  private:
+
+    std::string title_;
+    std::vector<std::pair<source_location, std::string>> locations_;
+    std::string suffix_; // hint or something like that
+};
+
+// forward decl
+template<typename TypeConfig>
+class basic_value;
+
+namespace detail
+{
+inline error_info make_error_info_rec(error_info e)
+{
+    return e;
+}
+inline error_info make_error_info_rec(error_info e, std::string s)
+{
+    e.suffix() = s;
+    return e;
+}
+
+template<typename TC, typename ... Ts>
+error_info make_error_info_rec(error_info e,
+        const basic_value<TC>& v, std::string msg, Ts&& ... tail);
+
+template<typename ... Ts>
+error_info make_error_info_rec(error_info e,
+        source_location loc, std::string msg, Ts&& ... tail)
+{
+    e.add_locations(std::move(loc), std::move(msg));
+    return make_error_info_rec(std::move(e), std::forward<Ts>(tail)...);
+}
+
+} // detail
+
+template<typename ... Ts>
+error_info make_error_info(
+    std::string title, source_location loc, std::string msg, Ts&& ... tail)
+{
+    error_info ei(std::move(title), std::move(loc), std::move(msg));
+    return detail::make_error_info_rec(ei, std::forward<Ts>(tail) ... );
+}
+
+std::string format_error(const std::string& errkind, const error_info& err);
+std::string format_error(const error_info& err);
+
+// for custom error message
+template<typename ... Ts>
+std::string format_error(std::string title,
+        source_location loc, std::string msg, Ts&& ... tail)
+{
+    return format_error("", make_error_info(std::move(title),
+                std::move(loc), std::move(msg), std::forward<Ts>(tail)...));
+}
+
+std::ostream& operator<<(std::ostream& os, const error_info& e);
+
+} // toml
+#endif // TOML11_ERROR_INFO_FWD_HPP
+
+#if ! defined(TOML11_COMPILE_SOURCES)
+#ifndef TOML11_ERROR_INFO_IMPL_HPP
+#define TOML11_ERROR_INFO_IMPL_HPP
+
+
+#include <sstream>
+
+namespace toml
+{
+
+TOML11_INLINE std::string format_error(const std::string& errkind, const error_info& err)
+{
+    std::string errmsg;
+    if( ! errkind.empty())
+    {
+        errmsg = errkind;
+        errmsg += ' ';
+    }
+    errmsg += err.title();
+    errmsg += '\n';
+
+    const auto lnw = [&err]() {
+        std::size_t width = 0;
+        for(const auto& l : err.locations())
+        {
+            width = (std::max)(detail::integer_width_base10(l.first.last_line_number()), width);
+        }
+        return width;
+    }();
+
+    bool first = true;
+    std::string prev_fname;
+    for(const auto& lm : err.locations())
+    {
+        if( ! first)
+        {
+            std::ostringstream oss;
+            oss << detail::make_string(lnw + 1, ' ')
+                << color::bold << color::blue << " |" << color::reset
+                << color::bold << " ...\n" << color::reset;
+            oss << detail::make_string(lnw + 1, ' ')
+                << color::bold << color::blue << " |\n" << color::reset;
+            errmsg += oss.str();
+        }
+
+        const auto& l = lm.first;
+        const auto& m = lm.second;
+
+        errmsg += detail::format_location_impl(lnw, prev_fname, l, m);
+
+        prev_fname = l.file_name();
+        first = false;
+    }
+
+    errmsg += err.suffix();
+
+    return errmsg;
+}
+
+TOML11_INLINE std::string format_error(const error_info& err)
+{
+    std::ostringstream oss;
+    oss << color::red << color::bold << "[error]" << color::reset;
+    return format_error(oss.str(), err);
+}
+
+TOML11_INLINE std::ostream& operator<<(std::ostream& os, const error_info& e)
+{
+    os << format_error(e);
+    return os;
+}
+
+} // toml
+#endif // TOML11_ERROR_INFO_IMPL_HPP
+#endif
+
+#endif // TOML11_ERROR_INFO_HPP
+#ifndef TOML11_VALUE_HPP
+#define TOML11_VALUE_HPP
+
+
+#ifdef TOML11_HAS_STRING_VIEW
+#include <string_view>
+#endif
+
+#include <cassert>
+
+namespace toml
+{
+template<typename TypeConfig>
+class basic_value;
+
+struct type_error final : public ::toml::exception
+{
+  public:
+    type_error(std::string what_arg, source_location loc)
+        : what_(std::move(what_arg)), loc_(std::move(loc))
+    {}
+    ~type_error() noexcept override = default;
+
+    const char* what() const noexcept override {return what_.c_str();}
+
+    source_location const& location() const noexcept {return loc_;}
+
+  private:
+    std::string what_;
+    source_location loc_;
+};
+
+// only for internal use
+namespace detail
+{
+template<typename TC>
+error_info make_type_error(const basic_value<TC>&, const std::string&, const value_t);
+
+template<typename TC>
+error_info make_not_found_error(const basic_value<TC>&, const std::string&, const typename basic_value<TC>::key_type&);
+
+template<typename TC>
+void change_region_of_value(basic_value<TC>&, const basic_value<TC>&);
+
+template<typename TC, value_t V>
+struct getter;
+} // detail
+
+template<typename TypeConfig>
+class basic_value
+{
+  public:
+
+    using config_type          = TypeConfig;
+    using key_type             = typename config_type::string_type;
+    using value_type           = basic_value<config_type>;
+    using boolean_type         = typename config_type::boolean_type;
+    using integer_type         = typename config_type::integer_type;
+    using floating_type        = typename config_type::floating_type;
+    using string_type          = typename config_type::string_type;
+    using local_time_type      = ::toml::local_time;
+    using local_date_type      = ::toml::local_date;
+    using local_datetime_type  = ::toml::local_datetime;
+    using offset_datetime_type = ::toml::offset_datetime;
+    using array_type           = typename config_type::template array_type<value_type>;
+    using table_type           = typename config_type::template table_type<key_type, value_type>;
+    using comment_type         = typename config_type::comment_type;
+    using char_type            = typename string_type::value_type;
+
+  private:
+
+    using region_type = detail::region;
+
+  public:
+
+    basic_value() noexcept
+        : type_(value_t::empty), empty_('\0'), region_{}, comments_{}
+    {}
+    ~basic_value() noexcept {this->cleanup();}
+
+    // copy/move constructor/assigner ===================================== {{{
+
+    basic_value(const basic_value& v)
+        : type_(v.type_), region_(v.region_), comments_(v.comments_)
+    {
+        switch(this->type_)
+        {
+            case value_t::boolean        : assigner(boolean_        , v.boolean_        ); break;
+            case value_t::integer        : assigner(integer_        , v.integer_        ); break;
+            case value_t::floating       : assigner(floating_       , v.floating_       ); break;
+            case value_t::string         : assigner(string_         , v.string_         ); break;
+            case value_t::offset_datetime: assigner(offset_datetime_, v.offset_datetime_); break;
+            case value_t::local_datetime : assigner(local_datetime_ , v.local_datetime_ ); break;
+            case value_t::local_date     : assigner(local_date_     , v.local_date_     ); break;
+            case value_t::local_time     : assigner(local_time_     , v.local_time_     ); break;
+            case value_t::array          : assigner(array_          , v.array_          ); break;
+            case value_t::table          : assigner(table_          , v.table_          ); break;
+            default                      : assigner(empty_          , '\0'              ); break;
+        }
+    }
+    basic_value(basic_value&& v)
+        : type_(v.type()), region_(std::move(v.region_)),
+          comments_(std::move(v.comments_))
+    {
+        switch(this->type_)
+        {
+            case value_t::boolean        : assigner(boolean_        , std::move(v.boolean_        )); break;
+            case value_t::integer        : assigner(integer_        , std::move(v.integer_        )); break;
+            case value_t::floating       : assigner(floating_       , std::move(v.floating_       )); break;
+            case value_t::string         : assigner(string_         , std::move(v.string_         )); break;
+            case value_t::offset_datetime: assigner(offset_datetime_, std::move(v.offset_datetime_)); break;
+            case value_t::local_datetime : assigner(local_datetime_ , std::move(v.local_datetime_ )); break;
+            case value_t::local_date     : assigner(local_date_     , std::move(v.local_date_     )); break;
+            case value_t::local_time     : assigner(local_time_     , std::move(v.local_time_     )); break;
+            case value_t::array          : assigner(array_          , std::move(v.array_          )); break;
+            case value_t::table          : assigner(table_          , std::move(v.table_          )); break;
+            default                      : assigner(empty_          , '\0'                         ); break;
+        }
+    }
+
+    basic_value& operator=(const basic_value& v)
+    {
+        if(this == std::addressof(v)) {return *this;}
+
+        this->cleanup();
+        this->type_     = v.type_;
+        this->region_   = v.region_;
+        this->comments_ = v.comments_;
+        switch(this->type_)
+        {
+            case value_t::boolean        : assigner(boolean_        , v.boolean_        ); break;
+            case value_t::integer        : assigner(integer_        , v.integer_        ); break;
+            case value_t::floating       : assigner(floating_       , v.floating_       ); break;
+            case value_t::string         : assigner(string_         , v.string_         ); break;
+            case value_t::offset_datetime: assigner(offset_datetime_, v.offset_datetime_); break;
+            case value_t::local_datetime : assigner(local_datetime_ , v.local_datetime_ ); break;
+            case value_t::local_date     : assigner(local_date_     , v.local_date_     ); break;
+            case value_t::local_time     : assigner(local_time_     , v.local_time_     ); break;
+            case value_t::array          : assigner(array_          , v.array_          ); break;
+            case value_t::table          : assigner(table_          , v.table_          ); break;
+            default                      : assigner(empty_          , '\0'              ); break;
+        }
+        return *this;
+    }
+    basic_value& operator=(basic_value&& v)
+    {
+        if(this == std::addressof(v)) {return *this;}
+
+        this->cleanup();
+        this->type_     = v.type_;
+        this->region_   = std::move(v.region_);
+        this->comments_ = std::move(v.comments_);
+        switch(this->type_)
+        {
+            case value_t::boolean        : assigner(boolean_        , std::move(v.boolean_        )); break;
+            case value_t::integer        : assigner(integer_        , std::move(v.integer_        )); break;
+            case value_t::floating       : assigner(floating_       , std::move(v.floating_       )); break;
+            case value_t::string         : assigner(string_         , std::move(v.string_         )); break;
+            case value_t::offset_datetime: assigner(offset_datetime_, std::move(v.offset_datetime_)); break;
+            case value_t::local_datetime : assigner(local_datetime_ , std::move(v.local_datetime_ )); break;
+            case value_t::local_date     : assigner(local_date_     , std::move(v.local_date_     )); break;
+            case value_t::local_time     : assigner(local_time_     , std::move(v.local_time_     )); break;
+            case value_t::array          : assigner(array_          , std::move(v.array_          )); break;
+            case value_t::table          : assigner(table_          , std::move(v.table_          )); break;
+            default                      : assigner(empty_          , '\0'                         ); break;
+        }
+        return *this;
+    }
+    // }}}
+
+    // constructor to overwrite commnets ================================== {{{
+
+    basic_value(basic_value v, std::vector<std::string> com)
+        : type_(v.type()), region_(std::move(v.region_)),
+          comments_(std::move(com))
+    {
+        switch(this->type_)
+        {
+            case value_t::boolean        : assigner(boolean_        , std::move(v.boolean_        )); break;
+            case value_t::integer        : assigner(integer_        , std::move(v.integer_        )); break;
+            case value_t::floating       : assigner(floating_       , std::move(v.floating_       )); break;
+            case value_t::string         : assigner(string_         , std::move(v.string_         )); break;
+            case value_t::offset_datetime: assigner(offset_datetime_, std::move(v.offset_datetime_)); break;
+            case value_t::local_datetime : assigner(local_datetime_ , std::move(v.local_datetime_ )); break;
+            case value_t::local_date     : assigner(local_date_     , std::move(v.local_date_     )); break;
+            case value_t::local_time     : assigner(local_time_     , std::move(v.local_time_     )); break;
+            case value_t::array          : assigner(array_          , std::move(v.array_          )); break;
+            case value_t::table          : assigner(table_          , std::move(v.table_          )); break;
+            default                      : assigner(empty_          , '\0'                         ); break;
+        }
+    }
+    // }}}
+
+    // conversion between different basic_values ========================== {{{
+
+    template<typename TI>
+    basic_value(basic_value<TI> other)
+        : type_(other.type_),
+          region_(std::move(other.region_)),
+          comments_(std::move(other.comments_))
+    {
+        switch(other.type_)
+        {
+            // use auto-convert in constructor
+            case value_t::boolean        : assigner(boolean_        , std::move(other.boolean_        )); break;
+            case value_t::integer        : assigner(integer_        , std::move(other.integer_        )); break;
+            case value_t::floating       : assigner(floating_       , std::move(other.floating_       )); break;
+            case value_t::string         : assigner(string_         , std::move(other.string_         )); break;
+            case value_t::offset_datetime: assigner(offset_datetime_, std::move(other.offset_datetime_)); break;
+            case value_t::local_datetime : assigner(local_datetime_ , std::move(other.local_datetime_ )); break;
+            case value_t::local_date     : assigner(local_date_     , std::move(other.local_date_     )); break;
+            case value_t::local_time     : assigner(local_time_     , std::move(other.local_time_     )); break;
+
+            // may have different container type
+            case value_t::array          :
+            {
+                array_type tmp(
+                    std::make_move_iterator(other.array_.value.get().begin()),
+                    std::make_move_iterator(other.array_.value.get().end()));
+                assigner(array_, array_storage(
+                        detail::storage<array_type>(std::move(tmp)),
+                        other.array_.format
+                    ));
+                break;
+            }
+            case value_t::table          :
+            {
+                table_type tmp(
+                    std::make_move_iterator(other.table_.value.get().begin()),
+                    std::make_move_iterator(other.table_.value.get().end()));
+                assigner(table_, table_storage(
+                        detail::storage<table_type>(std::move(tmp)),
+                        other.table_.format
+                    ));
+                break;
+            }
+            default: break;
+        }
+    }
+
+    template<typename TI>
+    basic_value(basic_value<TI> other, std::vector<std::string> com)
+        : type_(other.type_),
+          region_(std::move(other.region_)),
+          comments_(std::move(com))
+    {
+        switch(other.type_)
+        {
+            // use auto-convert in constructor
+            case value_t::boolean        : assigner(boolean_        , std::move(other.boolean_        )); break;
+            case value_t::integer        : assigner(integer_        , std::move(other.integer_        )); break;
+            case value_t::floating       : assigner(floating_       , std::move(other.floating_       )); break;
+            case value_t::string         : assigner(string_         , std::move(other.string_         )); break;
+            case value_t::offset_datetime: assigner(offset_datetime_, std::move(other.offset_datetime_)); break;
+            case value_t::local_datetime : assigner(local_datetime_ , std::move(other.local_datetime_ )); break;
+            case value_t::local_date     : assigner(local_date_     , std::move(other.local_date_     )); break;
+            case value_t::local_time     : assigner(local_time_     , std::move(other.local_time_     )); break;
+
+            // may have different container type
+            case value_t::array          :
+            {
+                array_type tmp(
+                    std::make_move_iterator(other.array_.value.get().begin()),
+                    std::make_move_iterator(other.array_.value.get().end()));
+                assigner(array_, array_storage(
+                        detail::storage<array_type>(std::move(tmp)),
+                        other.array_.format
+                    ));
+                break;
+            }
+            case value_t::table          :
+            {
+                table_type tmp(
+                    std::make_move_iterator(other.table_.value.get().begin()),
+                    std::make_move_iterator(other.table_.value.get().end()));
+                assigner(table_, table_storage(
+                        detail::storage<table_type>(std::move(tmp)),
+                        other.table_.format
+                    ));
+                break;
+            }
+            default: break;
+        }
+    }
+    template<typename TI>
+    basic_value& operator=(basic_value<TI> other)
+    {
+        this->cleanup();
+        this->region_ = other.region_;
+        this->comments_    = comment_type(other.comments_);
+        this->type_        = other.type_;
+        switch(other.type_)
+        {
+            // use auto-convert in constructor
+            case value_t::boolean        : assigner(boolean_        , std::move(other.boolean_        )); break;
+            case value_t::integer        : assigner(integer_        , std::move(other.integer_        )); break;
+            case value_t::floating       : assigner(floating_       , std::move(other.floating_       )); break;
+            case value_t::string         : assigner(string_         , std::move(other.string_         )); break;
+            case value_t::offset_datetime: assigner(offset_datetime_, std::move(other.offset_datetime_)); break;
+            case value_t::local_datetime : assigner(local_datetime_ , std::move(other.local_datetime_ )); break;
+            case value_t::local_date     : assigner(local_date_     , std::move(other.local_date_     )); break;
+            case value_t::local_time     : assigner(local_time_     , std::move(other.local_time_     )); break;
+
+            // may have different container type
+            case value_t::array          :
+            {
+                array_type tmp(
+                    std::make_move_iterator(other.array_.value.get().begin()),
+                    std::make_move_iterator(other.array_.value.get().end()));
+                assigner(array_, array_storage(
+                        detail::storage<array_type>(std::move(tmp)),
+                        other.array_.format
+                    ));
+                break;
+            }
+            case value_t::table          :
+            {
+                table_type tmp(
+                    std::make_move_iterator(other.table_.value.get().begin()),
+                    std::make_move_iterator(other.table_.value.get().end()));
+                assigner(table_, table_storage(
+                        detail::storage<table_type>(std::move(tmp)),
+                        other.table_.format
+                    ));
+                break;
+            }
+            default: break;
+        }
+        return *this;
+    }
+    // }}}
+
+    // constructor (boolean) ============================================== {{{
+
+    basic_value(boolean_type x)
+        : basic_value(x, boolean_format_info{}, std::vector<std::string>{}, region_type{})
+    {}
+    basic_value(boolean_type x, boolean_format_info fmt)
+        : basic_value(x, fmt, std::vector<std::string>{}, region_type{})
+    {}
+    basic_value(boolean_type x, std::vector<std::string> com)
+        : basic_value(x, boolean_format_info{}, std::move(com), region_type{})
+    {}
+    basic_value(boolean_type x, boolean_format_info fmt, std::vector<std::string> com)
+        : basic_value(x, fmt, std::move(com), region_type{})
+    {}
+    basic_value(boolean_type x, boolean_format_info fmt,
+                std::vector<std::string> com, region_type reg)
+        : type_(value_t::boolean), boolean_(boolean_storage(x, fmt)),
+          region_(std::move(reg)), comments_(std::move(com))
+    {}
+    basic_value& operator=(boolean_type x)
+    {
+        boolean_format_info fmt;
+        if(this->is_boolean())
+        {
+            fmt = this->as_boolean_fmt();
+        }
+        this->cleanup();
+        this->type_   = value_t::boolean;
+        this->region_ = region_type{};
+        assigner(this->boolean_, boolean_storage(x, fmt));
+        return *this;
+    }
+
+    // }}}
+
+    // constructor (integer) ============================================== {{{
+
+    basic_value(integer_type x)
+        : basic_value(std::move(x), integer_format_info{}, std::vector<std::string>{}, region_type{})
+    {}
+    basic_value(integer_type x, integer_format_info fmt)
+        : basic_value(std::move(x), std::move(fmt), std::vector<std::string>{}, region_type{})
+    {}
+    basic_value(integer_type x, std::vector<std::string> com)
+        : basic_value(std::move(x), integer_format_info{}, std::move(com), region_type{})
+    {}
+    basic_value(integer_type x, integer_format_info fmt, std::vector<std::string> com)
+        : basic_value(std::move(x), std::move(fmt), std::move(com), region_type{})
+    {}
+    basic_value(integer_type x, integer_format_info fmt, std::vector<std::string> com, region_type reg)
+        : type_(value_t::integer), integer_(integer_storage(std::move(x), std::move(fmt))),
+          region_(std::move(reg)), comments_(std::move(com))
+    {}
+    basic_value& operator=(integer_type x)
+    {
+        integer_format_info fmt;
+        if(this->is_integer())
+        {
+            fmt = this->as_integer_fmt();
+        }
+        this->cleanup();
+        this->type_   = value_t::integer;
+        this->region_ = region_type{};
+        assigner(this->integer_, integer_storage(std::move(x), std::move(fmt)));
+        return *this;
+    }
+
+  private:
+
+    template<typename T>
+    using enable_if_integer_like_t = cxx::enable_if_t<cxx::conjunction<
+            cxx::negation<std::is_same<cxx::remove_cvref_t<T>, boolean_type>>,
+            cxx::negation<std::is_same<cxx::remove_cvref_t<T>, integer_type>>,
+            std::is_integral<cxx::remove_cvref_t<T>>
+        >::value, std::nullptr_t>;
+
+  public:
+
+    template<typename T, enable_if_integer_like_t<T> = nullptr>
+    basic_value(T x)
+        : basic_value(std::move(x), integer_format_info{}, std::vector<std::string>{}, region_type{})
+    {}
+    template<typename T, enable_if_integer_like_t<T> = nullptr>
+    basic_value(T x, integer_format_info fmt)
+        : basic_value(std::move(x), std::move(fmt), std::vector<std::string>{}, region_type{})
+    {}
+    template<typename T, enable_if_integer_like_t<T> = nullptr>
+    basic_value(T x, std::vector<std::string> com)
+        : basic_value(std::move(x), integer_format_info{}, std::move(com), region_type{})
+    {}
+    template<typename T, enable_if_integer_like_t<T> = nullptr>
+    basic_value(T x, integer_format_info fmt, std::vector<std::string> com)
+        : basic_value(std::move(x), std::move(fmt), std::move(com), region_type{})
+    {}
+    template<typename T, enable_if_integer_like_t<T> = nullptr>
+    basic_value(T x, integer_format_info fmt, std::vector<std::string> com, region_type reg)
+        : type_(value_t::integer), integer_(integer_storage(std::move(x), std::move(fmt))),
+          region_(std::move(reg)), comments_(std::move(com))
+    {}
+    template<typename T, enable_if_integer_like_t<T> = nullptr>
+    basic_value& operator=(T x)
+    {
+        integer_format_info fmt;
+        if(this->is_integer())
+        {
+            fmt = this->as_integer_fmt();
+        }
+        this->cleanup();
+        this->type_   = value_t::integer;
+        this->region_ = region_type{};
+        assigner(this->integer_, integer_storage(x, std::move(fmt)));
+        return *this;
+    }
+
+    // }}}
+
+    // constructor (floating) ============================================= {{{
+
+    basic_value(floating_type x)
+        : basic_value(std::move(x), floating_format_info{}, std::vector<std::string>{}, region_type{})
+    {}
+    basic_value(floating_type x, floating_format_info fmt)
+        : basic_value(std::move(x), std::move(fmt), std::vector<std::string>{}, region_type{})
+    {}
+    basic_value(floating_type x, std::vector<std::string> com)
+        : basic_value(std::move(x), floating_format_info{}, std::move(com), region_type{})
+    {}
+    basic_value(floating_type x, floating_format_info fmt, std::vector<std::string> com)
+        : basic_value(std::move(x), std::move(fmt), std::move(com), region_type{})
+    {}
+    basic_value(floating_type x, floating_format_info fmt, std::vector<std::string> com, region_type reg)
+        : type_(value_t::floating), floating_(floating_storage(std::move(x), std::move(fmt))),
+          region_(std::move(reg)), comments_(std::move(com))
+    {}
+    basic_value& operator=(floating_type x)
+    {
+        floating_format_info fmt;
+        if(this->is_floating())
+        {
+            fmt = this->as_floating_fmt();
+        }
+        this->cleanup();
+        this->type_   = value_t::floating;
+        this->region_ = region_type{};
+        assigner(this->floating_, floating_storage(std::move(x), std::move(fmt)));
+        return *this;
+    }
+
+  private:
+
+    template<typename T>
+    using enable_if_floating_like_t = cxx::enable_if_t<cxx::conjunction<
+            cxx::negation<std::is_same<cxx::remove_cvref_t<T>, floating_type>>,
+            std::is_floating_point<cxx::remove_cvref_t<T>>
+        >::value, std::nullptr_t>;
+
+  public:
+
+    template<typename T, enable_if_floating_like_t<T> = nullptr>
+    basic_value(T x)
+        : basic_value(x, floating_format_info{}, std::vector<std::string>{}, region_type{})
+    {}
+
+    template<typename T, enable_if_floating_like_t<T> = nullptr>
+    basic_value(T x, floating_format_info fmt)
+        : basic_value(x, std::move(fmt), std::vector<std::string>{}, region_type{})
+    {}
+
+    template<typename T, enable_if_floating_like_t<T> = nullptr>
+    basic_value(T x, std::vector<std::string> com)
+        : basic_value(x, floating_format_info{}, std::move(com), region_type{})
+    {}
+
+    template<typename T, enable_if_floating_like_t<T> = nullptr>
+    basic_value(T x, floating_format_info fmt, std::vector<std::string> com)
+        : basic_value(x, std::move(fmt), std::move(com), region_type{})
+    {}
+
+    template<typename T, enable_if_floating_like_t<T> = nullptr>
+    basic_value(T x, floating_format_info fmt, std::vector<std::string> com, region_type reg)
+        : type_(value_t::floating), floating_(floating_storage(x, std::move(fmt))),
+          region_(std::move(reg)), comments_(std::move(com))
+    {}
+
+    template<typename T, enable_if_floating_like_t<T> = nullptr>
+    basic_value& operator=(T x)
+    {
+        floating_format_info fmt;
+        if(this->is_floating())
+        {
+            fmt = this->as_floating_fmt();
+        }
+        this->cleanup();
+        this->type_   = value_t::floating;
+        this->region_ = region_type{};
+        assigner(this->floating_, floating_storage(x, std::move(fmt)));
+        return *this;
+    }
+
+    // }}}
+
+    // constructor (string) =============================================== {{{
+
+    basic_value(string_type x)
+        : basic_value(std::move(x), string_format_info{}, std::vector<std::string>{}, region_type{})
+    {}
+    basic_value(string_type x, string_format_info fmt)
+        : basic_value(std::move(x), std::move(fmt), std::vector<std::string>{}, region_type{})
+    {}
+    basic_value(string_type x, std::vector<std::string> com)
+        : basic_value(std::move(x), string_format_info{}, std::move(com), region_type{})
+    {}
+    basic_value(string_type x, string_format_info fmt, std::vector<std::string> com)
+        : basic_value(std::move(x), std::move(fmt), std::move(com), region_type{})
+    {}
+    basic_value(string_type x, string_format_info fmt,
+                std::vector<std::string> com, region_type reg)
+        : type_(value_t::string), string_(string_storage(std::move(x), std::move(fmt))),
+          region_(std::move(reg)), comments_(std::move(com))
+    {}
+    basic_value& operator=(string_type x)
+    {
+        string_format_info fmt;
+        if(this->is_string())
+        {
+            fmt = this->as_string_fmt();
+        }
+        this->cleanup();
+        this->type_   = value_t::string;
+        this->region_ = region_type{};
+        assigner(this->string_, string_storage(x, std::move(fmt)));
+        return *this;
+    }
+
+    // "string literal"
+
+    basic_value(const typename string_type::value_type* x)
+        : basic_value(x, string_format_info{}, std::vector<std::string>{}, region_type{})
+    {}
+    basic_value(const typename string_type::value_type* x, string_format_info fmt)
+        : basic_value(x, std::move(fmt), std::vector<std::string>{}, region_type{})
+    {}
+    basic_value(const typename string_type::value_type* x, std::vector<std::string> com)
+        : basic_value(x, string_format_info{}, std::move(com), region_type{})
+    {}
+    basic_value(const typename string_type::value_type* x, string_format_info fmt, std::vector<std::string> com)
+        : basic_value(x, std::move(fmt), std::move(com), region_type{})
+    {}
+    basic_value(const typename string_type::value_type* x, string_format_info fmt,
+                std::vector<std::string> com, region_type reg)
+        : type_(value_t::string), string_(string_storage(string_type(x), std::move(fmt))),
+          region_(std::move(reg)), comments_(std::move(com))
+    {}
+    basic_value& operator=(const typename string_type::value_type* x)
+    {
+        string_format_info fmt;
+        if(this->is_string())
+        {
+            fmt = this->as_string_fmt();
+        }
+        this->cleanup();
+        this->type_   = value_t::string;
+        this->region_ = region_type{};
+        assigner(this->string_, string_storage(string_type(x), std::move(fmt)));
+        return *this;
+    }
+
+#if defined(TOML11_HAS_STRING_VIEW)
+    using string_view_type = std::basic_string_view<
+        typename string_type::value_type, typename string_type::traits_type>;
+
+    basic_value(string_view_type x)
+        : basic_value(x, string_format_info{}, std::vector<std::string>{}, region_type{})
+    {}
+    basic_value(string_view_type x, string_format_info fmt)
+        : basic_value(x, std::move(fmt), std::vector<std::string>{}, region_type{})
+    {}
+    basic_value(string_view_type x, std::vector<std::string> com)
+        : basic_value(x, string_format_info{}, std::move(com), region_type{})
+    {}
+    basic_value(string_view_type x, string_format_info fmt, std::vector<std::string> com)
+        : basic_value(x, std::move(fmt), std::move(com), region_type{})
+    {}
+    basic_value(string_view_type x, string_format_info fmt,
+                std::vector<std::string> com, region_type reg)
+        : type_(value_t::string), string_(string_storage(string_type(x), std::move(fmt))),
+          region_(std::move(reg)), comments_(std::move(com))
+    {}
+    basic_value& operator=(string_view_type x)
+    {
+        string_format_info fmt;
+        if(this->is_string())
+        {
+            fmt = this->as_string_fmt();
+        }
+        this->cleanup();
+        this->type_   = value_t::string;
+        this->region_ = region_type{};
+        assigner(this->string_, string_storage(string_type(x), std::move(fmt)));
+        return *this;
+    }
+
+#endif // TOML11_HAS_STRING_VIEW
+
+    template<typename T, cxx::enable_if_t<cxx::conjunction<
+            cxx::negation<std::is_same<cxx::remove_cvref_t<T>, string_type>>,
+            detail::is_1byte_std_basic_string<T>
+        >::value, std::nullptr_t> = nullptr>
+    basic_value(const T& x)
+        : basic_value(x, string_format_info{}, std::vector<std::string>{}, region_type{})
+    {}
+    template<typename T, cxx::enable_if_t<cxx::conjunction<
+            cxx::negation<std::is_same<cxx::remove_cvref_t<T>, string_type>>,
+            detail::is_1byte_std_basic_string<T>
+        >::value, std::nullptr_t> = nullptr>
+    basic_value(const T& x, string_format_info fmt)
+        : basic_value(x, std::move(fmt), std::vector<std::string>{}, region_type{})
+    {}
+    template<typename T, cxx::enable_if_t<cxx::conjunction<
+            cxx::negation<std::is_same<cxx::remove_cvref_t<T>, string_type>>,
+            detail::is_1byte_std_basic_string<T>
+        >::value, std::nullptr_t> = nullptr>
+    basic_value(const T& x, std::vector<std::string> com)
+        : basic_value(x, string_format_info{}, std::move(com), region_type{})
+    {}
+    template<typename T, cxx::enable_if_t<cxx::conjunction<
+            cxx::negation<std::is_same<cxx::remove_cvref_t<T>, string_type>>,
+            detail::is_1byte_std_basic_string<T>
+        >::value, std::nullptr_t> = nullptr>
+    basic_value(const T& x, string_format_info fmt, std::vector<std::string> com)
+        : basic_value(x, std::move(fmt), std::move(com), region_type{})
+    {}
+    template<typename T, cxx::enable_if_t<cxx::conjunction<
+            cxx::negation<std::is_same<cxx::remove_cvref_t<T>, string_type>>,
+            detail::is_1byte_std_basic_string<T>
+        >::value, std::nullptr_t> = nullptr>
+    basic_value(const T& x, string_format_info fmt,
+                std::vector<std::string> com, region_type reg)
+        : type_(value_t::string),
+          string_(string_storage(detail::string_conv<string_type>(x), std::move(fmt))),
+          region_(std::move(reg)), comments_(std::move(com))
+    {}
+    template<typename T, cxx::enable_if_t<cxx::conjunction<
+            cxx::negation<std::is_same<cxx::remove_cvref_t<T>, string_type>>,
+            detail::is_1byte_std_basic_string<T>
+        >::value, std::nullptr_t> = nullptr>
+    basic_value& operator=(const T& x)
+    {
+        string_format_info fmt;
+        if(this->is_string())
+        {
+            fmt = this->as_string_fmt();
+        }
+        this->cleanup();
+        this->type_   = value_t::string;
+        this->region_ = region_type{};
+        assigner(this->string_, string_storage(detail::string_conv<string_type>(x), std::move(fmt)));
+        return *this;
+    }
+
+    // }}}
+
+    // constructor (local_date) =========================================== {{{
+
+    basic_value(local_date_type x)
+        : basic_value(x, local_date_format_info{}, std::vector<std::string>{}, region_type{})
+    {}
+    basic_value(local_date_type x, local_date_format_info fmt)
+        : basic_value(x, fmt, std::vector<std::string>{}, region_type{})
+    {}
+    basic_value(local_date_type x, std::vector<std::string> com)
+        : basic_value(x, local_date_format_info{}, std::move(com), region_type{})
+    {}
+    basic_value(local_date_type x, local_date_format_info fmt, std::vector<std::string> com)
+        : basic_value(x, fmt, std::move(com), region_type{})
+    {}
+    basic_value(local_date_type x, local_date_format_info fmt,
+                std::vector<std::string> com, region_type reg)
+        : type_(value_t::local_date), local_date_(local_date_storage(x, fmt)),
+          region_(std::move(reg)), comments_(std::move(com))
+    {}
+    basic_value& operator=(local_date_type x)
+    {
+        local_date_format_info fmt;
+        if(this->is_local_date())
+        {
+            fmt = this->as_local_date_fmt();
+        }
+        this->cleanup();
+        this->type_   = value_t::local_date;
+        this->region_ = region_type{};
+        assigner(this->local_date_, local_date_storage(x, fmt));
+        return *this;
+    }
+
+    // }}}
+
+    // constructor (local_time) =========================================== {{{
+
+    basic_value(local_time_type x)
+        : basic_value(x, local_time_format_info{}, std::vector<std::string>{}, region_type{})
+    {}
+    basic_value(local_time_type x, local_time_format_info fmt)
+        : basic_value(x, fmt, std::vector<std::string>{}, region_type{})
+    {}
+    basic_value(local_time_type x, std::vector<std::string> com)
+        : basic_value(x, local_time_format_info{}, std::move(com), region_type{})
+    {}
+    basic_value(local_time_type x, local_time_format_info fmt, std::vector<std::string> com)
+        : basic_value(x, fmt, std::move(com), region_type{})
+    {}
+    basic_value(local_time_type x, local_time_format_info fmt,
+                std::vector<std::string> com, region_type reg)
+        : type_(value_t::local_time), local_time_(local_time_storage(x, fmt)),
+          region_(std::move(reg)), comments_(std::move(com))
+    {}
+    basic_value& operator=(local_time_type x)
+    {
+        local_time_format_info fmt;
+        if(this->is_local_time())
+        {
+            fmt = this->as_local_time_fmt();
+        }
+        this->cleanup();
+        this->type_   = value_t::local_time;
+        this->region_ = region_type{};
+        assigner(this->local_time_, local_time_storage(x, fmt));
+        return *this;
+    }
+
+    template<typename Rep, typename Period>
+    basic_value(const std::chrono::duration<Rep, Period>& x)
+        : basic_value(local_time_type(x), local_time_format_info{}, std::vector<std::string>{}, region_type{})
+    {}
+    template<typename Rep, typename Period>
+    basic_value(const std::chrono::duration<Rep, Period>& x, local_time_format_info fmt)
+        : basic_value(local_time_type(x), std::move(fmt), std::vector<std::string>{}, region_type{})
+    {}
+    template<typename Rep, typename Period>
+    basic_value(const std::chrono::duration<Rep, Period>& x, std::vector<std::string> com)
+        : basic_value(local_time_type(x), local_time_format_info{}, std::move(com), region_type{})
+    {}
+    template<typename Rep, typename Period>
+    basic_value(const std::chrono::duration<Rep, Period>& x, local_time_format_info fmt, std::vector<std::string> com)
+        : basic_value(local_time_type(x), std::move(fmt), std::move(com), region_type{})
+    {}
+    template<typename Rep, typename Period>
+    basic_value(const std::chrono::duration<Rep, Period>& x,
+                local_time_format_info fmt,
+                std::vector<std::string> com, region_type reg)
+        : basic_value(local_time_type(x), std::move(fmt), std::move(com), std::move(reg))
+    {}
+    template<typename Rep, typename Period>
+    basic_value& operator=(const std::chrono::duration<Rep, Period>& x)
+    {
+        local_time_format_info fmt;
+        if(this->is_local_time())
+        {
+            fmt = this->as_local_time_fmt();
+        }
+        this->cleanup();
+        this->type_   = value_t::local_time;
+        this->region_ = region_type{};
+        assigner(this->local_time_, local_time_storage(local_time_type(x), std::move(fmt)));
+        return *this;
+    }
+
+    // }}}
+
+    // constructor (local_datetime) =========================================== {{{
+
+    basic_value(local_datetime_type x)
+        : basic_value(x, local_datetime_format_info{}, std::vector<std::string>{}, region_type{})
+    {}
+    basic_value(local_datetime_type x, local_datetime_format_info fmt)
+        : basic_value(x, fmt, std::vector<std::string>{}, region_type{})
+    {}
+    basic_value(local_datetime_type x, std::vector<std::string> com)
+        : basic_value(x, local_datetime_format_info{}, std::move(com), region_type{})
+    {}
+    basic_value(local_datetime_type x, local_datetime_format_info fmt, std::vector<std::string> com)
+        : basic_value(x, fmt, std::move(com), region_type{})
+    {}
+    basic_value(local_datetime_type x, local_datetime_format_info fmt,
+                std::vector<std::string> com, region_type reg)
+        : type_(value_t::local_datetime), local_datetime_(local_datetime_storage(x, fmt)),
+          region_(std::move(reg)), comments_(std::move(com))
+    {}
+    basic_value& operator=(local_datetime_type x)
+    {
+        local_datetime_format_info fmt;
+        if(this->is_local_datetime())
+        {
+            fmt = this->as_local_datetime_fmt();
+        }
+        this->cleanup();
+        this->type_   = value_t::local_datetime;
+        this->region_ = region_type{};
+        assigner(this->local_datetime_, local_datetime_storage(x, fmt));
+        return *this;
+    }
+
+    // }}}
+
+    // constructor (offset_datetime) =========================================== {{{
+
+    basic_value(offset_datetime_type x)
+        : basic_value(x, offset_datetime_format_info{}, std::vector<std::string>{}, region_type{})
+    {}
+    basic_value(offset_datetime_type x, offset_datetime_format_info fmt)
+        : basic_value(x, fmt, std::vector<std::string>{}, region_type{})
+    {}
+    basic_value(offset_datetime_type x, std::vector<std::string> com)
+        : basic_value(x, offset_datetime_format_info{}, std::move(com), region_type{})
+    {}
+    basic_value(offset_datetime_type x, offset_datetime_format_info fmt, std::vector<std::string> com)
+        : basic_value(x, fmt, std::move(com), region_type{})
+    {}
+    basic_value(offset_datetime_type x, offset_datetime_format_info fmt,
+                std::vector<std::string> com, region_type reg)
+        : type_(value_t::offset_datetime), offset_datetime_(offset_datetime_storage(x, fmt)),
+          region_(std::move(reg)), comments_(std::move(com))
+    {}
+    basic_value& operator=(offset_datetime_type x)
+    {
+        offset_datetime_format_info fmt;
+        if(this->is_offset_datetime())
+        {
+            fmt = this->as_offset_datetime_fmt();
+        }
+        this->cleanup();
+        this->type_   = value_t::offset_datetime;
+        this->region_ = region_type{};
+        assigner(this->offset_datetime_, offset_datetime_storage(x, fmt));
+        return *this;
+    }
+
+    // system_clock::time_point
+
+    basic_value(std::chrono::system_clock::time_point x)
+        : basic_value(offset_datetime_type(x), offset_datetime_format_info{}, std::vector<std::string>{}, region_type{})
+    {}
+    basic_value(std::chrono::system_clock::time_point x, offset_datetime_format_info fmt)
+        : basic_value(offset_datetime_type(x), fmt, std::vector<std::string>{}, region_type{})
+    {}
+    basic_value(std::chrono::system_clock::time_point x, std::vector<std::string> com)
+        : basic_value(offset_datetime_type(x), offset_datetime_format_info{}, std::move(com), region_type{})
+    {}
+    basic_value(std::chrono::system_clock::time_point x, offset_datetime_format_info fmt, std::vector<std::string> com)
+        : basic_value(offset_datetime_type(x), fmt, std::move(com), region_type{})
+    {}
+    basic_value(std::chrono::system_clock::time_point x, offset_datetime_format_info fmt,
+                std::vector<std::string> com, region_type reg)
+        : basic_value(offset_datetime_type(x), std::move(fmt), std::move(com), std::move(reg))
+    {}
+    basic_value& operator=(std::chrono::system_clock::time_point x)
+    {
+        offset_datetime_format_info fmt;
+        if(this->is_offset_datetime())
+        {
+            fmt = this->as_offset_datetime_fmt();
+        }
+        this->cleanup();
+        this->type_   = value_t::offset_datetime;
+        this->region_ = region_type{};
+        assigner(this->offset_datetime_, offset_datetime_storage(offset_datetime_type(x), fmt));
+        return *this;
+    }
+
+    // }}}
+
+    // constructor (array) ================================================ {{{
+
+    basic_value(array_type x)
+        : basic_value(std::move(x), array_format_info{}, std::vector<std::string>{}, region_type{})
+    {}
+    basic_value(array_type x, array_format_info fmt)
+        : basic_value(std::move(x), std::move(fmt), std::vector<std::string>{}, region_type{})
+    {}
+    basic_value(array_type x, std::vector<std::string> com)
+        : basic_value(std::move(x), array_format_info{}, std::move(com), region_type{})
+    {}
+    basic_value(array_type x, array_format_info fmt, std::vector<std::string> com)
+        : basic_value(std::move(x), fmt, std::move(com), region_type{})
+    {}
+    basic_value(array_type x, array_format_info fmt,
+                std::vector<std::string> com, region_type reg)
+        : type_(value_t::array), array_(array_storage(
+              detail::storage<array_type>(std::move(x)), std::move(fmt)
+          )), region_(std::move(reg)), comments_(std::move(com))
+    {}
+    basic_value& operator=(array_type x)
+    {
+        array_format_info fmt;
+        if(this->is_array())
+        {
+            fmt = this->as_array_fmt();
+        }
+        this->cleanup();
+        this->type_   = value_t::array;
+        this->region_ = region_type{};
+        assigner(this->array_, array_storage(
+                    detail::storage<array_type>(std::move(x)), std::move(fmt)));
+        return *this;
+    }
+
+  private:
+
+    template<typename T>
+    using enable_if_array_like_t = cxx::enable_if_t<cxx::conjunction<
+            detail::is_container<T>,
+            cxx::negation<std::is_same<T, array_type>>,
+            cxx::negation<detail::is_std_basic_string<T>>,
+#if defined(TOML11_HAS_STRING_VIEW)
+            cxx::negation<detail::is_std_basic_string_view<T>>,
+#endif
+            cxx::negation<detail::has_from_toml_method<T, config_type>>,
+            cxx::negation<detail::has_specialized_from<T>>
+        >::value, std::nullptr_t>;
+
+  public:
+
+    template<typename T, enable_if_array_like_t<T> = nullptr>
+    basic_value(T x)
+        : basic_value(std::move(x), array_format_info{}, std::vector<std::string>{}, region_type{})
+    {}
+    template<typename T, enable_if_array_like_t<T> = nullptr>
+    basic_value(T x, array_format_info fmt)
+        : basic_value(std::move(x), std::move(fmt), std::vector<std::string>{}, region_type{})
+    {}
+    template<typename T, enable_if_array_like_t<T> = nullptr>
+    basic_value(T x, std::vector<std::string> com)
+        : basic_value(std::move(x), array_format_info{}, std::move(com), region_type{})
+    {}
+    template<typename T, enable_if_array_like_t<T> = nullptr>
+    basic_value(T x, array_format_info fmt, std::vector<std::string> com)
+        : basic_value(std::move(x), fmt, std::move(com), region_type{})
+    {}
+    template<typename T, enable_if_array_like_t<T> = nullptr>
+    basic_value(T x, array_format_info fmt,
+                std::vector<std::string> com, region_type reg)
+        : type_(value_t::array), array_(array_storage(
+              detail::storage<array_type>(array_type(
+                      std::make_move_iterator(x.begin()),
+                      std::make_move_iterator(x.end()))
+              ), std::move(fmt)
+          )), region_(std::move(reg)), comments_(std::move(com))
+    {}
+    template<typename T, enable_if_array_like_t<T> = nullptr>
+    basic_value& operator=(T x)
+    {
+        array_format_info fmt;
+        if(this->is_array())
+        {
+            fmt = this->as_array_fmt();
+        }
+        this->cleanup();
+        this->type_   = value_t::array;
+        this->region_ = region_type{};
+
+        array_type a(std::make_move_iterator(x.begin()),
+                     std::make_move_iterator(x.end()));
+        assigner(this->array_, array_storage(
+                    detail::storage<array_type>(std::move(a)), std::move(fmt)));
+        return *this;
+    }
+
+    // }}}
+
+    // constructor (table) ================================================ {{{
+
+    basic_value(table_type x)
+        : basic_value(std::move(x), table_format_info{}, std::vector<std::string>{}, region_type{})
+    {}
+    basic_value(table_type x, table_format_info fmt)
+        : basic_value(std::move(x), std::move(fmt), std::vector<std::string>{}, region_type{})
+    {}
+    basic_value(table_type x, std::vector<std::string> com)
+        : basic_value(std::move(x), table_format_info{}, std::move(com), region_type{})
+    {}
+    basic_value(table_type x, table_format_info fmt, std::vector<std::string> com)
+        : basic_value(std::move(x), fmt, std::move(com), region_type{})
+    {}
+    basic_value(table_type x, table_format_info fmt,
+                std::vector<std::string> com, region_type reg)
+        : type_(value_t::table), table_(table_storage(
+                detail::storage<table_type>(std::move(x)), std::move(fmt)
+          )), region_(std::move(reg)), comments_(std::move(com))
+    {}
+    basic_value& operator=(table_type x)
+    {
+        table_format_info fmt;
+        if(this->is_table())
+        {
+            fmt = this->as_table_fmt();
+        }
+        this->cleanup();
+        this->type_   = value_t::table;
+        this->region_ = region_type{};
+        assigner(this->table_, table_storage(
+            detail::storage<table_type>(std::move(x)), std::move(fmt)));
+        return *this;
+    }
+
+    // table-like
+
+  private:
+
+    template<typename T>
+    using enable_if_table_like_t = cxx::enable_if_t<cxx::conjunction<
+            cxx::negation<std::is_same<T, table_type>>,
+            detail::is_map<T>,
+            cxx::negation<detail::has_from_toml_method<T, config_type>>,
+            cxx::negation<detail::has_specialized_from<T>>
+        >::value, std::nullptr_t>;
+
+  public:
+
+    template<typename T, enable_if_table_like_t<T> = nullptr>
+    basic_value(T x)
+        : basic_value(std::move(x), table_format_info{}, std::vector<std::string>{}, region_type{})
+    {}
+    template<typename T, enable_if_table_like_t<T> = nullptr>
+    basic_value(T x, table_format_info fmt)
+        : basic_value(std::move(x), std::move(fmt), std::vector<std::string>{}, region_type{})
+    {}
+    template<typename T, enable_if_table_like_t<T> = nullptr>
+    basic_value(T x, std::vector<std::string> com)
+        : basic_value(std::move(x), table_format_info{}, std::move(com), region_type{})
+    {}
+    template<typename T, enable_if_table_like_t<T> = nullptr>
+    basic_value(T x, table_format_info fmt, std::vector<std::string> com)
+        : basic_value(std::move(x), fmt, std::move(com), region_type{})
+    {}
+    template<typename T, enable_if_table_like_t<T> = nullptr>
+    basic_value(T x, table_format_info fmt,
+                std::vector<std::string> com, region_type reg)
+        : type_(value_t::table), table_(table_storage(
+              detail::storage<table_type>(table_type(
+                      std::make_move_iterator(x.begin()),
+                      std::make_move_iterator(x.end())
+              )), std::move(fmt)
+          )), region_(std::move(reg)), comments_(std::move(com))
+    {}
+    template<typename T, enable_if_table_like_t<T> = nullptr>
+    basic_value& operator=(T x)
+    {
+        table_format_info fmt;
+        if(this->is_table())
+        {
+            fmt = this->as_table_fmt();
+        }
+        this->cleanup();
+        this->type_   = value_t::table;
+        this->region_ = region_type{};
+
+        table_type t(std::make_move_iterator(x.begin()),
+                     std::make_move_iterator(x.end()));
+        assigner(this->table_, table_storage(
+            detail::storage<table_type>(std::move(t)), std::move(fmt)));
+        return *this;
+    }
+
+    // }}}
+
+    // constructor (user_defined) ========================================= {{{
+
+    template<typename T, cxx::enable_if_t<
+        detail::has_specialized_into<T>::value, std::nullptr_t> = nullptr>
+    basic_value(const T& ud)
+        : basic_value(
+            into<cxx::remove_cvref_t<T>>::template into_toml<config_type>(ud))
+    {}
+    template<typename T, cxx::enable_if_t<
+        detail::has_specialized_into<T>::value, std::nullptr_t> = nullptr>
+    basic_value(const T& ud, std::vector<std::string> com)
+        : basic_value(
+            into<cxx::remove_cvref_t<T>>::template into_toml<config_type>(ud),
+            std::move(com))
+    {}
+    template<typename T, cxx::enable_if_t<
+        detail::has_specialized_into<T>::value, std::nullptr_t> = nullptr>
+    basic_value& operator=(const T& ud)
+    {
+        *this = into<cxx::remove_cvref_t<T>>::template into_toml<config_type>(ud);
+        return *this;
+    }
+
+    template<typename T, cxx::enable_if_t<cxx::conjunction<
+            detail::has_into_toml_method<T>,
+            cxx::negation<detail::has_specialized_into<T>>
+        >::value, std::nullptr_t> = nullptr>
+    basic_value(const T& ud): basic_value(ud.into_toml()) {}
+
+    template<typename T, cxx::enable_if_t<cxx::conjunction<
+            detail::has_into_toml_method<T>,
+            cxx::negation<detail::has_specialized_into<T>>
+        >::value, std::nullptr_t> = nullptr>
+    basic_value(const T& ud, std::vector<std::string> com)
+        : basic_value(ud.into_toml(), std::move(com))
+    {}
+    template<typename T, cxx::enable_if_t<cxx::conjunction<
+            detail::has_into_toml_method<T>,
+            cxx::negation<detail::has_specialized_into<T>>
+        >::value, std::nullptr_t> = nullptr>
+    basic_value& operator=(const T& ud)
+    {
+        *this = ud.into_toml();
+        return *this;
+    }
+
+    template<typename T, cxx::enable_if_t<cxx::conjunction<
+            detail::has_template_into_toml_method<T, TypeConfig>,
+            cxx::negation<detail::has_specialized_into<T>>
+        >::value, std::nullptr_t> = nullptr>
+    basic_value(const T& ud): basic_value(ud.template into_toml<TypeConfig>()) {}
+
+    template<typename T, cxx::enable_if_t<cxx::conjunction<
+            detail::has_template_into_toml_method<T, TypeConfig>,
+            cxx::negation<detail::has_specialized_into<T>>
+        >::value, std::nullptr_t> = nullptr>
+    basic_value(const T& ud, std::vector<std::string> com)
+        : basic_value(ud.template into_toml<TypeConfig>(), std::move(com))
+    {}
+    template<typename T, cxx::enable_if_t<cxx::conjunction<
+            detail::has_template_into_toml_method<T, TypeConfig>,
+            cxx::negation<detail::has_specialized_into<T>>
+        >::value, std::nullptr_t> = nullptr>
+    basic_value& operator=(const T& ud)
+    {
+        *this = ud.template into_toml<TypeConfig>();
+        return *this;
+    }
+    // }}}
+
+    // empty value with region info ======================================= {{{
+
+    // mainly for `null` extension
+    basic_value(detail::none_t, region_type reg) noexcept
+        : type_(value_t::empty), empty_('\0'), region_(std::move(reg)), comments_{}
+    {}
+
+    // }}}
+
+    // type checking ====================================================== {{{
+
+    template<typename T, cxx::enable_if_t<
+        detail::is_exact_toml_type<cxx::remove_cvref_t<T>, value_type>::value,
+        std::nullptr_t> = nullptr>
+    bool is() const noexcept
+    {
+        return detail::type_to_enum<T, value_type>::value == this->type_;
+    }
+    bool is(value_t t) const noexcept {return t == this->type_;}
+
+    bool is_empty()           const noexcept {return this->is(value_t::empty          );}
+    bool is_boolean()         const noexcept {return this->is(value_t::boolean        );}
+    bool is_integer()         const noexcept {return this->is(value_t::integer        );}
+    bool is_floating()        const noexcept {return this->is(value_t::floating       );}
+    bool is_string()          const noexcept {return this->is(value_t::string         );}
+    bool is_offset_datetime() const noexcept {return this->is(value_t::offset_datetime);}
+    bool is_local_datetime()  const noexcept {return this->is(value_t::local_datetime );}
+    bool is_local_date()      const noexcept {return this->is(value_t::local_date     );}
+    bool is_local_time()      const noexcept {return this->is(value_t::local_time     );}
+    bool is_array()           const noexcept {return this->is(value_t::array          );}
+    bool is_table()           const noexcept {return this->is(value_t::table          );}
+
+    bool is_array_of_tables() const noexcept
+    {
+        if( ! this->is_array()) {return false;}
+        const auto& a = this->as_array(std::nothrow); // already checked.
+
+        // when you define [[array.of.tables]], at least one empty table will be
+        // assigned. In case of array of inline tables, `array_of_tables = []`,
+        // there is no reason to consider this as an array of *tables*.
+        // So empty array is not an array-of-tables.
+        if(a.empty()) {return false;}
+
+        // since toml v1.0.0 allows array of heterogeneous types, we need to
+        // check all the elements. if any of the elements is not a table, it
+        // is a heterogeneous array and cannot be expressed by `[[aot]]` form.
+        for(const auto& e : a)
+        {
+            if( ! e.is_table()) {return false;}
+        }
+        return true;
+    }
+
+    value_t type() const noexcept {return type_;}
+
+    // }}}
+
+    // as_xxx (noexcept) version ========================================== {{{
+
+    template<value_t T>
+    detail::enum_to_type_t<T, basic_value<config_type>> const&
+    as(const std::nothrow_t&) const noexcept
+    {
+        return detail::getter<config_type, T>::get_nothrow(*this);
+    }
+    template<value_t T>
+    detail::enum_to_type_t<T, basic_value<config_type>>&
+    as(const std::nothrow_t&) noexcept
+    {
+        return detail::getter<config_type, T>::get_nothrow(*this);
+    }
+
+    boolean_type         const& as_boolean        (const std::nothrow_t&) const noexcept {return this->boolean_.value;}
+    integer_type         const& as_integer        (const std::nothrow_t&) const noexcept {return this->integer_.value;}
+    floating_type        const& as_floating       (const std::nothrow_t&) const noexcept {return this->floating_.value;}
+    string_type          const& as_string         (const std::nothrow_t&) const noexcept {return this->string_.value;}
+    offset_datetime_type const& as_offset_datetime(const std::nothrow_t&) const noexcept {return this->offset_datetime_.value;}
+    local_datetime_type  const& as_local_datetime (const std::nothrow_t&) const noexcept {return this->local_datetime_.value;}
+    local_date_type      const& as_local_date     (const std::nothrow_t&) const noexcept {return this->local_date_.value;}
+    local_time_type      const& as_local_time     (const std::nothrow_t&) const noexcept {return this->local_time_.value;}
+    array_type           const& as_array          (const std::nothrow_t&) const noexcept {return this->array_.value.get();}
+    table_type           const& as_table          (const std::nothrow_t&) const noexcept {return this->table_.value.get();}
+
+    boolean_type        & as_boolean        (const std::nothrow_t&) noexcept {return this->boolean_.value;}
+    integer_type        & as_integer        (const std::nothrow_t&) noexcept {return this->integer_.value;}
+    floating_type       & as_floating       (const std::nothrow_t&) noexcept {return this->floating_.value;}
+    string_type         & as_string         (const std::nothrow_t&) noexcept {return this->string_.value;}
+    offset_datetime_type& as_offset_datetime(const std::nothrow_t&) noexcept {return this->offset_datetime_.value;}
+    local_datetime_type & as_local_datetime (const std::nothrow_t&) noexcept {return this->local_datetime_.value;}
+    local_date_type     & as_local_date     (const std::nothrow_t&) noexcept {return this->local_date_.value;}
+    local_time_type     & as_local_time     (const std::nothrow_t&) noexcept {return this->local_time_.value;}
+    array_type          & as_array          (const std::nothrow_t&) noexcept {return this->array_.value.get();}
+    table_type          & as_table          (const std::nothrow_t&) noexcept {return this->table_.value.get();}
+
+    // }}}
+
+    // as_xxx (throw) ===================================================== {{{
+
+    template<value_t T>
+    detail::enum_to_type_t<T, basic_value<config_type>> const& as() const
+    {
+        return detail::getter<config_type, T>::get(*this);
+    }
+    template<value_t T>
+    detail::enum_to_type_t<T, basic_value<config_type>>& as()
+    {
+        return detail::getter<config_type, T>::get(*this);
+    }
+
+    boolean_type const& as_boolean() const
+    {
+        if(this->type_ != value_t::boolean)
+        {
+            this->throw_bad_cast("toml::value::as_boolean()", value_t::boolean);
+        }
+        return this->boolean_.value;
+    }
+    integer_type const& as_integer() const
+    {
+        if(this->type_ != value_t::integer)
+        {
+            this->throw_bad_cast("toml::value::as_integer()", value_t::integer);
+        }
+        return this->integer_.value;
+    }
+    floating_type const& as_floating() const
+    {
+        if(this->type_ != value_t::floating)
+        {
+            this->throw_bad_cast("toml::value::as_floating()", value_t::floating);
+        }
+        return this->floating_.value;
+    }
+    string_type const& as_string() const
+    {
+        if(this->type_ != value_t::string)
+        {
+            this->throw_bad_cast("toml::value::as_string()", value_t::string);
+        }
+        return this->string_.value;
+    }
+    offset_datetime_type const& as_offset_datetime() const
+    {
+        if(this->type_ != value_t::offset_datetime)
+        {
+            this->throw_bad_cast("toml::value::as_offset_datetime()", value_t::offset_datetime);
+        }
+        return this->offset_datetime_.value;
+    }
+    local_datetime_type const& as_local_datetime() const
+    {
+        if(this->type_ != value_t::local_datetime)
+        {
+            this->throw_bad_cast("toml::value::as_local_datetime()", value_t::local_datetime);
+        }
+        return this->local_datetime_.value;
+    }
+    local_date_type const& as_local_date() const
+    {
+        if(this->type_ != value_t::local_date)
+        {
+            this->throw_bad_cast("toml::value::as_local_date()", value_t::local_date);
+        }
+        return this->local_date_.value;
+    }
+    local_time_type const& as_local_time() const
+    {
+        if(this->type_ != value_t::local_time)
+        {
+            this->throw_bad_cast("toml::value::as_local_time()", value_t::local_time);
+        }
+        return this->local_time_.value;
+    }
+    array_type const& as_array() const
+    {
+        if(this->type_ != value_t::array)
+        {
+            this->throw_bad_cast("toml::value::as_array()", value_t::array);
+        }
+        return this->array_.value.get();
+    }
+    table_type const& as_table() const
+    {
+        if(this->type_ != value_t::table)
+        {
+            this->throw_bad_cast("toml::value::as_table()", value_t::table);
+        }
+        return this->table_.value.get();
+    }
+
+    // ------------------------------------------------------------------------
+    // nonconst reference
+
+    boolean_type& as_boolean()
+    {
+        if(this->type_ != value_t::boolean)
+        {
+            this->throw_bad_cast("toml::value::as_boolean()", value_t::boolean);
+        }
+        return this->boolean_.value;
+    }
+    integer_type& as_integer()
+    {
+        if(this->type_ != value_t::integer)
+        {
+            this->throw_bad_cast("toml::value::as_integer()", value_t::integer);
+        }
+        return this->integer_.value;
+    }
+    floating_type& as_floating()
+    {
+        if(this->type_ != value_t::floating)
+        {
+            this->throw_bad_cast("toml::value::as_floating()", value_t::floating);
+        }
+        return this->floating_.value;
+    }
+    string_type& as_string()
+    {
+        if(this->type_ != value_t::string)
+        {
+            this->throw_bad_cast("toml::value::as_string()", value_t::string);
+        }
+        return this->string_.value;
+    }
+    offset_datetime_type& as_offset_datetime()
+    {
+        if(this->type_ != value_t::offset_datetime)
+        {
+            this->throw_bad_cast("toml::value::as_offset_datetime()", value_t::offset_datetime);
+        }
+        return this->offset_datetime_.value;
+    }
+    local_datetime_type& as_local_datetime()
+    {
+        if(this->type_ != value_t::local_datetime)
+        {
+            this->throw_bad_cast("toml::value::as_local_datetime()", value_t::local_datetime);
+        }
+        return this->local_datetime_.value;
+    }
+    local_date_type& as_local_date()
+    {
+        if(this->type_ != value_t::local_date)
+        {
+            this->throw_bad_cast("toml::value::as_local_date()", value_t::local_date);
+        }
+        return this->local_date_.value;
+    }
+    local_time_type& as_local_time()
+    {
+        if(this->type_ != value_t::local_time)
+        {
+            this->throw_bad_cast("toml::value::as_local_time()", value_t::local_time);
+        }
+        return this->local_time_.value;
+    }
+    array_type& as_array()
+    {
+        if(this->type_ != value_t::array)
+        {
+            this->throw_bad_cast("toml::value::as_array()", value_t::array);
+        }
+        return this->array_.value.get();
+    }
+    table_type& as_table()
+    {
+        if(this->type_ != value_t::table)
+        {
+            this->throw_bad_cast("toml::value::as_table()", value_t::table);
+        }
+        return this->table_.value.get();
+    }
+
+    // }}}
+
+    // format accessors (noexcept) ======================================== {{{
+
+    template<value_t T>
+    detail::enum_to_fmt_type_t<T> const&
+    as_fmt(const std::nothrow_t&) const noexcept
+    {
+        return detail::getter<config_type, T>::get_fmt_nothrow(*this);
+    }
+    template<value_t T>
+    detail::enum_to_fmt_type_t<T>&
+    as_fmt(const std::nothrow_t&) noexcept
+    {
+        return detail::getter<config_type, T>::get_fmt_nothrow(*this);
+    }
+
+    boolean_format_info        & as_boolean_fmt        (const std::nothrow_t&) noexcept {return this->boolean_.format;}
+    integer_format_info        & as_integer_fmt        (const std::nothrow_t&) noexcept {return this->integer_.format;}
+    floating_format_info       & as_floating_fmt       (const std::nothrow_t&) noexcept {return this->floating_.format;}
+    string_format_info         & as_string_fmt         (const std::nothrow_t&) noexcept {return this->string_.format;}
+    offset_datetime_format_info& as_offset_datetime_fmt(const std::nothrow_t&) noexcept {return this->offset_datetime_.format;}
+    local_datetime_format_info & as_local_datetime_fmt (const std::nothrow_t&) noexcept {return this->local_datetime_.format;}
+    local_date_format_info     & as_local_date_fmt     (const std::nothrow_t&) noexcept {return this->local_date_.format;}
+    local_time_format_info     & as_local_time_fmt     (const std::nothrow_t&) noexcept {return this->local_time_.format;}
+    array_format_info          & as_array_fmt          (const std::nothrow_t&) noexcept {return this->array_.format;}
+    table_format_info          & as_table_fmt          (const std::nothrow_t&) noexcept {return this->table_.format;}
+
+    boolean_format_info         const& as_boolean_fmt        (const std::nothrow_t&) const noexcept {return this->boolean_.format;}
+    integer_format_info         const& as_integer_fmt        (const std::nothrow_t&) const noexcept {return this->integer_.format;}
+    floating_format_info        const& as_floating_fmt       (const std::nothrow_t&) const noexcept {return this->floating_.format;}
+    string_format_info          const& as_string_fmt         (const std::nothrow_t&) const noexcept {return this->string_.format;}
+    offset_datetime_format_info const& as_offset_datetime_fmt(const std::nothrow_t&) const noexcept {return this->offset_datetime_.format;}
+    local_datetime_format_info  const& as_local_datetime_fmt (const std::nothrow_t&) const noexcept {return this->local_datetime_.format;}
+    local_date_format_info      const& as_local_date_fmt     (const std::nothrow_t&) const noexcept {return this->local_date_.format;}
+    local_time_format_info      const& as_local_time_fmt     (const std::nothrow_t&) const noexcept {return this->local_time_.format;}
+    array_format_info           const& as_array_fmt          (const std::nothrow_t&) const noexcept {return this->array_.format;}
+    table_format_info           const& as_table_fmt          (const std::nothrow_t&) const noexcept {return this->table_.format;}
+
+    // }}}
+
+    // format accessors (throw) =========================================== {{{
+
+    template<value_t T>
+    detail::enum_to_fmt_type_t<T> const& as_fmt() const
+    {
+        return detail::getter<config_type, T>::get_fmt(*this);
+    }
+    template<value_t T>
+    detail::enum_to_fmt_type_t<T>& as_fmt()
+    {
+        return detail::getter<config_type, T>::get_fmt(*this);
+    }
+
+    boolean_format_info const& as_boolean_fmt() const
+    {
+        if(this->type_ != value_t::boolean)
+        {
+            this->throw_bad_cast("toml::value::as_boolean_fmt()", value_t::boolean);
+        }
+        return this->boolean_.format;
+    }
+    integer_format_info const& as_integer_fmt() const
+    {
+        if(this->type_ != value_t::integer)
+        {
+            this->throw_bad_cast("toml::value::as_integer_fmt()", value_t::integer);
+        }
+        return this->integer_.format;
+    }
+    floating_format_info const& as_floating_fmt() const
+    {
+        if(this->type_ != value_t::floating)
+        {
+            this->throw_bad_cast("toml::value::as_floating_fmt()", value_t::floating);
+        }
+        return this->floating_.format;
+    }
+    string_format_info const& as_string_fmt() const
+    {
+        if(this->type_ != value_t::string)
+        {
+            this->throw_bad_cast("toml::value::as_string_fmt()", value_t::string);
+        }
+        return this->string_.format;
+    }
+    offset_datetime_format_info const& as_offset_datetime_fmt() const
+    {
+        if(this->type_ != value_t::offset_datetime)
+        {
+            this->throw_bad_cast("toml::value::as_offset_datetime_fmt()", value_t::offset_datetime);
+        }
+        return this->offset_datetime_.format;
+    }
+    local_datetime_format_info const& as_local_datetime_fmt() const
+    {
+        if(this->type_ != value_t::local_datetime)
+        {
+            this->throw_bad_cast("toml::value::as_local_datetime_fmt()", value_t::local_datetime);
+        }
+        return this->local_datetime_.format;
+    }
+    local_date_format_info const& as_local_date_fmt() const
+    {
+        if(this->type_ != value_t::local_date)
+        {
+            this->throw_bad_cast("toml::value::as_local_date_fmt()", value_t::local_date);
+        }
+        return this->local_date_.format;
+    }
+    local_time_format_info const& as_local_time_fmt() const
+    {
+        if(this->type_ != value_t::local_time)
+        {
+            this->throw_bad_cast("toml::value::as_local_time_fmt()", value_t::local_time);
+        }
+        return this->local_time_.format;
+    }
+    array_format_info const& as_array_fmt() const
+    {
+        if(this->type_ != value_t::array)
+        {
+            this->throw_bad_cast("toml::value::as_array_fmt()", value_t::array);
+        }
+        return this->array_.format;
+    }
+    table_format_info const& as_table_fmt() const
+    {
+        if(this->type_ != value_t::table)
+        {
+            this->throw_bad_cast("toml::value::as_table_fmt()", value_t::table);
+        }
+        return this->table_.format;
+    }
+
+    // ------------------------------------------------------------------------
+    // nonconst reference
+
+    boolean_format_info& as_boolean_fmt()
+    {
+        if(this->type_ != value_t::boolean)
+        {
+            this->throw_bad_cast("toml::value::as_boolean_fmt()", value_t::boolean);
+        }
+        return this->boolean_.format;
+    }
+    integer_format_info& as_integer_fmt()
+    {
+        if(this->type_ != value_t::integer)
+        {
+            this->throw_bad_cast("toml::value::as_integer_fmt()", value_t::integer);
+        }
+        return this->integer_.format;
+    }
+    floating_format_info& as_floating_fmt()
+    {
+        if(this->type_ != value_t::floating)
+        {
+            this->throw_bad_cast("toml::value::as_floating_fmt()", value_t::floating);
+        }
+        return this->floating_.format;
+    }
+    string_format_info& as_string_fmt()
+    {
+        if(this->type_ != value_t::string)
+        {
+            this->throw_bad_cast("toml::value::as_string_fmt()", value_t::string);
+        }
+        return this->string_.format;
+    }
+    offset_datetime_format_info& as_offset_datetime_fmt()
+    {
+        if(this->type_ != value_t::offset_datetime)
+        {
+            this->throw_bad_cast("toml::value::as_offset_datetime_fmt()", value_t::offset_datetime);
+        }
+        return this->offset_datetime_.format;
+    }
+    local_datetime_format_info& as_local_datetime_fmt()
+    {
+        if(this->type_ != value_t::local_datetime)
+        {
+            this->throw_bad_cast("toml::value::as_local_datetime_fmt()", value_t::local_datetime);
+        }
+        return this->local_datetime_.format;
+    }
+    local_date_format_info& as_local_date_fmt()
+    {
+        if(this->type_ != value_t::local_date)
+        {
+            this->throw_bad_cast("toml::value::as_local_date_fmt()", value_t::local_date);
+        }
+        return this->local_date_.format;
+    }
+    local_time_format_info& as_local_time_fmt()
+    {
+        if(this->type_ != value_t::local_time)
+        {
+            this->throw_bad_cast("toml::value::as_local_time_fmt()", value_t::local_time);
+        }
+        return this->local_time_.format;
+    }
+    array_format_info& as_array_fmt()
+    {
+        if(this->type_ != value_t::array)
+        {
+            this->throw_bad_cast("toml::value::as_array_fmt()", value_t::array);
+        }
+        return this->array_.format;
+    }
+    table_format_info& as_table_fmt()
+    {
+        if(this->type_ != value_t::table)
+        {
+            this->throw_bad_cast("toml::value::as_table_fmt()", value_t::table);
+        }
+        return this->table_.format;
+    }
+    // }}}
+
+    // table accessors ==================================================== {{{
+
+    value_type& at(const key_type& k)
+    {
+        if(!this->is_table())
+        {
+            this->throw_bad_cast("toml::value::at(key_type)", value_t::table);
+        }
+        auto& table = this->as_table(std::nothrow);
+        const auto found = table.find(k);
+        if(found == table.end())
+        {
+            this->throw_key_not_found_error("toml::value::at", k);
+        }
+        assert(found->first == k);
+        return found->second;
+    }
+    value_type const& at(const key_type& k) const
+    {
+        if(!this->is_table())
+        {
+            this->throw_bad_cast("toml::value::at(key_type)", value_t::table);
+        }
+        const auto& table = this->as_table(std::nothrow);
+        const auto found = table.find(k);
+        if(found == table.end())
+        {
+            this->throw_key_not_found_error("toml::value::at", k);
+        }
+        assert(found->first == k);
+        return found->second;
+    }
+    value_type& operator[](const key_type& k)
+    {
+        if(this->is_empty())
+        {
+            (*this) = table_type{};
+        }
+        else if( ! this->is_table()) // initialized, but not a table
+        {
+            this->throw_bad_cast("toml::value::operator[](key_type)", value_t::table);
+        }
+        return (this->as_table(std::nothrow))[k];
+    }
+    std::size_t count(const key_type& k) const
+    {
+        if(!this->is_table())
+        {
+            this->throw_bad_cast("toml::value::count(key_type)", value_t::table);
+        }
+        return this->as_table(std::nothrow).count(k);
+    }
+    bool contains(const key_type& k) const
+    {
+        if(!this->is_table())
+        {
+            this->throw_bad_cast("toml::value::contains(key_type)", value_t::table);
+        }
+        const auto& table = this->as_table(std::nothrow);
+        return table.find(k) != table.end();
+    }
+    // }}}
+
+    // array accessors ==================================================== {{{
+
+    value_type& at(const std::size_t idx)
+    {
+        if(!this->is_array())
+        {
+            this->throw_bad_cast("toml::value::at(idx)", value_t::array);
+        }
+        auto& ar = this->as_array(std::nothrow);
+
+        if(ar.size() <= idx)
+        {
+            std::ostringstream oss;
+            oss << "actual length (" << ar.size()
+                << ") is shorter than the specified index (" << idx << ").";
+            throw std::out_of_range(format_error(
+                "toml::value::at(idx): no element corresponding to the index",
+                this->location(), oss.str()
+                ));
+        }
+        return ar.at(idx);
+    }
+    value_type const& at(const std::size_t idx) const
+    {
+        if(!this->is_array())
+        {
+            this->throw_bad_cast("toml::value::at(idx)", value_t::array);
+        }
+        const auto& ar = this->as_array(std::nothrow);
+
+        if(ar.size() <= idx)
+        {
+            std::ostringstream oss;
+            oss << "actual length (" << ar.size()
+                << ") is shorter than the specified index (" << idx << ").";
+
+            throw std::out_of_range(format_error(
+                "toml::value::at(idx): no element corresponding to the index",
+                this->location(), oss.str()
+                ));
+        }
+        return ar.at(idx);
+    }
+
+    value_type&       operator[](const std::size_t idx) noexcept
+    {
+        // no check...
+        return this->as_array(std::nothrow)[idx];
+    }
+    value_type const& operator[](const std::size_t idx) const noexcept
+    {
+        // no check...
+        return this->as_array(std::nothrow)[idx];
+    }
+
+    void push_back(const value_type& x)
+    {
+        if(!this->is_array())
+        {
+            this->throw_bad_cast("toml::value::push_back(idx)", value_t::array);
+        }
+        this->as_array(std::nothrow).push_back(x);
+        return;
+    }
+    void push_back(value_type&& x)
+    {
+        if(!this->is_array())
+        {
+            this->throw_bad_cast("toml::value::push_back(idx)", value_t::array);
+        }
+        this->as_array(std::nothrow).push_back(std::move(x));
+        return;
+    }
+
+    template<typename ... Ts>
+    value_type& emplace_back(Ts&& ... args)
+    {
+        if(!this->is_array())
+        {
+            this->throw_bad_cast("toml::value::emplace_back(idx)", value_t::array);
+        }
+        auto& ar = this->as_array(std::nothrow);
+        ar.emplace_back(std::forward<Ts>(args) ...);
+        return ar.back();
+    }
+
+    std::size_t size() const
+    {
+        switch(this->type_)
+        {
+            case value_t::array:
+            {
+                return this->as_array(std::nothrow).size();
+            }
+            case value_t::table:
+            {
+                return this->as_table(std::nothrow).size();
+            }
+            case value_t::string:
+            {
+                return this->as_string(std::nothrow).size();
+            }
+            default:
+            {
+                throw type_error(format_error(
+                    "toml::value::size(): bad_cast to container types",
+                    this->location(),
+                    "the actual type is " + to_string(this->type_)
+                    ), this->location());
+            }
+        }
+    }
+
+    // }}}
+
+    source_location location() const
+    {
+        return source_location(this->region_);
+    }
+
+    comment_type const& comments() const noexcept {return this->comments_;}
+    comment_type&       comments()       noexcept {return this->comments_;}
+
+  private:
+
+    // private helper functions =========================================== {{{
+
+    void cleanup() noexcept
+    {
+        switch(this->type_)
+        {
+            case value_t::boolean         : { boolean_        .~boolean_storage         (); break; }
+            case value_t::integer         : { integer_        .~integer_storage         (); break; }
+            case value_t::floating        : { floating_       .~floating_storage        (); break; }
+            case value_t::string          : { string_         .~string_storage          (); break; }
+            case value_t::offset_datetime : { offset_datetime_.~offset_datetime_storage (); break; }
+            case value_t::local_datetime  : { local_datetime_ .~local_datetime_storage  (); break; }
+            case value_t::local_date      : { local_date_     .~local_date_storage      (); break; }
+            case value_t::local_time      : { local_time_     .~local_time_storage      (); break; }
+            case value_t::array           : { array_          .~array_storage           (); break; }
+            case value_t::table           : { table_          .~table_storage           (); break; }
+            default                       : { break; }
+        }
+        this->type_ = value_t::empty;
+        return;
+    }
+
+    template<typename T, typename U>
+    static void assigner(T& dst, U&& v)
+    {
+        const auto tmp = ::new(std::addressof(dst)) T(std::forward<U>(v));
+        assert(tmp == std::addressof(dst));
+        (void)tmp;
+    }
+
+    [[noreturn]]
+    void throw_bad_cast(const std::string& funcname, const value_t ty) const
+    {
+        throw type_error(format_error(detail::make_type_error(*this, funcname, ty)),
+                         this->location());
+    }
+
+    [[noreturn]]
+    void throw_key_not_found_error(const std::string& funcname, const key_type& key) const
+    {
+        throw std::out_of_range(format_error(
+                    detail::make_not_found_error(*this, funcname, key)));
+    }
+
+    template<typename TC>
+    friend void detail::change_region_of_value(basic_value<TC>&, const basic_value<TC>&);
+
+    template<typename TC>
+    friend class basic_value;
+
+    // }}}
+
+  private:
+
+    using boolean_storage         = detail::value_with_format<boolean_type,                boolean_format_info        >;
+    using integer_storage         = detail::value_with_format<integer_type,                integer_format_info        >;
+    using floating_storage        = detail::value_with_format<floating_type,               floating_format_info       >;
+    using string_storage          = detail::value_with_format<string_type,                 string_format_info         >;
+    using offset_datetime_storage = detail::value_with_format<offset_datetime_type,        offset_datetime_format_info>;
+    using local_datetime_storage  = detail::value_with_format<local_datetime_type,         local_datetime_format_info >;
+    using local_date_storage      = detail::value_with_format<local_date_type,             local_date_format_info     >;
+    using local_time_storage      = detail::value_with_format<local_time_type,             local_time_format_info     >;
+    using array_storage           = detail::value_with_format<detail::storage<array_type>, array_format_info          >;
+    using table_storage           = detail::value_with_format<detail::storage<table_type>, table_format_info          >;
+
+  private:
+
+    value_t type_;
+    union
+    {
+        char                    empty_; // the smallest type
+        boolean_storage         boolean_;
+        integer_storage         integer_;
+        floating_storage        floating_;
+        string_storage          string_;
+        offset_datetime_storage offset_datetime_;
+        local_datetime_storage  local_datetime_;
+        local_date_storage      local_date_;
+        local_time_storage      local_time_;
+        array_storage           array_;
+        table_storage           table_;
+    };
+    region_type  region_;
+    comment_type comments_;
+};
+
+template<typename TC>
+bool operator==(const basic_value<TC>& lhs, const basic_value<TC>& rhs)
+{
+    if(lhs.type()     != rhs.type())     {return false;}
+    if(lhs.comments() != rhs.comments()) {return false;}
+
+    switch(lhs.type())
+    {
+        case value_t::boolean  :
+        {
+            return lhs.as_boolean() == rhs.as_boolean();
+        }
+        case value_t::integer  :
+        {
+            return lhs.as_integer() == rhs.as_integer();
+        }
+        case value_t::floating :
+        {
+            return lhs.as_floating() == rhs.as_floating();
+        }
+        case value_t::string   :
+        {
+            return lhs.as_string() == rhs.as_string();
+        }
+        case value_t::offset_datetime:
+        {
+            return lhs.as_offset_datetime() == rhs.as_offset_datetime();
+        }
+        case value_t::local_datetime:
+        {
+            return lhs.as_local_datetime() == rhs.as_local_datetime();
+        }
+        case value_t::local_date:
+        {
+            return lhs.as_local_date() == rhs.as_local_date();
+        }
+        case value_t::local_time:
+        {
+            return lhs.as_local_time() == rhs.as_local_time();
+        }
+        case value_t::array    :
+        {
+            return lhs.as_array() == rhs.as_array();
+        }
+        case value_t::table    :
+        {
+            return lhs.as_table() == rhs.as_table();
+        }
+        case value_t::empty    : {return true; }
+        default:                 {return false;}
+    }
+}
+
+template<typename TC>
+bool operator!=(const basic_value<TC>& lhs, const basic_value<TC>& rhs)
+{
+    return !(lhs == rhs);
+}
+
+template<typename TC>
+cxx::enable_if_t<cxx::conjunction<
+    detail::is_comparable<typename basic_value<TC>::array_type>,
+    detail::is_comparable<typename basic_value<TC>::table_type>
+    >::value, bool>
+operator<(const basic_value<TC>& lhs, const basic_value<TC>& rhs)
+{
+    if(lhs.type() != rhs.type())
+    {
+        return (lhs.type() < rhs.type());
+    }
+    switch(lhs.type())
+    {
+        case value_t::boolean  :
+        {
+            return lhs.as_boolean() <  rhs.as_boolean() ||
+                  (lhs.as_boolean() == rhs.as_boolean() &&
+                   lhs.comments() < rhs.comments());
+        }
+        case value_t::integer  :
+        {
+            return lhs.as_integer() <  rhs.as_integer() ||
+                  (lhs.as_integer() == rhs.as_integer() &&
+                   lhs.comments() < rhs.comments());
+        }
+        case value_t::floating :
+        {
+            return lhs.as_floating() <  rhs.as_floating() ||
+                  (lhs.as_floating() == rhs.as_floating() &&
+                   lhs.comments() < rhs.comments());
+        }
+        case value_t::string   :
+        {
+            return lhs.as_string() <  rhs.as_string() ||
+                  (lhs.as_string() == rhs.as_string() &&
+                   lhs.comments() < rhs.comments());
+        }
+        case value_t::offset_datetime:
+        {
+            return lhs.as_offset_datetime() <  rhs.as_offset_datetime() ||
+                  (lhs.as_offset_datetime() == rhs.as_offset_datetime() &&
+                   lhs.comments() < rhs.comments());
+        }
+        case value_t::local_datetime:
+        {
+            return lhs.as_local_datetime() <  rhs.as_local_datetime() ||
+                  (lhs.as_local_datetime() == rhs.as_local_datetime() &&
+                   lhs.comments() < rhs.comments());
+        }
+        case value_t::local_date:
+        {
+            return lhs.as_local_date() <  rhs.as_local_date() ||
+                  (lhs.as_local_date() == rhs.as_local_date() &&
+                   lhs.comments() < rhs.comments());
+        }
+        case value_t::local_time:
+        {
+            return lhs.as_local_time() <  rhs.as_local_time() ||
+                  (lhs.as_local_time() == rhs.as_local_time() &&
+                   lhs.comments() < rhs.comments());
+        }
+        case value_t::array    :
+        {
+            return lhs.as_array() <  rhs.as_array() ||
+                  (lhs.as_array() == rhs.as_array() &&
+                   lhs.comments() < rhs.comments());
+        }
+        case value_t::table    :
+        {
+            return lhs.as_table() <  rhs.as_table() ||
+                  (lhs.as_table() == rhs.as_table() &&
+                   lhs.comments() < rhs.comments());
+        }
+        case value_t::empty    :
+        {
+            return lhs.comments() < rhs.comments();
+        }
+        default:
+        {
+            return lhs.comments() < rhs.comments();
+        }
+    }
+}
+
+template<typename TC>
+cxx::enable_if_t<cxx::conjunction<
+    detail::is_comparable<typename basic_value<TC>::array_type>,
+    detail::is_comparable<typename basic_value<TC>::table_type>
+    >::value, bool>
+operator<=(const basic_value<TC>& lhs, const basic_value<TC>& rhs)
+{
+    return (lhs < rhs) || (lhs == rhs);
+}
+template<typename TC>
+cxx::enable_if_t<cxx::conjunction<
+    detail::is_comparable<typename basic_value<TC>::array_type>,
+    detail::is_comparable<typename basic_value<TC>::table_type>
+    >::value, bool>
+operator>(const basic_value<TC>& lhs, const basic_value<TC>& rhs)
+{
+    return !(lhs <= rhs);
+}
+template<typename TC>
+cxx::enable_if_t<cxx::conjunction<
+    detail::is_comparable<typename basic_value<TC>::array_type>,
+    detail::is_comparable<typename basic_value<TC>::table_type>
+    >::value, bool>
+operator>=(const basic_value<TC>& lhs, const basic_value<TC>& rhs)
+{
+    return !(lhs < rhs);
+}
+
+// error_info helper
+namespace detail
+{
+template<typename TC, typename ... Ts>
+error_info make_error_info_rec(error_info e,
+        const basic_value<TC>& v, std::string msg, Ts&& ... tail)
+{
+    return make_error_info_rec(std::move(e), v.location(), std::move(msg), std::forward<Ts>(tail)...);
+}
+} // detail
+
+template<typename TC, typename ... Ts>
+error_info make_error_info(
+        std::string title, const basic_value<TC>& v, std::string msg, Ts&& ... tail)
+{
+    return make_error_info(std::move(title),
+            v.location(), std::move(msg), std::forward<Ts>(tail)...);
+}
+template<typename TC, typename ... Ts>
+std::string format_error(std::string title,
+        const basic_value<TC>& v, std::string msg, Ts&& ... tail)
+{
+    return format_error(std::move(title),
+            v.location(), std::move(msg), std::forward<Ts>(tail)...);
+}
+
+namespace detail
+{
+
+template<typename TC>
+error_info make_type_error(const basic_value<TC>& v, const std::string& fname, const value_t ty)
+{
+    return make_error_info(fname + ": bad_cast to " + to_string(ty),
+        v.location(), "the actual type is " + to_string(v.type()));
+}
+template<typename TC>
+error_info make_not_found_error(const basic_value<TC>& v, const std::string& fname, const typename basic_value<TC>::key_type& key)
+{
+    const auto loc = v.location();
+    const std::string title = fname + ": key \"" + string_conv<std::string>(key) + "\" not found";
+
+    std::vector<std::pair<source_location, std::string>> locs;
+    if( ! loc.is_ok())
+    {
+        return error_info(title, locs);
+    }
+
+    if(loc.first_line_number() == 1 && loc.first_column_number() == 1 && loc.length() == 1)
+    {
+        // The top-level table has its region at the 0th character of the file.
+        // That means that, in the case when a key is not found in the top-level
+        // table, the error message points to the first character. If the file has
+        // the first table at the first line, the error message would be like this.
+        // ```console
+        // [error] key "a" not found
+        //  --> example.toml
+        //    |
+        //  1 | [table]
+        //    | ^------ in this table
+        // ```
+        // It actually points to the top-level table at the first character, not
+        // `[table]`. But it is too confusing. To avoid the confusion, the error
+        // message should explicitly say "key not found in the top-level table".
+        locs.emplace_back(v.location(), "at the top-level table");
+    }
+    else
+    {
+        locs.emplace_back(v.location(), "in this table");
+    }
+    return error_info(title, locs);
+}
+
+#define TOML11_DETAIL_GENERATE_COMPTIME_GETTER(ty)                              \
+    template<typename TC>                                                       \
+    struct getter<TC, value_t::ty>                                              \
+    {                                                                           \
+        using value_type = basic_value<TC>;                                     \
+        using result_type = enum_to_type_t<value_t::ty, value_type>;            \
+        using format_type = enum_to_fmt_type_t<value_t::ty>;                    \
+                                                                                \
+        static result_type&       get(value_type& v)                            \
+        {                                                                       \
+            return v.as_ ## ty();                                               \
+        }                                                                       \
+        static result_type const& get(const value_type& v)                      \
+        {                                                                       \
+            return v.as_ ## ty();                                               \
+        }                                                                       \
+                                                                                \
+        static result_type&       get_nothrow(value_type& v) noexcept           \
+        {                                                                       \
+            return v.as_ ## ty(std::nothrow);                                   \
+        }                                                                       \
+        static result_type const& get_nothrow(const value_type& v) noexcept     \
+        {                                                                       \
+            return v.as_ ## ty(std::nothrow);                                   \
+        }                                                                       \
+                                                                                \
+        static format_type&       get_fmt(value_type& v)                        \
+        {                                                                       \
+            return v.as_ ## ty ## _fmt();                                       \
+        }                                                                       \
+        static format_type const& get_fmt(const value_type& v)                  \
+        {                                                                       \
+            return v.as_ ## ty ## _fmt();                                       \
+        }                                                                       \
+                                                                                \
+        static format_type&       get_fmt_nothrow(value_type& v) noexcept       \
+        {                                                                       \
+            return v.as_ ## ty ## _fmt(std::nothrow);                           \
+        }                                                                       \
+        static format_type const& get_fmt_nothrow(const value_type& v) noexcept \
+        {                                                                       \
+            return v.as_ ## ty ## _fmt(std::nothrow);                           \
+        }                                                                       \
+    };
+
+TOML11_DETAIL_GENERATE_COMPTIME_GETTER(boolean        )
+TOML11_DETAIL_GENERATE_COMPTIME_GETTER(integer        )
+TOML11_DETAIL_GENERATE_COMPTIME_GETTER(floating       )
+TOML11_DETAIL_GENERATE_COMPTIME_GETTER(string         )
+TOML11_DETAIL_GENERATE_COMPTIME_GETTER(offset_datetime)
+TOML11_DETAIL_GENERATE_COMPTIME_GETTER(local_datetime )
+TOML11_DETAIL_GENERATE_COMPTIME_GETTER(local_date     )
+TOML11_DETAIL_GENERATE_COMPTIME_GETTER(local_time     )
+TOML11_DETAIL_GENERATE_COMPTIME_GETTER(array          )
+TOML11_DETAIL_GENERATE_COMPTIME_GETTER(table          )
+
+#undef TOML11_DETAIL_GENERATE_COMPTIME_GETTER
+
+template<typename TC>
+void change_region_of_value(basic_value<TC>& dst, const basic_value<TC>& src)
+{
+    dst.region_ = std::move(src.region_);
+    return;
+}
+
+} // namespace detail
+} // namespace toml
+#endif // TOML11_VALUE_HPP
+#ifndef TOML11_VISIT_HPP
+#define TOML11_VISIT_HPP
+
+
+namespace toml
+{
+
+template<typename Visitor, typename TC>
+cxx::return_type_of_t<Visitor, const typename basic_value<TC>::boolean_type&>
+visit(Visitor&& visitor, const basic_value<TC>& v)
+{
+    switch(v.type())
+    {
+        case value_t::boolean        : {return visitor(v.as_boolean        ());}
+        case value_t::integer        : {return visitor(v.as_integer        ());}
+        case value_t::floating       : {return visitor(v.as_floating       ());}
+        case value_t::string         : {return visitor(v.as_string         ());}
+        case value_t::offset_datetime: {return visitor(v.as_offset_datetime());}
+        case value_t::local_datetime : {return visitor(v.as_local_datetime ());}
+        case value_t::local_date     : {return visitor(v.as_local_date     ());}
+        case value_t::local_time     : {return visitor(v.as_local_time     ());}
+        case value_t::array          : {return visitor(v.as_array          ());}
+        case value_t::table          : {return visitor(v.as_table          ());}
+        case value_t::empty          : break;
+        default: break;
+    }
+    throw type_error(format_error("[error] toml::visit: toml::basic_value "
+            "does not have any valid type.", v.location(), "here"), v.location());
+}
+
+template<typename Visitor, typename TC>
+cxx::return_type_of_t<Visitor, typename basic_value<TC>::boolean_type&>
+visit(Visitor&& visitor, basic_value<TC>& v)
+{
+    switch(v.type())
+    {
+        case value_t::boolean        : {return visitor(v.as_boolean        ());}
+        case value_t::integer        : {return visitor(v.as_integer        ());}
+        case value_t::floating       : {return visitor(v.as_floating       ());}
+        case value_t::string         : {return visitor(v.as_string         ());}
+        case value_t::offset_datetime: {return visitor(v.as_offset_datetime());}
+        case value_t::local_datetime : {return visitor(v.as_local_datetime ());}
+        case value_t::local_date     : {return visitor(v.as_local_date     ());}
+        case value_t::local_time     : {return visitor(v.as_local_time     ());}
+        case value_t::array          : {return visitor(v.as_array          ());}
+        case value_t::table          : {return visitor(v.as_table          ());}
+        case value_t::empty          : break;
+        default: break;
+    }
+    throw type_error(format_error("[error] toml::visit: toml::basic_value "
+            "does not have any valid type.", v.location(), "here"), v.location());
+}
+
+template<typename Visitor, typename TC>
+cxx::return_type_of_t<Visitor, typename basic_value<TC>::boolean_type&&>
+visit(Visitor&& visitor, basic_value<TC>&& v)
+{
+    switch(v.type())
+    {
+        case value_t::boolean        : {return visitor(std::move(v.as_boolean        ()));}
+        case value_t::integer        : {return visitor(std::move(v.as_integer        ()));}
+        case value_t::floating       : {return visitor(std::move(v.as_floating       ()));}
+        case value_t::string         : {return visitor(std::move(v.as_string         ()));}
+        case value_t::offset_datetime: {return visitor(std::move(v.as_offset_datetime()));}
+        case value_t::local_datetime : {return visitor(std::move(v.as_local_datetime ()));}
+        case value_t::local_date     : {return visitor(std::move(v.as_local_date     ()));}
+        case value_t::local_time     : {return visitor(std::move(v.as_local_time     ()));}
+        case value_t::array          : {return visitor(std::move(v.as_array          ()));}
+        case value_t::table          : {return visitor(std::move(v.as_table          ()));}
+        case value_t::empty          : break;
+        default: break;
+    }
+    throw type_error(format_error("[error] toml::visit: toml::basic_value "
+            "does not have any valid type.", v.location(), "here"), v.location());
+}
+
+} // toml
+#endif // TOML11_VISIT_HPP
+#ifndef TOML11_TYPES_HPP
+#define TOML11_TYPES_HPP
+
+
+#include <ostream>
+#include <sstream>
+#include <string>
+#include <type_traits>
+#include <unordered_map>
+#include <vector>
+
+#include <cstdint>
+#include <cstdio>
+
+namespace toml
+{
+
+// forward decl
+template<typename TypeConfig>
+class basic_value;
+
+// when you use a special integer type as toml::value::integer_type, parse must
+// be able to read it. So, type_config has static member functions that read the
+// integer_type as {dec, hex, oct, bin}-integer. But, in most cases, operator<<
+// is enough. To make config easy, we provide the default read functions.
+//
+// Before this functions is called, syntax is checked and prefix(`0x` etc) and
+// spacer(`_`) are removed.
+
+template<typename T>
+result<T, error_info>
+read_dec_int(const std::string& str, const source_location src)
+{
+    constexpr auto max_digits = std::numeric_limits<T>::digits;
+    assert( ! str.empty());
+
+    T val{0};
+    std::istringstream iss(str);
+    iss >> val;
+    if(iss.fail())
+    {
+        return err(make_error_info("toml::parse_dec_integer: "
+            "too large integer: current max digits = 2^" + std::to_string(max_digits),
+            std::move(src), "must be < 2^" + std::to_string(max_digits)));
+    }
+    return ok(val);
+}
+
+template<typename T>
+result<T, error_info>
+read_hex_int(const std::string& str, const source_location src)
+{
+    constexpr auto max_digits = std::numeric_limits<T>::digits;
+    assert( ! str.empty());
+
+    T val{0};
+    std::istringstream iss(str);
+    iss >> std::hex >> val;
+    if(iss.fail())
+    {
+        return err(make_error_info("toml::parse_hex_integer: "
+            "too large integer: current max value = 2^" + std::to_string(max_digits),
+            std::move(src), "must be < 2^" + std::to_string(max_digits)));
+    }
+    return ok(val);
+}
+
+template<typename T>
+result<T, error_info>
+read_oct_int(const std::string& str, const source_location src)
+{
+    constexpr auto max_digits = std::numeric_limits<T>::digits;
+    assert( ! str.empty());
+
+    T val{0};
+    std::istringstream iss(str);
+    iss >> std::oct >> val;
+    if(iss.fail())
+    {
+        return err(make_error_info("toml::parse_oct_integer: "
+            "too large integer: current max value = 2^" + std::to_string(max_digits),
+            std::move(src), "must be < 2^" + std::to_string(max_digits)));
+    }
+    return ok(val);
+}
+
+template<typename T>
+result<T, error_info>
+read_bin_int(const std::string& str, const source_location src)
+{
+    constexpr auto is_bounded =  std::numeric_limits<T>::is_bounded;
+    constexpr auto max_digits =  std::numeric_limits<T>::digits;
+    const auto max_value  = (std::numeric_limits<T>::max)();
+
+    T val{0};
+    T base{1};
+    for(auto i = str.rbegin(); i != str.rend(); ++i)
+    {
+        const auto c = *i;
+        if(c == '1')
+        {
+            val += base;
+            // prevent `base` from overflow
+            if(is_bounded && max_value / 2 < base && std::next(i) != str.rend())
+            {
+                base = 0;
+            }
+            else
+            {
+                base *= 2;
+            }
+        }
+        else
+        {
+            assert(c == '0');
+
+            if(is_bounded && max_value / 2 < base && std::next(i) != str.rend())
+            {
+                base = 0;
+            }
+            else
+            {
+                base *= 2;
+            }
+        }
+    }
+    if(base == 0)
+    {
+        return err(make_error_info("toml::parse_bin_integer: "
+            "too large integer: current max value = 2^" + std::to_string(max_digits),
+            std::move(src), "must be < 2^" + std::to_string(max_digits)));
+    }
+    return ok(val);
+}
+
+template<typename T>
+result<T, error_info>
+read_int(const std::string& str, const source_location src, const std::uint8_t base)
+{
+    assert(base == 10 || base == 16 || base == 8 || base == 2);
+    switch(base)
+    {
+        case  2: { return read_bin_int<T>(str, src); }
+        case  8: { return read_oct_int<T>(str, src); }
+        case 16: { return read_hex_int<T>(str, src); }
+        default:
+        {
+            assert(base == 10);
+            return read_dec_int<T>(str, src);
+        }
+    }
+}
+
+inline result<float, error_info>
+read_hex_float(const std::string& str, const source_location src, float val)
+{
+#if defined(_MSC_VER) && ! defined(__clang__)
+    const auto res = ::sscanf_s(str.c_str(), "%a", std::addressof(val));
+#else
+    const auto res = std::sscanf(str.c_str(), "%a", std::addressof(val));
+#endif
+    if(res != 1)
+    {
+        return err(make_error_info("toml::parse_floating: "
+            "failed to read hexadecimal floating point value ",
+            std::move(src), "here"));
+    }
+    return ok(val);
+}
+inline result<double, error_info>
+read_hex_float(const std::string& str, const source_location src, double val)
+{
+#if defined(_MSC_VER) && ! defined(__clang__)
+    const auto res = ::sscanf_s(str.c_str(), "%la", std::addressof(val));
+#else
+    const auto res = std::sscanf(str.c_str(), "%la", std::addressof(val));
+#endif
+    if(res != 1)
+    {
+        return err(make_error_info("toml::parse_floating: "
+            "failed to read hexadecimal floating point value ",
+            std::move(src), "here"));
+    }
+    return ok(val);
+}
+template<typename T>
+cxx::enable_if_t<cxx::conjunction<
+    cxx::negation<std::is_same<cxx::remove_cvref_t<T>, double>>,
+    cxx::negation<std::is_same<cxx::remove_cvref_t<T>, float>>
+    >::value, result<T, error_info>>
+read_hex_float(const std::string&, const source_location src, T)
+{
+    return err(make_error_info("toml::parse_floating: failed to read "
+        "floating point value because of unknown type in type_config",
+        std::move(src), "here"));
+}
+
+template<typename T>
+result<T, error_info>
+read_dec_float(const std::string& str, const source_location src)
+{
+    T val;
+    std::istringstream iss(str);
+    iss >> val;
+    if(iss.fail())
+    {
+        return err(make_error_info("toml::parse_floating: "
+            "failed to read floating point value from stream",
+            std::move(src), "here"));
+    }
+    return ok(val);
+}
+
+template<typename T>
+result<T, error_info>
+read_float(const std::string& str, const source_location src, const bool is_hex)
+{
+    if(is_hex)
+    {
+        return read_hex_float(str, src, T{});
+    }
+    else
+    {
+        return read_dec_float<T>(str, src);
+    }
+}
+
+struct type_config
+{
+    using comment_type  = preserve_comments;
+
+    using boolean_type  = bool;
+    using integer_type  = std::int64_t;
+    using floating_type = double;
+    using string_type   = std::string;
+
+    template<typename T>
+    using array_type = std::vector<T>;
+    template<typename K, typename T>
+    using table_type = std::unordered_map<K, T>;
+
+    static result<integer_type, error_info>
+    parse_int(const std::string& str, const source_location src, const std::uint8_t base)
+    {
+        return read_int<integer_type>(str, src, base);
+    }
+    static result<floating_type, error_info>
+    parse_float(const std::string& str, const source_location src, const bool is_hex)
+    {
+        return read_float<floating_type>(str, src, is_hex);
+    }
+};
+
+using value = basic_value<type_config>;
+using table = typename value::table_type;
+using array = typename value::array_type;
+
+struct ordered_type_config
+{
+    using comment_type  = preserve_comments;
+
+    using boolean_type  = bool;
+    using integer_type  = std::int64_t;
+    using floating_type = double;
+    using string_type   = std::string;
+
+    template<typename T>
+    using array_type = std::vector<T>;
+    template<typename K, typename T>
+    using table_type = ordered_map<K, T>;
+
+    static result<integer_type, error_info>
+    parse_int(const std::string& str, const source_location src, const std::uint8_t base)
+    {
+        return read_int<integer_type>(str, src, base);
+    }
+    static result<floating_type, error_info>
+    parse_float(const std::string& str, const source_location src, const bool is_hex)
+    {
+        return read_float<floating_type>(str, src, is_hex);
+    }
+};
+
+using ordered_value = basic_value<ordered_type_config>;
+using ordered_table = typename ordered_value::table_type;
+using ordered_array = typename ordered_value::array_type;
+
+// ----------------------------------------------------------------------------
+// meta functions for internal use
+
+namespace detail
+{
+
+// ----------------------------------------------------------------------------
+// check if type T has all the needed member types
+
+struct has_comment_type_impl
+{
+    template<typename T> static std::true_type  check(typename T::comment_type*);
+    template<typename T> static std::false_type check(...);
+};
+template<typename T>
+using has_comment_type = decltype(has_comment_type_impl::check<T>(nullptr));
+
+struct has_integer_type_impl
+{
+    template<typename T> static std::true_type  check(typename T::integer_type*);
+    template<typename T> static std::false_type check(...);
+};
+template<typename T>
+using has_integer_type = decltype(has_integer_type_impl::check<T>(nullptr));
+
+struct has_floating_type_impl
+{
+    template<typename T> static std::true_type  check(typename T::floating_type*);
+    template<typename T> static std::false_type check(...);
+};
+template<typename T>
+using has_floating_type = decltype(has_floating_type_impl::check<T>(nullptr));
+
+struct has_string_type_impl
+{
+    template<typename T> static std::true_type  check(typename T::string_type*);
+    template<typename T> static std::false_type check(...);
+};
+template<typename T>
+using has_string_type = decltype(has_string_type_impl::check<T>(nullptr));
+
+struct has_array_type_impl
+{
+    template<typename T> static std::true_type  check(typename T::template array_type<int>*);
+    template<typename T> static std::false_type check(...);
+};
+template<typename T>
+using has_array_type = decltype(has_array_type_impl::check<T>(nullptr));
+
+struct has_table_type_impl
+{
+    template<typename T> static std::true_type  check(typename T::template table_type<int, int>*);
+    template<typename T> static std::false_type check(...);
+};
+template<typename T>
+using has_table_type = decltype(has_table_type_impl::check<T>(nullptr));
+
+struct has_parse_int_impl
+{
+    template<typename T> static std::true_type  check(decltype(std::declval<T>().parse_int(
+            std::declval<const std::string&>(),
+            std::declval<const source_location>(),
+            std::declval<const std::uint8_t>()
+        ))*);
+    template<typename T> static std::false_type check(...);
+};
+template<typename T>
+using has_parse_int = decltype(has_parse_int_impl::check<T>(nullptr));
+
+struct has_parse_float_impl
+{
+    template<typename T> static std::true_type  check(decltype(std::declval<T>().parse_float(
+            std::declval<const std::string&>(),
+            std::declval<const source_location>(),
+            std::declval<const bool>()
+        ))*);
+    template<typename T> static std::false_type check(...);
+};
+template<typename T>
+using has_parse_float = decltype(has_parse_float_impl::check<T>(nullptr));
+
+template<typename T>
+using is_type_config = cxx::conjunction<
+    has_comment_type<T>,
+    has_integer_type<T>,
+    has_floating_type<T>,
+    has_string_type<T>,
+    has_array_type<T>,
+    has_table_type<T>,
+    has_parse_int<T>,
+    has_parse_float<T>
+    >;
+
+} // namespace detail
+} // namespace toml
+
+#if defined(TOML11_COMPILE_SOURCES)
+namespace toml
+{
+extern template class basic_value<type_config>;
+extern template class basic_value<ordered_type_config>;
+} // toml
+#endif // TOML11_COMPILE_SOURCES
+
+#endif // TOML11_TYPES_HPP
+#ifndef TOML11_GET_HPP
+#define TOML11_GET_HPP
+
+#include <algorithm>
+
+
+#if defined(TOML11_HAS_STRING_VIEW)
+#include <string_view>
+#endif // string_view
+
+namespace toml
+{
+
+// ============================================================================
+// T is toml::value; identity transformation.
+
+template<typename T, typename TC>
+cxx::enable_if_t<std::is_same<T, basic_value<TC>>::value, T>&
+get(basic_value<TC>& v)
+{
+    return v;
+}
+
+template<typename T, typename TC>
+cxx::enable_if_t<std::is_same<T, basic_value<TC>>::value, T> const&
+get(const basic_value<TC>& v)
+{
+    return v;
+}
+
+template<typename T, typename TC>
+cxx::enable_if_t<std::is_same<T, basic_value<TC>>::value, T>
+get(basic_value<TC>&& v)
+{
+    return basic_value<TC>(std::move(v));
+}
+
+// ============================================================================
+// exact toml::* type
+
+template<typename T, typename TC>
+cxx::enable_if_t<detail::is_exact_toml_type<T, basic_value<TC>>::value, T> &
+get(basic_value<TC>& v)
+{
+    constexpr auto ty = detail::type_to_enum<T, basic_value<TC>>::value;
+    return detail::getter<TC, ty>::get(v);
+}
+
+template<typename T, typename TC>
+cxx::enable_if_t<detail::is_exact_toml_type<T, basic_value<TC>>::value, T> const&
+get(const basic_value<TC>& v)
+{
+    constexpr auto ty = detail::type_to_enum<T, basic_value<TC>>::value;
+    return detail::getter<TC, ty>::get(v);
+}
+
+template<typename T, typename TC>
+cxx::enable_if_t<detail::is_exact_toml_type<T, basic_value<TC>>::value, T>
+get(basic_value<TC>&& v)
+{
+    constexpr auto ty = detail::type_to_enum<T, basic_value<TC>>::value;
+    return detail::getter<TC, ty>::get(std::move(v));
+}
+
+// ============================================================================
+// T is toml::basic_value<U>
+
+template<typename T, typename TC>
+cxx::enable_if_t<cxx::conjunction<
+    detail::is_basic_value<T>,
+    cxx::negation<std::is_same<T, basic_value<TC>>>
+    >::value, T>
+get(basic_value<TC> v)
+{
+    return T(std::move(v));
+}
+
+// ============================================================================
+// integer convertible from toml::value::integer_type
+
+template<typename T, typename TC>
+cxx::enable_if_t<cxx::conjunction<
+    std::is_integral<T>,
+    cxx::negation<std::is_same<T, bool>>,
+    detail::is_not_toml_type<T, basic_value<TC>>,
+    cxx::negation<detail::has_from_toml_method<T, TC>>,
+    cxx::negation<detail::has_specialized_from<T>>
+    >::value, T>
+get(const basic_value<TC>& v)
+{
+    return static_cast<T>(v.as_integer());
+}
+
+// ============================================================================
+// floating point convertible from toml::value::floating_type
+
+template<typename T, typename TC>
+cxx::enable_if_t<cxx::conjunction<
+    std::is_floating_point<T>,
+    detail::is_not_toml_type<T, basic_value<TC>>,
+    cxx::negation<detail::has_from_toml_method<T, TC>>,
+    cxx::negation<detail::has_specialized_from<T>>
+    >::value, T>
+get(const basic_value<TC>& v)
+{
+    return static_cast<T>(v.as_floating());
+}
+
+// ============================================================================
+// std::string with different char/trait/allocator
+
+template<typename T, typename TC>
+cxx::enable_if_t<cxx::conjunction<
+    detail::is_not_toml_type<T, basic_value<TC>>,
+    detail::is_1byte_std_basic_string<T>
+    >::value, T>
+get(const basic_value<TC>& v)
+{
+    return detail::string_conv<cxx::remove_cvref_t<T>>(v.as_string());
+}
+
+// ============================================================================
+// std::string_view
+
+#if defined(TOML11_HAS_STRING_VIEW)
+
+template<typename T, typename TC>
+cxx::enable_if_t<detail::is_string_view_of<T, typename basic_value<TC>::string_type>::value, T>
+get(const basic_value<TC>& v)
+{
+    return T(v.as_string());
+}
+
+#endif // string_view
+
+// ============================================================================
+// std::chrono::duration from toml::local_time
+
+template<typename T, typename TC>
+cxx::enable_if_t<detail::is_chrono_duration<T>::value, T>
+get(const basic_value<TC>& v)
+{
+    return std::chrono::duration_cast<T>(
+            std::chrono::nanoseconds(v.as_local_time()));
+}
+
+// ============================================================================
+// std::chrono::system_clock::time_point from toml::datetime variants
+
+template<typename T, typename TC>
+cxx::enable_if_t<
+    std::is_same<std::chrono::system_clock::time_point, T>::value, T>
+get(const basic_value<TC>& v)
+{
+    switch(v.type())
+    {
+        case value_t::local_date:
+        {
+            return std::chrono::system_clock::time_point(v.as_local_date());
+        }
+        case value_t::local_datetime:
+        {
+            return std::chrono::system_clock::time_point(v.as_local_datetime());
+        }
+        case value_t::offset_datetime:
+        {
+            return std::chrono::system_clock::time_point(v.as_offset_datetime());
+        }
+        default:
+        {
+            const auto loc = v.location();
+            throw type_error(format_error("toml::get: "
+                "bad_cast to std::chrono::system_clock::time_point", loc,
+                "the actual type is " + to_string(v.type())), loc);
+        }
+    }
+}
+
+// ============================================================================
+// forward declaration to use this recursively. ignore this and go ahead.
+
+// array-like (w/ push_back)
+template<typename T, typename TC>
+cxx::enable_if_t<cxx::conjunction<
+    detail::is_container<T>,                            // T is a container
+    detail::has_push_back_method<T>,                    // .push_back() works
+    detail::is_not_toml_type<T, basic_value<TC>>,       // but not toml::array
+    cxx::negation<detail::is_std_basic_string<T>>,      // but not std::basic_string<CharT>
+#if defined(TOML11_HAS_STRING_VIEW)
+    cxx::negation<detail::is_std_basic_string_view<T>>,      // but not std::basic_string_view<CharT>
+#endif
+    cxx::negation<detail::has_from_toml_method<T, TC>>, // no T.from_toml()
+    cxx::negation<detail::has_specialized_from<T>>,     // no toml::from<T>
+    cxx::negation<std::is_constructible<T, const basic_value<TC>&>>
+    >::value, T>
+get(const basic_value<TC>&);
+
+// std::array
+template<typename T, typename TC>
+cxx::enable_if_t<detail::is_std_array<T>::value, T>
+get(const basic_value<TC>&);
+
+// std::forward_list
+template<typename T, typename TC>
+cxx::enable_if_t<detail::is_std_forward_list<T>::value, T>
+get(const basic_value<TC>&);
+
+// std::pair<T1, T2>
+template<typename T, typename TC>
+cxx::enable_if_t<detail::is_std_pair<T>::value, T>
+get(const basic_value<TC>&);
+
+// std::tuple<T1, T2, ...>
+template<typename T, typename TC>
+cxx::enable_if_t<detail::is_std_tuple<T>::value, T>
+get(const basic_value<TC>&);
+
+// std::map<key, value> (key is convertible from toml::value::key_type)
+template<typename T, typename TC>
+cxx::enable_if_t<cxx::conjunction<
+    detail::is_map<T>,                                  // T is map
+    detail::is_not_toml_type<T, basic_value<TC>>,       // but not toml::table
+    std::is_convertible<typename basic_value<TC>::key_type,
+                        typename T::key_type>,          // keys are convertible
+    cxx::negation<detail::has_from_toml_method<T, TC>>, // no T.from_toml()
+    cxx::negation<detail::has_specialized_from<T>>,     // no toml::from<T>
+    cxx::negation<std::is_constructible<T, const basic_value<TC>&>>
+    >::value, T>
+get(const basic_value<TC>& v);
+
+// std::map<key, value> (key is not convertible from toml::value::key_type, but
+// is a std::basic_string)
+template<typename T, typename TC>
+cxx::enable_if_t<cxx::conjunction<
+    detail::is_map<T>,                                  // T is map
+    detail::is_not_toml_type<T, basic_value<TC>>,       // but not toml::table
+    cxx::negation<std::is_convertible<typename basic_value<TC>::key_type,
+        typename T::key_type>>,                         // keys are NOT convertible
+    detail::is_1byte_std_basic_string<typename T::key_type>, // is std::basic_string
+    cxx::negation<detail::has_from_toml_method<T, TC>>, // no T.from_toml()
+    cxx::negation<detail::has_specialized_from<T>>,     // no toml::from<T>
+    cxx::negation<std::is_constructible<T, const basic_value<TC>&>>
+    >::value, T>
+get(const basic_value<TC>& v);
+
+// toml::from<T>::from_toml(v)
+template<typename T, typename TC>
+cxx::enable_if_t<detail::has_specialized_from<T>::value, T>
+get(const basic_value<TC>&);
+
+// has T.from_toml(v) but no from<T>
+template<typename T, typename TC>
+cxx::enable_if_t<cxx::conjunction<
+    detail::has_from_toml_method<T, TC>,            // has T.from_toml()
+    cxx::negation<detail::has_specialized_from<T>>, // no toml::from<T>
+    std::is_default_constructible<T>                // T{} works
+    >::value, T>
+get(const basic_value<TC>&);
+
+// T(const toml::value&) and T is not toml::basic_value,
+// and it does not have `from<T>` nor `from_toml`.
+template<typename T, typename TC>
+cxx::enable_if_t<cxx::conjunction<
+    std::is_constructible<T, const basic_value<TC>&>,   // has T(const basic_value&)
+    cxx::negation<detail::is_basic_value<T>>,           // but not basic_value itself
+    cxx::negation<detail::has_from_toml_method<T, TC>>, // no .from_toml()
+    cxx::negation<detail::has_specialized_from<T>>      // no toml::from<T>
+    >::value, T>
+get(const basic_value<TC>&);
+
+// ============================================================================
+// array-like types; most likely STL container, like std::vector, etc.
+
+template<typename T, typename TC>
+cxx::enable_if_t<cxx::conjunction<
+    detail::is_container<T>,                            // T is a container
+    detail::has_push_back_method<T>,                    // .push_back() works
+    detail::is_not_toml_type<T, basic_value<TC>>,       // but not toml::array
+    cxx::negation<detail::is_std_basic_string<T>>,      // but not std::basic_string<CharT>
+#if defined(TOML11_HAS_STRING_VIEW)
+    cxx::negation<detail::is_std_basic_string_view<T>>, // but not std::basic_string_view<CharT>
+#endif
+    cxx::negation<detail::has_from_toml_method<T, TC>>, // no T.from_toml()
+    cxx::negation<detail::has_specialized_from<T>>,     // no toml::from<T>
+    cxx::negation<std::is_constructible<T, const basic_value<TC>&>>
+    >::value, T>
+get(const basic_value<TC>& v)
+{
+    using value_type = typename T::value_type;
+    const auto& a = v.as_array();
+
+    T container;
+    detail::try_reserve(container, a.size()); // if T has .reserve(), call it
+
+    for(const auto& elem : a)
+    {
+        container.push_back(get<value_type>(elem));
+    }
+    return container;
+}
+
+// ============================================================================
+// std::array
+
+template<typename T, typename TC>
+cxx::enable_if_t<detail::is_std_array<T>::value, T>
+get(const basic_value<TC>& v)
+{
+    using value_type = typename T::value_type;
+    const auto& a = v.as_array();
+
+    T container;
+    if(a.size() != container.size())
+    {
+        const auto loc = v.location();
+        throw std::out_of_range(format_error("toml::get: while converting to an array: "
+            " array size is " + std::to_string(container.size()) +
+            " but there are " + std::to_string(a.size()) + " elements in toml array.",
+            loc, "here"));
+    }
+    for(std::size_t i=0; i<a.size(); ++i)
+    {
+        container.at(i) = ::toml::get<value_type>(a.at(i));
+    }
+    return container;
+}
+
+// ============================================================================
+// std::forward_list
+
+template<typename T, typename TC>
+cxx::enable_if_t<detail::is_std_forward_list<T>::value, T>
+get(const basic_value<TC>& v)
+{
+    using value_type = typename T::value_type;
+
+    T container;
+    for(const auto& elem : v.as_array())
+    {
+        container.push_front(get<value_type>(elem));
+    }
+    container.reverse();
+    return container;
+}
+
+// ============================================================================
+// std::pair
+
+template<typename T, typename TC>
+cxx::enable_if_t<detail::is_std_pair<T>::value, T>
+get(const basic_value<TC>& v)
+{
+    using first_type  = typename T::first_type;
+    using second_type = typename T::second_type;
+
+    const auto& ar = v.as_array();
+    if(ar.size() != 2)
+    {
+        const auto loc = v.location();
+        throw std::out_of_range(format_error("toml::get: while converting std::pair: "
+            " but there are " + std::to_string(ar.size()) + " > 2 elements in toml array.",
+            loc, "here"));
+    }
+    return std::make_pair(::toml::get<first_type >(ar.at(0)),
+                          ::toml::get<second_type>(ar.at(1)));
+}
+
+// ============================================================================
+// std::tuple.
+
+namespace detail
+{
+template<typename T, typename Array, std::size_t ... I>
+T get_tuple_impl(const Array& a, cxx::index_sequence<I...>)
+{
+    return std::make_tuple(
+        ::toml::get<typename std::tuple_element<I, T>::type>(a.at(I))...);
+}
+} // detail
+
+template<typename T, typename TC>
+cxx::enable_if_t<detail::is_std_tuple<T>::value, T>
+get(const basic_value<TC>& v)
+{
+    const auto& ar = v.as_array();
+    if(ar.size() != std::tuple_size<T>::value)
+    {
+        const auto loc = v.location();
+        throw std::out_of_range(format_error("toml::get: while converting std::tuple: "
+            " there are " + std::to_string(ar.size()) + " > " +
+            std::to_string(std::tuple_size<T>::value) + " elements in toml array.",
+            loc, "here"));
+    }
+    return detail::get_tuple_impl<T>(ar,
+            cxx::make_index_sequence<std::tuple_size<T>::value>{});
+}
+
+// ============================================================================
+// map-like types; most likely STL map, like std::map or std::unordered_map.
+
+// key is convertible from toml::value::key_type
+template<typename T, typename TC>
+cxx::enable_if_t<cxx::conjunction<
+    detail::is_map<T>,                                  // T is map
+    detail::is_not_toml_type<T, basic_value<TC>>,       // but not toml::table
+    std::is_convertible<typename basic_value<TC>::key_type,
+                        typename T::key_type>,          // keys are convertible
+    cxx::negation<detail::has_from_toml_method<T, TC>>, // no T.from_toml()
+    cxx::negation<detail::has_specialized_from<T>>,     // no toml::from<T>
+    cxx::negation<std::is_constructible<T, const basic_value<TC>&>>
+    >::value, T>
+get(const basic_value<TC>& v)
+{
+    using key_type    = typename T::key_type;
+    using mapped_type = typename T::mapped_type;
+    static_assert(
+        std::is_convertible<typename basic_value<TC>::key_type, key_type>::value,
+        "toml::get only supports map type of which key_type is "
+        "convertible from toml::basic_value::key_type.");
+
+    T m;
+    for(const auto& kv : v.as_table())
+    {
+        m.emplace(key_type(kv.first), get<mapped_type>(kv.second));
+    }
+    return m;
+}
+
+// key is NOT convertible from toml::value::key_type but std::basic_string
+template<typename T, typename TC>
+cxx::enable_if_t<cxx::conjunction<
+    detail::is_map<T>,                                       // T is map
+    detail::is_not_toml_type<T, basic_value<TC>>,            // but not toml::table
+    cxx::negation<std::is_convertible<typename basic_value<TC>::key_type,
+        typename T::key_type>>,                              // keys are NOT convertible
+    detail::is_1byte_std_basic_string<typename T::key_type>, // is std::basic_string
+    cxx::negation<detail::has_from_toml_method<T, TC>>,      // no T.from_toml()
+    cxx::negation<detail::has_specialized_from<T>>,          // no toml::from<T>
+    cxx::negation<std::is_constructible<T, const basic_value<TC>&>>
+    >::value, T>
+get(const basic_value<TC>& v)
+{
+    using key_type    = typename T::key_type;
+    using mapped_type = typename T::mapped_type;
+
+    T m;
+    for(const auto& kv : v.as_table())
+    {
+        m.emplace(detail::string_conv<key_type>(kv.first), get<mapped_type>(kv.second));
+    }
+    return m;
+}
+
+// ============================================================================
+// user-defined, but convertible types.
+
+// toml::from<T>
+template<typename T, typename TC>
+cxx::enable_if_t<detail::has_specialized_from<T>::value, T>
+get(const basic_value<TC>& v)
+{
+    return ::toml::from<T>::from_toml(v);
+}
+
+// has T.from_toml(v) but no from<T>
+template<typename T, typename TC>
+cxx::enable_if_t<cxx::conjunction<
+    detail::has_from_toml_method<T, TC>,            // has T.from_toml()
+    cxx::negation<detail::has_specialized_from<T>>, // no toml::from<T>
+    std::is_default_constructible<T>                // T{} works
+    >::value, T>
+get(const basic_value<TC>& v)
+{
+    T ud;
+    ud.from_toml(v);
+    return ud;
+}
+
+// T(const toml::value&) and T is not toml::basic_value,
+// and it does not have `from<T>` nor `from_toml`.
+template<typename T, typename TC>
+cxx::enable_if_t<cxx::conjunction<
+    std::is_constructible<T, const basic_value<TC>&>,   // has T(const basic_value&)
+    cxx::negation<detail::is_basic_value<T>>,           // but not basic_value itself
+    cxx::negation<detail::has_from_toml_method<T, TC>>, // no .from_toml()
+    cxx::negation<detail::has_specialized_from<T>>      // no toml::from<T>
+    >::value, T>
+get(const basic_value<TC>& v)
+{
+    return T(v);
+}
+
+// ============================================================================
+// get_or(value, fallback)
+
+template<typename TC>
+cxx::enable_if_t<detail::is_type_config<TC>::value, basic_value<TC>> const&
+get_or(const basic_value<TC>& v, const basic_value<TC>&)
+{
+    return v;
+}
+
+template<typename TC>
+cxx::enable_if_t<detail::is_type_config<TC>::value, basic_value<TC>>&
+get_or(basic_value<TC>& v, basic_value<TC>&)
+{
+    return v;
+}
+
+template<typename TC>
+cxx::enable_if_t<detail::is_type_config<TC>::value, basic_value<TC>>
+get_or(basic_value<TC>&& v, basic_value<TC>&&)
+{
+    return v;
+}
+
+// ----------------------------------------------------------------------------
+// specialization for the exact toml types (return type becomes lvalue ref)
+
+template<typename T, typename TC>
+cxx::enable_if_t<
+    detail::is_exact_toml_type<T, basic_value<TC>>::value, T> const&
+get_or(const basic_value<TC>& v, const T& opt) noexcept
+{
+    try
+    {
+        return get<cxx::remove_cvref_t<T>>(v);
+    }
+    catch(...)
+    {
+        return opt;
+    }
+}
+template<typename T, typename TC>
+cxx::enable_if_t<cxx::conjunction<
+        cxx::negation<std::is_const<T>>,
+        detail::is_exact_toml_type<T, basic_value<TC>>
+    >::value, T>&
+get_or(basic_value<TC>& v, T& opt) noexcept
+{
+    try
+    {
+        return get<cxx::remove_cvref_t<T>>(v);
+    }
+    catch(...)
+    {
+        return opt;
+    }
+}
+template<typename T, typename TC>
+cxx::enable_if_t<detail::is_exact_toml_type<cxx::remove_cvref_t<T>,
+    basic_value<TC>>::value, cxx::remove_cvref_t<T>>
+get_or(basic_value<TC>&& v, T&& opt) noexcept
+{
+    try
+    {
+        return get<cxx::remove_cvref_t<T>>(std::move(v));
+    }
+    catch(...)
+    {
+        return cxx::remove_cvref_t<T>(std::forward<T>(opt));
+    }
+}
+
+// ----------------------------------------------------------------------------
+// specialization for string literal
+
+// template<std::size_t N, typename TC>
+// typename basic_value<TC>::string_type
+// get_or(const basic_value<TC>& v,
+//        const typename basic_value<TC>::string_type::value_type (&opt)[N])
+// {
+//     try
+//     {
+//         return v.as_string();
+//     }
+//     catch(...)
+//     {
+//         return typename basic_value<TC>::string_type(opt);
+//     }
+// }
+//
+// The above only matches to the literal, like `get_or(v, "foo");` but not
+// ```cpp
+// const auto opt = "foo";
+// const auto str = get_or(v, opt);
+// ```
+// . And the latter causes an error.
+// To match to both `"foo"` and `const auto opt = "foo"`, we take a pointer to
+// a character here.
+
+template<typename TC>
+typename basic_value<TC>::string_type
+get_or(const basic_value<TC>& v,
+       const typename basic_value<TC>::string_type::value_type* opt)
+{
+    try
+    {
+        return v.as_string();
+    }
+    catch(...)
+    {
+        return typename basic_value<TC>::string_type(opt);
+    }
+}
+
+// ----------------------------------------------------------------------------
+// others (require type conversion and return type cannot be lvalue reference)
+
+template<typename T, typename TC>
+cxx::enable_if_t<cxx::conjunction<
+    cxx::negation<detail::is_basic_value<T>>,
+    cxx::negation<detail::is_exact_toml_type<T, basic_value<TC>>>,
+    cxx::negation<std::is_same<cxx::remove_cvref_t<T>, typename basic_value<TC>::string_type::value_type const*>>
+    >::value, cxx::remove_cvref_t<T>>
+get_or(const basic_value<TC>& v, T&& opt)
+{
+    try
+    {
+        return get<cxx::remove_cvref_t<T>>(v);
+    }
+    catch(...)
+    {
+        return cxx::remove_cvref_t<T>(std::forward<T>(opt));
+    }
+}
+
+} // toml
+#endif // TOML11_GET_HPP
+#ifndef TOML11_FIND_HPP
+#define TOML11_FIND_HPP
+
+#include <algorithm>
+
+
+#if defined(TOML11_HAS_STRING_VIEW)
+#include <string_view>
+#endif
+
+namespace toml
+{
+
+// ----------------------------------------------------------------------------
+// find<T>(value, key);
+
+template<typename T, typename TC>
+decltype(::toml::get<T>(std::declval<basic_value<TC> const&>()))
+find(const basic_value<TC>& v, const typename basic_value<TC>::key_type& ky)
+{
+    return ::toml::get<T>(v.at(ky));
+}
+
+template<typename T, typename TC>
+decltype(::toml::get<T>(std::declval<basic_value<TC>&>()))
+find(basic_value<TC>& v, const typename basic_value<TC>::key_type& ky)
+{
+    return ::toml::get<T>(v.at(ky));
+}
+
+template<typename T, typename TC>
+decltype(::toml::get<T>(std::declval<basic_value<TC>&&>()))
+find(basic_value<TC>&& v, const typename basic_value<TC>::key_type& ky)
+{
+    return ::toml::get<T>(std::move(v.at(ky)));
+}
+
+// ----------------------------------------------------------------------------
+// find<T>(value, idx)
+
+template<typename T, typename TC>
+decltype(::toml::get<T>(std::declval<basic_value<TC> const&>()))
+find(const basic_value<TC>& v, const std::size_t idx)
+{
+    return ::toml::get<T>(v.at(idx));
+}
+template<typename T, typename TC>
+decltype(::toml::get<T>(std::declval<basic_value<TC>&>()))
+find(basic_value<TC>& v, const std::size_t idx)
+{
+    return ::toml::get<T>(v.at(idx));
+}
+template<typename T, typename TC>
+decltype(::toml::get<T>(std::declval<basic_value<TC>&&>()))
+find(basic_value<TC>&& v, const std::size_t idx)
+{
+    return ::toml::get<T>(std::move(v.at(idx)));
+}
+
+// ----------------------------------------------------------------------------
+// find(value, key/idx), w/o conversion
+
+template<typename TC>
+cxx::enable_if_t<detail::is_type_config<TC>::value, basic_value<TC>>&
+find(basic_value<TC>& v, const typename basic_value<TC>::key_type& ky)
+{
+    return v.at(ky);
+}
+template<typename TC>
+cxx::enable_if_t<detail::is_type_config<TC>::value, basic_value<TC>> const&
+find(basic_value<TC> const& v, const typename basic_value<TC>::key_type& ky)
+{
+    return v.at(ky);
+}
+template<typename TC>
+cxx::enable_if_t<detail::is_type_config<TC>::value, basic_value<TC>>
+find(basic_value<TC>&& v, const typename basic_value<TC>::key_type& ky)
+{
+    return basic_value<TC>(std::move(v.at(ky)));
+}
+
+template<typename TC>
+cxx::enable_if_t<detail::is_type_config<TC>::value, basic_value<TC>>&
+find(basic_value<TC>& v, const std::size_t idx)
+{
+    return v.at(idx);
+}
+template<typename TC>
+cxx::enable_if_t<detail::is_type_config<TC>::value, basic_value<TC>> const&
+find(basic_value<TC> const& v, const std::size_t idx)
+{
+    return v.at(idx);
+}
+template<typename TC>
+cxx::enable_if_t<detail::is_type_config<TC>::value, basic_value<TC>>
+find(basic_value<TC>&& v, const std::size_t idx)
+{
+    return basic_value<TC>(std::move(v.at(idx)));
+}
+
+// --------------------------------------------------------------------------
+// toml::find(toml::value, toml::key, Ts&& ... keys)
+
+namespace detail
+{
+
+// It suppresses warnings by -Wsign-conversion when we pass integer literal
+// to toml::find. integer literal `0` is deduced as an int, and will be
+// converted to std::size_t. This causes sign-conversion.
+
+template<typename TC>
+std::size_t key_cast(const std::size_t& v) noexcept
+{
+    return v;
+}
+template<typename TC, typename T>
+cxx::enable_if_t<std::is_integral<cxx::remove_cvref_t<T>>::value, std::size_t>
+key_cast(const T& v) noexcept
+{
+    return static_cast<std::size_t>(v);
+}
+
+// for string-like (string, string literal, string_view)
+
+template<typename TC>
+typename basic_value<TC>::key_type const&
+key_cast(const typename basic_value<TC>::key_type& v) noexcept
+{
+    return v;
+}
+template<typename TC>
+typename basic_value<TC>::key_type
+key_cast(const typename basic_value<TC>::key_type::value_type* v)
+{
+    return typename basic_value<TC>::key_type(v);
+}
+#if defined(TOML11_HAS_STRING_VIEW)
+template<typename TC>
+typename basic_value<TC>::key_type
+key_cast(const std::string_view v)
+{
+    return typename basic_value<TC>::key_type(v);
+}
+#endif // string_view
+
+} // detail
+
+// ----------------------------------------------------------------------------
+// find(v, keys...)
+
+template<typename TC, typename K1, typename K2, typename ... Ks>
+cxx::enable_if_t<detail::is_type_config<TC>::value, basic_value<TC>> const&
+find(const basic_value<TC>& v, const K1& k1, const K2& k2, const Ks& ... ks)
+{
+    return find(v.at(detail::key_cast<TC>(k1)), detail::key_cast<TC>(k2), ks...);
+}
+template<typename TC, typename K1, typename K2, typename ... Ks>
+cxx::enable_if_t<detail::is_type_config<TC>::value, basic_value<TC>>&
+find(basic_value<TC>& v, const K1& k1, const K2& k2, const Ks& ... ks)
+{
+    return find(v.at(detail::key_cast<TC>(k1)), detail::key_cast<TC>(k2), ks...);
+}
+template<typename TC, typename K1, typename K2, typename ... Ks>
+cxx::enable_if_t<detail::is_type_config<TC>::value, basic_value<TC>>
+find(basic_value<TC>&& v, const K1& k1, const K2& k2, const Ks& ... ks)
+{
+    return find(std::move(v.at(detail::key_cast<TC>(k1))), detail::key_cast<TC>(k2), ks...);
+}
+
+// ----------------------------------------------------------------------------
+// find<T>(v, keys...)
+
+template<typename T, typename TC, typename K1, typename K2, typename ... Ks>
+decltype(::toml::get<T>(std::declval<const basic_value<TC>&>()))
+find(const basic_value<TC>& v, const K1& k1, const K2& k2, const Ks& ... ks)
+{
+    return find<T>(v.at(detail::key_cast<TC>(k1)), detail::key_cast<TC>(k2), ks...);
+}
+template<typename T, typename TC, typename K1, typename K2, typename ... Ks>
+decltype(::toml::get<T>(std::declval<basic_value<TC>&>()))
+find(basic_value<TC>& v, const K1& k1, const K2& k2, const Ks& ... ks)
+{
+    return find<T>(v.at(detail::key_cast<TC>(k1)), detail::key_cast<TC>(k2), ks...);
+}
+template<typename T, typename TC, typename K1, typename K2, typename ... Ks>
+decltype(::toml::get<T>(std::declval<basic_value<TC>&&>()))
+find(basic_value<TC>&& v, const K1& k1, const K2& k2, const Ks& ... ks)
+{
+    return find<T>(std::move(v.at(detail::key_cast<TC>(k1))), detail::key_cast<TC>(k2), ks...);
+}
+
+// ===========================================================================
+// find_or<T>(value, key, fallback)
+
+// ---------------------------------------------------------------------------
+// find_or(v, key, other_v)
+
+template<typename TC, typename K>
+cxx::enable_if_t<detail::is_type_config<TC>::value, basic_value<TC>>&
+find_or(basic_value<TC>& v, const K& k, basic_value<TC>& opt) noexcept
+{
+    try
+    {
+        return ::toml::find(v, detail::key_cast<TC>(k));
+    }
+    catch(...)
+    {
+        return opt;
+    }
+}
+template<typename TC, typename K>
+cxx::enable_if_t<detail::is_type_config<TC>::value, basic_value<TC>> const&
+find_or(const basic_value<TC>& v, const K& k, const basic_value<TC>& opt) noexcept
+{
+    try
+    {
+        return ::toml::find(v, detail::key_cast<TC>(k));
+    }
+    catch(...)
+    {
+        return opt;
+    }
+}
+template<typename TC, typename K>
+cxx::enable_if_t<detail::is_type_config<TC>::value, basic_value<TC>>
+find_or(basic_value<TC>&& v, const K& k, basic_value<TC>&& opt) noexcept
+{
+    try
+    {
+        return ::toml::find(v, detail::key_cast<TC>(k));
+    }
+    catch(...)
+    {
+        return opt;
+    }
+}
+
+// ---------------------------------------------------------------------------
+// toml types (return type can be a reference)
+
+template<typename T, typename TC, typename K>
+cxx::enable_if_t<detail::is_exact_toml_type<T, basic_value<TC>>::value,
+    cxx::remove_cvref_t<T> const&>
+find_or(const basic_value<TC>& v, const K& k, const T& opt)
+{
+    try
+    {
+        return ::toml::get<T>(v.at(detail::key_cast<TC>(k)));
+    }
+    catch(...)
+    {
+        return opt;
+    }
+}
+
+template<typename T, typename TC, typename K>
+cxx::enable_if_t<cxx::conjunction<
+        cxx::negation<std::is_const<T>>,
+        detail::is_exact_toml_type<T, basic_value<TC>>
+    >::value, cxx::remove_cvref_t<T>&>
+find_or(basic_value<TC>& v, const K& k, T& opt)
+{
+    try
+    {
+        return ::toml::get<T>(v.at(detail::key_cast<TC>(k)));
+    }
+    catch(...)
+    {
+        return opt;
+    }
+}
+
+template<typename T, typename TC, typename K>
+cxx::enable_if_t<detail::is_exact_toml_type<T, basic_value<TC>>::value,
+    cxx::remove_cvref_t<T>>
+find_or(basic_value<TC>&& v, const K& k, T opt)
+{
+    try
+    {
+        return ::toml::get<T>(std::move(v.at(detail::key_cast<TC>(k))));
+    }
+    catch(...)
+    {
+        return T(std::move(opt));
+    }
+}
+
+// ---------------------------------------------------------------------------
+// string literal (deduced as std::string)
+
+// XXX to avoid confusion when T is explicitly specified in find_or<T>(),
+//     we restrict the string type as std::string.
+template<typename TC, typename K>
+cxx::enable_if_t<detail::is_type_config<TC>::value, std::string>
+find_or(const basic_value<TC>& v, const K& k, const char* opt)
+{
+    try
+    {
+        return ::toml::get<std::string>(v.at(detail::key_cast<TC>(k)));
+    }
+    catch(...)
+    {
+        return std::string(opt);
+    }
+}
+
+// ---------------------------------------------------------------------------
+// other types (requires type conversion and return type cannot be a reference)
+
+template<typename T, typename TC, typename K>
+cxx::enable_if_t<cxx::conjunction<
+        cxx::negation<detail::is_basic_value<cxx::remove_cvref_t<T>>>,
+        detail::is_not_toml_type<cxx::remove_cvref_t<T>, basic_value<TC>>,
+        cxx::negation<std::is_same<cxx::remove_cvref_t<T>,
+            const typename basic_value<TC>::string_type::value_type*>>
+    >::value, cxx::remove_cvref_t<T>>
+find_or(const basic_value<TC>& v, const K& ky, T opt)
+{
+    try
+    {
+        return ::toml::get<cxx::remove_cvref_t<T>>(v.at(detail::key_cast<TC>(ky)));
+    }
+    catch(...)
+    {
+        return cxx::remove_cvref_t<T>(std::move(opt));
+    }
+}
+
+// ----------------------------------------------------------------------------
+// recursive
+
+namespace detail
+{
+
+template<typename ...Ts>
+auto last_one(Ts&&... args)
+ -> decltype(std::get<sizeof...(Ts)-1>(std::forward_as_tuple(std::forward<Ts>(args)...)))
+{
+    return std::get<sizeof...(Ts)-1>(std::forward_as_tuple(std::forward<Ts>(args)...));
+}
+
+} // detail
+
+template<typename Value, typename K1, typename K2, typename K3, typename ... Ks>
+auto find_or(Value&& v, const K1& k1, const K2& k2, K3&& k3, Ks&& ... keys) noexcept
+    -> cxx::enable_if_t<
+        detail::is_basic_value<cxx::remove_cvref_t<Value>>::value,
+        decltype(find_or(v, k2, std::forward<K3>(k3), std::forward<Ks>(keys)...))
+    >
+{
+    try
+    {
+        return find_or(v.at(k1), k2, std::forward<K3>(k3), std::forward<Ks>(keys)...);
+    }
+    catch(...)
+    {
+        return detail::last_one(k3, keys...);
+    }
+}
+
+template<typename T, typename TC, typename K1, typename K2, typename K3, typename ... Ks>
+T find_or(const basic_value<TC>& v, const K1& k1, const K2& k2, const K3& k3, const Ks& ... keys) noexcept
+{
+    try
+    {
+        return find_or<T>(v.at(k1), k2, k3, keys...);
+    }
+    catch(...)
+    {
+        return static_cast<T>(detail::last_one(k3, keys...));
+    }
+}
+
+} // toml
+#endif // TOML11_FIND_HPP
+#ifndef TOML11_CONVERSION_HPP
+#define TOML11_CONVERSION_HPP
+
+
+#if defined(TOML11_HAS_OPTIONAL)
+
+#include <optional>
+
+namespace toml
+{
+namespace detail
+{
+
+template<typename T>
+inline constexpr bool is_optional_v = false;
+
+template<typename T>
+inline constexpr bool is_optional_v<std::optional<T>> = true;
+
+template<typename T, typename TC>
+void find_member_variable_from_value(T& obj, const basic_value<TC>& v, const char* var_name)
+{
+    if constexpr(is_optional_v<T>)
+    {
+        if(v.contains(var_name))
+        {
+            obj = toml::find<typename T::value_type>(v, var_name);
+        }
+        else
+        {
+            obj = std::nullopt;
+        }
+    }
+    else
+    {
+        obj = toml::find<T>(v, var_name);
+    }
+}
+
+template<typename T, typename TC>
+void assign_member_variable_to_value(const T& obj, basic_value<TC>& v, const char* var_name)
+{
+    if constexpr(is_optional_v<T>)
+    {
+        if(obj.has_value())
+        {
+            v[var_name] = obj.value();
+        }
+    }
+    else
+    {
+        v[var_name] = obj;
+    }
+}
+
+} // detail
+} // toml
+
+#else
+
+namespace toml
+{
+namespace detail
+{
+
+template<typename T, typename TC>
+void find_member_variable_from_value(T& obj, const basic_value<TC>& v, const char* var_name)
+{
+    obj = toml::find<T>(v, var_name);
+}
+
+template<typename T, typename TC>
+void assign_member_variable_to_value(const T& obj, basic_value<TC>& v, const char* var_name)
+{
+    v[var_name] = obj;
+}
+
+} // detail
+} // toml
+
+#endif // optional
+
+// use it in the following way.
+// ```cpp
+// namespace foo
+// {
+// struct Foo
+// {
+//     std::string s;
+//     double      d;
+//     int         i;
+// };
+// } // foo
+//
+// TOML11_DEFINE_CONVERSION_NON_INTRUSIVE(foo::Foo, s, d, i)
+// ```
+//
+// And then you can use `toml::get<foo::Foo>(v)` and `toml::find<foo::Foo>(file, "foo");`
+//
+
+#define TOML11_STRINGIZE_AUX(x) #x
+#define TOML11_STRINGIZE(x)     TOML11_STRINGIZE_AUX(x)
+
+#define TOML11_CONCATENATE_AUX(x, y) x##y
+#define TOML11_CONCATENATE(x, y)     TOML11_CONCATENATE_AUX(x, y)
+
+// ============================================================================
+// TOML11_DEFINE_CONVERSION_NON_INTRUSIVE
+
+#ifndef TOML11_WITHOUT_DEFINE_NON_INTRUSIVE
+
+// ----------------------------------------------------------------------------
+// TOML11_ARGS_SIZE
+
+#define TOML11_INDEX_RSEQ() \
+    32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, \
+    16, 15, 14, 13, 12, 11, 10,  9,  8,  7,  6,  5,  4,  3,  2,  1, 0
+#define TOML11_ARGS_SIZE_IMPL(\
+    ARG1,  ARG2,  ARG3,  ARG4,  ARG5,  ARG6,  ARG7,  ARG8,  ARG9,  ARG10, \
+    ARG11, ARG12, ARG13, ARG14, ARG15, ARG16, ARG17, ARG18, ARG19, ARG20, \
+    ARG21, ARG22, ARG23, ARG24, ARG25, ARG26, ARG27, ARG28, ARG29, ARG30, \
+    ARG31, ARG32, N, ...) N
+#define TOML11_ARGS_SIZE_AUX(...) TOML11_ARGS_SIZE_IMPL(__VA_ARGS__)
+#define TOML11_ARGS_SIZE(...) TOML11_ARGS_SIZE_AUX(__VA_ARGS__, TOML11_INDEX_RSEQ())
+
+// ----------------------------------------------------------------------------
+// TOML11_FOR_EACH_VA_ARGS
+
+#define TOML11_FOR_EACH_VA_ARGS_AUX_1( FUNCTOR, ARG1     ) FUNCTOR(ARG1)
+#define TOML11_FOR_EACH_VA_ARGS_AUX_2( FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_1( FUNCTOR, __VA_ARGS__)
+#define TOML11_FOR_EACH_VA_ARGS_AUX_3( FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_2( FUNCTOR, __VA_ARGS__)
+#define TOML11_FOR_EACH_VA_ARGS_AUX_4( FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_3( FUNCTOR, __VA_ARGS__)
+#define TOML11_FOR_EACH_VA_ARGS_AUX_5( FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_4( FUNCTOR, __VA_ARGS__)
+#define TOML11_FOR_EACH_VA_ARGS_AUX_6( FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_5( FUNCTOR, __VA_ARGS__)
+#define TOML11_FOR_EACH_VA_ARGS_AUX_7( FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_6( FUNCTOR, __VA_ARGS__)
+#define TOML11_FOR_EACH_VA_ARGS_AUX_8( FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_7( FUNCTOR, __VA_ARGS__)
+#define TOML11_FOR_EACH_VA_ARGS_AUX_9( FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_8( FUNCTOR, __VA_ARGS__)
+#define TOML11_FOR_EACH_VA_ARGS_AUX_10(FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_9( FUNCTOR, __VA_ARGS__)
+#define TOML11_FOR_EACH_VA_ARGS_AUX_11(FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_10(FUNCTOR, __VA_ARGS__)
+#define TOML11_FOR_EACH_VA_ARGS_AUX_12(FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_11(FUNCTOR, __VA_ARGS__)
+#define TOML11_FOR_EACH_VA_ARGS_AUX_13(FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_12(FUNCTOR, __VA_ARGS__)
+#define TOML11_FOR_EACH_VA_ARGS_AUX_14(FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_13(FUNCTOR, __VA_ARGS__)
+#define TOML11_FOR_EACH_VA_ARGS_AUX_15(FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_14(FUNCTOR, __VA_ARGS__)
+#define TOML11_FOR_EACH_VA_ARGS_AUX_16(FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_15(FUNCTOR, __VA_ARGS__)
+#define TOML11_FOR_EACH_VA_ARGS_AUX_17(FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_16(FUNCTOR, __VA_ARGS__)
+#define TOML11_FOR_EACH_VA_ARGS_AUX_18(FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_17(FUNCTOR, __VA_ARGS__)
+#define TOML11_FOR_EACH_VA_ARGS_AUX_19(FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_18(FUNCTOR, __VA_ARGS__)
+#define TOML11_FOR_EACH_VA_ARGS_AUX_20(FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_19(FUNCTOR, __VA_ARGS__)
+#define TOML11_FOR_EACH_VA_ARGS_AUX_21(FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_20(FUNCTOR, __VA_ARGS__)
+#define TOML11_FOR_EACH_VA_ARGS_AUX_22(FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_21(FUNCTOR, __VA_ARGS__)
+#define TOML11_FOR_EACH_VA_ARGS_AUX_23(FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_22(FUNCTOR, __VA_ARGS__)
+#define TOML11_FOR_EACH_VA_ARGS_AUX_24(FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_23(FUNCTOR, __VA_ARGS__)
+#define TOML11_FOR_EACH_VA_ARGS_AUX_25(FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_24(FUNCTOR, __VA_ARGS__)
+#define TOML11_FOR_EACH_VA_ARGS_AUX_26(FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_25(FUNCTOR, __VA_ARGS__)
+#define TOML11_FOR_EACH_VA_ARGS_AUX_27(FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_26(FUNCTOR, __VA_ARGS__)
+#define TOML11_FOR_EACH_VA_ARGS_AUX_28(FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_27(FUNCTOR, __VA_ARGS__)
+#define TOML11_FOR_EACH_VA_ARGS_AUX_29(FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_28(FUNCTOR, __VA_ARGS__)
+#define TOML11_FOR_EACH_VA_ARGS_AUX_30(FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_29(FUNCTOR, __VA_ARGS__)
+#define TOML11_FOR_EACH_VA_ARGS_AUX_31(FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_30(FUNCTOR, __VA_ARGS__)
+#define TOML11_FOR_EACH_VA_ARGS_AUX_32(FUNCTOR, ARG1, ...) FUNCTOR(ARG1) TOML11_FOR_EACH_VA_ARGS_AUX_31(FUNCTOR, __VA_ARGS__)
+
+#define TOML11_FOR_EACH_VA_ARGS(FUNCTOR, ...)\
+    TOML11_CONCATENATE(TOML11_FOR_EACH_VA_ARGS_AUX_, TOML11_ARGS_SIZE(__VA_ARGS__))(FUNCTOR, __VA_ARGS__)
+
+
+#define TOML11_FIND_MEMBER_VARIABLE_FROM_VALUE(VAR_NAME)\
+    toml::detail::find_member_variable_from_value(obj.VAR_NAME, v, TOML11_STRINGIZE(VAR_NAME));
+
+#define TOML11_ASSIGN_MEMBER_VARIABLE_TO_VALUE(VAR_NAME)\
+    toml::detail::assign_member_variable_to_value(obj.VAR_NAME, v, TOML11_STRINGIZE(VAR_NAME));
+
+#define TOML11_DEFINE_CONVERSION_NON_INTRUSIVE(NAME, ...)\
+    namespace toml {                                                                     \
+    template<>                                                                           \
+    struct from<NAME>                                                                    \
+    {                                                                                    \
+        template<typename TC>                                                            \
+        static NAME from_toml(const basic_value<TC>& v)                                  \
+        {                                                                                \
+            NAME obj;                                                                    \
+            TOML11_FOR_EACH_VA_ARGS(TOML11_FIND_MEMBER_VARIABLE_FROM_VALUE, __VA_ARGS__) \
+            return obj;                                                                  \
+        }                                                                                \
+    };                                                                                   \
+    template<>                                                                           \
+    struct into<NAME>                                                                    \
+    {                                                                                    \
+        template<typename TC>                                                            \
+        static basic_value<TC> into_toml(const NAME& obj)                                \
+        {                                                                                \
+            ::toml::basic_value<TC> v = typename ::toml::basic_value<TC>::table_type{};  \
+            TOML11_FOR_EACH_VA_ARGS(TOML11_ASSIGN_MEMBER_VARIABLE_TO_VALUE, __VA_ARGS__) \
+            return v;                                                                    \
+        }                                                                                \
+    };                                                                                   \
+    } /* toml */
+
+#endif// TOML11_WITHOUT_DEFINE_NON_INTRUSIVE
+
+#endif // TOML11_CONVERSION_HPP
+#ifndef TOML11_CONTEXT_HPP
+#define TOML11_CONTEXT_HPP
+
+
+#include <vector>
+
+namespace toml
+{
+namespace detail
+{
+
+template<typename TypeConfig>
+class context
+{
+  public:
+
+    explicit context(const spec& toml_spec)
+        : toml_spec_(toml_spec), errors_{}
+    {}
+
+    bool has_error() const noexcept {return !errors_.empty();}
+
+    std::vector<error_info> const& errors() const noexcept {return errors_;}
+
+    semantic_version&       toml_version()       noexcept {return toml_spec_.version;}
+    semantic_version const& toml_version() const noexcept {return toml_spec_.version;}
+
+    spec&       toml_spec()       noexcept {return toml_spec_;}
+    spec const& toml_spec() const noexcept {return toml_spec_;}
+
+    void report_error(error_info err)
+    {
+        this->errors_.push_back(std::move(err));
+    }
+
+    error_info pop_last_error()
+    {
+        assert( ! errors_.empty());
+        auto e = std::move(errors_.back());
+        errors_.pop_back();
+        return e;
+    }
+
+  private:
+
+    spec toml_spec_;
+    std::vector<error_info> errors_;
+};
+
+} // detail
+} // toml
+
+#if defined(TOML11_COMPILE_SOURCES)
+namespace toml
+{
+struct type_config;
+struct ordered_type_config;
+namespace detail
+{
+extern template class context<::toml::type_config>;
+extern template class context<::toml::ordered_type_config>;
+} // detail
+} // toml
+#endif // TOML11_COMPILE_SOURCES
+
+#endif // TOML11_CONTEXT_HPP
+#ifndef TOML11_SCANNER_HPP
+#define TOML11_SCANNER_HPP
+
+#ifndef TOML11_SCANNER_FWD_HPP
+#define TOML11_SCANNER_FWD_HPP
+
+
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include <cassert>
+#include <cstdio>
+#include <cctype>
+
+namespace toml
+{
+namespace detail
+{
+
+class scanner_base
+{
+  public:
+    virtual ~scanner_base() = default;
+    virtual region scan(location& loc) const = 0;
+    virtual scanner_base* clone() const = 0;
+
+    // returns expected character or set of characters or literal.
+    // to show the error location, it changes loc (in `sequence`, especially).
+    virtual std::string expected_chars(location& loc) const = 0;
+    virtual std::string name() const = 0;
+};
+
+// make `scanner*` copyable
+struct scanner_storage
+{
+    template<typename Scanner, cxx::enable_if_t<
+        std::is_base_of<scanner_base, cxx::remove_cvref_t<Scanner>>::value,
+        std::nullptr_t> = nullptr>
+    explicit scanner_storage(Scanner&& s)
+        : scanner_(cxx::make_unique<cxx::remove_cvref_t<Scanner>>(std::forward<Scanner>(s)))
+    {}
+    ~scanner_storage() = default;
+
+    scanner_storage(const scanner_storage& other);
+    scanner_storage& operator=(const scanner_storage& other);
+    scanner_storage(scanner_storage&&) = default;
+    scanner_storage& operator=(scanner_storage&&) = default;
+
+    bool is_ok() const noexcept {return static_cast<bool>(scanner_);}
+
+    region scan(location& loc) const;
+
+    std::string expected_chars(location& loc) const;
+
+    scanner_base& get() const noexcept;
+
+    std::string name() const;
+
+  private:
+
+    std::unique_ptr<scanner_base> scanner_;
+};
+
+// ----------------------------------------------------------------------------
+
+class character final : public scanner_base
+{
+  public:
+
+    using char_type = location::char_type;
+
+  public:
+
+    explicit character(const char_type c) noexcept
+        : value_(c)
+    {}
+    ~character() override = default;
+
+    region scan(location& loc) const override;
+
+    std::string expected_chars(location&) const override;
+
+    scanner_base* clone() const override;
+
+    std::string name() const override;
+
+  private:
+    char_type value_;
+};
+
+// ----------------------------------------------------------------------------
+
+class character_either final : public scanner_base
+{
+  public:
+
+    using char_type = location::char_type;
+
+  public:
+
+    explicit character_either(std::initializer_list<char_type> cs) noexcept
+        : chars_(std::move(cs))
+    {
+        assert(! this->chars_.empty());
+    }
+
+    template<std::size_t N>
+    explicit character_either(const char (&cs)[N]) noexcept
+        : chars_(N-1, '\0')
+    {
+        static_assert(N >= 1, "");
+        for(std::size_t i=0; i+1<N; ++i)
+        {
+            chars_.at(i) = char_type(cs[i]);
+        }
+    }
+    ~character_either() override = default;
+
+    region scan(location& loc) const override;
+
+    std::string expected_chars(location&) const override;
+
+    scanner_base* clone() const override;
+
+    void push_back(const char_type c);
+
+    std::string name() const override;
+
+  private:
+    std::vector<char_type> chars_;
+};
+
+// ----------------------------------------------------------------------------
+
+class character_in_range final : public scanner_base
+{
+  public:
+
+    using char_type = location::char_type;
+
+  public:
+
+    explicit character_in_range(const char_type from, const char_type to) noexcept
+        : from_(from), to_(to)
+    {}
+    ~character_in_range() override = default;
+
+    region scan(location& loc) const override;
+
+    std::string expected_chars(location&) const override;
+
+    scanner_base* clone() const override;
+
+    std::string name() const override;
+
+  private:
+    char_type from_;
+    char_type to_;
+};
+
+// ----------------------------------------------------------------------------
+
+class literal final : public scanner_base
+{
+  public:
+
+    using char_type = location::char_type;
+
+  public:
+
+    template<std::size_t N>
+    explicit literal(const char (&cs)[N]) noexcept
+        : value_(cs), size_(N-1) // remove null character at the end
+    {}
+    ~literal() override = default;
+
+    region scan(location& loc) const override;
+
+    std::string expected_chars(location&) const override;
+
+    scanner_base* clone() const override;
+
+    std::string name() const override;
+
+  private:
+    const char* value_;
+    std::size_t size_;
+};
+
+// ----------------------------------------------------------------------------
+
+class sequence final: public scanner_base
+{
+  public:
+    using char_type = location::char_type;
+
+  public:
+
+    template<typename ... Ts>
+    explicit sequence(Ts&& ... args)
+    {
+        push_back_all(std::forward<Ts>(args)...);
+    }
+    sequence(const sequence&)            = default;
+    sequence(sequence&&)                 = default;
+    sequence& operator=(const sequence&) = default;
+    sequence& operator=(sequence&&)      = default;
+    ~sequence() override                 = default;
+
+    region scan(location& loc) const override;
+
+    std::string expected_chars(location& loc) const override;
+
+    scanner_base* clone() const override;
+
+    template<typename Scanner>
+    void push_back(Scanner&& other_scanner)
+    {
+        this->others_.emplace_back(std::forward<Scanner>(other_scanner));
+    }
+
+    std::string name() const override;
+
+  private:
+
+    void push_back_all()
+    {
+        return;
+    }
+    template<typename T, typename ... Ts>
+    void push_back_all(T&& head, Ts&& ... args)
+    {
+        others_.emplace_back(std::forward<T>(head));
+        push_back_all(std::forward<Ts>(args)...);
+        return;
+    }
+
+  private:
+    std::vector<scanner_storage> others_;
+};
+
+// ----------------------------------------------------------------------------
+
+class either final: public scanner_base
+{
+  public:
+    using char_type = location::char_type;
+
+  public:
+
+    template<typename ... Ts>
+    explicit either(Ts&& ... args)
+    {
+        push_back_all(std::forward<Ts>(args)...);
+    }
+    either(const either&)            = default;
+    either(either&&)                 = default;
+    either& operator=(const either&) = default;
+    either& operator=(either&&)      = default;
+    ~either() override               = default;
+
+    region scan(location& loc) const override;
+
+    std::string expected_chars(location& loc) const override;
+
+    scanner_base* clone() const override;
+
+    template<typename Scanner>
+    void push_back(Scanner&& other_scanner)
+    {
+        this->others_.emplace_back(std::forward<Scanner>(other_scanner));
+    }
+
+    std::string name() const override;
+
+  private:
+
+    void push_back_all()
+    {
+        return;
+    }
+    template<typename T, typename ... Ts>
+    void push_back_all(T&& head, Ts&& ... args)
+    {
+        others_.emplace_back(std::forward<T>(head));
+        push_back_all(std::forward<Ts>(args)...);
+        return;
+    }
+
+  private:
+    std::vector<scanner_storage> others_;
+};
+
+// ----------------------------------------------------------------------------
+
+class repeat_exact final: public scanner_base
+{
+  public:
+    using char_type = location::char_type;
+
+  public:
+
+    template<typename Scanner>
+    repeat_exact(const std::size_t length, Scanner&& other)
+        : length_(length), other_(std::forward<Scanner>(other))
+    {}
+    repeat_exact(const repeat_exact&)            = default;
+    repeat_exact(repeat_exact&&)                 = default;
+    repeat_exact& operator=(const repeat_exact&) = default;
+    repeat_exact& operator=(repeat_exact&&)      = default;
+    ~repeat_exact() override                     = default;
+
+    region scan(location& loc) const override;
+
+    std::string expected_chars(location& loc) const override;
+
+    scanner_base* clone() const override;
+
+    std::string name() const override;
+
+  private:
+    std::size_t length_;
+    scanner_storage other_;
+};
+
+// ----------------------------------------------------------------------------
+
+class repeat_at_least final: public scanner_base
+{
+  public:
+    using char_type = location::char_type;
+
+  public:
+
+    template<typename Scanner>
+    repeat_at_least(const std::size_t length, Scanner&& s)
+        : length_(length), other_(std::forward<Scanner>(s))
+    {}
+    repeat_at_least(const repeat_at_least&)            = default;
+    repeat_at_least(repeat_at_least&&)                 = default;
+    repeat_at_least& operator=(const repeat_at_least&) = default;
+    repeat_at_least& operator=(repeat_at_least&&)      = default;
+    ~repeat_at_least() override                        = default;
+
+    region scan(location& loc) const override;
+
+    std::string expected_chars(location& loc) const override;
+
+    scanner_base* clone() const override;
+
+    std::string name() const override;
+
+  private:
+    std::size_t length_;
+    scanner_storage other_;
+};
+
+// ----------------------------------------------------------------------------
+
+class maybe final: public scanner_base
+{
+  public:
+    using char_type = location::char_type;
+
+  public:
+
+    template<typename Scanner>
+    explicit maybe(Scanner&& s)
+        : other_(std::forward<Scanner>(s))
+    {}
+    maybe(const maybe&)            = default;
+    maybe(maybe&&)                 = default;
+    maybe& operator=(const maybe&) = default;
+    maybe& operator=(maybe&&)      = default;
+    ~maybe() override              = default;
+
+    region scan(location& loc) const override;
+
+    std::string expected_chars(location&) const override;
+
+    scanner_base* clone() const override;
+
+    std::string name() const override;
+
+  private:
+    scanner_storage other_;
+};
+
+} // detail
+} // toml
+#endif // TOML11_SCANNER_FWD_HPP
+
+#if ! defined(TOML11_COMPILE_SOURCES)
+#ifndef TOML11_SCANNER_IMPL_HPP
+#define TOML11_SCANNER_IMPL_HPP
+
+
+namespace toml
+{
+namespace detail
+{
+
+TOML11_INLINE scanner_storage::scanner_storage(const scanner_storage& other)
+    : scanner_(nullptr)
+{
+    if(other.is_ok())
+    {
+        scanner_.reset(other.get().clone());
+    }
+}
+TOML11_INLINE scanner_storage& scanner_storage::operator=(const scanner_storage& other)
+{
+    if(this == std::addressof(other)) {return *this;}
+    if(other.is_ok())
+    {
+        scanner_.reset(other.get().clone());
+    }
+    return *this;
+}
+
+TOML11_INLINE region scanner_storage::scan(location& loc) const
+{
+    assert(this->is_ok());
+    return this->scanner_->scan(loc);
+}
+
+TOML11_INLINE std::string scanner_storage::expected_chars(location& loc) const
+{
+    assert(this->is_ok());
+    return this->scanner_->expected_chars(loc);
+}
+
+TOML11_INLINE scanner_base& scanner_storage::get() const noexcept
+{
+    assert(this->is_ok());
+    return *scanner_;
+}
+
+TOML11_INLINE std::string scanner_storage::name() const
+{
+    assert(this->is_ok());
+    return this->scanner_->name();
+}
+
+// ----------------------------------------------------------------------------
+
+TOML11_INLINE region character::scan(location& loc) const
+{
+    if(loc.eof()) {return region{};}
+
+    if(loc.current() == this->value_)
+    {
+        const auto first = loc;
+        loc.advance(1);
+        return region(first, loc);
+    }
+    return region{};
+}
+
+TOML11_INLINE std::string character::expected_chars(location&) const
+{
+    return show_char(value_);
+}
+
+TOML11_INLINE scanner_base* character::clone() const
+{
+    return new character(*this);
+}
+
+TOML11_INLINE std::string character::name() const
+{
+    return "character{" + show_char(value_) + "}";
+}
+
+// ----------------------------------------------------------------------------
+
+TOML11_INLINE region character_either::scan(location& loc) const
+{
+    if(loc.eof()) {return region{};}
+
+    for(const auto c : this->chars_)
+    {
+        if(loc.current() == c)
+        {
+            const auto first = loc;
+            loc.advance(1);
+            return region(first, loc);
+        }
+    }
+    return region{};
+}
+
+TOML11_INLINE std::string character_either::expected_chars(location&) const
+{
+    assert( ! chars_.empty());
+
+    std::string expected;
+    if(chars_.size() == 1)
+    {
+        expected += show_char(chars_.at(0));
+    }
+    else if(chars_.size() == 2)
+    {
+        expected += show_char(chars_.at(0)) + " or " + show_char(chars_.at(1));
+    }
+    else
+    {
+        for(std::size_t i=0; i<chars_.size(); ++i)
+        {
+            if(i != 0)
+            {
+                expected += ", ";
+            }
+            if(i + 1 == chars_.size())
+            {
+                expected += "or ";
+            }
+            expected += show_char(chars_.at(i));
+        }
+    }
+    return expected;
+}
+
+TOML11_INLINE scanner_base* character_either::clone() const
+{
+    return new character_either(*this);
+}
+
+TOML11_INLINE void character_either::push_back(const char_type c)
+{
+    chars_.push_back(c);
+}
+
+TOML11_INLINE std::string character_either::name() const
+{
+    std::string n("character_either{");
+    for(const auto c : this->chars_)
+    {
+        n += show_char(c);
+        n += ", ";
+    }
+    if( ! this->chars_.empty())
+    {
+        n.pop_back();
+        n.pop_back();
+    }
+    n += "}";
+    return n;
+}
+
+// ----------------------------------------------------------------------------
+// character_in_range
+
+TOML11_INLINE region character_in_range::scan(location& loc) const
+{
+    if(loc.eof()) {return region{};}
+
+    const auto curr = loc.current();
+    if(this->from_ <= curr && curr <= this->to_)
+    {
+        const auto first = loc;
+        loc.advance(1);
+        return region(first, loc);
+    }
+    return region{};
+}
+
+TOML11_INLINE std::string character_in_range::expected_chars(location&) const
+{
+    std::string expected("from `");
+    expected += show_char(from_);
+    expected += "` to `";
+    expected += show_char(to_);
+    expected += "`";
+    return expected;
+}
+
+TOML11_INLINE scanner_base* character_in_range::clone() const
+{
+    return new character_in_range(*this);
+}
+
+TOML11_INLINE std::string character_in_range::name() const
+{
+    return "character_in_range{" + show_char(from_) + "," + show_char(to_) + "}";
+}
+
+// ----------------------------------------------------------------------------
+// literal
+
+TOML11_INLINE region literal::scan(location& loc) const
+{
+    const auto first = loc;
+    for(std::size_t i=0; i<size_; ++i)
+    {
+        if(loc.eof() || char_type(value_[i]) != loc.current())
+        {
+            loc = first;
+            return region{};
+        }
+        loc.advance(1);
+    }
+    return region(first, loc);
+}
+
+TOML11_INLINE std::string literal::expected_chars(location&) const
+{
+    return std::string(value_);
+}
+
+TOML11_INLINE scanner_base* literal::clone() const
+{
+    return new literal(*this);
+}
+
+TOML11_INLINE std::string literal::name() const
+{
+    return std::string("literal{") + std::string(value_, size_) + "}";
+}
+
+// ----------------------------------------------------------------------------
+// sequence
+
+TOML11_INLINE region sequence::scan(location& loc) const
+{
+    const auto first = loc;
+    for(const auto& other : others_)
+    {
+        const auto reg = other.scan(loc);
+        if( ! reg.is_ok())
+        {
+            loc = first;
+            return region{};
+        }
+    }
+    return region(first, loc);
+}
+
+TOML11_INLINE std::string sequence::expected_chars(location& loc) const
+{
+    const auto first = loc;
+    for(const auto& other : others_)
+    {
+        const auto reg = other.scan(loc);
+        if( ! reg.is_ok())
+        {
+            return other.expected_chars(loc);
+        }
+    }
+    assert(false);
+    return ""; // XXX
+}
+
+TOML11_INLINE scanner_base* sequence::clone() const
+{
+    return new sequence(*this);
+}
+
+TOML11_INLINE std::string sequence::name() const
+{
+    std::string n("sequence{");
+    for(const auto& other : others_)
+    {
+        n += other.name();
+        n += ", ";
+    }
+    if( ! this->others_.empty())
+    {
+        n.pop_back();
+        n.pop_back();
+    }
+    n += "}";
+    return n;
+}
+
+// ----------------------------------------------------------------------------
+// either
+
+TOML11_INLINE region either::scan(location& loc) const
+{
+    for(const auto& other : others_)
+    {
+        const auto reg = other.scan(loc);
+        if(reg.is_ok())
+        {
+            return reg;
+        }
+    }
+    return region{};
+}
+
+TOML11_INLINE std::string either::expected_chars(location& loc) const
+{
+    assert( ! others_.empty());
+
+    std::string expected = others_.at(0).expected_chars(loc);
+    if(others_.size() == 2)
+    {
+        expected += " or ";
+        expected += others_.at(1).expected_chars(loc);
+    }
+    else
+    {
+        for(std::size_t i=1; i<others_.size(); ++i)
+        {
+            expected += ", ";
+            if(i + 1 == others_.size())
+            {
+                expected += "or ";
+            }
+            expected += others_.at(i).expected_chars(loc);
+        }
+    }
+    return expected;
+}
+
+TOML11_INLINE scanner_base* either::clone() const
+{
+    return new either(*this);
+}
+
+TOML11_INLINE std::string either::name() const
+{
+    std::string n("either{");
+    for(const auto& other : others_)
+    {
+        n += other.name();
+        n += ", ";
+    }
+    if( ! this->others_.empty())
+    {
+        n.pop_back();
+        n.pop_back();
+    }
+    n += "}";
+    return n;
+}
+
+// ----------------------------------------------------------------------------
+// repeat_exact
+
+TOML11_INLINE region repeat_exact::scan(location& loc) const
+{
+    const auto first = loc;
+    for(std::size_t i=0; i<length_; ++i)
+    {
+        const auto reg = other_.scan(loc);
+        if( ! reg.is_ok())
+        {
+            loc = first;
+            return region{};
+        }
+    }
+    return region(first, loc);
+}
+
+TOML11_INLINE std::string repeat_exact::expected_chars(location& loc) const
+{
+    for(std::size_t i=0; i<length_; ++i)
+    {
+        const auto reg = other_.scan(loc);
+        if( ! reg.is_ok())
+        {
+            return other_.expected_chars(loc);
+        }
+    }
+    assert(false);
+    return "";
+}
+
+TOML11_INLINE scanner_base* repeat_exact::clone() const
+{
+    return new repeat_exact(*this);
+}
+
+TOML11_INLINE std::string repeat_exact::name() const
+{
+    return "repeat_exact{" + std::to_string(length_) + ", " + other_.name() + "}";
+}
+
+// ----------------------------------------------------------------------------
+// repeat_at_least
+
+TOML11_INLINE region repeat_at_least::scan(location& loc) const
+{
+    const auto first = loc;
+    for(std::size_t i=0; i<length_; ++i)
+    {
+        const auto reg = other_.scan(loc);
+        if( ! reg.is_ok())
+        {
+            loc = first;
+            return region{};
+        }
+    }
+    while( ! loc.eof())
+    {
+        const auto checkpoint = loc;
+        const auto reg = other_.scan(loc);
+        if( ! reg.is_ok())
+        {
+            loc = checkpoint;
+            return region(first, loc);
+        }
+    }
+    return region(first, loc);
+}
+
+TOML11_INLINE std::string repeat_at_least::expected_chars(location& loc) const
+{
+    for(std::size_t i=0; i<length_; ++i)
+    {
+        const auto reg = other_.scan(loc);
+        if( ! reg.is_ok())
+        {
+            return other_.expected_chars(loc);
+        }
+    }
+    assert(false);
+    return "";
+}
+
+TOML11_INLINE scanner_base* repeat_at_least::clone() const
+{
+    return new repeat_at_least(*this);
+}
+
+TOML11_INLINE std::string repeat_at_least::name() const
+{
+    return "repeat_at_least{" + std::to_string(length_) + ", " + other_.name() + "}";
+}
+
+// ----------------------------------------------------------------------------
+// maybe
+
+TOML11_INLINE region maybe::scan(location& loc) const
+{
+    const auto first = loc;
+    const auto reg = other_.scan(loc);
+    if( ! reg.is_ok())
+    {
+        loc = first;
+    }
+    return region(first, loc);
+}
+
+TOML11_INLINE std::string maybe::expected_chars(location&) const
+{
+    return "";
+}
+
+TOML11_INLINE scanner_base* maybe::clone() const
+{
+    return new maybe(*this);
+}
+
+TOML11_INLINE std::string maybe::name() const
+{
+    return "maybe{" + other_.name() + "}";
+}
+
+} // detail
+} // toml
+#endif // TOML11_SCANNER_IMPL_HPP
+#endif
+
+#endif // TOML11_SCANNER_HPP
+#ifndef TOML11_SYNTAX_HPP
+#define TOML11_SYNTAX_HPP
+
+#ifndef TOML11_SYNTAX_FWD_HPP
+#define TOML11_SYNTAX_FWD_HPP
+
+
+namespace toml
+{
+namespace detail
+{
+namespace syntax
+{
+
+using char_type = location::char_type;
+
+// ===========================================================================
+// UTF-8
+
+// avoid redundant representation and out-of-unicode sequence
+
+character_in_range utf8_1byte (const spec&);
+sequence           utf8_2bytes(const spec&);
+sequence           utf8_3bytes(const spec&);
+sequence           utf8_4bytes(const spec&);
+
+class non_ascii final : public scanner_base
+{
+  public:
+
+    using char_type = location::char_type;
+
+  public:
+
+    explicit non_ascii(const spec& s) noexcept;
+    ~non_ascii() override = default;
+
+    region scan(location& loc) const override
+    {
+        return scanner_.scan(loc);
+    }
+
+    std::string expected_chars(location&) const override
+    {
+        return "non-ascii utf-8 bytes";
+    }
+
+    scanner_base* clone() const override
+    {
+        return new non_ascii(*this);
+    }
+
+    std::string name() const override
+    {
+        return "non_ascii";
+    }
+
+  private:
+
+    either scanner_;
+};
+
+// ===========================================================================
+// Whitespace
+
+character_either wschar(const spec&);
+
+repeat_at_least ws(const spec& s);
+
+// ===========================================================================
+// Newline
+
+either newline(const spec&);
+
+// ===========================================================================
+// Comments
+
+either allowed_comment_char(const spec& s);
+
+// XXX Note that it does not take newline
+sequence comment(const spec& s);
+
+// ===========================================================================
+// Boolean
+
+either boolean(const spec&);
+
+// ===========================================================================
+// Integer
+
+class digit final : public scanner_base
+{
+  public:
+
+    using char_type = location::char_type;
+
+  public:
+
+    explicit digit(const spec&) noexcept;
+    ~digit() override = default;
+
+    region scan(location& loc) const override
+    {
+        return scanner_.scan(loc);
+    }
+
+    std::string expected_chars(location&) const override
+    {
+        return "digit [0-9]";
+    }
+
+    scanner_base* clone() const override
+    {
+        return new digit(*this);
+    }
+
+    std::string name() const override
+    {
+        return "digit";
+    }
+
+  private:
+
+    character_in_range scanner_;
+};
+
+class alpha final : public scanner_base
+{
+  public:
+
+    using char_type = location::char_type;
+
+  public:
+
+    explicit alpha(const spec&) noexcept;
+    ~alpha() override = default;
+
+    region scan(location& loc) const override
+    {
+        return scanner_.scan(loc);
+    }
+
+    std::string expected_chars(location&) const override
+    {
+        return "alpha [a-zA-Z]";
+    }
+
+    scanner_base* clone() const override
+    {
+        return new alpha(*this);
+    }
+
+    std::string name() const override
+    {
+        return "alpha";
+    }
+
+  private:
+
+    either scanner_;
+};
+
+class hexdig final : public scanner_base
+{
+  public:
+
+    using char_type = location::char_type;
+
+  public:
+
+    explicit hexdig(const spec& s) noexcept;
+    ~hexdig() override = default;
+
+    region scan(location& loc) const override
+    {
+        return scanner_.scan(loc);
+    }
+
+    std::string expected_chars(location&) const override
+    {
+        return "hex [0-9a-fA-F]";
+    }
+
+    scanner_base* clone() const override
+    {
+        return new hexdig(*this);
+    }
+
+    std::string name() const override
+    {
+        return "hexdig";
+    }
+
+  private:
+
+    either scanner_;
+};
+
+sequence num_suffix(const spec& s);
+
+sequence dec_int(const spec& s);
+sequence hex_int(const spec& s);
+sequence oct_int(const spec&);
+sequence bin_int(const spec&);
+either   integer(const spec& s);
+
+// ===========================================================================
+// Floating
+
+sequence zero_prefixable_int(const spec& s);
+sequence fractional_part(const spec& s);
+sequence exponent_part(const spec& s);
+sequence hex_floating(const spec& s);
+either   floating(const spec& s);
+
+// ===========================================================================
+// Datetime
+
+sequence local_date(const spec& s);
+sequence local_time(const spec& s);
+either time_offset(const spec& s);
+sequence full_time(const spec& s);
+character_either time_delim(const spec&);
+sequence local_datetime(const spec& s);
+sequence offset_datetime(const spec& s);
+
+// ===========================================================================
+// String
+
+sequence escaped(const spec& s);
+
+either basic_char(const spec& s);
+
+sequence basic_string(const spec& s);
+
+// ---------------------------------------------------------------------------
+// multiline string
+
+sequence escaped_newline(const spec& s);
+sequence ml_basic_string(const spec& s);
+
+// ---------------------------------------------------------------------------
+// literal string
+
+either literal_char(const spec& s);
+sequence literal_string(const spec& s);
+
+sequence ml_literal_string(const spec& s);
+
+either string(const spec& s);
+
+// ===========================================================================
+// Keys
+
+// to keep `expected_chars` simple
+class non_ascii_key_char final : public scanner_base
+{
+  public:
+
+    using char_type = location::char_type;
+
+  private:
+
+    using in_range = character_in_range; // make definition short
+
+  public:
+
+    explicit non_ascii_key_char(const spec& s) noexcept;
+    ~non_ascii_key_char() override = default;
+
+    region scan(location& loc) const override;
+
+    std::string expected_chars(location&) const override
+    {
+        return "bare key non-ASCII script";
+    }
+
+    scanner_base* clone() const override
+    {
+        return new non_ascii_key_char(*this);
+    }
+
+    std::string name() const override
+    {
+        return "non-ASCII bare key";
+    }
+
+  private:
+
+    std::uint32_t read_utf8(location& loc) const;
+};
+
+
+repeat_at_least unquoted_key(const spec& s);
+
+either quoted_key(const spec& s);
+
+either simple_key(const spec& s);
+
+sequence dot_sep(const spec& s);
+
+sequence dotted_key(const spec& s);
+
+
+class key final : public scanner_base
+{
+  public:
+
+    using char_type = location::char_type;
+
+  public:
+
+    explicit key(const spec& s) noexcept;
+    ~key() override = default;
+
+    region scan(location& loc) const override
+    {
+        return scanner_.scan(loc);
+    }
+
+    std::string expected_chars(location&) const override
+    {
+        return "basic key([a-zA-Z0-9_-]) or quoted key(\" or ')";
+    }
+
+    scanner_base* clone() const override
+    {
+        return new key(*this);
+    }
+
+    std::string name() const override
+    {
+        return "key";
+    }
+
+  private:
+
+    either scanner_;
+};
+
+sequence keyval_sep(const spec& s);
+
+// ===========================================================================
+// Table key
+
+sequence std_table(const spec& s);
+
+sequence array_table(const spec& s);
+
+// ===========================================================================
+// extension: null
+
+literal null_value(const spec&);
+
+} // namespace syntax
+} // namespace detail
+} // namespace toml
+#endif // TOML11_SYNTAX_FWD_HPP
+
+#if ! defined(TOML11_COMPILE_SOURCES)
+#ifndef TOML11_SYNTAX_IMPL_HPP
+#define TOML11_SYNTAX_IMPL_HPP
+
+
+namespace toml
+{
+namespace detail
+{
+namespace syntax
+{
+
+using char_type = location::char_type;
+
+// ===========================================================================
+// UTF-8
+
+// avoid redundant representation and out-of-unicode sequence
+
+TOML11_INLINE character_in_range utf8_1byte(const spec&)
+{
+    return character_in_range(0x00, 0x7F);
+}
+
+TOML11_INLINE sequence utf8_2bytes(const spec&)
+{
+    return sequence(character_in_range(0xC2, 0xDF),
+                    character_in_range(0x80, 0xBF));
+}
+
+TOML11_INLINE sequence utf8_3bytes(const spec&)
+{
+    return sequence(/*1~2 bytes = */either(
+        sequence(character         (0xE0),       character_in_range(0xA0, 0xBF)),
+        sequence(character_in_range(0xE1, 0xEC), character_in_range(0x80, 0xBF)),
+        sequence(character         (0xED),       character_in_range(0x80, 0x9F)),
+        sequence(character_in_range(0xEE, 0xEF), character_in_range(0x80, 0xBF))
+    ), /*3rd byte = */ character_in_range(0x80, 0xBF));
+}
+
+TOML11_INLINE sequence utf8_4bytes(const spec&)
+{
+    return sequence(/*1~2 bytes = */either(
+        sequence(character         (0xF0),       character_in_range(0x90, 0xBF)),
+        sequence(character_in_range(0xF1, 0xF3), character_in_range(0x80, 0xBF)),
+        sequence(character         (0xF4),       character_in_range(0x80, 0x8F))
+    ), character_in_range(0x80, 0xBF), character_in_range(0x80, 0xBF));
+}
+
+TOML11_INLINE non_ascii::non_ascii(const spec& s) noexcept
+    : scanner_(utf8_2bytes(s), utf8_3bytes(s), utf8_4bytes(s))
+{}
+
+
+// ===========================================================================
+// Whitespace
+
+TOML11_INLINE character_either wschar(const spec&)
+{
+    return character_either{char_type(' '), char_type('\t')};
+}
+
+TOML11_INLINE repeat_at_least ws(const spec& s)
+{
+    return repeat_at_least(0, wschar(s));
+}
+
+// ===========================================================================
+// Newline
+
+TOML11_INLINE either newline(const spec&)
+{
+    return either(character(char_type('\n')), literal("\r\n"));
+}
+
+// ===========================================================================
+// Comments
+
+TOML11_INLINE either allowed_comment_char(const spec& s)
+{
+    if(s.v1_1_0_allow_control_characters_in_comments)
+    {
+        return either(
+            character_in_range(0x01, 0x09),
+            character_in_range(0x0E, 0x7F),
+            non_ascii(s)
+        );
+    }
+    else
+    {
+        return either(
+            character(0x09),
+            character_in_range(0x20, 0x7E),
+            non_ascii(s)
+        );
+    }
+}
+
+// XXX Note that it does not take newline
+TOML11_INLINE sequence comment(const spec& s)
+{
+    return sequence(character(char_type('#')),
+                    repeat_at_least(0, allowed_comment_char(s)));
+}
+
+// ===========================================================================
+// Boolean
+
+TOML11_INLINE either boolean(const spec&)
+{
+    return either(literal("true"), literal("false"));
+}
+
+// ===========================================================================
+// Integer
+
+TOML11_INLINE digit::digit(const spec&) noexcept
+    : scanner_(char_type('0'), char_type('9'))
+{}
+
+TOML11_INLINE alpha::alpha(const spec&) noexcept
+    : scanner_(
+        character_in_range(char_type('a'), char_type('z')),
+        character_in_range(char_type('A'), char_type('Z'))
+    )
+{}
+
+TOML11_INLINE hexdig::hexdig(const spec& s) noexcept
+    : scanner_(
+        digit(s),
+        character_in_range(char_type('a'), char_type('f')),
+        character_in_range(char_type('A'), char_type('F'))
+    )
+{}
+
+// non-digit-graph = ([a-zA-Z]|unicode mb char)
+// graph           = ([a-zA-Z0-9]|unicode mb char)
+// suffix          = _ non-digit-graph (graph | _graph)
+TOML11_INLINE sequence num_suffix(const spec& s)
+{
+    const auto non_digit_graph = [&s]() {
+        return either(
+            alpha(s),
+            non_ascii(s)
+        );
+    };
+    const auto graph = [&s]() {
+        return either(
+            alpha(s),
+            digit(s),
+            non_ascii(s)
+        );
+    };
+
+    return sequence(
+            character(char_type('_')),
+            non_digit_graph(),
+            repeat_at_least(0,
+                either(
+                    sequence(character(char_type('_')), graph()),
+                    graph()
+                )
+            )
+        );
+}
+
+TOML11_INLINE sequence dec_int(const spec& s)
+{
+    const auto digit19 = []() {
+        return character_in_range(char_type('1'), char_type('9'));
+    };
+    return sequence(
+            maybe(character_either{char_type('-'), char_type('+')}),
+            either(
+                sequence(
+                    digit19(),
+                    repeat_at_least(1,
+                        either(
+                            digit(s),
+                            sequence(character(char_type('_')), digit(s))
+                        )
+                    )
+                ),
+                digit(s)
+            )
+        );
+}
+
+TOML11_INLINE sequence hex_int(const spec& s)
+{
+    return sequence(
+            literal("0x"),
+            hexdig(s),
+            repeat_at_least(0,
+                either(
+                    hexdig(s),
+                    sequence(character(char_type('_')), hexdig(s))
+                )
+            )
+        );
+}
+
+TOML11_INLINE sequence oct_int(const spec&)
+{
+    const auto digit07 = []() {
+        return character_in_range(char_type('0'), char_type('7'));
+    };
+    return sequence(
+            literal("0o"),
+            digit07(),
+            repeat_at_least(0,
+                either(
+                    digit07(),
+                    sequence(character(char_type('_')), digit07())
+                )
+            )
+        );
+}
+
+TOML11_INLINE sequence bin_int(const spec&)
+{
+    const auto digit01 = []() {
+        return character_either{char_type('0'), char_type('1')};
+    };
+    return sequence(
+            literal("0b"),
+            digit01(),
+            repeat_at_least(0,
+                either(
+                    digit01(),
+                    sequence(character(char_type('_')), digit01())
+                )
+            )
+        );
+}
+
+TOML11_INLINE either integer(const spec& s)
+{
+    return either(
+            hex_int(s),
+            oct_int(s),
+            bin_int(s),
+            dec_int(s)
+        );
+}
+
+
+// ===========================================================================
+// Floating
+
+TOML11_INLINE sequence zero_prefixable_int(const spec& s)
+{
+    return sequence(
+            digit(s),
+            repeat_at_least(0,
+                either(
+                    digit(s),
+                    sequence(character('_'), digit(s))
+                )
+            )
+        );
+}
+
+TOML11_INLINE sequence fractional_part(const spec& s)
+{
+    return sequence(
+            character('.'),
+            zero_prefixable_int(s)
+        );
+}
+
+TOML11_INLINE sequence exponent_part(const spec& s)
+{
+    return sequence(
+            character_either{char_type('e'), char_type('E')},
+            maybe(character_either{char_type('+'), char_type('-')}),
+            zero_prefixable_int(s)
+        );
+}
+
+TOML11_INLINE sequence hex_floating(const spec& s)
+{
+    // C99 hexfloat (%a)
+    // [+-]? 0x ( [0-9a-fA-F]*\.[0-9a-fA-F]+ | [0-9a-fA-F]+\.? ) [pP] [+-]? [0-9]+
+
+    // - 0x(int).(frac)p[+-](int)
+    // - 0x(int).p[+-](int)
+    // - 0x.(frac)p[+-](int)
+    // - 0x(int)p[+-](int)
+
+    return sequence(
+            maybe(character_either{char_type('+'), char_type('-')}),
+            character('0'),
+            character_either{char_type('x'), char_type('X')},
+            either(
+                sequence(
+                    repeat_at_least(0, hexdig(s)),
+                    character('.'),
+                    repeat_at_least(1, hexdig(s))
+                ),
+                sequence(
+                    repeat_at_least(1, hexdig(s)),
+                    maybe(character('.'))
+                )
+            ),
+            character_either{char_type('p'), char_type('P')},
+            maybe(character_either{char_type('+'), char_type('-')}),
+            repeat_at_least(1, character_in_range('0', '9'))
+        );
+}
+
+TOML11_INLINE either floating(const spec& s)
+{
+    return either(
+            sequence(
+                dec_int(s),
+                either(
+                    exponent_part(s),
+                    sequence(fractional_part(s), maybe(exponent_part(s)))
+                )
+            ),
+            sequence(
+                maybe(character_either{char_type('-'), char_type('+')}),
+                either(literal("inf"), literal("nan"))
+            )
+        );
+}
+
+// ===========================================================================
+// Datetime
+
+TOML11_INLINE sequence local_date(const spec& s)
+{
+    return sequence(
+            repeat_exact(4, digit(s)),
+            character('-'),
+            repeat_exact(2, digit(s)),
+            character('-'),
+            repeat_exact(2, digit(s))
+        );
+}
+TOML11_INLINE sequence local_time(const spec& s)
+{
+    auto time = sequence(
+            repeat_exact(2, digit(s)),
+            character(':'),
+            repeat_exact(2, digit(s))
+        );
+
+    if(s.v1_1_0_make_seconds_optional)
+    {
+        time.push_back(maybe(sequence(
+                character(':'),
+                repeat_exact(2, digit(s)),
+                maybe(sequence(character('.'), repeat_at_least(1, digit(s))))
+            )));
+    }
+    else
+    {
+        time.push_back(character(':'));
+        time.push_back(repeat_exact(2, digit(s)));
+        time.push_back(
+            maybe(sequence(character('.'), repeat_at_least(1, digit(s))))
+        );
+    }
+
+    return time;
+}
+TOML11_INLINE either time_offset(const spec& s)
+{
+    return either(
+            character_either{'Z', 'z'},
+            sequence(character_either{'+', '-'},
+                     repeat_exact(2, digit(s)),
+                     character(':'),
+                     repeat_exact(2, digit(s))
+             )
+        );
+}
+TOML11_INLINE sequence full_time(const spec& s)
+{
+    return sequence(local_time(s), time_offset(s));
+}
+TOML11_INLINE character_either time_delim(const spec&)
+{
+    return character_either{'T', 't', ' '};
+}
+TOML11_INLINE sequence local_datetime(const spec& s)
+{
+    return sequence(local_date(s), time_delim(s), local_time(s));
+}
+TOML11_INLINE sequence offset_datetime(const spec& s)
+{
+    return sequence(local_date(s), time_delim(s), full_time(s));
+}
+
+// ===========================================================================
+// String
+
+TOML11_INLINE sequence escaped(const spec& s)
+{
+    character_either escape_char{
+        '\"','\\', 'b', 'f', 'n', 'r', 't'
+    };
+    if(s.v1_1_0_add_escape_sequence_e)
+    {
+        escape_char.push_back(char_type('e'));
+    }
+
+    either escape_seq(
+            std::move(escape_char),
+            sequence(character('u'), repeat_exact(4, hexdig(s))),
+            sequence(character('U'), repeat_exact(8, hexdig(s)))
+        );
+
+    if(s.v1_1_0_add_escape_sequence_x)
+    {
+        escape_seq.push_back(
+            sequence(character('x'), repeat_exact(2, hexdig(s)))
+        );
+    }
+
+    return sequence(
+            character('\\'),
+            std::move(escape_seq)
+        );
+}
+
+TOML11_INLINE either basic_char(const spec& s)
+{
+    const auto basic_unescaped = [&s]() {
+        return either(
+                wschar(s),
+                character(0x21),                // 22 is "
+                character_in_range(0x23, 0x5B), // 5C is backslash
+                character_in_range(0x5D, 0x7E), // 7F is DEL
+                non_ascii(s)
+            );
+    };
+    return either(basic_unescaped(), escaped(s));
+}
+
+TOML11_INLINE sequence basic_string(const spec& s)
+{
+    return sequence(
+            character('"'),
+            repeat_at_least(0, basic_char(s)),
+            character('"')
+        );
+}
+
+// ---------------------------------------------------------------------------
+// multiline string
+
+TOML11_INLINE sequence escaped_newline(const spec& s)
+{
+    return sequence(
+            character('\\'), ws(s), newline(s),
+            repeat_at_least(0, either(wschar(s), newline(s)))
+        );
+}
+
+TOML11_INLINE sequence ml_basic_string(const spec& s)
+{
+    const auto mlb_content = [&s]() {
+        return either(basic_char(s), newline(s), escaped_newline(s));
+    };
+    const auto mlb_quotes = []() {
+        return either(literal("\"\""), character('\"'));
+    };
+
+    return sequence(
+            literal("\"\"\""),
+            maybe(newline(s)),
+            repeat_at_least(0, mlb_content()),
+            repeat_at_least(0,
+                sequence(
+                    mlb_quotes(),
+                    repeat_at_least(1, mlb_content())
+                )
+            ),
+            // XXX """ and mlb_quotes are intentionally reordered to avoid
+            //     unexpected match of mlb_quotes
+            literal("\"\"\""),
+            maybe(mlb_quotes())
+        );
+}
+
+// ---------------------------------------------------------------------------
+// literal string
+
+TOML11_INLINE either literal_char(const spec& s)
+{
+    return either(
+            character         (0x09),
+            character_in_range(0x20, 0x26),
+            character_in_range(0x28, 0x7E),
+            non_ascii(s)
+        );
+}
+
+TOML11_INLINE sequence literal_string(const spec& s)
+{
+    return sequence(
+            character('\''),
+            repeat_at_least(0, literal_char(s)),
+            character('\'')
+        );
+}
+
+TOML11_INLINE sequence ml_literal_string(const spec& s)
+{
+    const auto mll_quotes = []() {
+        return either(literal("''"), character('\''));
+    };
+    const auto mll_content = [&s]() {
+        return either(literal_char(s), newline(s));
+    };
+
+    return sequence(
+            literal("'''"),
+            maybe(newline(s)),
+            repeat_at_least(0, mll_content()),
+            repeat_at_least(0, sequence(
+                    mll_quotes(),
+                    repeat_at_least(1, mll_content())
+                )
+            ),
+            literal("'''"),
+            maybe(mll_quotes())
+            // XXX ''' and mll_quotes are intentionally reordered to avoid
+            //     unexpected match of mll_quotes
+        );
+}
+
+TOML11_INLINE either string(const spec& s)
+{
+    return either(
+            ml_basic_string(s),
+            ml_literal_string(s),
+            basic_string(s),
+            literal_string(s)
+        );
+}
+
+// ===========================================================================
+// Keys
+
+// to keep `expected_chars` simple
+TOML11_INLINE non_ascii_key_char::non_ascii_key_char(const spec& s) noexcept
+{
+    assert(s.v1_1_0_allow_non_english_in_bare_keys);
+    (void)s; // for NDEBUG
+}
+
+TOML11_INLINE std::uint32_t non_ascii_key_char::read_utf8(location& loc) const
+{
+    // U+0000   ... U+0079  ; 0xxx_xxxx
+    // U+0080   ... U+07FF  ; 110y_yyyx 10xx_xxxx;
+    // U+0800   ... U+FFFF  ; 1110_yyyy 10yx_xxxx 10xx_xxxx
+    // U+010000 ... U+10FFFF; 1111_0yyy 10yy_xxxx 10xx_xxxx 10xx_xxxx
+
+    const unsigned char b1 = loc.current(); loc.advance(1);
+    if(b1 < 0x80)
+    {
+        return static_cast<std::uint32_t>(b1);
+    }
+    else if((b1 >> 5) == 6) // 0b110 == 6
+    {
+        const auto b2 = loc.current(); loc.advance(1);
+
+        const std::uint32_t c1 = b1 & ((1 << 5) - 1);
+        const std::uint32_t c2 = b2 & ((1 << 6) - 1);
+        const std::uint32_t codep = (c1 << 6) + c2;
+
+        if(codep < 0x80)
+        {
+            return 0xFFFFFFFF;
+        }
+        return codep;
+    }
+    else if((b1 >> 4) == 14) // 0b1110 == 14
+    {
+        const auto b2 = loc.current(); loc.advance(1); if(loc.eof()) {return 0xFFFFFFFF;}
+        const auto b3 = loc.current(); loc.advance(1);
+
+        const std::uint32_t c1 = b1 & ((1 << 4) - 1);
+        const std::uint32_t c2 = b2 & ((1 << 6) - 1);
+        const std::uint32_t c3 = b3 & ((1 << 6) - 1);
+
+        const std::uint32_t codep = (c1 << 12) + (c2 << 6) + c3;
+        if(codep < 0x800)
+        {
+            return 0xFFFFFFFF;
+        }
+        return codep;
+    }
+    else if((b1 >> 3) == 30) // 0b11110 == 30
+    {
+        const auto b2 = loc.current(); loc.advance(1); if(loc.eof()) {return 0xFFFFFFFF;}
+        const auto b3 = loc.current(); loc.advance(1); if(loc.eof()) {return 0xFFFFFFFF;}
+        const auto b4 = loc.current(); loc.advance(1);
+
+        const std::uint32_t c1 = b1 & ((1 << 3) - 1);
+        const std::uint32_t c2 = b2 & ((1 << 6) - 1);
+        const std::uint32_t c3 = b3 & ((1 << 6) - 1);
+        const std::uint32_t c4 = b4 & ((1 << 6) - 1);
+        const std::uint32_t codep = (c1 << 18) + (c2 << 12) + (c3 << 6) + c4;
+
+        if(codep < 0x10000)
+        {
+            return 0xFFFFFFFF;
+        }
+        return codep;
+    }
+    else // not a Unicode codepoint in UTF-8
+    {
+        return 0xFFFFFFFF;
+    }
+}
+
+TOML11_INLINE region non_ascii_key_char::scan(location& loc) const
+{
+    if(loc.eof()) {return region{};}
+
+    const auto first = loc;
+
+    const auto cp = read_utf8(loc);
+
+    if(cp == 0xFFFFFFFF)
+    {
+        return region{};
+    }
+
+    // ALPHA / DIGIT / %x2D / %x5F    ; a-z A-Z 0-9 - _
+    // / %xB2 / %xB3 / %xB9 / %xBC-BE ; superscript digits, fractions
+    // / %xC0-D6 / %xD8-F6 / %xF8-37D ; non-symbol chars in Latin block
+    // / %x37F-1FFF                   ; exclude GREEK QUESTION MARK, which is basically a semi-colon
+    // / %x200C-200D / %x203F-2040    ; from General Punctuation Block, include the two tie symbols and ZWNJ, ZWJ
+    // / %x2070-218F / %x2460-24FF    ; include super-/subscripts, letterlike/numberlike forms, enclosed alphanumerics
+    // / %x2C00-2FEF / %x3001-D7FF    ; skip arrows, math, box drawing etc, skip 2FF0-3000 ideographic up/down markers and spaces
+    // / %xF900-FDCF / %xFDF0-FFFD    ; skip D800-DFFF surrogate block, E000-F8FF Private Use area, FDD0-FDEF intended for process-internal use (unicode)
+    // / %x10000-EFFFF                ; all chars outside BMP range, excluding Private Use planes (F0000-10FFFF)
+
+    if(cp == 0xB2 || cp == 0xB3 || cp == 0xB9 || (0xBC <= cp && cp <= 0xBE) ||
+       (0xC0    <= cp && cp <= 0xD6  ) || (0xD8 <= cp && cp <= 0xF6) || (0xF8 <= cp && cp <= 0x37D) ||
+       (0x37F   <= cp && cp <= 0x1FFF) ||
+       (0x200C  <= cp && cp <= 0x200D) || (0x203F <= cp && cp <= 0x2040) ||
+       (0x2070  <= cp && cp <= 0x218F) || (0x2460 <= cp && cp <= 0x24FF) ||
+       (0x2C00  <= cp && cp <= 0x2FEF) || (0x3001 <= cp && cp <= 0xD7FF) ||
+       (0xF900  <= cp && cp <= 0xFDCF) || (0xFDF0 <= cp && cp <= 0xFFFD) ||
+       (0x10000 <= cp && cp <= 0xEFFFF) )
+    {
+        return region(first, loc);
+    }
+    loc = first;
+    return region{};
+}
+
+TOML11_INLINE repeat_at_least unquoted_key(const spec& s)
+{
+    auto keychar = either(
+            alpha(s), digit(s), character{0x2D}, character{0x5F}
+        );
+
+    if(s.v1_1_0_allow_non_english_in_bare_keys)
+    {
+        keychar.push_back(non_ascii_key_char(s));
+    }
+
+    return repeat_at_least(1, std::move(keychar));
+}
+
+TOML11_INLINE either quoted_key(const spec& s)
+{
+    return either(basic_string(s), literal_string(s));
+}
+
+TOML11_INLINE either simple_key(const spec& s)
+{
+    return either(unquoted_key(s), quoted_key(s));
+}
+
+TOML11_INLINE sequence dot_sep(const spec& s)
+{
+    return sequence(ws(s), character('.'), ws(s));
+}
+
+TOML11_INLINE sequence dotted_key(const spec& s)
+{
+    return sequence(
+        simple_key(s),
+        repeat_at_least(1, sequence(dot_sep(s), simple_key(s)))
+    );
+}
+
+TOML11_INLINE key::key(const spec& s) noexcept
+    : scanner_(dotted_key(s), simple_key(s))
+{}
+
+TOML11_INLINE sequence keyval_sep(const spec& s)
+{
+    return sequence(ws(s), character('='), ws(s));
+}
+
+// ===========================================================================
+// Table key
+
+TOML11_INLINE sequence std_table(const spec& s)
+{
+    return sequence(character('['), ws(s), key(s), ws(s), character(']'));
+}
+
+TOML11_INLINE sequence array_table(const spec& s)
+{
+    return sequence(literal("[["), ws(s), key(s), ws(s), literal("]]"));
+}
+
+// ===========================================================================
+// extension: null
+
+TOML11_INLINE literal null_value(const spec&)
+{
+    return literal("null");
+}
+
+} // namespace syntax
+} // namespace detail
+} // namespace toml
+#endif // TOML11_SYNTAX_IMPL_HPP
+#endif
+
+#endif// TOML11_SYNTAX_HPP
+#ifndef TOML11_SKIP_HPP
+#define TOML11_SKIP_HPP
+
+
+#include <cassert>
+
+namespace toml
+{
+namespace detail
+{
+
+template<typename TC>
+bool skip_whitespace(location& loc, const context<TC>& ctx)
+{
+    return syntax::ws(ctx.toml_spec()).scan(loc).is_ok();
+}
+
+template<typename TC>
+bool skip_empty_lines(location& loc, const context<TC>& ctx)
+{
+    return repeat_at_least(1, sequence(
+            syntax::ws(ctx.toml_spec()),
+            syntax::newline(ctx.toml_spec())
+        )).scan(loc).is_ok();
+}
+
+// For error recovery.
+//
+// In case if a comment line contains an invalid character, we need to skip it
+// to advance parsing.
+template<typename TC>
+void skip_comment_block(location& loc, const context<TC>& ctx)
+{
+    while( ! loc.eof())
+    {
+        skip_whitespace(loc, ctx);
+        if(loc.current() == '#')
+        {
+            while( ! loc.eof())
+            {
+                // both CRLF and LF ends with LF.
+                if(loc.current() == '\n')
+                {
+                    loc.advance();
+                    break;
+                }
+            }
+        }
+        else if(syntax::newline(ctx.toml_spec()).scan(loc).is_ok())
+        {
+            ; // an empty line. skip this also
+        }
+        else
+        {
+            // the next token is neither a comment nor empty line.
+            return ;
+        }
+    }
+    return ;
+}
+
+template<typename TC>
+void skip_empty_or_comment_lines(location& loc, const context<TC>& ctx)
+{
+    const auto& spec = ctx.toml_spec();
+    repeat_at_least(0, sequence(
+            syntax::ws(spec),
+            maybe(syntax::comment(spec)),
+            syntax::newline(spec))
+        ).scan(loc);
+    return ;
+}
+
+// For error recovery.
+//
+// Sometimes we need to skip a value and find a delimiter, like `,`, `]`, or `}`.
+// To find delimiter, we need to skip delimiters in a string.
+// Since we are skipping invalid value while error recovery, we don't need
+// to check the syntax. Here we just skip string-like region until closing quote
+// is found.
+template<typename TC>
+void skip_string_like(location& loc, const context<TC>&)
+{
+    // if """ is found, skip until the closing """ is found.
+    if(literal("\"\"\"").scan(loc).is_ok())
+    {
+        while( ! loc.eof())
+        {
+            if(literal("\"\"\"").scan(loc).is_ok())
+            {
+                return;
+            }
+            loc.advance();
+        }
+    }
+    else if(literal("'''").scan(loc).is_ok())
+    {
+        while( ! loc.eof())
+        {
+            if(literal("'''").scan(loc).is_ok())
+            {
+                return;
+            }
+            loc.advance();
+        }
+    }
+    // if " is found, skip until the closing " or newline is found.
+    else if(loc.current() == '"')
+    {
+        while( ! loc.eof())
+        {
+            loc.advance();
+            if(loc.current() == '"' || loc.current() == '\n')
+            {
+                loc.advance();
+                return;
+            }
+        }
+    }
+    else if(loc.current() == '\'')
+    {
+        while( ! loc.eof())
+        {
+            loc.advance();
+            if(loc.current() == '\'' || loc.current() == '\n')
+            {
+                loc.advance();
+                return ;
+            }
+        }
+    }
+    return;
+}
+
+template<typename TC>
+void skip_value(location& loc, const context<TC>& ctx);
+template<typename TC>
+void skip_array_like(location& loc, const context<TC>& ctx);
+template<typename TC>
+void skip_inline_table_like(location& loc, const context<TC>& ctx);
+template<typename TC>
+void skip_key_value_pair(location& loc, const context<TC>& ctx);
+
+template<typename TC>
+result<value_t, error_info>
+guess_value_type(const location& loc, const context<TC>& ctx);
+
+template<typename TC>
+void skip_array_like(location& loc, const context<TC>& ctx)
+{
+    const auto& spec = ctx.toml_spec();
+    assert(loc.current() == '[');
+    loc.advance();
+
+    while( ! loc.eof())
+    {
+        if(loc.current() == '\"' || loc.current() == '\'')
+        {
+            skip_string_like(loc, ctx);
+        }
+        else if(loc.current() == '#')
+        {
+            skip_comment_block(loc, ctx);
+        }
+        else if(loc.current() == '{')
+        {
+            skip_inline_table_like(loc, ctx);
+        }
+        else if(loc.current() == '[')
+        {
+            const auto checkpoint = loc;
+            if(syntax::std_table(spec).scan(loc).is_ok() ||
+               syntax::array_table(spec).scan(loc).is_ok())
+            {
+                loc = checkpoint;
+                break;
+            }
+            // if it is not a table-definition, then it is an array.
+            skip_array_like(loc, ctx);
+        }
+        else if(loc.current() == '=')
+        {
+            // key-value pair cannot be inside the array.
+            // guessing the error is "missing closing bracket `]`".
+            // find the previous key just before `=`.
+            while(loc.get_location() != 0)
+            {
+                loc.retrace();
+                if(loc.current() == '\n')
+                {
+                    loc.advance();
+                    break;
+                }
+            }
+            break;
+        }
+        else if(loc.current() == ']')
+        {
+            break; // found closing bracket
+        }
+        else
+        {
+            loc.advance();
+        }
+    }
+    return ;
+}
+
+template<typename TC>
+void skip_inline_table_like(location& loc, const context<TC>& ctx)
+{
+    assert(loc.current() == '{');
+    loc.advance();
+
+    const auto& spec = ctx.toml_spec();
+
+    while( ! loc.eof())
+    {
+        if(loc.current() == '\n' && ! spec.v1_1_0_allow_newlines_in_inline_tables)
+        {
+            break; // missing closing `}`.
+        }
+        else if(loc.current() == '\"' || loc.current() == '\'')
+        {
+            skip_string_like(loc, ctx);
+        }
+        else if(loc.current() == '#')
+        {
+            skip_comment_block(loc, ctx);
+            if( ! spec.v1_1_0_allow_newlines_in_inline_tables)
+            {
+                // comment must end with newline.
+                break; // missing closing `}`.
+            }
+        }
+        else if(loc.current() == '[')
+        {
+            const auto checkpoint = loc;
+            if(syntax::std_table(spec).scan(loc).is_ok() ||
+               syntax::array_table(spec).scan(loc).is_ok())
+            {
+                loc = checkpoint;
+                break; // missing closing `}`.
+            }
+            // if it is not a table-definition, then it is an array.
+            skip_array_like(loc, ctx);
+        }
+        else if(loc.current() == '{')
+        {
+            skip_inline_table_like(loc, ctx);
+        }
+        else if(loc.current() == '}')
+        {
+            // closing brace found. guessing the error is inside the table.
+            break;
+        }
+        else
+        {
+            // skip otherwise.
+            loc.advance();
+        }
+    }
+    return ;
+}
+
+template<typename TC>
+void skip_value(location& loc, const context<TC>& ctx)
+{
+    value_t ty = guess_value_type(loc, ctx).unwrap_or(value_t::empty);
+    if(ty == value_t::string)
+    {
+        skip_string_like(loc, ctx);
+    }
+    else if(ty == value_t::array)
+    {
+        skip_array_like(loc, ctx);
+    }
+    else if(ty == value_t::table)
+    {
+        // In case of multiline tables, it may skip key-value pair but not the
+        // whole table.
+        skip_inline_table_like(loc, ctx);
+    }
+    else // others are an "in-line" values. skip until the next line
+    {
+        while( ! loc.eof())
+        {
+            if(loc.current() == '\n')
+            {
+                break;
+            }
+            else if(loc.current() == ',' || loc.current() == ']' || loc.current() == '}')
+            {
+                break;
+            }
+            loc.advance();
+        }
+    }
+    return;
+}
+
+template<typename TC>
+void skip_key_value_pair(location& loc, const context<TC>& ctx)
+{
+    while( ! loc.eof())
+    {
+        if(loc.current() == '=')
+        {
+            skip_whitespace(loc, ctx);
+            skip_value(loc, ctx);
+            return;
+        }
+        else if(loc.current() == '\n')
+        {
+            // newline is found before finding `=`. assuming "missing `=`".
+            return;
+        }
+        loc.advance();
+    }
+    return ;
+}
+
+template<typename TC>
+void skip_until_next_table(location& loc, const context<TC>& ctx)
+{
+    const auto& spec = ctx.toml_spec();
+    while( ! loc.eof())
+    {
+        if(loc.current() == '\n')
+        {
+            loc.advance();
+            const auto line_begin = loc;
+
+            skip_whitespace(loc, ctx);
+            if(syntax::std_table(spec).scan(loc).is_ok())
+            {
+                loc = line_begin;
+                return ;
+            }
+            if(syntax::array_table(spec).scan(loc).is_ok())
+            {
+                loc = line_begin;
+                return ;
+            }
+        }
+        loc.advance();
+    }
+}
+
+} // namespace detail
+} // namespace toml
+
+#if defined(TOML11_COMPILE_SOURCES)
+namespace toml
+{
+struct type_config;
+struct ordered_type_config;
+
+namespace detail
+{
+extern template bool skip_whitespace            <type_config>(location& loc, const context<type_config>&);
+extern template bool skip_empty_lines           <type_config>(location& loc, const context<type_config>&);
+extern template void skip_comment_block         <type_config>(location& loc, const context<type_config>&);
+extern template void skip_empty_or_comment_lines<type_config>(location& loc, const context<type_config>&);
+extern template void skip_string_like           <type_config>(location& loc, const context<type_config>&);
+extern template void skip_array_like            <type_config>(location& loc, const context<type_config>&);
+extern template void skip_inline_table_like     <type_config>(location& loc, const context<type_config>&);
+extern template void skip_value                 <type_config>(location& loc, const context<type_config>&);
+extern template void skip_key_value_pair        <type_config>(location& loc, const context<type_config>&);
+extern template void skip_until_next_table      <type_config>(location& loc, const context<type_config>&);
+
+extern template bool skip_whitespace            <ordered_type_config>(location& loc, const context<ordered_type_config>&);
+extern template bool skip_empty_lines           <ordered_type_config>(location& loc, const context<ordered_type_config>&);
+extern template void skip_comment_block         <ordered_type_config>(location& loc, const context<ordered_type_config>&);
+extern template void skip_empty_or_comment_lines<ordered_type_config>(location& loc, const context<ordered_type_config>&);
+extern template void skip_string_like           <ordered_type_config>(location& loc, const context<ordered_type_config>&);
+extern template void skip_array_like            <ordered_type_config>(location& loc, const context<ordered_type_config>&);
+extern template void skip_inline_table_like     <ordered_type_config>(location& loc, const context<ordered_type_config>&);
+extern template void skip_value                 <ordered_type_config>(location& loc, const context<ordered_type_config>&);
+extern template void skip_key_value_pair        <ordered_type_config>(location& loc, const context<ordered_type_config>&);
+extern template void skip_until_next_table      <ordered_type_config>(location& loc, const context<ordered_type_config>&);
+
+} // detail
+} // toml
+#endif // TOML11_COMPILE_SOURCES
+
+#endif // TOML11_SKIP_HPP
+#ifndef TOML11_PARSER_HPP
+#define TOML11_PARSER_HPP
+
+
+#include <fstream>
+#include <sstream>
+
+#include <cassert>
+#include <cmath>
+
+#if defined(TOML11_HAS_FILESYSTEM) && TOML11_HAS_FILESYSTEM
+#include <filesystem>
+#endif
+
+namespace toml
+{
+
+struct syntax_error final : public ::toml::exception
+{
+  public:
+    syntax_error(std::string what_arg, std::vector<error_info> err)
+        : what_(std::move(what_arg)), err_(std::move(err))
+    {}
+    ~syntax_error() noexcept override = default;
+
+    const char* what() const noexcept override {return what_.c_str();}
+
+    std::vector<error_info> const& errors() const noexcept
+    {
+        return err_;
+    }
+
+  private:
+    std::string what_;
+    std::vector<error_info> err_;
+};
+
+struct file_io_error final : public ::toml::exception
+{
+  public:
+
+    file_io_error(const std::string& msg, const std::string& fname)
+        : errno_(cxx::make_nullopt()),
+          what_(msg + " \"" + fname + "\"")
+    {}
+    file_io_error(int errnum, const std::string& msg, const std::string& fname)
+        : errno_(errnum),
+          what_(msg + " \"" + fname + "\": errno=" + std::to_string(errnum))
+    {}
+    ~file_io_error() noexcept override = default;
+
+    const char* what() const noexcept override {return what_.c_str();}
+
+    bool has_errno() const noexcept {return errno_.has_value();}
+    int  get_errno() const noexcept {return errno_.value_or(0);}
+
+  private:
+
+    cxx::optional<int> errno_;
+    std::string what_;
+};
+
+namespace detail
+{
+
+/* ============================================================================
+ *    __ ___ _ __  _ __  ___ _ _
+ *   / _/ _ \ '  \| '  \/ _ \ ' \
+ *   \__\___/_|_|_|_|_|_\___/_||_|
+ */
+
+template<typename S>
+error_info make_syntax_error(std::string title,
+        const S& scanner, location loc, std::string suffix = "")
+{
+    auto msg = std::string("expected ") + scanner.expected_chars(loc);
+    auto src = source_location(region(loc));
+    return make_error_info(
+        std::move(title), std::move(src), std::move(msg), std::move(suffix));
+}
+
+
+/* ============================================================================
+ *                             _
+ *  __ ___ _ __  _ __  ___ _ _| |_
+ * / _/ _ \ '  \| '  \/ -_) ' \  _|
+ * \__\___/_|_|_|_|_|_\___|_||_\__|
+ */
+
+template<typename TC>
+result<cxx::optional<std::string>, error_info>
+parse_comment_line(location& loc, context<TC>& ctx)
+{
+    const auto& spec = ctx.toml_spec();
+    const auto first = loc;
+
+    skip_whitespace(loc, ctx);
+
+    const auto com_reg = syntax::comment(spec).scan(loc);
+    if(com_reg.is_ok())
+    {
+        // once comment started, newline must follow (or reach EOF).
+        if( ! loc.eof() && ! syntax::newline(spec).scan(loc).is_ok())
+        {
+            while( ! loc.eof()) // skip until newline to continue parsing
+            {
+                loc.advance();
+                if(loc.current() == '\n') { /*skip LF*/ loc.advance(); break; }
+            }
+            return err(make_error_info("toml::parse_comment_line: "
+                "newline (LF / CRLF) or EOF is expected",
+                source_location(region(loc)), "but got this",
+                "Hint: most of the control characters are not allowed in comments"));
+        }
+        return ok(cxx::optional<std::string>(com_reg.as_string()));
+    }
+    else
+    {
+        loc = first; // rollback whitespace to parse indent
+        return ok(cxx::optional<std::string>(cxx::make_nullopt()));
+    }
+}
+
+/* ============================================================================
+ *  ___           _
+ * | _ ) ___  ___| |___ __ _ _ _
+ * | _ \/ _ \/ _ \ / -_) _` | ' \
+ * |___/\___/\___/_\___\__,_|_||_|
+ */
+
+template<typename TC>
+result<basic_value<TC>, error_info>
+parse_boolean(location& loc, const context<TC>& ctx)
+{
+    const auto& spec = ctx.toml_spec();
+
+    // ----------------------------------------------------------------------
+    // check syntax
+    auto reg = syntax::boolean(spec).scan(loc);
+    if( ! reg.is_ok())
+    {
+        return err(make_syntax_error("toml::parse_boolean: "
+            "invalid boolean: boolean must be `true` or `false`, in lowercase. "
+            "string must be surrounded by `\"`", syntax::boolean(spec), loc));
+    }
+
+    // ----------------------------------------------------------------------
+    // it matches. gen value
+    const auto str = reg.as_string();
+    const auto val = [&str]() {
+        if(str == "true")
+        {
+            return true;
+        }
+        else
+        {
+            assert(str == "false");
+            return false;
+        }
+    }();
+
+    // ----------------------------------------------------------------------
+    // no format info for boolean
+    boolean_format_info fmt;
+
+    return ok(basic_value<TC>(val, std::move(fmt), {}, std::move(reg)));
+}
+
+/* ============================================================================
+ *  ___     _
+ * |_ _|_ _| |_ ___ __ _ ___ _ _
+ *  | || ' \  _/ -_) _` / -_) '_|
+ * |___|_||_\__\___\__, \___|_|
+ *                 |___/
+ */
+
+template<typename TC>
+result<basic_value<TC>, error_info>
+parse_bin_integer(location& loc, const context<TC>& ctx)
+{
+    const auto first = loc;
+    const auto& spec = ctx.toml_spec();
+    auto reg = syntax::bin_int(spec).scan(loc);
+    if( ! reg.is_ok())
+    {
+        return err(make_syntax_error("toml::parse_bin_integer: "
+            "invalid integer: bin_int must be like: 0b0101, 0b1111_0000",
+            syntax::bin_int(spec), loc));
+    }
+
+    auto str = reg.as_string();
+
+    integer_format_info fmt;
+    fmt.fmt   = integer_format::bin;
+    fmt.width = str.size() - 2 - static_cast<std::size_t>(std::count(str.begin(), str.end(), '_'));
+
+    const auto first_underscore = std::find(str.rbegin(), str.rend(), '_');
+    if(first_underscore != str.rend())
+    {
+        fmt.spacer = static_cast<std::size_t>(std::distance(str.rbegin(), first_underscore));
+    }
+
+    // skip prefix `0b` and zeros and underscores at the MSB
+    str.erase(str.begin(), std::find(std::next(str.begin(), 2), str.end(), '1'));
+
+    // remove all `_` before calling TC::parse_int
+    str.erase(std::remove(str.begin(), str.end(), '_'), str.end());
+
+    // 0b0000_0000 becomes empty.
+    if(str.empty()) { str = "0"; }
+
+    const auto val = TC::parse_int(str, source_location(region(loc)), 2);
+    if(val.is_ok())
+    {
+        return ok(basic_value<TC>(val.as_ok(), std::move(fmt), {}, std::move(reg)));
+    }
+    else
+    {
+        loc = first;
+        return err(val.as_err());
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+template<typename TC>
+result<basic_value<TC>, error_info>
+parse_oct_integer(location& loc, const context<TC>& ctx)
+{
+    const auto first = loc;
+    const auto& spec = ctx.toml_spec();
+    auto reg = syntax::oct_int(spec).scan(loc);
+    if( ! reg.is_ok())
+    {
+        return err(make_syntax_error("toml::parse_oct_integer: "
+            "invalid integer: oct_int must be like: 0o775, 0o04_44",
+            syntax::oct_int(spec), loc));
+    }
+
+    auto str = reg.as_string();
+
+    integer_format_info fmt;
+    fmt.fmt   = integer_format::oct;
+    fmt.width = str.size() - 2 - static_cast<std::size_t>(std::count(str.begin(), str.end(), '_'));
+
+    const auto first_underscore = std::find(str.rbegin(), str.rend(), '_');
+    if(first_underscore != str.rend())
+    {
+        fmt.spacer = static_cast<std::size_t>(std::distance(str.rbegin(), first_underscore));
+    }
+
+    // skip prefix `0o` and zeros and underscores at the MSB
+    str.erase(str.begin(), std::find_if(
+                std::next(str.begin(), 2), str.end(), [](const char c) {
+                    return c != '0' && c != '_';
+                }));
+
+    // remove all `_` before calling TC::parse_int
+    str.erase(std::remove(str.begin(), str.end(), '_'), str.end());
+
+    // 0o0000_0000 becomes empty.
+    if(str.empty()) { str = "0"; }
+
+    const auto val = TC::parse_int(str, source_location(region(loc)), 8);
+    if(val.is_ok())
+    {
+        return ok(basic_value<TC>(val.as_ok(), std::move(fmt), {}, std::move(reg)));
+    }
+    else
+    {
+        loc = first;
+        return err(val.as_err());
+    }
+}
+
+template<typename TC>
+result<basic_value<TC>, error_info>
+parse_hex_integer(location& loc, const context<TC>& ctx)
+{
+    const auto first = loc;
+    const auto& spec = ctx.toml_spec();
+    auto reg = syntax::hex_int(spec).scan(loc);
+    if( ! reg.is_ok())
+    {
+        return err(make_syntax_error("toml::parse_hex_integer: "
+            "invalid integer: hex_int must be like: 0xC0FFEE, 0xdead_beef",
+            syntax::hex_int(spec), loc));
+    }
+
+    auto str = reg.as_string();
+
+    integer_format_info fmt;
+    fmt.fmt   = integer_format::hex;
+    fmt.width = str.size() - 2 - static_cast<std::size_t>(std::count(str.begin(), str.end(), '_'));
+
+    const auto first_underscore = std::find(str.rbegin(), str.rend(), '_');
+    if(first_underscore != str.rend())
+    {
+        fmt.spacer = static_cast<std::size_t>(std::distance(str.rbegin(), first_underscore));
+    }
+
+    // skip prefix `0x` and zeros and underscores at the MSB
+    str.erase(str.begin(), std::find_if(
+                std::next(str.begin(), 2), str.end(), [](const char c) {
+                    return c != '0' && c != '_';
+                }));
+
+    // remove all `_` before calling TC::parse_int
+    str.erase(std::remove(str.begin(), str.end(), '_'), str.end());
+
+    // 0x0000_0000 becomes empty.
+    if(str.empty()) { str = "0"; }
+
+    // prefix zero and _ is removed. check if it uses upper/lower case.
+    // if both upper and lower case letters are found, set upper=true.
+    const auto lower_not_found = std::find_if(str.begin(), str.end(),
+        [](const char c) { return std::islower(static_cast<int>(c)) != 0; }) == str.end();
+    const auto upper_found = std::find_if(str.begin(), str.end(),
+        [](const char c) { return std::isupper(static_cast<int>(c)) != 0; }) != str.end();
+    fmt.uppercase = lower_not_found || upper_found;
+
+    const auto val = TC::parse_int(str, source_location(region(loc)), 16);
+    if(val.is_ok())
+    {
+        return ok(basic_value<TC>(val.as_ok(), std::move(fmt), {}, std::move(reg)));
+    }
+    else
+    {
+        loc = first;
+        return err(val.as_err());
+    }
+}
+
+template<typename TC>
+result<basic_value<TC>, error_info>
+parse_dec_integer(location& loc, const context<TC>& ctx)
+{
+    const auto first = loc;
+    const auto& spec = ctx.toml_spec();
+
+    // ----------------------------------------------------------------------
+    // check syntax
+    auto reg = syntax::dec_int(spec).scan(loc);
+    if( ! reg.is_ok())
+    {
+        return err(make_syntax_error("toml::parse_dec_integer: "
+            "invalid integer: dec_int must be like: 42, 123_456_789",
+            syntax::dec_int(spec), loc));
+    }
+
+    // ----------------------------------------------------------------------
+    // it matches. gen value
+    auto str = reg.as_string();
+
+    integer_format_info fmt;
+    fmt.fmt = integer_format::dec;
+    fmt.width = str.size() - static_cast<std::size_t>(std::count(str.begin(), str.end(), '_'));
+
+    const auto first_underscore = std::find(str.rbegin(), str.rend(), '_');
+    if(first_underscore != str.rend())
+    {
+        fmt.spacer = static_cast<std::size_t>(std::distance(str.rbegin(), first_underscore));
+    }
+
+    // remove all `_` before calling TC::parse_int
+    str.erase(std::remove(str.begin(), str.end(), '_'), str.end());
+
+    auto src = source_location(region(loc));
+    const auto val = TC::parse_int(str, src, 10);
+    if(val.is_err())
+    {
+        loc = first;
+        return err(val.as_err());
+    }
+
+    // ----------------------------------------------------------------------
+    // parse suffix (extension)
+
+    if(spec.ext_num_suffix && loc.current() == '_')
+    {
+        const auto sfx_reg = syntax::num_suffix(spec).scan(loc);
+        if( ! sfx_reg.is_ok())
+        {
+            loc = first;
+            return err(make_error_info("toml::parse_dec_integer: "
+                "invalid suffix: should be `_ non-digit-graph (graph | _graph)`",
+                source_location(region(loc)), "here"));
+        }
+        auto sfx = sfx_reg.as_string();
+        assert( ! sfx.empty() && sfx.front() == '_');
+        sfx.erase(sfx.begin()); // remove the first `_`
+
+        fmt.suffix = sfx;
+    }
+
+    return ok(basic_value<TC>(val.as_ok(), std::move(fmt), {}, std::move(reg)));
+}
+
+template<typename TC>
+result<basic_value<TC>, error_info>
+parse_integer(location& loc, const context<TC>& ctx)
+{
+    const auto first = loc;
+
+    if( ! loc.eof() && (loc.current() == '+' || loc.current() == '-'))
+    {
+        // skip +/- to diagnose +0xDEADBEEF or -0b0011 (invalid).
+        // without this, +0xDEAD_BEEF will be parsed as a decimal int and
+        // unexpected "xDEAD_BEEF" will appear after integer "+0".
+        loc.advance();
+    }
+
+    if( ! loc.eof() && loc.current() == '0')
+    {
+        loc.advance();
+        if(loc.eof())
+        {
+            // `[+-]?0`. parse as an decimal integer.
+            loc = first;
+            return parse_dec_integer(loc, ctx);
+        }
+
+        const auto prefix = loc.current();
+        auto prefix_src = source_location(region(loc));
+
+        loc = first;
+
+        if(prefix == 'b') {return parse_bin_integer(loc, ctx);}
+        if(prefix == 'o') {return parse_oct_integer(loc, ctx);}
+        if(prefix == 'x') {return parse_hex_integer(loc, ctx);}
+
+        if(std::isdigit(prefix))
+        {
+            auto src = source_location(region(loc));
+            return err(make_error_info("toml::parse_integer: "
+                "leading zero in an decimal integer is not allowed",
+                std::move(src), "leading zero"));
+        }
+    }
+
+    loc = first;
+    return parse_dec_integer(loc, ctx);
+}
+
+/* ============================================================================
+ *  ___ _           _   _
+ * | __| |___  __ _| |_(_)_ _  __ _
+ * | _|| / _ \/ _` |  _| | ' \/ _` |
+ * |_| |_\___/\__,_|\__|_|_||_\__, |
+ *                            |___/
+ */
+
+template<typename TC>
+result<basic_value<TC>, error_info>
+parse_floating(location& loc, const context<TC>& ctx)
+{
+    using floating_type = typename basic_value<TC>::floating_type;
+
+    const auto first = loc;
+    const auto& spec = ctx.toml_spec();
+
+    // ----------------------------------------------------------------------
+    // check syntax
+    bool is_hex = false;
+    std::string str;
+    region reg;
+    if(spec.ext_hex_float && sequence(character('0'), character('x')).scan(loc).is_ok())
+    {
+        loc = first;
+        is_hex = true;
+
+        reg = syntax::hex_floating(spec).scan(loc);
+        if( ! reg.is_ok())
+        {
+            return err(make_syntax_error("toml::parse_floating: "
+                "invalid hex floating: float must be like: 0xABCp-3f",
+                syntax::floating(spec), loc));
+        }
+        str = reg.as_string();
+    }
+    else
+    {
+        reg = syntax::floating(spec).scan(loc);
+        if( ! reg.is_ok())
+        {
+            return err(make_syntax_error("toml::parse_floating: "
+                "invalid floating: float must be like: -3.14159_26535, 6.022e+23, "
+                "inf, or nan (lowercase).", syntax::floating(spec), loc));
+        }
+        str = reg.as_string();
+    }
+
+    // ----------------------------------------------------------------------
+    // it matches. gen value
+
+    floating_format_info fmt;
+
+    if(is_hex)
+    {
+        fmt.fmt = floating_format::hex;
+    }
+    else
+    {
+        // since we already checked that the string conforms the TOML standard.
+        if(std::find(str.begin(), str.end(), 'e') != str.end() ||
+           std::find(str.begin(), str.end(), 'E') != str.end())
+        {
+            fmt.fmt = floating_format::scientific; // use exponent part
+        }
+        else
+        {
+            fmt.fmt = floating_format::fixed; // do not use exponent part
+        }
+    }
+
+    str.erase(std::remove(str.begin(), str.end(), '_'), str.end());
+
+    floating_type val{0};
+
+    if(str == "inf" || str == "+inf")
+    {
+        TOML11_CONSTEXPR_IF(std::numeric_limits<floating_type>::has_infinity)
+        {
+            val = std::numeric_limits<floating_type>::infinity();
+        }
+        else
+        {
+            return err(make_error_info("toml::parse_floating: inf value found"
+                " but the current environment does not support inf. Please"
+                " make sure that the floating-point implementation conforms"
+                " IEEE 754/ISO 60559 international standard.",
+                source_location(region(loc)),
+                "floating_type: inf is not supported"));
+        }
+    }
+    else if(str == "-inf")
+    {
+        TOML11_CONSTEXPR_IF(std::numeric_limits<floating_type>::has_infinity)
+        {
+            val = -std::numeric_limits<floating_type>::infinity();
+        }
+        else
+        {
+            return err(make_error_info("toml::parse_floating: inf value found"
+                " but the current environment does not support inf. Please"
+                " make sure that the floating-point implementation conforms"
+                " IEEE 754/ISO 60559 international standard.",
+                source_location(region(loc)),
+                "floating_type: inf is not supported"));
+        }
+    }
+    else if(str == "nan" || str == "+nan")
+    {
+        TOML11_CONSTEXPR_IF(std::numeric_limits<floating_type>::has_quiet_NaN)
+        {
+            val = std::numeric_limits<floating_type>::quiet_NaN();
+        }
+        else TOML11_CONSTEXPR_IF(std::numeric_limits<floating_type>::has_signaling_NaN)
+        {
+            val = std::numeric_limits<floating_type>::signaling_NaN();
+        }
+        else
+        {
+            return err(make_error_info("toml::parse_floating: NaN value found"
+                " but the current environment does not support NaN. Please"
+                " make sure that the floating-point implementation conforms"
+                " IEEE 754/ISO 60559 international standard.",
+                source_location(region(loc)),
+                "floating_type: NaN is not supported"));
+        }
+    }
+    else if(str == "-nan")
+    {
+        using std::copysign;
+        TOML11_CONSTEXPR_IF(std::numeric_limits<floating_type>::has_quiet_NaN)
+        {
+            val = copysign(std::numeric_limits<floating_type>::quiet_NaN(), floating_type(-1));
+        }
+        else TOML11_CONSTEXPR_IF(std::numeric_limits<floating_type>::has_signaling_NaN)
+        {
+            val = copysign(std::numeric_limits<floating_type>::signaling_NaN(), floating_type(-1));
+        }
+        else
+        {
+            return err(make_error_info("toml::parse_floating: NaN value found"
+                " but the current environment does not support NaN. Please"
+                " make sure that the floating-point implementation conforms"
+                " IEEE 754/ISO 60559 international standard.",
+                source_location(region(loc)),
+                "floating_type: NaN is not supported"));
+        }
+    }
+    else
+    {
+        // set precision
+        const auto has_sign = ! str.empty() && (str.front() == '+' || str.front() == '-');
+        const auto decpoint = std::find(str.begin(), str.end(), '.');
+        const auto exponent = std::find_if(str.begin(), str.end(),
+            [](const char c) { return c == 'e' || c == 'E'; });
+        if(decpoint != str.end() && exponent != str.end())
+        {
+            assert(decpoint < exponent);
+        }
+
+        if(fmt.fmt == floating_format::scientific)
+        {
+            // total width
+            fmt.prec = static_cast<std::size_t>(std::distance(str.begin(), exponent));
+            if(has_sign)
+            {
+                fmt.prec -= 1;
+            }
+            if(decpoint != str.end())
+            {
+                fmt.prec -= 1;
+            }
+        }
+        else if(fmt.fmt == floating_format::hex)
+        {
+            fmt.prec = std::numeric_limits<floating_type>::max_digits10;
+        }
+        else
+        {
+            // width after decimal point
+            fmt.prec = static_cast<std::size_t>(std::distance(std::next(decpoint), exponent));
+        }
+
+        auto src = source_location(region(loc));
+        const auto res = TC::parse_float(str, src, is_hex);
+        if(res.is_ok())
+        {
+            val = res.as_ok();
+        }
+        else
+        {
+            return err(res.as_err());
+        }
+    }
+
+    // ----------------------------------------------------------------------
+    // parse suffix (extension)
+
+    if(spec.ext_num_suffix && loc.current() == '_')
+    {
+        const auto sfx_reg = syntax::num_suffix(spec).scan(loc);
+        if( ! sfx_reg.is_ok())
+        {
+            auto src = source_location(region(loc));
+            loc = first;
+            return err(make_error_info("toml::parse_floating: "
+                "invalid suffix: should be `_ non-digit-graph (graph | _graph)`",
+                std::move(src), "here"));
+        }
+        auto sfx = sfx_reg.as_string();
+        assert( ! sfx.empty() && sfx.front() == '_');
+        sfx.erase(sfx.begin()); // remove the first `_`
+
+        fmt.suffix = sfx;
+    }
+
+    return ok(basic_value<TC>(val, std::move(fmt), {}, std::move(reg)));
+}
+
+/* ============================================================================
+ *  ___       _       _   _
+ * |   \ __ _| |_ ___| |_(_)_ __  ___
+ * | |) / _` |  _/ -_)  _| | '  \/ -_)
+ * |___/\__,_|\__\___|\__|_|_|_|_\___|
+ */
+
+// all the offset_datetime, local_datetime, local_date parses date part.
+template<typename TC>
+result<std::tuple<local_date, local_date_format_info, region>, error_info>
+parse_local_date_only(location& loc, const context<TC>& ctx)
+{
+    const auto first = loc;
+    const auto& spec = ctx.toml_spec();
+
+    local_date_format_info fmt;
+
+    // ----------------------------------------------------------------------
+    // check syntax
+    auto reg = syntax::local_date(spec).scan(loc);
+    if( ! reg.is_ok())
+    {
+        return err(make_syntax_error("toml::parse_local_date: "
+            "invalid date: date must be like: 1234-05-06, yyyy-mm-dd.",
+            syntax::local_date(spec), loc));
+    }
+
+    // ----------------------------------------------------------------------
+    // it matches. gen value
+    const auto str = reg.as_string();
+
+    // 0123456789
+    // yyyy-mm-dd
+    const auto year_r  = from_string<int>(str.substr(0, 4));
+    const auto month_r = from_string<int>(str.substr(5, 2));
+    const auto day_r   = from_string<int>(str.substr(8, 2));
+
+    if(year_r.is_err())
+    {
+        auto src = source_location(region(first));
+        return err(make_error_info("toml::parse_local_date: "
+            "failed to read year `" + str.substr(0, 4) + "`",
+            std::move(src), "here"));
+    }
+    if(month_r.is_err())
+    {
+        auto src = source_location(region(first));
+        return err(make_error_info("toml::parse_local_date: "
+            "failed to read month `" + str.substr(5, 2) + "`",
+            std::move(src), "here"));
+    }
+    if(day_r.is_err())
+    {
+        auto src = source_location(region(first));
+        return err(make_error_info("toml::parse_local_date: "
+            "failed to read day `" + str.substr(8, 2) + "`",
+            std::move(src), "here"));
+    }
+
+    const auto year  = year_r.unwrap();
+    const auto month = month_r.unwrap();
+    const auto day   = day_r.unwrap();
+
+    {
+        // We briefly check whether the input date is valid or not.
+        //     Actually, because of the historical reasons, there are several
+        // edge cases, such as 1582/10/5-1582/10/14 (only in several countries).
+        // But here, we do not care about it.
+        // It makes the code complicated and there is only low probability
+        // that such a specific date is needed in practice. If someone need to
+        // validate date accurately, that means that the one need a specialized
+        // library for their purpose in another layer.
+
+        const bool is_leap = (year % 4 == 0) && ((year % 100 != 0) || (year % 400 == 0));
+        const auto max_day = [month, is_leap]() {
+            if(month == 2)
+            {
+                return is_leap ? 29 : 28;
+            }
+            if(month == 4 || month == 6 || month == 9 || month == 11)
+            {
+                return 30;
+            }
+            return 31;
+        }();
+
+        if((month < 1 || 12 < month) || (day < 1 || max_day < day))
+        {
+            auto src = source_location(region(first));
+            return err(make_error_info("toml::parse_local_date: invalid date.",
+                std::move(src), "month must be 01-12, day must be any of "
+                "01-28,29,30,31 depending on the month/year."));
+        }
+    }
+
+    return ok(std::make_tuple(
+            local_date(year, static_cast<month_t>(month - 1), day),
+            std::move(fmt), std::move(reg)
+        ));
+}
+
+template<typename TC>
+result<basic_value<TC>, error_info>
+parse_local_date(location& loc, const context<TC>& ctx)
+{
+    auto val_fmt_reg = parse_local_date_only(loc, ctx);
+    if(val_fmt_reg.is_err())
+    {
+        return err(val_fmt_reg.unwrap_err());
+    }
+
+    auto val = std::move(std::get<0>(val_fmt_reg.unwrap()));
+    auto fmt = std::move(std::get<1>(val_fmt_reg.unwrap()));
+    auto reg = std::move(std::get<2>(val_fmt_reg.unwrap()));
+
+    return ok(basic_value<TC>(std::move(val), std::move(fmt), {}, std::move(reg)));
+}
+
+// all the offset_datetime, local_datetime, local_time parses date part.
+template<typename TC>
+result<std::tuple<local_time, local_time_format_info, region>, error_info>
+parse_local_time_only(location& loc, const context<TC>& ctx)
+{
+    const auto first = loc;
+    const auto& spec = ctx.toml_spec();
+
+    local_time_format_info fmt;
+
+    // ----------------------------------------------------------------------
+    // check syntax
+    auto reg = syntax::local_time(spec).scan(loc);
+    if( ! reg.is_ok())
+    {
+        if(spec.v1_1_0_make_seconds_optional)
+        {
+            return err(make_syntax_error("toml::parse_local_time: "
+                "invalid time: time must be HH:MM(:SS.sss) (seconds are optional)",
+                syntax::local_time(spec), loc));
+        }
+        else
+        {
+            return err(make_syntax_error("toml::parse_local_time: "
+                "invalid time: time must be HH:MM:SS(.sss) (subseconds are optional)",
+                syntax::local_time(spec), loc));
+        }
+    }
+
+    // ----------------------------------------------------------------------
+    // it matches. gen value
+    const auto str = reg.as_string();
+
+    // at least we have HH:MM.
+    // 01234
+    // HH:MM
+    const auto hour_r   = from_string<int>(str.substr(0, 2));
+    const auto minute_r = from_string<int>(str.substr(3, 2));
+
+    if(hour_r.is_err())
+    {
+        auto src = source_location(region(first));
+        return err(make_error_info("toml::parse_local_time: "
+            "failed to read hour `" + str.substr(0, 2) + "`",
+            std::move(src), "here"));
+    }
+    if(minute_r.is_err())
+    {
+        auto src = source_location(region(first));
+        return err(make_error_info("toml::parse_local_time: "
+            "failed to read minute `" + str.substr(3, 2) + "`",
+            std::move(src), "here"));
+    }
+
+    const auto hour   = hour_r.unwrap();
+    const auto minute = minute_r.unwrap();
+
+    if((hour < 0 || 24 <= hour) || (minute < 0 || 60 <= minute))
+    {
+        auto src = source_location(region(first));
+        return err(make_error_info("toml::parse_local_time: invalid time.",
+            std::move(src), "hour must be 00-23, minute must be 00-59."));
+    }
+
+    // -----------------------------------------------------------------------
+    // we have hour and minute.
+    // Since toml v1.1.0, second and subsecond part becomes optional.
+    // Check the version and return if second does not exist.
+
+    if(str.size() == 5 && spec.v1_1_0_make_seconds_optional)
+    {
+        fmt.has_seconds = false;
+        fmt.subsecond_precision = 0;
+        return ok(std::make_tuple(local_time(hour, minute, 0), std::move(fmt), std::move(reg)));
+    }
+    assert(str.at(5) == ':');
+
+    // we have at least `:SS` part. `.subseconds` are optional.
+
+    // 0         1
+    // 012345678901234
+    // HH:MM:SS.subsec
+    const auto sec_r = from_string<int>(str.substr(6, 2));
+    if(sec_r.is_err())
+    {
+        auto src = source_location(region(first));
+        return err(make_error_info("toml::parse_local_time: "
+            "failed to read second `" + str.substr(6, 2) + "`",
+            std::move(src), "here"));
+    }
+    const auto sec = sec_r.unwrap();
+
+    if(sec < 0 || 60 < sec) // :60 is allowed
+    {
+        auto src = source_location(region(first));
+        return err(make_error_info("toml::parse_local_time: invalid time.",
+                    std::move(src), "second must be 00-60."));
+    }
+
+    if(str.size() == 8)
+    {
+        fmt.has_seconds = true;
+        fmt.subsecond_precision = 0;
+        return ok(std::make_tuple(local_time(hour, minute, sec), std::move(fmt), std::move(reg)));
+    }
+
+    assert(str.at(8) == '.');
+
+    auto secfrac = str.substr(9, str.size() - 9);
+
+    fmt.has_seconds = true;
+    fmt.subsecond_precision = secfrac.size();
+
+    while(secfrac.size() < 9)
+    {
+        secfrac += '0';
+    }
+    assert(9 <= secfrac.size());
+    const auto ms_r = from_string<int>(secfrac.substr(0, 3));
+    const auto us_r = from_string<int>(secfrac.substr(3, 3));
+    const auto ns_r = from_string<int>(secfrac.substr(6, 3));
+
+    if(ms_r.is_err())
+    {
+        auto src = source_location(region(first));
+        return err(make_error_info("toml::parse_local_time: "
+            "failed to read milliseconds `" + secfrac.substr(0, 3) + "`",
+            std::move(src), "here"));
+    }
+    if(us_r.is_err())
+    {
+        auto src = source_location(region(first));
+        return err(make_error_info("toml::parse_local_time: "
+            "failed to read microseconds`" + str.substr(3, 3) + "`",
+            std::move(src), "here"));
+    }
+    if(ns_r.is_err())
+    {
+        auto src = source_location(region(first));
+        return err(make_error_info("toml::parse_local_time: "
+            "failed to read nanoseconds`" + str.substr(6, 3) + "`",
+            std::move(src), "here"));
+    }
+    const auto ms = ms_r.unwrap();
+    const auto us = us_r.unwrap();
+    const auto ns = ns_r.unwrap();
+
+    return ok(std::make_tuple(local_time(hour, minute, sec, ms, us, ns), std::move(fmt), std::move(reg)));
+}
+
+template<typename TC>
+result<basic_value<TC>, error_info>
+parse_local_time(location& loc, const context<TC>& ctx)
+{
+    const auto first = loc;
+
+    auto val_fmt_reg = parse_local_time_only(loc, ctx);
+    if(val_fmt_reg.is_err())
+    {
+        return err(val_fmt_reg.unwrap_err());
+    }
+
+    auto val = std::move(std::get<0>(val_fmt_reg.unwrap()));
+    auto fmt = std::move(std::get<1>(val_fmt_reg.unwrap()));
+    auto reg = std::move(std::get<2>(val_fmt_reg.unwrap()));
+
+    return ok(basic_value<TC>(std::move(val), std::move(fmt), {}, std::move(reg)));
+}
+
+template<typename TC>
+result<basic_value<TC>, error_info>
+parse_local_datetime(location& loc, const context<TC>& ctx)
+{
+    using char_type = location::char_type;
+
+    const auto first = loc;
+
+    local_datetime_format_info fmt;
+
+    // ----------------------------------------------------------------------
+
+    auto date_fmt_reg = parse_local_date_only(loc, ctx);
+    if(date_fmt_reg.is_err())
+    {
+        return err(date_fmt_reg.unwrap_err());
+    }
+
+    if(loc.current() == char_type('T'))
+    {
+        loc.advance();
+        fmt.delimiter = datetime_delimiter_kind::upper_T;
+    }
+    else if(loc.current() == char_type('t'))
+    {
+        loc.advance();
+        fmt.delimiter = datetime_delimiter_kind::lower_t;
+    }
+    else if(loc.current() == char_type(' '))
+    {
+        loc.advance();
+        fmt.delimiter = datetime_delimiter_kind::space;
+    }
+    else
+    {
+        auto src = source_location(region(loc));
+        return err(make_error_info("toml::parse_local_datetime: "
+            "expect date-time delimiter `T`, `t` or ` `(space).",
+            std::move(src), "here"));
+    }
+
+    auto time_fmt_reg = parse_local_time_only(loc, ctx);
+    if(time_fmt_reg.is_err())
+    {
+        return err(time_fmt_reg.unwrap_err());
+    }
+
+    fmt.has_seconds         = std::get<1>(time_fmt_reg.unwrap()).has_seconds;
+    fmt.subsecond_precision = std::get<1>(time_fmt_reg.unwrap()).subsecond_precision;
+
+    // ----------------------------------------------------------------------
+
+    region reg(first, loc);
+    local_datetime val(std::get<0>(date_fmt_reg.unwrap()),
+                       std::get<0>(time_fmt_reg.unwrap()));
+
+    return ok(basic_value<TC>(val, std::move(fmt), {}, std::move(reg)));
+}
+
+template<typename TC>
+result<basic_value<TC>, error_info>
+parse_offset_datetime(location& loc, const context<TC>& ctx)
+{
+    using char_type = location::char_type;
+
+    const auto first = loc;
+    const auto& spec = ctx.toml_spec();
+
+    offset_datetime_format_info fmt;
+
+    // ----------------------------------------------------------------------
+    // date part
+
+    auto date_fmt_reg = parse_local_date_only(loc, ctx);
+    if(date_fmt_reg.is_err())
+    {
+        return err(date_fmt_reg.unwrap_err());
+    }
+
+    // ----------------------------------------------------------------------
+    // delimiter
+
+    if(loc.current() == char_type('T'))
+    {
+        loc.advance();
+        fmt.delimiter = datetime_delimiter_kind::upper_T;
+    }
+    else if(loc.current() == char_type('t'))
+    {
+        loc.advance();
+        fmt.delimiter = datetime_delimiter_kind::lower_t;
+    }
+    else if(loc.current() == char_type(' '))
+    {
+        loc.advance();
+        fmt.delimiter = datetime_delimiter_kind::space;
+    }
+    else
+    {
+        auto src = source_location(region(loc));
+        return err(make_error_info("toml::parse_offset_datetime: "
+            "expect date-time delimiter `T` or ` `(space).", std::move(src), "here"
+        ));
+    }
+
+    // ----------------------------------------------------------------------
+    // time part
+
+    auto time_fmt_reg = parse_local_time_only(loc, ctx);
+    if(time_fmt_reg.is_err())
+    {
+        return err(time_fmt_reg.unwrap_err());
+    }
+
+    fmt.has_seconds         = std::get<1>(time_fmt_reg.unwrap()).has_seconds;
+    fmt.subsecond_precision = std::get<1>(time_fmt_reg.unwrap()).subsecond_precision;
+
+    // ----------------------------------------------------------------------
+    // offset part
+
+    const auto ofs_reg = syntax::time_offset(spec).scan(loc);
+    if( ! ofs_reg.is_ok())
+    {
+        return err(make_syntax_error("toml::parse_offset_datetime: "
+            "invalid offset: offset must be like: Z, +01:00, or -10:00.",
+            syntax::time_offset(spec), loc));
+    }
+
+    const auto ofs_str = ofs_reg.as_string();
+
+    time_offset offset(0, 0);
+
+    assert(ofs_str.size() != 0);
+
+    if(ofs_str.at(0) == char_type('+') || ofs_str.at(0) == char_type('-'))
+    {
+        const auto hour_r   = from_string<int>(ofs_str.substr(1, 2));
+        const auto minute_r = from_string<int>(ofs_str.substr(4, 2));
+        if(hour_r.is_err())
+        {
+            auto src = source_location(region(loc));
+            return err(make_error_info("toml::parse_offset_datetime: "
+                "Failed to read offset hour part", std::move(src), "here"));
+        }
+        if(minute_r.is_err())
+        {
+            auto src = source_location(region(loc));
+            return err(make_error_info("toml::parse_offset_datetime: "
+                "Failed to read offset minute part", std::move(src), "here"));
+        }
+        const auto hour   = hour_r.unwrap();
+        const auto minute = minute_r.unwrap();
+
+        if(ofs_str.at(0) == '+')
+        {
+            offset = time_offset(hour, minute);
+        }
+        else
+        {
+            offset = time_offset(-hour, -minute);
+        }
+    }
+    else
+    {
+        assert(ofs_str.at(0) == char_type('Z') || ofs_str.at(0) == char_type('z'));
+    }
+
+    if (offset.hour   < -24 || 24 < offset.hour ||
+        offset.minute < -60 || 60 < offset.minute)
+    {
+        return err(make_error_info("toml::parse_offset_datetime: "
+            "too large offset: |hour| <= 24, |minute| <= 60",
+            source_location(region(first, loc)), "here"));
+    }
+
+
+    // ----------------------------------------------------------------------
+
+    region reg(first, loc);
+    offset_datetime val(local_datetime(std::get<0>(date_fmt_reg.unwrap()),
+                                       std::get<0>(time_fmt_reg.unwrap())),
+                                       offset);
+
+    return ok(basic_value<TC>(val, std::move(fmt), {}, std::move(reg)));
+}
+
+/* ============================================================================
+ *   ___ _       _
+ *  / __| |_ _ _(_)_ _  __ _
+ *  \__ \  _| '_| | ' \/ _` |
+ *  |___/\__|_| |_|_||_\__, |
+ *                     |___/
+ */
+
+template<typename TC>
+result<typename basic_value<TC>::string_type, error_info>
+parse_utf8_codepoint(const region& reg)
+{
+    using string_type = typename basic_value<TC>::string_type;
+    using char_type = typename string_type::value_type;
+
+    // assert(reg.as_lines().size() == 1); // XXX heavy check
+
+    const auto str = reg.as_string();
+    assert( ! str.empty());
+    assert(str.front() == 'u' || str.front() == 'U' || str.front() == 'x');
+
+    std::uint_least32_t codepoint;
+    std::istringstream iss(str.substr(1));
+    iss >> std::hex >> codepoint;
+
+    const auto to_char = [](const std::uint_least32_t i) noexcept -> char_type {
+        const auto uc = static_cast<unsigned char>(i & 0xFF);
+        return cxx::bit_cast<char_type>(uc);
+    };
+
+    string_type character;
+    if(codepoint < 0x80) // U+0000 ... U+0079 ; just an ASCII.
+    {
+        character += static_cast<char>(codepoint);
+    }
+    else if(codepoint < 0x800) //U+0080 ... U+07FF
+    {
+        // 110yyyyx 10xxxxxx; 0x3f == 0b0011'1111
+        character += to_char(0xC0|(codepoint >> 6  ));
+        character += to_char(0x80|(codepoint & 0x3F));
+    }
+    else if(codepoint < 0x10000) // U+0800...U+FFFF
+    {
+        if(0xD800 <= codepoint && codepoint <= 0xDFFF)
+        {
+            auto src = source_location(reg);
+            return err(make_error_info("toml::parse_utf8_codepoint: "
+                "[0xD800, 0xDFFF] is not a valid UTF-8",
+                std::move(src), "here"));
+        }
+        assert(codepoint < 0xD800 || 0xDFFF < codepoint);
+        // 1110yyyy 10yxxxxx 10xxxxxx
+        character += to_char(0xE0| (codepoint >> 12));
+        character += to_char(0x80|((codepoint >> 6 ) & 0x3F));
+        character += to_char(0x80|((codepoint      ) & 0x3F));
+    }
+    else if(codepoint < 0x110000) // U+010000 ... U+10FFFF
+    {
+        // 11110yyy 10yyxxxx 10xxxxxx 10xxxxxx
+        character += to_char(0xF0| (codepoint >> 18));
+        character += to_char(0x80|((codepoint >> 12) & 0x3F));
+        character += to_char(0x80|((codepoint >> 6 ) & 0x3F));
+        character += to_char(0x80|((codepoint      ) & 0x3F));
+    }
+    else // out of UTF-8 region
+    {
+        auto src = source_location(reg);
+        return err(make_error_info("toml::parse_utf8_codepoint: "
+            "input codepoint is too large.",
+            std::move(src), "must be in range [0x00, 0x10FFFF]"));
+    }
+    return ok(character);
+}
+
+template<typename TC>
+result<typename basic_value<TC>::string_type, error_info>
+parse_escape_sequence(location& loc, const context<TC>& ctx)
+{
+    using string_type = typename basic_value<TC>::string_type;
+    using char_type = typename string_type::value_type;
+
+    const auto& spec = ctx.toml_spec();
+
+    assert( ! loc.eof());
+    assert(loc.current() == '\\');
+    loc.advance(); // consume the first backslash
+
+    string_type retval;
+
+    if     (loc.current() == '\\') { retval += char_type('\\'); loc.advance(); }
+    else if(loc.current() == '"')  { retval += char_type('\"'); loc.advance(); }
+    else if(loc.current() == 'b')  { retval += char_type('\b'); loc.advance(); }
+    else if(loc.current() == 'f')  { retval += char_type('\f'); loc.advance(); }
+    else if(loc.current() == 'n')  { retval += char_type('\n'); loc.advance(); }
+    else if(loc.current() == 'r')  { retval += char_type('\r'); loc.advance(); }
+    else if(loc.current() == 't')  { retval += char_type('\t'); loc.advance(); }
+    else if(spec.v1_1_0_add_escape_sequence_e && loc.current() == 'e')
+    {
+        retval += char_type('\x1b');
+        loc.advance();
+    }
+    else if(spec.v1_1_0_add_escape_sequence_x && loc.current() == 'x')
+    {
+        auto scanner = sequence(character('x'), repeat_exact(2, syntax::hexdig(spec)));
+        const auto reg = scanner.scan(loc);
+        if( ! reg.is_ok())
+        {
+            auto src = source_location(region(loc));
+            return err(make_error_info("toml::parse_escape_sequence: "
+                   "invalid token found in UTF-8 codepoint \\xhh",
+                   std::move(src), "here"));
+        }
+        const auto utf8 = parse_utf8_codepoint<TC>(reg);
+        if(utf8.is_err())
+        {
+            return err(utf8.as_err());
+        }
+        retval += utf8.unwrap();
+    }
+    else if(loc.current() == 'u')
+    {
+        auto scanner = sequence(character('u'), repeat_exact(4, syntax::hexdig(spec)));
+        const auto reg = scanner.scan(loc);
+        if( ! reg.is_ok())
+        {
+            auto src = source_location(region(loc));
+            return err(make_error_info("toml::parse_escape_sequence: "
+                   "invalid token found in UTF-8 codepoint \\uhhhh",
+                   std::move(src), "here"));
+        }
+        const auto utf8 = parse_utf8_codepoint<TC>(reg);
+        if(utf8.is_err())
+        {
+            return err(utf8.as_err());
+        }
+        retval += utf8.unwrap();
+    }
+    else if(loc.current() == 'U')
+    {
+        auto scanner = sequence(character('U'), repeat_exact(8, syntax::hexdig(spec)));
+        const auto reg = scanner.scan(loc);
+        if( ! reg.is_ok())
+        {
+            auto src = source_location(region(loc));
+            return err(make_error_info("toml::parse_escape_sequence: "
+                   "invalid token found in UTF-8 codepoint \\Uhhhhhhhh",
+                   std::move(src), "here"));
+        }
+        const auto utf8 = parse_utf8_codepoint<TC>(reg);
+        if(utf8.is_err())
+        {
+            return err(utf8.as_err());
+        }
+        retval += utf8.unwrap();
+    }
+    else
+    {
+        auto src = source_location(region(loc));
+        std::string escape_seqs = "allowed escape seqs: \\\\, \\\", \\b, \\f, \\n, \\r, \\t";
+        if(spec.v1_1_0_add_escape_sequence_e)
+        {
+            escape_seqs += ", \\e";
+        }
+        if(spec.v1_1_0_add_escape_sequence_x)
+        {
+            escape_seqs += ", \\xhh";
+        }
+        escape_seqs += ", \\uhhhh, or \\Uhhhhhhhh";
+
+        return err(make_error_info("toml::parse_escape_sequence: "
+               "unknown escape sequence.", std::move(src), escape_seqs));
+    }
+    return ok(retval);
+}
+
+template<typename TC>
+result<basic_value<TC>, error_info>
+parse_ml_basic_string(location& loc, const context<TC>& ctx)
+{
+    const auto first = loc;
+    const auto& spec = ctx.toml_spec();
+
+    string_format_info fmt;
+    fmt.fmt = string_format::multiline_basic;
+
+    auto reg = syntax::ml_basic_string(spec).scan(loc);
+    if( ! reg.is_ok())
+    {
+        return err(make_syntax_error("toml::parse_ml_basic_string: "
+            "invalid string format",
+            syntax::ml_basic_string(spec), loc));
+    }
+
+    // ----------------------------------------------------------------------
+    // it matches. gen value
+
+    auto str = reg.as_string();
+
+    // we already checked that it starts with """ and ends with """.
+    assert(str.substr(0, 3) == "\"\"\"");
+    str.erase(0, 3);
+
+    assert(str.size() >= 3);
+    assert(str.substr(str.size()-3, 3) == "\"\"\"");
+    str.erase(str.size()-3, 3);
+
+    // the first newline just after """ is trimmed
+    if(str.size() >= 1 && str.at(0) == '\n')
+    {
+        str.erase(0, 1);
+        fmt.start_with_newline = true;
+    }
+    else if(str.size() >= 2 && str.at(0) == '\r' && str.at(1) == '\n')
+    {
+        str.erase(0, 2);
+        fmt.start_with_newline = true;
+    }
+
+    using string_type = typename basic_value<TC>::string_type;
+    string_type val;
+    {
+        auto iter = str.cbegin();
+        while(iter != str.cend())
+        {
+            if(*iter == '\\') // remove whitespaces around escaped-newline
+            {
+                // we assume that the string is not too long to copy
+                auto loc2 = make_temporary_location(make_string(iter, str.cend()));
+                if(syntax::escaped_newline(spec).scan(loc2).is_ok())
+                {
+                    std::advance(iter, loc2.get_location()); // skip escaped newline and indent
+                    // now iter points non-WS char
+                    assert(iter == str.end() || (*iter != ' ' && *iter != '\t'));
+                }
+                else // normal escape seq.
+                {
+                    auto esc = parse_escape_sequence(loc2, ctx);
+
+                    // syntax does not check its value. the unicode codepoint may be
+                    // invalid, e.g. out-of-bound, [0xD800, 0xDFFF]
+                    if(esc.is_err())
+                    {
+                        return err(esc.unwrap_err());
+                    }
+
+                    val += esc.unwrap();
+                    std::advance(iter, loc2.get_location());
+                }
+            }
+            else // we already checked the syntax. we don't need to check it again.
+            {
+                val += static_cast<typename string_type::value_type>(*iter);
+                ++iter;
+            }
+        }
+    }
+
+    return ok(basic_value<TC>(
+            std::move(val), std::move(fmt), {}, std::move(reg)
+        ));
+}
+
+template<typename TC>
+result<std::pair<typename basic_value<TC>::string_type, region>, error_info>
+parse_basic_string_only(location& loc, const context<TC>& ctx)
+{
+    const auto first = loc;
+    const auto& spec = ctx.toml_spec();
+
+    auto reg = syntax::basic_string(spec).scan(loc);
+    if( ! reg.is_ok())
+    {
+        return err(make_syntax_error("toml::parse_basic_string: "
+            "invalid string format",
+            syntax::basic_string(spec), loc));
+    }
+
+    // ----------------------------------------------------------------------
+    // it matches. gen value
+
+    auto str = reg.as_string();
+
+    assert(str.back() == '\"');
+    str.pop_back();
+    assert(str.at(0) == '\"');
+    str.erase(0, 1);
+
+    using string_type = typename basic_value<TC>::string_type;
+    using char_type   = typename string_type::value_type;
+    string_type val;
+
+    {
+        auto iter = str.begin();
+        while(iter != str.end())
+        {
+            if(*iter == '\\')
+            {
+                auto loc2 = make_temporary_location(make_string(iter, str.end()));
+
+                auto esc = parse_escape_sequence(loc2, ctx);
+
+                // syntax does not check its value. the unicode codepoint may be
+                // invalid, e.g. out-of-bound, [0xD800, 0xDFFF]
+                if(esc.is_err())
+                {
+                    return err(esc.unwrap_err());
+                }
+
+                val += esc.unwrap();
+                std::advance(iter, loc2.get_location());
+            }
+            else
+            {
+                val += char_type(*iter); // we already checked the syntax.
+                ++iter;
+            }
+        }
+    }
+    return ok(std::make_pair(val, reg));
+}
+
+template<typename TC>
+result<basic_value<TC>, error_info>
+parse_basic_string(location& loc, const context<TC>& ctx)
+{
+    const auto first = loc;
+
+    string_format_info fmt;
+    fmt.fmt = string_format::basic;
+
+    auto val_res = parse_basic_string_only(loc, ctx);
+    if(val_res.is_err())
+    {
+        return err(std::move(val_res.unwrap_err()));
+    }
+    auto val = std::move(val_res.unwrap().first );
+    auto reg = std::move(val_res.unwrap().second);
+
+    return ok(basic_value<TC>(std::move(val), std::move(fmt), {}, std::move(reg)));
+}
+
+template<typename TC>
+result<basic_value<TC>, error_info>
+parse_ml_literal_string(location& loc, const context<TC>& ctx)
+{
+    const auto first = loc;
+    const auto& spec = ctx.toml_spec();
+
+    string_format_info fmt;
+    fmt.fmt = string_format::multiline_literal;
+
+    auto reg = syntax::ml_literal_string(spec).scan(loc);
+    if( ! reg.is_ok())
+    {
+        return err(make_syntax_error("toml::parse_ml_literal_string: "
+            "invalid string format",
+            syntax::ml_literal_string(spec), loc));
+    }
+
+    // ----------------------------------------------------------------------
+    // it matches. gen value
+
+    auto str = reg.as_string();
+
+    assert(str.substr(0, 3) == "'''");
+    assert(str.substr(str.size()-3, 3) == "'''");
+    str.erase(0, 3);
+    str.erase(str.size()-3, 3);
+
+    // the first newline just after """ is trimmed
+    if(str.size() >= 1 && str.at(0) == '\n')
+    {
+        str.erase(0, 1);
+        fmt.start_with_newline = true;
+    }
+    else if(str.size() >= 2 && str.at(0) == '\r' && str.at(1) == '\n')
+    {
+        str.erase(0, 2);
+        fmt.start_with_newline = true;
+    }
+
+    using string_type = typename basic_value<TC>::string_type;
+    string_type val(str.begin(), str.end());
+
+    return ok(basic_value<TC>(
+            std::move(val), std::move(fmt), {}, std::move(reg)
+        ));
+}
+
+template<typename TC>
+result<std::pair<typename basic_value<TC>::string_type, region>, error_info>
+parse_literal_string_only(location& loc, const context<TC>& ctx)
+{
+    const auto first = loc;
+    const auto& spec = ctx.toml_spec();
+
+    auto reg = syntax::literal_string(spec).scan(loc);
+    if( ! reg.is_ok())
+    {
+        return err(make_syntax_error("toml::parse_literal_string: "
+            "invalid string format",
+            syntax::literal_string(spec), loc));
+    }
+
+    // ----------------------------------------------------------------------
+    // it matches. gen value
+
+    auto str = reg.as_string();
+
+    assert(str.back() == '\'');
+    str.pop_back();
+    assert(str.at(0) == '\'');
+    str.erase(0, 1);
+
+    using string_type = typename basic_value<TC>::string_type;
+    string_type val(str.begin(), str.end());
+
+    return ok(std::make_pair(std::move(val), std::move(reg)));
+}
+
+template<typename TC>
+result<basic_value<TC>, error_info>
+parse_literal_string(location& loc, const context<TC>& ctx)
+{
+    const auto first = loc;
+
+    string_format_info fmt;
+    fmt.fmt = string_format::literal;
+
+    auto val_res = parse_literal_string_only(loc, ctx);
+    if(val_res.is_err())
+    {
+        return err(std::move(val_res.unwrap_err()));
+    }
+    auto val = std::move(val_res.unwrap().first );
+    auto reg = std::move(val_res.unwrap().second);
+
+    return ok(basic_value<TC>(
+            std::move(val), std::move(fmt), {}, std::move(reg)
+        ));
+}
+
+template<typename TC>
+result<basic_value<TC>, error_info>
+parse_string(location& loc, const context<TC>& ctx)
+{
+    const auto first = loc;
+
+    if( ! loc.eof() && loc.current() == '"')
+    {
+        if(literal("\"\"\"").scan(loc).is_ok())
+        {
+            loc = first;
+            return parse_ml_basic_string(loc, ctx);
+        }
+        else
+        {
+            loc = first;
+            return parse_basic_string(loc, ctx);
+        }
+    }
+    else if( ! loc.eof() && loc.current() == '\'')
+    {
+        if(literal("'''").scan(loc).is_ok())
+        {
+            loc = first;
+            return parse_ml_literal_string(loc, ctx);
+        }
+        else
+        {
+            loc = first;
+            return parse_literal_string(loc, ctx);
+        }
+    }
+    else
+    {
+        auto src = source_location(region(loc));
+        return err(make_error_info("toml::parse_string: "
+            "not a string", std::move(src), "here"));
+    }
+}
+
+template<typename TC>
+result<basic_value<TC>, error_info>
+parse_null(location& loc, const context<TC>& ctx)
+{
+    const auto& spec = ctx.toml_spec();
+    if( ! spec.ext_null_value)
+    {
+        return err(make_error_info("toml::parse_null: "
+            "invalid spec: spec.ext_null_value must be true.",
+            source_location(region(loc)), "here"));
+    }
+
+    // ----------------------------------------------------------------------
+    // check syntax
+    auto reg = syntax::null_value(spec).scan(loc);
+    if( ! reg.is_ok())
+    {
+        return err(make_syntax_error("toml::parse_null: "
+            "invalid null: null must be lowercase. ",
+            syntax::null_value(spec), loc));
+    }
+
+    // ----------------------------------------------------------------------
+    // it matches. gen value
+
+    // ----------------------------------------------------------------------
+    // no format info for boolean
+
+    return ok(basic_value<TC>(detail::none_t{}, std::move(reg)));
+}
+
+/* ============================================================================
+ *   _  __
+ *  | |/ /___ _  _
+ *  | ' </ -_) || |
+ *  |_|\_\___|\_, |
+ *            |__/
+ */
+
+// non-dotted key.
+template<typename TC>
+result<typename basic_value<TC>::key_type, error_info>
+parse_simple_key(location& loc, const context<TC>& ctx)
+{
+    using key_type = typename basic_value<TC>::key_type;
+    const auto& spec = ctx.toml_spec();
+
+    if(loc.current() == '\"')
+    {
+        auto str_res = parse_basic_string_only(loc, ctx);
+        if(str_res.is_ok())
+        {
+            return ok(std::move(str_res.unwrap().first));
+        }
+        else
+        {
+            return err(std::move(str_res.unwrap_err()));
+        }
+    }
+    else if(loc.current() == '\'')
+    {
+        auto str_res = parse_literal_string_only(loc, ctx);
+        if(str_res.is_ok())
+        {
+            return ok(std::move(str_res.unwrap().first));
+        }
+        else
+        {
+            return err(std::move(str_res.unwrap_err()));
+        }
+    }
+
+    // bare key.
+
+    if(const auto bare = syntax::unquoted_key(spec).scan(loc))
+    {
+        return ok(string_conv<key_type>(bare.as_string()));
+    }
+    else
+    {
+        std::string postfix;
+        if(spec.v1_1_0_allow_non_english_in_bare_keys)
+        {
+            postfix = "Hint: Not all Unicode characters are allowed as bare key.\n";
+        }
+        else
+        {
+            postfix = "Hint: non-ASCII scripts are allowed in toml v1.1.0, but not in v1.0.0.\n";
+        }
+        return err(make_syntax_error("toml::parse_simple_key: "
+            "invalid key: key must be \"quoted\", 'quoted-literal', or bare key.",
+            syntax::unquoted_key(spec), loc, postfix));
+    }
+}
+
+// dotted key become vector of keys
+template<typename TC>
+result<std::pair<std::vector<typename basic_value<TC>::key_type>, region>, error_info>
+parse_key(location& loc, const context<TC>& ctx)
+{
+    const auto first = loc;
+    const auto& spec = ctx.toml_spec();
+
+    using key_type = typename basic_value<TC>::key_type;
+    std::vector<key_type> keys;
+    while( ! loc.eof())
+    {
+        auto key = parse_simple_key(loc, ctx);
+        if( ! key.is_ok())
+        {
+            return err(key.unwrap_err());
+        }
+        keys.push_back(std::move(key.unwrap()));
+
+        auto reg = syntax::dot_sep(spec).scan(loc);
+        if( ! reg.is_ok())
+        {
+            break;
+        }
+    }
+    if(keys.empty())
+    {
+        auto src = source_location(region(first));
+        return err(make_error_info("toml::parse_key: expected a new key, "
+                    "but got nothing", std::move(src), "reached EOF"));
+    }
+
+    return ok(std::make_pair(std::move(keys), region(first, loc)));
+}
+
+// ============================================================================
+
+// forward-decl to implement parse_array and parse_table
+template<typename TC>
+result<basic_value<TC>, error_info>
+parse_value(location&, context<TC>& ctx);
+
+template<typename TC>
+result<std::pair<
+        std::pair<std::vector<typename basic_value<TC>::key_type>, region>,
+        basic_value<TC>
+    >, error_info>
+parse_key_value_pair(location& loc, context<TC>& ctx)
+{
+    const auto first = loc;
+    const auto& spec = ctx.toml_spec();
+
+    auto key_res = parse_key(loc, ctx);
+    if(key_res.is_err())
+    {
+        loc = first;
+        return err(key_res.unwrap_err());
+    }
+
+    if( ! syntax::keyval_sep(spec).scan(loc).is_ok())
+    {
+        auto e = make_syntax_error("toml::parse_key_value_pair: "
+            "invalid key value separator `=`", syntax::keyval_sep(spec), loc);
+        loc = first;
+        return err(std::move(e));
+    }
+
+    auto v_res = parse_value(loc, ctx);
+    if(v_res.is_err())
+    {
+        // loc = first;
+        return err(v_res.unwrap_err());
+    }
+    return ok(std::make_pair(std::move(key_res.unwrap()), std::move(v_res.unwrap())));
+}
+
+/* ============================================================================
+ *    __ _ _ _ _ _ __ _ _  _
+ *   / _` | '_| '_/ _` | || |
+ *   \__,_|_| |_| \__,_|\_, |
+ *                      |__/
+ */
+
+// array(and multiline inline table with `{` and `}`) has the following format.
+// `[`
+// (ws|newline|comment-line)? (value) (ws|newline|comment-line)? `,`
+// (ws|newline|comment-line)? (value) (ws|newline|comment-line)? `,`
+// ...
+// (ws|newline|comment-line)? (value) (ws|newline|comment-line)? (`,`)?
+// (ws|newline|comment-line)? `]`
+// it skips (ws|newline|comment-line) and returns the token.
+template<typename TC>
+struct multiline_spacer
+{
+    using comment_type = typename TC::comment_type;
+    bool         newline_found;
+    indent_char  indent_type;
+    std::int32_t indent;
+    comment_type comments;
+};
+template<typename T>
+std::ostream& operator<<(std::ostream& os, const multiline_spacer<T>& sp)
+{
+    os << "{newline="    << sp.newline_found << ", ";
+    os << "indent_type=" << sp.indent_type << ", ";
+    os << "indent="      << sp.indent << ", ";
+    os << "comments="    << sp.comments.size() << "}";
+    return os;
+}
+
+template<typename TC>
+cxx::optional<multiline_spacer<TC>>
+skip_multiline_spacer(location& loc, context<TC>& ctx, const bool newline_found = false)
+{
+    const auto& spec = ctx.toml_spec();
+
+    multiline_spacer<TC> spacer;
+    spacer.newline_found = newline_found;
+    spacer.indent_type   = indent_char::none;
+    spacer.indent        = 0;
+    spacer.comments.clear();
+
+    bool spacer_found = false;
+    while( ! loc.eof())
+    {
+        if(auto comm = sequence(syntax::comment(spec), syntax::newline(spec)).scan(loc))
+        {
+            spacer.newline_found = true;
+            auto comment = comm.as_string();
+            if( ! comment.empty() && comment.back() == '\n')
+            {
+                comment.pop_back();
+                if (!comment.empty() && comment.back() == '\r')
+                {
+                    comment.pop_back();
+                }
+            }
+
+            spacer.comments.push_back(std::move(comment));
+            spacer.indent_type = indent_char::none;
+            spacer.indent = 0;
+            spacer_found = true;
+        }
+        else if(auto nl = syntax::newline(spec).scan(loc))
+        {
+            spacer.newline_found = true;
+            spacer.comments.clear();
+            spacer.indent_type = indent_char::none;
+            spacer.indent = 0;
+            spacer_found = true;
+        }
+        else if(auto sp = repeat_at_least(1, character(cxx::bit_cast<location::char_type>(' '))).scan(loc))
+        {
+            spacer.indent_type = indent_char::space;
+            spacer.indent      = static_cast<std::int32_t>(sp.length());
+            spacer_found = true;
+        }
+        else if(auto tabs = repeat_at_least(1, character(cxx::bit_cast<location::char_type>('\t'))).scan(loc))
+        {
+            spacer.indent_type = indent_char::tab;
+            spacer.indent      = static_cast<std::int32_t>(tabs.length());
+            spacer_found = true;
+        }
+        else
+        {
+            break; // done
+        }
+    }
+    if( ! spacer_found)
+    {
+        return cxx::make_nullopt();
+    }
+    return spacer;
+}
+
+// not an [[array.of.tables]]. It parses ["this", "type"]
+template<typename TC>
+result<basic_value<TC>, error_info>
+parse_array(location& loc, context<TC>& ctx)
+{
+    const auto num_errors = ctx.errors().size();
+
+    const auto first = loc;
+
+    if(loc.eof() || loc.current() != '[')
+    {
+        auto src = source_location(region(loc));
+        return err(make_error_info("toml::parse_array: "
+                "The next token is not an array", std::move(src), "here"));
+    }
+    loc.advance();
+
+    typename basic_value<TC>::array_type val;
+
+    array_format_info fmt;
+    fmt.fmt = array_format::oneline;
+    fmt.indent_type = indent_char::none;
+
+    auto spacer = skip_multiline_spacer(loc, ctx);
+    if(spacer.has_value() && spacer.value().newline_found)
+    {
+        fmt.fmt = array_format::multiline;
+    }
+
+    bool comma_found = true;
+    while( ! loc.eof())
+    {
+        if(loc.current() == location::char_type(']'))
+        {
+            if(spacer.has_value() && spacer.value().newline_found &&
+                spacer.value().indent_type != indent_char::none)
+            {
+                fmt.indent_type    = spacer.value().indent_type;
+                fmt.closing_indent = spacer.value().indent;
+            }
+            break;
+        }
+
+        if( ! comma_found)
+        {
+            auto src = source_location(region(loc));
+            return err(make_error_info("toml::parse_array: "
+                    "expected value-separator `,` or closing `]`",
+                    std::move(src), "here"));
+        }
+
+        if(spacer.has_value() && spacer.value().newline_found &&
+            spacer.value().indent_type != indent_char::none)
+        {
+            fmt.indent_type = spacer.value().indent_type;
+            fmt.body_indent = spacer.value().indent;
+        }
+
+        if(auto elem_res = parse_value(loc, ctx))
+        {
+            auto elem = std::move(elem_res.unwrap());
+
+            if(spacer.has_value()) // copy previous comments to value
+            {
+                elem.comments() = std::move(spacer.value().comments);
+            }
+
+            // parse spaces between a value and a comma
+            // array = [
+            //     42    , # the answer
+            //       ^^^^
+            //     3.14 # pi
+            //   , 2.71 ^^^^
+            // ^^
+            spacer = skip_multiline_spacer(loc, ctx);
+            if(spacer.has_value())
+            {
+                for(std::size_t i=0; i<spacer.value().comments.size(); ++i)
+                {
+                    elem.comments().push_back(std::move(spacer.value().comments.at(i)));
+                }
+                if(spacer.value().newline_found)
+                {
+                    fmt.fmt = array_format::multiline;
+                }
+            }
+
+            comma_found = character(',').scan(loc).is_ok();
+
+            // parse comment after a comma
+            // array = [
+            //     42    , # the answer
+            //             ^^^^^^^^^^^^
+            //     3.14 # pi
+            //          ^^^^
+            // ]
+            auto com_res = parse_comment_line(loc, ctx);
+            if(com_res.is_err())
+            {
+                ctx.report_error(com_res.unwrap_err());
+            }
+
+            const bool comment_found = com_res.is_ok() && com_res.unwrap().has_value();
+            if(comment_found)
+            {
+                fmt.fmt = array_format::multiline;
+                elem.comments().push_back(com_res.unwrap().value());
+            }
+            if(comma_found)
+            {
+                spacer = skip_multiline_spacer(loc, ctx, comment_found);
+                if(spacer.has_value() && spacer.value().newline_found)
+                {
+                    fmt.fmt = array_format::multiline;
+                }
+            }
+            val.push_back(std::move(elem));
+        }
+        else
+        {
+            // if err, push error to ctx and try recovery.
+            ctx.report_error(std::move(elem_res.unwrap_err()));
+
+            // if it looks like some value, then skip the value.
+            // otherwise, it may be a new key-value pair or a new table and
+            // the error is "missing closing ]". stop parsing.
+
+            const auto before_skip = loc.get_location();
+            skip_value(loc, ctx);
+            if(before_skip == loc.get_location()) // cannot skip! break...
+            {
+                break;
+            }
+        }
+    }
+
+    if(loc.current() != ']')
+    {
+        auto src = source_location(region(loc));
+        return err(make_error_info("toml::parse_array: missing closing bracket `]`",
+            std::move(src), "expected `]`, reached EOF"));
+    }
+    else
+    {
+        loc.advance();
+    }
+    // any error reported from this function
+    if(num_errors != ctx.errors().size())
+    {
+        assert(ctx.has_error()); // already reported
+        return err(ctx.errors().back());
+    }
+
+    return ok(basic_value<TC>(
+            std::move(val), std::move(fmt), {}, region(first, loc)
+        ));
+}
+
+/* ============================================================================
+ *   _      _ _            _        _    _
+ *  (_)_ _ | (_)_ _  ___  | |_ __ _| |__| |___
+ *  | | ' \| | | ' \/ -_) |  _/ _` | '_ \ / -_)
+ *  |_|_||_|_|_|_||_\___|  \__\__,_|_.__/_\___|
+ */
+
+// ----------------------------------------------------------------------------
+// insert_value is the most complicated part of the toml spec.
+//
+// To parse a toml file correctly, we sometimes need to check an exising value
+// is appendable or not.
+//
+// For example while parsing an inline array of tables,
+//
+// ```toml
+// aot = [
+//   {a = "foo"},
+//   {a = "bar", b = "baz"},
+// ]
+// ```
+//
+// this `aot` is appendable until parser reaches to `]`. After that, it becomes
+// non-appendable.
+//
+// On the other hand, a normal array of tables, such as
+//
+// ```toml
+// [[aot]]
+// a = "foo"
+//
+// [[aot]]
+// a = "bar"
+// b = "baz"
+// ```
+// This `[[aot]]` is appendable until the parser reaches to the EOF.
+//
+//
+// It becomes a bit more difficult in case of dotted keys.
+// In TOML, it is allowed to append a key-value pair to a table that is
+// *implicitly* defined by a subtable definitino.
+//
+// ```toml
+// [x.y.z]
+// w = 123
+//
+// [x]
+// a = "foo" # OK. x is defined implicitly by `[x.y.z]`.
+// ```
+//
+// But if the table is defined by a dotted keys, it is not appendable.
+//
+// ```toml
+// [x]
+// y.z.w = 123
+//
+// [x.y]
+// # ERROR. x.y is already defined by a dotted table in the previous table.
+// ```
+//
+// Also, reopening a table using dotted keys is invalid.
+//
+// ```toml
+// [x.y.z]
+// w = 123
+//
+// [x]
+// y.z.v = 42 # ERROR. [x.y.z] is already defined.
+// ```
+//
+//
+// ```toml
+// [a]
+// b.c = "foo"
+// b.d = "bar"
+// ```
+//
+//
+// ```toml
+// a.b = "foo"
+// [a]
+// c = "bar" # ERROR
+// ```
+//
+// In summary,
+// - a table must be defined only once.
+// - assignment to an exising table is possible only when:
+//   - defining a subtable [x.y] to an existing table [x].
+//   - defining supertable [x] explicitly after [x.y].
+//   - adding dotted keys in the same table.
+
+enum class inserting_value_kind : std::uint8_t
+{
+    std_table,   // insert [standard.table]
+    array_table, // insert [[array.of.tables]]
+    dotted_keys  // insert a.b.c = "this"
+};
+
+template<typename TC>
+result<basic_value<TC>*, error_info>
+insert_value(const inserting_value_kind kind,
+    typename basic_value<TC>::table_type* current_table_ptr,
+    const std::vector<typename basic_value<TC>::key_type>& keys, region key_reg,
+    basic_value<TC> val)
+{
+    using value_type = basic_value<TC>;
+    using array_type = typename basic_value<TC>::array_type;
+    using table_type = typename basic_value<TC>::table_type;
+
+    auto key_loc = source_location(key_reg);
+
+    assert( ! keys.empty());
+
+    // dotted key can insert to dotted key tables defined at the same level.
+    // dotted key can NOT reopen a table even if it is implcitly-defined one.
+    //
+    // [x.y.z] # define x and x.y implicitly.
+    // a = 42
+    //
+    // [x] # reopening implcitly defined table
+    // r.s.t = 3.14 # VALID r and r.s are new tables.
+    // r.s.u = 2.71 # VALID r and r.s are dotted-key tables. valid.
+    //
+    // y.z.b = "foo" # INVALID x.y.z are multiline table, not a dotted key.
+    // y.c   = "bar" # INVALID x.y is implicit multiline table, not a dotted key.
+
+    // a table cannot reopen dotted-key tables.
+    //
+    // [t1]
+    // t2.t3.v = 0
+    // [t1.t2] # INVALID t1.t2 is defined as a dotted-key table.
+
+    for(std::size_t i=0; i<keys.size(); ++i)
+    {
+        const auto& key = keys.at(i);
+        table_type& current_table = *current_table_ptr;
+
+        if(i+1 < keys.size()) // there are more keys. go down recursively...
+        {
+            const auto found = current_table.find(key);
+            if(found == current_table.end()) // not found. add new table
+            {
+                table_format_info fmt;
+                fmt.indent_type = indent_char::none;
+                if(kind == inserting_value_kind::dotted_keys)
+                {
+                    fmt.fmt = table_format::dotted;
+                }
+                else // table / array of tables
+                {
+                    fmt.fmt = table_format::implicit;
+                }
+                current_table.emplace(key, value_type(
+                    table_type{}, fmt, std::vector<std::string>{}, key_reg));
+
+                assert(current_table.at(key).is_table());
+                current_table_ptr = std::addressof(current_table.at(key).as_table());
+            }
+            else if (found->second.is_table())
+            {
+                const auto fmt = found->second.as_table_fmt().fmt;
+                if(fmt == table_format::oneline || fmt == table_format::multiline_oneline)
+                {
+                    // foo = {bar = "baz"} or foo = { \n bar = "baz" \n }
+                    return err(make_error_info("toml::insert_value: "
+                        "failed to insert a value: inline table is immutable",
+                        key_loc, "inserting this",
+                        found->second.location(), "to this table"));
+                }
+                // dotted key cannot reopen a table.
+                if(kind ==inserting_value_kind::dotted_keys && fmt != table_format::dotted)
+                {
+                    return err(make_error_info("toml::insert_value: "
+                        "reopening a table using dotted keys",
+                        key_loc, "dotted key cannot reopen a table",
+                        found->second.location(), "this table is already closed"));
+                }
+                assert(found->second.is_table());
+                current_table_ptr = std::addressof(found->second.as_table());
+            }
+            else if(found->second.is_array_of_tables())
+            {
+                // aot = [{this = "type", of = "aot"}] # cannot be reopened
+                if(found->second.as_array_fmt().fmt != array_format::array_of_tables)
+                {
+                    return err(make_error_info("toml::insert_value:"
+                        "inline array of tables are immutable",
+                        key_loc, "inserting this",
+                        found->second.location(), "inline array of tables"));
+                }
+                // appending to [[aot]]
+
+                if(kind == inserting_value_kind::dotted_keys)
+                {
+                    // [[array.of.tables]]
+                    // [array.of]          # reopening supertable is okay
+                    // tables.x = "foo"    # appending `x` to the first table
+                    return err(make_error_info("toml::insert_value:"
+                        "dotted key cannot reopen an array-of-tables",
+                        key_loc, "inserting this",
+                        found->second.location(), "to this array-of-tables."));
+                }
+
+                // insert_value_by_dotkeys::std_table
+                // [[array.of.tables]]
+                // [array.of.tables.subtable] # appending to the last aot
+                //
+                // insert_value_by_dotkeys::array_table
+                // [[array.of.tables]]
+                // [[array.of.tables.subtable]] # appending to the last aot
+                auto& current_array_table = found->second.as_array().back();
+
+                assert(current_array_table.is_table());
+                current_table_ptr = std::addressof(current_array_table.as_table());
+            }
+            else
+            {
+                return err(make_error_info("toml::insert_value: "
+                    "failed to insert a value, value already exists",
+                    key_loc, "while inserting this",
+                    found->second.location(), "non-table value already exists"));
+            }
+        }
+        else // this is the last key. insert a new value.
+        {
+            switch(kind)
+            {
+                case inserting_value_kind::dotted_keys:
+                {
+                    if(current_table.find(key) != current_table.end())
+                    {
+                        return err(make_error_info("toml::insert_value: "
+                            "failed to insert a value, value already exists",
+                            key_loc, "inserting this",
+                            current_table.at(key).location(), "but value already exists"));
+                    }
+                    current_table.emplace(key, std::move(val));
+                    return ok(std::addressof(current_table.at(key)));
+                }
+                case inserting_value_kind::std_table:
+                {
+                    // defining a new table or reopening supertable
+                    auto found = current_table.find(key);
+                    if(found == current_table.end()) // define a new aot
+                    {
+                        current_table.emplace(key, std::move(val));
+                        return ok(std::addressof(current_table.at(key)));
+                    }
+                    else // the table is already defined, reopen it
+                    {
+                        // assigning a [std.table]. it must be an implicit table.
+                        auto& target = found->second;
+                        if( ! target.is_table() || // could be an array-of-tables
+                            target.as_table_fmt().fmt != table_format::implicit)
+                        {
+                            return err(make_error_info("toml::insert_value: "
+                                "failed to insert a table, table already defined",
+                                key_loc, "inserting this",
+                                target.location(), "this table is explicitly defined"));
+                        }
+
+                        // merge table
+                        for(const auto& kv : val.as_table())
+                        {
+                            if(target.contains(kv.first))
+                            {
+                                // [x.y.z]
+                                // w = "foo"
+                                // [x]
+                                // y = "bar"
+                                return err(make_error_info("toml::insert_value: "
+                                    "failed to insert a table, table keys conflict to each other",
+                                    key_loc, "inserting this table",
+                                    kv.second.location(), "having this value",
+                                    target.at(kv.first).location(), "already defined here"));
+                            }
+                            else
+                            {
+                                target[kv.first] = kv.second;
+                            }
+                        }
+                        // change implicit -> explicit
+                        target.as_table_fmt().fmt = table_format::multiline;
+                        // change definition region
+                        change_region_of_value(target, val);
+
+                        return ok(std::addressof(current_table.at(key)));
+                    }
+                }
+                case inserting_value_kind::array_table:
+                {
+                    auto found = current_table.find(key);
+                    if(found == current_table.end()) // define a new aot
+                    {
+                        array_format_info fmt;
+                        fmt.fmt = array_format::array_of_tables;
+                        fmt.indent_type = indent_char::none;
+
+                        current_table.emplace(key, value_type(
+                                array_type{ std::move(val) }, std::move(fmt),
+                                std::vector<std::string>{}, std::move(key_reg)
+                            ));
+
+                        assert( ! current_table.at(key).as_array().empty());
+                        return ok(std::addressof(current_table.at(key).as_array().back()));
+                    }
+                    else // the array is already defined, append to it
+                    {
+                        if( ! found->second.is_array_of_tables())
+                        {
+                            return err(make_error_info("toml::insert_value: "
+                                "failed to insert an array of tables, value already exists",
+                                key_loc, "while inserting this",
+                                found->second.location(), "non-table value already exists"));
+                        }
+                        if(found->second.as_array_fmt().fmt != array_format::array_of_tables)
+                        {
+                            return err(make_error_info("toml::insert_value: "
+                                "failed to insert a table, inline array of tables is immutable",
+                                key_loc, "while inserting this",
+                                found->second.location(), "this is inline array-of-tables"));
+                        }
+                        found->second.as_array().push_back(std::move(val));
+                        assert( ! current_table.at(key).as_array().empty());
+                        return ok(std::addressof(current_table.at(key).as_array().back()));
+                    }
+                }
+                default: {assert(false);}
+            }
+        }
+    }
+    return err(make_error_info("toml::insert_key: no keys found",
+                std::move(key_loc), "here"));
+}
+
+// ----------------------------------------------------------------------------
+
+template<typename TC>
+result<basic_value<TC>, error_info>
+parse_inline_table(location& loc, context<TC>& ctx)
+{
+    using table_type = typename basic_value<TC>::table_type;
+
+    const auto num_errors = ctx.errors().size();
+
+    const auto first = loc;
+    const auto& spec = ctx.toml_spec();
+
+    if(loc.eof() || loc.current() != '{')
+    {
+        auto src = source_location(region(loc));
+        return err(make_error_info("toml::parse_inline_table: "
+            "The next token is not an inline table", std::move(src), "here"));
+    }
+    loc.advance();
+
+    table_type table;
+    table_format_info fmt;
+    fmt.fmt = table_format::oneline;
+    fmt.indent_type = indent_char::none;
+
+    cxx::optional<multiline_spacer<TC>> spacer(cxx::make_nullopt());
+
+    if(spec.v1_1_0_allow_newlines_in_inline_tables)
+    {
+        spacer = skip_multiline_spacer(loc, ctx);
+        if(spacer.has_value() && spacer.value().newline_found)
+        {
+            fmt.fmt = table_format::multiline_oneline;
+        }
+    }
+    else
+    {
+        skip_whitespace(loc, ctx);
+    }
+
+    bool still_empty = true;
+    bool comma_found = false;
+    while( ! loc.eof())
+    {
+        // closing!
+        if(loc.current() == '}')
+        {
+            if(comma_found && ! spec.v1_1_0_allow_trailing_comma_in_inline_tables)
+            {
+                auto src = source_location(region(loc));
+                return err(make_error_info("toml::parse_inline_table: trailing "
+                    "comma is not allowed in TOML-v1.0.0)", std::move(src), "here"));
+            }
+
+            if(spec.v1_1_0_allow_newlines_in_inline_tables)
+            {
+                if(spacer.has_value() && spacer.value().newline_found &&
+                    spacer.value().indent_type != indent_char::none)
+                {
+                    fmt.indent_type    = spacer.value().indent_type;
+                    fmt.closing_indent = spacer.value().indent;
+                }
+            }
+            break;
+        }
+
+        // if we already found a value and didn't found `,` nor `}`, error.
+        if( ! comma_found && ! still_empty)
+        {
+            auto src = source_location(region(loc));
+            return err(make_error_info("toml::parse_inline_table: "
+                    "expected value-separator `,` or closing `}`",
+                    std::move(src), "here"));
+        }
+
+        // parse indent.
+        if(spacer.has_value() && spacer.value().newline_found &&
+            spacer.value().indent_type != indent_char::none)
+        {
+            fmt.indent_type = spacer.value().indent_type;
+            fmt.body_indent = spacer.value().indent;
+        }
+
+        still_empty = false; // parsing a value...
+        if(auto kv_res = parse_key_value_pair<TC>(loc, ctx))
+        {
+            auto keys    = std::move(kv_res.unwrap().first.first);
+            auto key_reg = std::move(kv_res.unwrap().first.second);
+            auto val     = std::move(kv_res.unwrap().second);
+
+            auto ins_res = insert_value(inserting_value_kind::dotted_keys,
+                std::addressof(table), keys, std::move(key_reg), std::move(val));
+            if(ins_res.is_err())
+            {
+                ctx.report_error(std::move(ins_res.unwrap_err()));
+                // we need to skip until the next value (or end of the table)
+                // because we don't have valid kv pair.
+                while( ! loc.eof())
+                {
+                    const auto c = loc.current();
+                    if(c == ',' || c == '\n' || c == '}')
+                    {
+                        comma_found = (c == ',');
+                        break;
+                    }
+                    loc.advance();
+                }
+                continue;
+            }
+
+            // if comment line follows immediately(without newline) after `,`, then
+            // the comment is for the elem. we need to check if comment follows `,`.
+            //
+            // (key) = (val) (ws|newline|comment-line)? `,` (ws)? (comment)?
+
+            if(spec.v1_1_0_allow_newlines_in_inline_tables)
+            {
+                if(spacer.has_value()) // copy previous comments to value
+                {
+                    for(std::size_t i=0; i<spacer.value().comments.size(); ++i)
+                    {
+                        ins_res.unwrap()->comments().push_back(spacer.value().comments.at(i));
+                    }
+                }
+                spacer = skip_multiline_spacer(loc, ctx);
+                if(spacer.has_value())
+                {
+                    for(std::size_t i=0; i<spacer.value().comments.size(); ++i)
+                    {
+                        ins_res.unwrap()->comments().push_back(spacer.value().comments.at(i));
+                    }
+                    if(spacer.value().newline_found)
+                    {
+                        fmt.fmt = table_format::multiline_oneline;
+                        if(spacer.value().indent_type != indent_char::none)
+                        {
+                            fmt.indent_type = spacer.value().indent_type;
+                            fmt.body_indent = spacer.value().indent;
+                        }
+                    }
+                }
+            }
+            else
+            {
+                skip_whitespace(loc, ctx);
+            }
+
+            comma_found = character(',').scan(loc).is_ok();
+
+            if(spec.v1_1_0_allow_newlines_in_inline_tables)
+            {
+                auto com_res = parse_comment_line(loc, ctx);
+                if(com_res.is_err())
+                {
+                    ctx.report_error(com_res.unwrap_err());
+                }
+                const bool comment_found = com_res.is_ok() && com_res.unwrap().has_value();
+                if(comment_found)
+                {
+                    fmt.fmt = table_format::multiline_oneline;
+                    ins_res.unwrap()->comments().push_back(com_res.unwrap().value());
+                }
+                if(comma_found)
+                {
+                    spacer = skip_multiline_spacer(loc, ctx, comment_found);
+                    if(spacer.has_value() && spacer.value().newline_found)
+                    {
+                        fmt.fmt = table_format::multiline_oneline;
+                    }
+                }
+            }
+            else
+            {
+                skip_whitespace(loc, ctx);
+            }
+        }
+        else
+        {
+            ctx.report_error(std::move(kv_res.unwrap_err()));
+            while( ! loc.eof())
+            {
+                if(loc.current() == '}')
+                {
+                    break;
+                }
+                if( ! spec.v1_1_0_allow_newlines_in_inline_tables && loc.current() == '\n')
+                {
+                    break;
+                }
+                loc.advance();
+            }
+            break;
+        }
+    }
+
+    if(loc.current() != '}')
+    {
+        auto src = source_location(region(loc));
+        return err(make_error_info("toml::parse_inline_table: "
+            "missing closing bracket `}`",
+            std::move(src), "expected `}`, reached line end"));
+    }
+    else
+    {
+        loc.advance(); // skip }
+    }
+
+    // any error reported from this function
+    if(num_errors < ctx.errors().size())
+    {
+        assert(ctx.has_error()); // already reported
+        return err(ctx.pop_last_error());
+    }
+
+    basic_value<TC> retval(
+        std::move(table), std::move(fmt), {}, region(first, loc));
+
+    return ok(std::move(retval));
+}
+
+/* ============================================================================
+ *            _
+ *  __ ____ _| |_  _ ___
+ *  \ V / _` | | || / -_)
+ *   \_/\__,_|_|\_,_\___|
+ */
+
+template<typename TC>
+result<value_t, error_info>
+guess_number_type(const location& first, const context<TC>& ctx)
+{
+    const auto& spec = ctx.toml_spec();
+    location loc = first;
+
+    if(syntax::offset_datetime(spec).scan(loc).is_ok())
+    {
+        return ok(value_t::offset_datetime);
+    }
+    loc = first;
+
+    if(syntax::local_datetime(spec).scan(loc).is_ok())
+    {
+        const auto curr = loc.current();
+        // if offset_datetime contains bad offset, it syntax::offset_datetime
+        // fails to scan it.
+        if(curr == '+' || curr == '-')
+        {
+            return err(make_syntax_error("bad offset: must be [+-]HH:MM or Z",
+                syntax::time_offset(spec), loc, std::string(
+                "Hint: valid  : +09:00, -05:30\n"
+                "Hint: invalid: +9:00,  -5:30\n")));
+        }
+        return ok(value_t::local_datetime);
+    }
+    loc = first;
+
+    if(syntax::local_date(spec).scan(loc).is_ok())
+    {
+        // bad time may appear after this.
+
+        if( ! loc.eof())
+        {
+            const auto c = loc.current();
+            if(c == 'T' || c == 't')
+            {
+                loc.advance();
+
+                return err(make_syntax_error("bad time: must be HH:MM:SS.subsec",
+                    syntax::local_time(spec), loc, std::string(
+                    "Hint: valid  : 1979-05-27T07:32:00, 1979-05-27 07:32:00.999999\n"
+                    "Hint: invalid: 1979-05-27T7:32:00, 1979-05-27 17:32\n")));
+            }
+            if(c == ' ')
+            {
+                // A space is allowed as a delimiter between local time.
+                // But there is a case where bad time follows a space.
+                // - invalid: 2019-06-16 7:00:00
+                // - valid  : 2019-06-16 07:00:00
+                loc.advance();
+                if( ! loc.eof() && ('0' <= loc.current() && loc.current() <= '9'))
+                {
+                    return err(make_syntax_error("bad time: must be HH:MM:SS.subsec",
+                        syntax::local_time(spec), loc, std::string(
+                        "Hint: valid  : 1979-05-27T07:32:00, 1979-05-27 07:32:00.999999\n"
+                        "Hint: invalid: 1979-05-27T7:32:00, 1979-05-27 17:32\n")));
+                }
+            }
+            if('0' <= c && c <= '9')
+            {
+                return err(make_syntax_error("bad datetime: missing T or space",
+                    character_either{'T', 't', ' '}, loc, std::string(
+                    "Hint: valid  : 1979-05-27T07:32:00, 1979-05-27 07:32:00.999999\n"
+                    "Hint: invalid: 1979-05-27T7:32:00, 1979-05-27 17:32\n")));
+            }
+        }
+        return ok(value_t::local_date);
+    }
+    loc = first;
+
+    if(syntax::local_time(spec).scan(loc).is_ok())
+    {
+        return ok(value_t::local_time);
+    }
+    loc = first;
+
+    if(syntax::floating(spec).scan(loc).is_ok())
+    {
+        if( ! loc.eof() && loc.current() == '_')
+        {
+            if(spec.ext_num_suffix && syntax::num_suffix(spec).scan(loc).is_ok())
+            {
+                return ok(value_t::floating);
+            }
+            auto src = source_location(region(loc));
+            return err(make_error_info(
+                "bad float: `_` must be surrounded by digits",
+                std::move(src), "invalid underscore",
+                "Hint: valid  : +1.0, -2e-2, 3.141_592_653_589, inf, nan\n"
+                "Hint: invalid: .0, 1., _1.0, 1.0_, 1_.0, 1.0__0\n"));
+        }
+        return ok(value_t::floating);
+    }
+    loc = first;
+
+    if(spec.ext_hex_float)
+    {
+        if(syntax::hex_floating(spec).scan(loc).is_ok())
+        {
+            if( ! loc.eof() && loc.current() == '_')
+            {
+                if(spec.ext_num_suffix && syntax::num_suffix(spec).scan(loc).is_ok())
+                {
+                    return ok(value_t::floating);
+                }
+                auto src = source_location(region(loc));
+                return err(make_error_info(
+                    "bad float: `_` must be surrounded by digits",
+                    std::move(src), "invalid underscore",
+                    "Hint: valid  : +1.0, -2e-2, 3.141_592_653_589, inf, nan\n"
+                    "Hint: invalid: .0, 1., _1.0, 1.0_, 1_.0, 1.0__0\n"));
+            }
+            return ok(value_t::floating);
+        }
+        loc = first;
+    }
+
+    if(auto int_reg = syntax::integer(spec).scan(loc))
+    {
+        if( ! loc.eof())
+        {
+            const auto c = loc.current();
+            if(c == '_')
+            {
+                if(spec.ext_num_suffix && syntax::num_suffix(spec).scan(loc).is_ok())
+                {
+                    return ok(value_t::integer);
+                }
+
+                if(int_reg.length() <= 2 && (int_reg.as_string() == "0" ||
+                    int_reg.as_string() == "-0" || int_reg.as_string() == "+0"))
+                {
+                    auto src = source_location(region(loc));
+                    return err(make_error_info(
+                        "bad integer: leading zero is not allowed in decimal int",
+                        std::move(src), "leading zero",
+                        "Hint: valid  : -42, 1_000, 1_2_3_4_5, 0xC0FFEE, 0b0010, 0o755\n"
+                        "Hint: invalid: _42, 1__000, 0123\n"));
+                }
+                else
+                {
+                    auto src = source_location(region(loc));
+                    return err(make_error_info(
+                        "bad integer: `_` must be surrounded by digits",
+                        std::move(src), "invalid underscore",
+                        "Hint: valid  : -42, 1_000, 1_2_3_4_5, 0xC0FFEE, 0b0010, 0o755\n"
+                        "Hint: invalid: _42, 1__000, 0123\n"));
+                }
+            }
+            if('0' <= c && c <= '9')
+            {
+                if(loc.current() == '0')
+                {
+                    loc.retrace();
+                    return err(make_error_info(
+                        "bad integer: leading zero",
+                        source_location(region(loc)), "leading zero is not allowed",
+                        std::string("Hint: valid  : -42, 1_000, 1_2_3_4_5, 0xC0FFEE, 0b0010, 0o755\n"
+                                    "Hint: invalid: _42, 1__000, 0123\n")
+                        ));
+                }
+                else // invalid digits, especially in oct/bin ints.
+                {
+                    return err(make_error_info(
+                        "bad integer: invalid digit after an integer",
+                        source_location(region(loc)), "this digit is not allowed",
+                        std::string("Hint: valid  : -42, 1_000, 1_2_3_4_5, 0xC0FFEE, 0b0010, 0o755\n"
+                                    "Hint: invalid: _42, 1__000, 0123\n")
+                        ));
+                }
+            }
+            if(c == ':' || c == '-')
+            {
+                auto src = source_location(region(loc));
+                return err(make_error_info("bad datetime: invalid format",
+                    std::move(src), "here",
+                    std::string("Hint: valid  : 1979-05-27T07:32:00-07:00, 1979-05-27 07:32:00.999999Z\n"
+                                "Hint: invalid: 1979-05-27T7:32:00-7:00, 1979-05-27 7:32-00:30")
+                    ));
+            }
+            if(c == '.' || c == 'e' || c == 'E')
+            {
+                auto src = source_location(region(loc));
+                return err(make_error_info("bad float: invalid format",
+                    std::move(src), "here", std::string(
+                    "Hint: valid  : +1.0, -2e-2, 3.141_592_653_589, inf, nan\n"
+                    "Hint: invalid: .0, 1., _1.0, 1.0_, 1_.0, 1.0__0\n")));
+            }
+        }
+        return ok(value_t::integer);
+    }
+    if( ! loc.eof() && loc.current() == '.')
+    {
+        auto src = source_location(region(loc));
+        return err(make_error_info("bad float: integer part is required before decimal point",
+            std::move(src), "missing integer part", std::string(
+            "Hint: valid  : +1.0, -2e-2, 3.141_592_653_589, inf, nan\n"
+            "Hint: invalid: .0, 1., _1.0, 1.0_, 1_.0, 1.0__0\n")
+            ));
+    }
+    if( ! loc.eof() && loc.current() == '_')
+    {
+        auto src = source_location(region(loc));
+        return err(make_error_info("bad number: `_` must be surrounded by digits",
+            std::move(src), "digits required before `_`", std::string(
+            "Hint: valid  : -42, 1_000, 1_2_3_4_5, 0xC0FFEE, 0b0010, 0o755\n"
+            "Hint: invalid: _42, 1__000, 0123\n")
+            ));
+    }
+
+    auto src = source_location(region(loc));
+    return err(make_error_info("bad format: unknown value appeared",
+                std::move(src), "here"));
+}
+
+template<typename TC>
+result<value_t, error_info>
+guess_value_type(const location& loc, const context<TC>& ctx)
+{
+    const auto& sp = ctx.toml_spec();
+    location inner(loc);
+
+    switch(loc.current())
+    {
+        case '"' : {return ok(value_t::string);  }
+        case '\'': {return ok(value_t::string);  }
+        case '[' : {return ok(value_t::array);   }
+        case '{' : {return ok(value_t::table);   }
+        case 't' :
+        {
+            return ok(value_t::boolean);
+        }
+        case 'f' :
+        {
+            return ok(value_t::boolean);
+        }
+        case 'T' : // invalid boolean.
+        {
+            return err(make_syntax_error("toml::parse_value: "
+                "`true` must be in lowercase. "
+                "A string must be surrounded by quotes.",
+                syntax::boolean(sp), inner));
+        }
+        case 'F' :
+        {
+            return err(make_syntax_error("toml::parse_value: "
+                "`false` must be in lowercase. "
+                "A string must be surrounded by quotes.",
+                syntax::boolean(sp), inner));
+        }
+        case 'i' : // inf or string without quotes(syntax error).
+        {
+            if(literal("inf").scan(inner).is_ok())
+            {
+                return ok(value_t::floating);
+            }
+            else
+            {
+                return err(make_syntax_error("toml::parse_value: "
+                    "`inf` must be in lowercase. "
+                    "A string must be surrounded by quotes.",
+                    syntax::floating(sp), inner));
+            }
+        }
+        case 'I' : // Inf or string without quotes(syntax error).
+        {
+            return err(make_syntax_error("toml::parse_value: "
+                "`inf` must be in lowercase. "
+                "A string must be surrounded by quotes.",
+                syntax::floating(sp), inner));
+        }
+        case 'n' : // nan or null-extension
+        {
+            if(sp.ext_null_value)
+            {
+                if(literal("nan").scan(inner).is_ok())
+                {
+                    return ok(value_t::floating);
+                }
+                else if(literal("null").scan(inner).is_ok())
+                {
+                    return ok(value_t::empty);
+                }
+                else
+                {
+                    return err(make_syntax_error("toml::parse_value: "
+                        "Both `nan` and `null` must be in lowercase. "
+                        "A string must be surrounded by quotes.",
+                        syntax::floating(sp), inner));
+                }
+            }
+            else // must be nan.
+            {
+                if(literal("nan").scan(inner).is_ok())
+                {
+                    return ok(value_t::floating);
+                }
+                else
+                {
+                    return err(make_syntax_error("toml::parse_value: "
+                        "`nan` must be in lowercase. "
+                        "A string must be surrounded by quotes.",
+                        syntax::floating(sp), inner));
+                }
+            }
+        }
+        case 'N' : // nan or null-extension
+        {
+            if(sp.ext_null_value)
+            {
+                return err(make_syntax_error("toml::parse_value: "
+                    "Both `nan` and `null` must be in lowercase. "
+                    "A string must be surrounded by quotes.",
+                    syntax::floating(sp), inner));
+            }
+            else
+            {
+                return err(make_syntax_error("toml::parse_value: "
+                    "`nan` must be in lowercase. "
+                    "A string must be surrounded by quotes.",
+                    syntax::floating(sp), inner));
+            }
+        }
+        default  :
+        {
+            return guess_number_type(loc, ctx);
+        }
+    }
+}
+
+template<typename TC>
+result<basic_value<TC>, error_info>
+parse_value(location& loc, context<TC>& ctx)
+{
+    const auto ty_res = guess_value_type(loc, ctx);
+    if(ty_res.is_err())
+    {
+        return err(ty_res.unwrap_err());
+    }
+
+    switch(ty_res.unwrap())
+    {
+        case value_t::empty:
+        {
+            if(ctx.toml_spec().ext_null_value)
+            {
+                return parse_null(loc, ctx);
+            }
+            else
+            {
+                auto src = source_location(region(loc));
+                return err(make_error_info("toml::parse_value: unknown value appeared",
+                            std::move(src), "here"));
+            }
+        }
+        case value_t::boolean        : {return parse_boolean        (loc, ctx);}
+        case value_t::integer        : {return parse_integer        (loc, ctx);}
+        case value_t::floating       : {return parse_floating       (loc, ctx);}
+        case value_t::string         : {return parse_string         (loc, ctx);}
+        case value_t::offset_datetime: {return parse_offset_datetime(loc, ctx);}
+        case value_t::local_datetime : {return parse_local_datetime (loc, ctx);}
+        case value_t::local_date     : {return parse_local_date     (loc, ctx);}
+        case value_t::local_time     : {return parse_local_time     (loc, ctx);}
+        case value_t::array          : {return parse_array          (loc, ctx);}
+        case value_t::table          : {return parse_inline_table   (loc, ctx);}
+        default:
+        {
+            auto src = source_location(region(loc));
+            return err(make_error_info("toml::parse_value: unknown value appeared",
+                        std::move(src), "here"));
+        }
+    }
+}
+
+/* ============================================================================
+ *  _____     _    _
+ * |_   _|_ _| |__| |___
+ *   | |/ _` | '_ \ / -_)
+ *   |_|\__,_|_.__/_\___|
+ */
+
+template<typename TC>
+result<std::pair<std::vector<typename basic_value<TC>::key_type>, region>, error_info>
+parse_table_key(location& loc, context<TC>& ctx)
+{
+    const auto first = loc;
+    const auto& spec = ctx.toml_spec();
+
+    auto reg = syntax::std_table(spec).scan(loc);
+    if(!reg.is_ok())
+    {
+        return err(make_syntax_error("toml::parse_table_key: invalid table key",
+            syntax::std_table(spec), loc));
+    }
+
+    loc = first;
+    loc.advance(); // skip [
+    skip_whitespace(loc, ctx);
+
+    auto keys_res = parse_key(loc, ctx);
+    if(keys_res.is_err())
+    {
+        return err(std::move(keys_res.unwrap_err()));
+    }
+
+    skip_whitespace(loc, ctx);
+    loc.advance(); // ]
+
+    return ok(std::make_pair(std::move(keys_res.unwrap().first), std::move(reg)));
+}
+
+template<typename TC>
+result<std::pair<std::vector<typename basic_value<TC>::key_type>, region>, error_info>
+parse_array_table_key(location& loc, context<TC>& ctx)
+{
+    const auto first = loc;
+    const auto& spec = ctx.toml_spec();
+
+    auto reg = syntax::array_table(spec).scan(loc);
+    if(!reg.is_ok())
+    {
+        return err(make_syntax_error("toml::parse_array_table_key: invalid array-of-tables key",
+            syntax::array_table(spec), loc));
+    }
+
+    loc = first;
+    loc.advance(); // [
+    loc.advance(); // [
+    skip_whitespace(loc, ctx);
+
+    auto keys_res = parse_key(loc, ctx);
+    if(keys_res.is_err())
+    {
+        return err(std::move(keys_res.unwrap_err()));
+    }
+
+    skip_whitespace(loc, ctx);
+    loc.advance(); // ]
+    loc.advance(); // ]
+
+    return ok(std::make_pair(std::move(keys_res.unwrap().first), std::move(reg)));
+}
+
+// called after reading [table.keys] and comments around it.
+// Since table may already contain a subtable ([x.y.z] can be defined before [x]),
+// the table that is being parsed is passed as an argument.
+template<typename TC>
+result<none_t, error_info>
+parse_table(location& loc, context<TC>& ctx, basic_value<TC>& table)
+{
+    assert(table.is_table());
+
+    const auto num_errors = ctx.errors().size();
+    const auto& spec = ctx.toml_spec();
+
+    // clear indent info
+    table.as_table_fmt().indent_type = indent_char::none;
+
+    bool newline_found = true;
+    while( ! loc.eof())
+    {
+        const auto start = loc;
+
+        auto sp = skip_multiline_spacer(loc, ctx, newline_found);
+
+        // if reached to EOF, the table ends here. return.
+        if(loc.eof())
+        {
+            break;
+        }
+        // if next table is comming, return.
+        if(sequence(syntax::ws(spec), character('[')).scan(loc).is_ok())
+        {
+            loc = start;
+            break;
+        }
+        // otherwise, it should be a key-value pair.
+        newline_found = newline_found || (sp.has_value() && sp.value().newline_found);
+        if( ! newline_found)
+        {
+            return err(make_error_info("toml::parse_table: "
+                "newline (LF / CRLF) or EOF is expected",
+                source_location(region(loc)), "here"));
+        }
+        if(sp.has_value() && sp.value().indent_type != indent_char::none)
+        {
+            table.as_table_fmt().indent_type = sp.value().indent_type;
+            table.as_table_fmt().body_indent = sp.value().indent;
+        }
+
+        newline_found = false; // reset
+        if(auto kv_res = parse_key_value_pair(loc, ctx))
+        {
+            auto keys    = std::move(kv_res.unwrap().first.first);
+            auto key_reg = std::move(kv_res.unwrap().first.second);
+            auto val     = std::move(kv_res.unwrap().second);
+
+            if(sp.has_value())
+            {
+                for(const auto& com : sp.value().comments)
+                {
+                    val.comments().push_back(com);
+                }
+            }
+
+            if(auto com_res = parse_comment_line(loc, ctx))
+            {
+                if(auto com_opt = com_res.unwrap())
+                {
+                    val.comments().push_back(com_opt.value());
+                    newline_found = true; // comment includes newline at the end
+                }
+            }
+            else
+            {
+                ctx.report_error(std::move(com_res.unwrap_err()));
+            }
+
+            auto ins_res = insert_value(inserting_value_kind::dotted_keys,
+                    std::addressof(table.as_table()),
+                    keys, std::move(key_reg), std::move(val));
+            if(ins_res.is_err())
+            {
+                ctx.report_error(std::move(ins_res.unwrap_err()));
+            }
+        }
+        else
+        {
+            ctx.report_error(std::move(kv_res.unwrap_err()));
+            skip_key_value_pair(loc, ctx);
+        }
+    }
+
+    if(num_errors < ctx.errors().size())
+    {
+        assert(ctx.has_error()); // already reported
+        return err(ctx.pop_last_error());
+    }
+    return ok();
+}
+
+template<typename TC>
+result<basic_value<TC>, std::vector<error_info>>
+parse_file(location& loc, context<TC>& ctx)
+{
+    using value_type = basic_value<TC>;
+    using table_type = typename value_type::table_type;
+
+    const auto first = loc;
+    const auto& spec = ctx.toml_spec();
+
+    if(loc.eof())
+    {
+        return ok(value_type(table_type(), table_format_info{}, {}, region(loc)));
+    }
+
+    value_type root(table_type(), table_format_info{}, {}, region(loc));
+    root.as_table_fmt().fmt = table_format::multiline;
+    root.as_table_fmt().indent_type = indent_char::none;
+
+    // parse top comment.
+    //
+    // ```toml
+    // # this is a comment for the top-level table.
+    //
+    // key = "the first value"
+    // ```
+    //
+    // ```toml
+    // # this is a comment for "the first value".
+    // key = "the first value"
+    // ```
+    while( ! loc.eof())
+    {
+        if(auto com_res = parse_comment_line(loc, ctx))
+        {
+            if(auto com_opt = com_res.unwrap())
+            {
+                root.comments().push_back(std::move(com_opt.value()));
+            }
+            else // no comment found.
+            {
+                // if it is not an empty line, clear the root comment.
+                if( ! sequence(syntax::ws(spec), syntax::newline(spec)).scan(loc).is_ok())
+                {
+                    loc = first;
+                    root.comments().clear();
+                }
+                break;
+            }
+        }
+        else
+        {
+            ctx.report_error(std::move(com_res.unwrap_err()));
+            skip_comment_block(loc, ctx);
+        }
+    }
+
+    // parse root table
+    {
+        const auto res = parse_table(loc, ctx, root);
+        if(res.is_err())
+        {
+            ctx.report_error(std::move(res.unwrap_err()));
+            skip_until_next_table(loc, ctx);
+        }
+    }
+
+    // parse tables
+
+    while( ! loc.eof())
+    {
+        auto sp = skip_multiline_spacer(loc, ctx, /*newline_found=*/true);
+
+        if(auto key_res = parse_array_table_key(loc, ctx))
+        {
+            auto key = std::move(std::get<0>(key_res.unwrap()));
+            auto reg = std::move(std::get<1>(key_res.unwrap()));
+
+            std::vector<std::string> com;
+            if(sp.has_value())
+            {
+                for(std::size_t i=0; i<sp.value().comments.size(); ++i)
+                {
+                    com.push_back(std::move(sp.value().comments.at(i)));
+                }
+            }
+
+            // [table.def] must be followed by one of
+            // - a comment line
+            // - whitespace + newline
+            // - EOF
+            if(auto com_res = parse_comment_line(loc, ctx))
+            {
+                if(auto com_opt = com_res.unwrap())
+                {
+                    com.push_back(com_opt.value());
+                }
+                else // if there is no comment, ws+newline must exist (or EOF)
+                {
+                    skip_whitespace(loc, ctx);
+                    if( ! loc.eof() && ! syntax::newline(ctx.toml_spec()).scan(loc).is_ok())
+                    {
+                        ctx.report_error(make_syntax_error("toml::parse_file: "
+                            "newline (or EOF) expected",
+                            syntax::newline(ctx.toml_spec()), loc));
+                        skip_until_next_table(loc, ctx);
+                        continue;
+                    }
+                }
+            }
+            else // comment syntax error (rare)
+            {
+                ctx.report_error(com_res.unwrap_err());
+                skip_until_next_table(loc, ctx);
+                continue;
+            }
+
+            table_format_info fmt;
+            fmt.fmt = table_format::multiline;
+            fmt.indent_type = indent_char::none;
+            auto tab = value_type(table_type{}, std::move(fmt), std::move(com), reg);
+
+            auto inserted = insert_value(inserting_value_kind::array_table,
+                std::addressof(root.as_table()),
+                key, std::move(reg), std::move(tab));
+
+            if(inserted.is_err())
+            {
+                ctx.report_error(inserted.unwrap_err());
+
+                // check errors in the table
+                auto tmp = basic_value<TC>(table_type());
+                auto res = parse_table(loc, ctx, tmp);
+                if(res.is_err())
+                {
+                    ctx.report_error(res.unwrap_err());
+                    skip_until_next_table(loc, ctx);
+                }
+                continue;
+            }
+
+            auto tab_ptr = inserted.unwrap();
+            assert(tab_ptr);
+
+            const auto tab_res = parse_table(loc, ctx, *tab_ptr);
+            if(tab_res.is_err())
+            {
+                ctx.report_error(tab_res.unwrap_err());
+                skip_until_next_table(loc, ctx);
+            }
+
+            // parse_table first clears `indent_type`.
+            // to keep header indent info, we must store it later.
+            if(sp.has_value() && sp.value().indent_type != indent_char::none)
+            {
+                tab_ptr->as_table_fmt().indent_type = sp.value().indent_type;
+                tab_ptr->as_table_fmt().name_indent = sp.value().indent;
+            }
+            continue;
+        }
+        if(auto key_res = parse_table_key(loc, ctx))
+        {
+            auto key = std::move(std::get<0>(key_res.unwrap()));
+            auto reg = std::move(std::get<1>(key_res.unwrap()));
+
+            std::vector<std::string> com;
+            if(sp.has_value())
+            {
+                for(std::size_t i=0; i<sp.value().comments.size(); ++i)
+                {
+                    com.push_back(std::move(sp.value().comments.at(i)));
+                }
+            }
+
+            // [table.def] must be followed by one of
+            // - a comment line
+            // - whitespace + newline
+            // - EOF
+            if(auto com_res = parse_comment_line(loc, ctx))
+            {
+                if(auto com_opt = com_res.unwrap())
+                {
+                    com.push_back(com_opt.value());
+                }
+                else // if there is no comment, ws+newline must exist (or EOF)
+                {
+                    skip_whitespace(loc, ctx);
+                    if( ! loc.eof() && ! syntax::newline(ctx.toml_spec()).scan(loc).is_ok())
+                    {
+                        ctx.report_error(make_syntax_error("toml::parse_file: "
+                            "newline (or EOF) expected",
+                            syntax::newline(ctx.toml_spec()), loc));
+                        skip_until_next_table(loc, ctx);
+                        continue;
+                    }
+                }
+            }
+            else // comment syntax error (rare)
+            {
+                ctx.report_error(com_res.unwrap_err());
+                skip_until_next_table(loc, ctx);
+                continue;
+            }
+
+            table_format_info fmt;
+            fmt.fmt = table_format::multiline;
+            fmt.indent_type = indent_char::none;
+            auto tab = value_type(table_type{}, std::move(fmt), std::move(com), reg);
+
+            auto inserted = insert_value(inserting_value_kind::std_table,
+                std::addressof(root.as_table()),
+                key, std::move(reg), std::move(tab));
+
+            if(inserted.is_err())
+            {
+                ctx.report_error(inserted.unwrap_err());
+
+                // check errors in the table
+                auto tmp = basic_value<TC>(table_type());
+                auto res = parse_table(loc, ctx, tmp);
+                if(res.is_err())
+                {
+                    ctx.report_error(res.unwrap_err());
+                    skip_until_next_table(loc, ctx);
+                }
+                continue;
+            }
+
+            auto tab_ptr = inserted.unwrap();
+            assert(tab_ptr);
+
+            const auto tab_res = parse_table(loc, ctx, *tab_ptr);
+            if(tab_res.is_err())
+            {
+                ctx.report_error(tab_res.unwrap_err());
+                skip_until_next_table(loc, ctx);
+            }
+            if(sp.has_value() && sp.value().indent_type != indent_char::none)
+            {
+                tab_ptr->as_table_fmt().indent_type = sp.value().indent_type;
+                tab_ptr->as_table_fmt().name_indent = sp.value().indent;
+            }
+            continue;
+        }
+
+        // does not match array_table nor std_table. report an error.
+        const auto keytop = loc;
+        const auto maybe_array_of_tables = literal("[[").scan(loc).is_ok();
+        loc = keytop;
+
+        if(maybe_array_of_tables)
+        {
+            ctx.report_error(make_syntax_error("toml::parse_file: invalid array-table key",
+                syntax::array_table(spec), loc));
+        }
+        else
+        {
+            ctx.report_error(make_syntax_error("toml::parse_file: invalid table key",
+                syntax::std_table(spec), loc));
+        }
+        skip_until_next_table(loc, ctx);
+    }
+
+    if( ! ctx.errors().empty())
+    {
+        return err(std::move(ctx.errors()));
+    }
+    return ok(std::move(root));
+}
+
+template<typename TC>
+result<basic_value<TC>, std::vector<error_info>>
+parse_impl(std::vector<location::char_type> cs, std::string fname, const spec& s)
+{
+    using value_type = basic_value<TC>;
+    using table_type = typename value_type::table_type;
+
+    // an empty file is a valid toml file.
+    if(cs.empty())
+    {
+        auto src = std::make_shared<std::vector<location::char_type>>(std::move(cs));
+        location loc(std::move(src), std::move(fname));
+        return ok(value_type(table_type(), table_format_info{}, std::vector<std::string>{}, region(loc)));
+    }
+
+    // to simplify parser, add newline at the end if there is no LF.
+    // But, if it has raw CR, the file is invalid (in TOML, CR is not a valid
+    // newline char). if it ends with CR, do not add LF and report it.
+    if(cs.back() != '\n' && cs.back() != '\r')
+    {
+        cs.push_back('\n');
+    }
+
+    auto src = std::make_shared<std::vector<location::char_type>>(std::move(cs));
+
+    location loc(std::move(src), std::move(fname));
+
+    // skip BOM if found
+    if(loc.source()->size() >= 3)
+    {
+        auto first = loc.get_location();
+
+        const auto c0 = loc.current(); loc.advance();
+        const auto c1 = loc.current(); loc.advance();
+        const auto c2 = loc.current(); loc.advance();
+
+        const auto bom_found = (c0 == 0xEF) && (c1 == 0xBB) && (c2 == 0xBF);
+        if( ! bom_found)
+        {
+            loc.set_location(first);
+        }
+    }
+
+    context<TC> ctx(s);
+
+    return parse_file(loc, ctx);
+}
+
+} // detail
+
+// -----------------------------------------------------------------------------
+// parse(byte array)
+
+template<typename TC = type_config>
+result<basic_value<TC>, std::vector<error_info>>
+try_parse(std::vector<unsigned char> content, std::string filename,
+          spec s = spec::default_version())
+{
+    return detail::parse_impl<TC>(std::move(content), std::move(filename), std::move(s));
+}
+template<typename TC = type_config>
+basic_value<TC>
+parse(std::vector<unsigned char> content, std::string filename,
+      spec s = spec::default_version())
+{
+    auto res = try_parse<TC>(std::move(content), std::move(filename), std::move(s));
+    if(res.is_ok())
+    {
+        return res.unwrap();
+    }
+    else
+    {
+        std::string msg;
+        for(const auto& err : res.unwrap_err())
+        {
+            msg += format_error(err);
+        }
+        throw syntax_error(std::move(msg), std::move(res.unwrap_err()));
+    }
+}
+
+// -----------------------------------------------------------------------------
+// parse(istream)
+
+template<typename TC = type_config>
+result<basic_value<TC>, std::vector<error_info>>
+try_parse(std::istream& is, std::string fname = "unknown file", spec s = spec::default_version())
+{
+    const auto beg = is.tellg();
+    is.seekg(0, std::ios::end);
+    const auto end = is.tellg();
+    const auto fsize = end - beg;
+    is.seekg(beg);
+
+    // read whole file as a sequence of char
+    assert(fsize >= 0);
+    std::vector<detail::location::char_type> letters(static_cast<std::size_t>(fsize), '\0');
+    is.read(reinterpret_cast<char*>(letters.data()), static_cast<std::streamsize>(fsize));
+
+    return detail::parse_impl<TC>(std::move(letters), std::move(fname), std::move(s));
+}
+
+template<typename TC = type_config>
+basic_value<TC> parse(std::istream& is, std::string fname = "unknown file", spec s = spec::default_version())
+{
+    auto res = try_parse<TC>(is, std::move(fname), std::move(s));
+    if(res.is_ok())
+    {
+        return res.unwrap();
+    }
+    else
+    {
+        std::string msg;
+        for(const auto& err : res.unwrap_err())
+        {
+            msg += format_error(err);
+        }
+        throw syntax_error(std::move(msg), std::move(res.unwrap_err()));
+    }
+}
+
+// -----------------------------------------------------------------------------
+// parse(filename)
+
+template<typename TC = type_config>
+result<basic_value<TC>, std::vector<error_info>>
+try_parse(std::string fname, spec s = spec::default_version())
+{
+    std::ifstream ifs(fname, std::ios_base::binary);
+    if(!ifs.good())
+    {
+        std::vector<error_info> e;
+        e.push_back(error_info("toml::parse: Error opening file \"" + fname + "\"", {}));
+        return err(std::move(e));
+    }
+    ifs.exceptions(std::ifstream::failbit | std::ifstream::badbit);
+
+    return try_parse<TC>(ifs, std::move(fname), std::move(s));
+}
+
+template<typename TC = type_config>
+basic_value<TC> parse(std::string fname, spec s = spec::default_version())
+{
+    std::ifstream ifs(fname, std::ios_base::binary);
+    if(!ifs.good())
+    {
+        throw file_io_error("toml::parse: error opening file", fname);
+    }
+    ifs.exceptions(std::ifstream::failbit | std::ifstream::badbit);
+
+    return parse<TC>(ifs, std::move(fname), std::move(s));
+}
+
+template<typename TC = type_config, std::size_t N>
+result<basic_value<TC>, std::vector<error_info>>
+try_parse(const char (&fname)[N], spec s = spec::default_version())
+{
+    return try_parse<TC>(std::string(fname), std::move(s));
+}
+
+template<typename TC = type_config, std::size_t N>
+basic_value<TC> parse(const char (&fname)[N], spec s = spec::default_version())
+{
+    return parse<TC>(std::string(fname), std::move(s));
+}
+
+// ----------------------------------------------------------------------------
+// parse_str
+
+template<typename TC = type_config>
+result<basic_value<TC>, std::vector<error_info>>
+try_parse_str(std::string content, spec s = spec::default_version(),
+              cxx::source_location loc = cxx::source_location::current())
+{
+    std::istringstream iss(std::move(content));
+    std::string name("internal string" + cxx::to_string(loc));
+    return try_parse<TC>(iss, std::move(name), std::move(s));
+}
+
+template<typename TC = type_config>
+basic_value<TC> parse_str(std::string content, spec s = spec::default_version(),
+        cxx::source_location loc = cxx::source_location::current())
+{
+    auto res = try_parse_str<TC>(std::move(content), std::move(s), std::move(loc));
+    if(res.is_ok())
+    {
+        return res.unwrap();
+    }
+    else
+    {
+        std::string msg;
+        for(const auto& err : res.unwrap_err())
+        {
+            msg += format_error(err);
+        }
+        throw syntax_error(std::move(msg), std::move(res.unwrap_err()));
+    }
+}
+
+// ----------------------------------------------------------------------------
+// filesystem
+
+#if defined(TOML11_HAS_FILESYSTEM)
+
+template<typename TC = type_config, typename FSPATH>
+cxx::enable_if_t<std::is_same<FSPATH, std::filesystem::path>::value,
+    result<basic_value<TC>, std::vector<error_info>>>
+try_parse(const FSPATH& fpath, spec s = spec::default_version())
+{
+    std::ifstream ifs(fpath, std::ios_base::binary);
+    if(!ifs.good())
+    {
+        std::vector<error_info> e;
+        e.push_back(error_info("toml::parse: Error opening file \"" + fpath.string() + "\"", {}));
+        return err(std::move(e));
+    }
+    ifs.exceptions(std::ifstream::failbit | std::ifstream::badbit);
+
+    return try_parse<TC>(ifs, fpath.string(), std::move(s));
+}
+
+template<typename TC = type_config, typename FSPATH>
+cxx::enable_if_t<std::is_same<FSPATH, std::filesystem::path>::value,
+    basic_value<TC>>
+parse(const FSPATH& fpath, spec s = spec::default_version())
+{
+    std::ifstream ifs(fpath, std::ios_base::binary);
+    if(!ifs.good())
+    {
+        throw file_io_error("toml::parse: error opening file", fpath.string());
+    }
+    ifs.exceptions(std::ifstream::failbit | std::ifstream::badbit);
+
+    return parse<TC>(ifs, fpath.string(), std::move(s));
+}
+#endif
+
+// -----------------------------------------------------------------------------
+// FILE*
+
+template<typename TC = type_config>
+result<basic_value<TC>, std::vector<error_info>>
+try_parse(FILE* fp, std::string filename, spec s = spec::default_version())
+{
+    const long beg = std::ftell(fp);
+    if (beg == -1L)
+    {
+        return err(std::vector<error_info>{error_info(
+            std::string("Failed to access: \"") + filename +
+            "\", errno = " + std::to_string(errno), {}
+        )});
+    }
+
+    const int res_seekend = std::fseek(fp, 0, SEEK_END);
+    if (res_seekend != 0)
+    {
+        return err(std::vector<error_info>{error_info(
+            std::string("Failed to seek: \"") + filename +
+            "\", errno = " + std::to_string(errno), {}
+        )});
+    }
+
+    const long end = std::ftell(fp);
+    if (end == -1L)
+    {
+        return err(std::vector<error_info>{error_info(
+            std::string("Failed to access: \"") + filename +
+            "\", errno = " + std::to_string(errno), {}
+        )});
+    }
+
+    const auto fsize = end - beg;
+
+    const auto res_seekbeg = std::fseek(fp, beg, SEEK_SET);
+    if (res_seekbeg != 0)
+    {
+        return err(std::vector<error_info>{error_info(
+            std::string("Failed to seek: \"") + filename +
+            "\", errno = " + std::to_string(errno), {}
+        )});
+
+    }
+
+    // read whole file as a sequence of char
+    assert(fsize >= 0);
+    std::vector<detail::location::char_type> letters(static_cast<std::size_t>(fsize));
+    const auto actual = std::fread(letters.data(), sizeof(char), static_cast<std::size_t>(fsize), fp);
+    if(actual != static_cast<std::size_t>(fsize))
+    {
+        return err(std::vector<error_info>{error_info(
+            std::string("File size changed: \"") + filename +
+            std::string("\" make sure that FILE* is in binary mode "
+                        "to avoid LF <-> CRLF conversion"), {}
+        )});
+    }
+
+    return detail::parse_impl<TC>(std::move(letters), std::move(filename), std::move(s));
+}
+
+template<typename TC = type_config>
+basic_value<TC>
+parse(FILE* fp, std::string filename, spec s = spec::default_version())
+{
+    const long beg = std::ftell(fp);
+    if (beg == -1L)
+    {
+        throw file_io_error(errno, "Failed to access", filename);
+    }
+
+    const int res_seekend = std::fseek(fp, 0, SEEK_END);
+    if (res_seekend != 0)
+    {
+        throw file_io_error(errno, "Failed to seek", filename);
+    }
+
+    const long end = std::ftell(fp);
+    if (end == -1L)
+    {
+        throw file_io_error(errno, "Failed to access", filename);
+    }
+
+    const auto fsize = end - beg;
+
+    const auto res_seekbeg = std::fseek(fp, beg, SEEK_SET);
+    if (res_seekbeg != 0)
+    {
+        throw file_io_error(errno, "Failed to seek", filename);
+    }
+
+    // read whole file as a sequence of char
+    assert(fsize >= 0);
+    std::vector<detail::location::char_type> letters(static_cast<std::size_t>(fsize));
+    const auto actual = std::fread(letters.data(), sizeof(char), static_cast<std::size_t>(fsize), fp);
+    if(actual != static_cast<std::size_t>(fsize))
+    {
+        throw file_io_error(errno, "File size changed; make sure that "
+            "FILE* is in binary mode to avoid LF <-> CRLF conversion", filename);
+    }
+
+    auto res = detail::parse_impl<TC>(std::move(letters), std::move(filename), std::move(s));
+    if(res.is_ok())
+    {
+        return res.unwrap();
+    }
+    else
+    {
+        std::string msg;
+        for(const auto& err : res.unwrap_err())
+        {
+            msg += format_error(err);
+        }
+        throw syntax_error(std::move(msg), std::move(res.unwrap_err()));
+    }
+}
+
+} // namespace toml
+
+#if defined(TOML11_COMPILE_SOURCES)
+namespace toml
+{
+struct type_config;
+struct ordered_type_config;
+
+extern template result<basic_value<type_config>, std::vector<error_info>> try_parse<type_config>(std::vector<unsigned char>, std::string, spec);
+extern template result<basic_value<type_config>, std::vector<error_info>> try_parse<type_config>(std::istream&, std::string, spec);
+extern template result<basic_value<type_config>, std::vector<error_info>> try_parse<type_config>(std::string, spec);
+extern template result<basic_value<type_config>, std::vector<error_info>> try_parse<type_config>(FILE*, std::string, spec);
+extern template result<basic_value<type_config>, std::vector<error_info>> try_parse_str<type_config>(std::string, spec, cxx::source_location);
+
+extern template basic_value<type_config> parse<type_config>(std::vector<unsigned char>, std::string, spec);
+extern template basic_value<type_config> parse<type_config>(std::istream&, std::string, spec);
+extern template basic_value<type_config> parse<type_config>(std::string, spec);
+extern template basic_value<type_config> parse<type_config>(FILE*, std::string, spec);
+extern template basic_value<type_config> parse_str<type_config>(std::string, spec, cxx::source_location);
+
+extern template result<basic_value<ordered_type_config>, std::vector<error_info>> try_parse<ordered_type_config>(std::vector<unsigned char>, std::string, spec);
+extern template result<basic_value<ordered_type_config>, std::vector<error_info>> try_parse<ordered_type_config>(std::istream&, std::string, spec);
+extern template result<basic_value<ordered_type_config>, std::vector<error_info>> try_parse<ordered_type_config>(std::string, spec);
+extern template result<basic_value<ordered_type_config>, std::vector<error_info>> try_parse<ordered_type_config>(FILE*, std::string, spec);
+extern template result<basic_value<ordered_type_config>, std::vector<error_info>> try_parse_str<ordered_type_config>(std::string, spec, cxx::source_location);
+
+extern template basic_value<ordered_type_config> parse<ordered_type_config>(std::vector<unsigned char>, std::string, spec);
+extern template basic_value<ordered_type_config> parse<ordered_type_config>(std::istream&, std::string, spec);
+extern template basic_value<ordered_type_config> parse<ordered_type_config>(std::string, spec);
+extern template basic_value<ordered_type_config> parse<ordered_type_config>(FILE*, std::string, spec);
+extern template basic_value<ordered_type_config> parse_str<ordered_type_config>(std::string, spec, cxx::source_location);
+
+#if defined(TOML11_HAS_FILESYSTEM)
+extern template cxx::enable_if_t<std::is_same<std::filesystem::path, std::filesystem::path>::value, result<basic_value<type_config>,         std::vector<error_info>>> try_parse<type_config,         std::filesystem::path>(const std::filesystem::path&, spec);
+extern template cxx::enable_if_t<std::is_same<std::filesystem::path, std::filesystem::path>::value, result<basic_value<ordered_type_config>, std::vector<error_info>>> try_parse<ordered_type_config, std::filesystem::path>(const std::filesystem::path&, spec);
+extern template cxx::enable_if_t<std::is_same<std::filesystem::path, std::filesystem::path>::value, basic_value<type_config>                                         > parse    <type_config,         std::filesystem::path>(const std::filesystem::path&, spec);
+extern template cxx::enable_if_t<std::is_same<std::filesystem::path, std::filesystem::path>::value, basic_value<ordered_type_config>                                 > parse    <ordered_type_config, std::filesystem::path>(const std::filesystem::path&, spec);
+#endif // filesystem
+
+} // toml
+#endif // TOML11_COMPILE_SOURCES
+
+#endif // TOML11_PARSER_HPP
+#ifndef TOML11_LITERAL_HPP
+#define TOML11_LITERAL_HPP
+
+#ifndef TOML11_LITERAL_FWD_HPP
+#define TOML11_LITERAL_FWD_HPP
+
+
+namespace toml
+{
+
+namespace detail
+{
+// implementation
+::toml::value literal_internal_impl(location loc);
+} // detail
+
+inline namespace literals
+{
+inline namespace toml_literals
+{
+
+::toml::value operator"" _toml(const char* str, std::size_t len);
+
+#if defined(TOML11_HAS_CHAR8_T)
+// value of u8"" literal has been changed from char to char8_t and char8_t is
+// NOT compatible to char
+::toml::value operator"" _toml(const char8_t* str, std::size_t len);
+#endif
+
+} // toml_literals
+} // literals
+} // toml
+#endif // TOML11_LITERAL_FWD_HPP
+
+#if ! defined(TOML11_COMPILE_SOURCES)
+#ifndef TOML11_LITERAL_IMPL_HPP
+#define TOML11_LITERAL_IMPL_HPP
+
+
+namespace toml
+{
+
+namespace detail
+{
+// implementation
+TOML11_INLINE ::toml::value literal_internal_impl(location loc)
+{
+    const auto s = ::toml::spec::default_version();
+    context<type_config> ctx(s);
+
+    const auto front = loc;
+
+    // ------------------------------------------------------------------------
+    // check if it is a raw value.
+
+    // skip empty lines and comment lines
+    auto sp = skip_multiline_spacer(loc, ctx);
+    if(loc.eof())
+    {
+        ::toml::value val;
+        if(sp.has_value())
+        {
+            for(std::size_t i=0; i<sp.value().comments.size(); ++i)
+            {
+                val.comments().push_back(std::move(sp.value().comments.at(i)));
+            }
+        }
+        return val;
+    }
+
+    // to distinguish arrays and tables, first check it is a table or not.
+    //
+    // "[1,2,3]"_toml;   // json: [1, 2, 3]
+    // "[table]"_toml;   // json: {"table": {}}
+    // "[[1,2,3]]"_toml; // json: [[1, 2, 3]]
+    // "[[table]]"_toml; // json: {"table": [{}]}
+    //
+    // "[[1]]"_toml;     // json: {"1": [{}]}
+    // "1 = [{}]"_toml;  // json: {"1": [{}]}
+    // "[[1,]]"_toml;    // json: [[1]]
+    // "[[1],]"_toml;    // json: [[1]]
+    const auto val_start = loc;
+
+    const bool is_table_key = syntax::std_table(s).scan(loc).is_ok();
+    loc = val_start;
+    const bool is_aots_key  = syntax::array_table(s).scan(loc).is_ok();
+    loc = val_start;
+
+    // If it is neither a table-key or a array-of-table-key, it may be a value.
+    if(!is_table_key && !is_aots_key)
+    {
+        auto data = parse_value(loc, ctx);
+        if(data.is_ok())
+        {
+            auto val = std::move(data.unwrap());
+            if(sp.has_value())
+            {
+                for(std::size_t i=0; i<sp.value().comments.size(); ++i)
+                {
+                    val.comments().push_back(std::move(sp.value().comments.at(i)));
+                }
+            }
+            auto com_res = parse_comment_line(loc, ctx);
+            if(com_res.is_ok() && com_res.unwrap().has_value())
+            {
+                val.comments().push_back(com_res.unwrap().value());
+            }
+            return val;
+        }
+    }
+
+    // -------------------------------------------------------------------------
+    // Note that still it can be a table, because the literal might be something
+    // like the following.
+    // ```cpp
+    // // c++11 raw-string literal
+    // const auto val = R"(
+    //   key = "value"
+    //   int = 42
+    // )"_toml;
+    // ```
+    // It is a valid toml file.
+    // It should be parsed as if we parse a file with this content.
+
+    loc = front;
+    auto data = parse_file(loc, ctx);
+    if(data.is_ok())
+    {
+        return data.unwrap();
+    }
+    else // not a value && not a file. error.
+    {
+        std::string msg;
+        for(const auto& err : data.unwrap_err())
+        {
+            msg += format_error(err);
+        }
+        throw ::toml::syntax_error(std::move(msg), std::move(data.unwrap_err()));
+    }
+}
+
+} // detail
+
+inline namespace literals
+{
+inline namespace toml_literals
+{
+
+TOML11_INLINE ::toml::value
+operator"" _toml(const char* str, std::size_t len)
+{
+    if(len == 0)
+    {
+        return ::toml::value{};
+    }
+
+    ::toml::detail::location::container_type c(len);
+    std::copy(reinterpret_cast<const ::toml::detail::location::char_type*>(str),
+              reinterpret_cast<const ::toml::detail::location::char_type*>(str + len),
+              c.begin());
+    if( ! c.empty() && c.back())
+    {
+        c.push_back('\n'); // to make it easy to parse comment, we add newline
+    }
+
+    return literal_internal_impl(::toml::detail::location(
+        std::make_shared<const toml::detail::location::container_type>(std::move(c)),
+        "TOML literal encoded in a C++ code"));
+}
+
+#if defined(__cpp_char8_t)
+#  if __cpp_char8_t >= 201811L
+#    define TOML11_HAS_CHAR8_T 1
+#  endif
+#endif
+
+#if defined(TOML11_HAS_CHAR8_T)
+// value of u8"" literal has been changed from char to char8_t and char8_t is
+// NOT compatible to char
+TOML11_INLINE ::toml::value
+operator"" _toml(const char8_t* str, std::size_t len)
+{
+    if(len == 0)
+    {
+        return ::toml::value{};
+    }
+
+    ::toml::detail::location::container_type c(len);
+    std::copy(reinterpret_cast<const ::toml::detail::location::char_type*>(str),
+              reinterpret_cast<const ::toml::detail::location::char_type*>(str + len),
+              c.begin());
+    if( ! c.empty() && c.back())
+    {
+        c.push_back('\n'); // to make it easy to parse comment, we add newline
+    }
+
+    return literal_internal_impl(::toml::detail::location(
+        std::make_shared<const toml::detail::location::container_type>(std::move(c)),
+        "TOML literal encoded in a C++ code"));
+}
+#endif
+
+} // toml_literals
+} // literals
+} // toml
+#endif // TOML11_LITERAL_IMPL_HPP
+#endif
+
+#endif // TOML11_LITERAL_HPP
+#ifndef TOML11_SERIALIZER_HPP
+#define TOML11_SERIALIZER_HPP
+
+
+#include <iomanip>
+#include <iterator>
+#include <sstream>
+
+#include <cmath>
+#include <cstdio>
+
+namespace toml
+{
+
+struct serialization_error final : public ::toml::exception
+{
+  public:
+    explicit serialization_error(std::string what_arg, source_location loc)
+        : what_(std::move(what_arg)), loc_(std::move(loc))
+    {}
+    ~serialization_error() noexcept override = default;
+
+    const char* what() const noexcept override {return what_.c_str();}
+    source_location const& location() const noexcept {return loc_;}
+
+  private:
+    std::string what_;
+    source_location loc_;
+};
+
+namespace detail
+{
+template<typename TC>
+class serializer
+{
+  public:
+
+    using value_type           = basic_value<TC>;
+
+    using key_type             = typename value_type::key_type            ;
+    using comment_type         = typename value_type::comment_type        ;
+    using boolean_type         = typename value_type::boolean_type        ;
+    using integer_type         = typename value_type::integer_type        ;
+    using floating_type        = typename value_type::floating_type       ;
+    using string_type          = typename value_type::string_type         ;
+    using local_time_type      = typename value_type::local_time_type     ;
+    using local_date_type      = typename value_type::local_date_type     ;
+    using local_datetime_type  = typename value_type::local_datetime_type ;
+    using offset_datetime_type = typename value_type::offset_datetime_type;
+    using array_type           = typename value_type::array_type          ;
+    using table_type           = typename value_type::table_type          ;
+
+    using char_type            = typename string_type::value_type;
+
+  public:
+
+    explicit serializer(const spec& sp)
+        : spec_(sp), force_inline_(false), current_indent_(0)
+    {}
+
+    string_type operator()(const std::vector<key_type>& ks, const value_type& v)
+    {
+        for(const auto& k : ks)
+        {
+            this->keys_.push_back(k);
+        }
+        return (*this)(v);
+    }
+
+    string_type operator()(const key_type& k, const value_type& v)
+    {
+        this->keys_.push_back(k);
+        return (*this)(v);
+    }
+
+    string_type operator()(const value_type& v)
+    {
+        switch(v.type())
+        {
+            case value_t::boolean        : {return (*this)(v.as_boolean        (), v.as_boolean_fmt        (), v.location());}
+            case value_t::integer        : {return (*this)(v.as_integer        (), v.as_integer_fmt        (), v.location());}
+            case value_t::floating       : {return (*this)(v.as_floating       (), v.as_floating_fmt       (), v.location());}
+            case value_t::string         : {return (*this)(v.as_string         (), v.as_string_fmt         (), v.location());}
+            case value_t::offset_datetime: {return (*this)(v.as_offset_datetime(), v.as_offset_datetime_fmt(), v.location());}
+            case value_t::local_datetime : {return (*this)(v.as_local_datetime (), v.as_local_datetime_fmt (), v.location());}
+            case value_t::local_date     : {return (*this)(v.as_local_date     (), v.as_local_date_fmt     (), v.location());}
+            case value_t::local_time     : {return (*this)(v.as_local_time     (), v.as_local_time_fmt     (), v.location());}
+            case value_t::array          :
+            {
+                return (*this)(v.as_array(), v.as_array_fmt(), v.comments(), v.location());
+            }
+            case value_t::table          :
+            {
+                string_type retval;
+                if(this->keys_.empty()) // it might be the root table. emit comments here.
+                {
+                    retval += format_comments(v.comments(), v.as_table_fmt().indent_type);
+                }
+                if( ! retval.empty()) // we have comment.
+                {
+                    retval += char_type('\n');
+                }
+
+                retval += (*this)(v.as_table(), v.as_table_fmt(), v.comments(), v.location());
+                return retval;
+            }
+            case value_t::empty:
+            {
+                if(this->spec_.ext_null_value)
+                {
+                    return string_conv<string_type>("null");
+                }
+                break;
+            }
+            default:
+            {
+                break;
+            }
+        }
+        throw serialization_error(format_error(
+            "[error] toml::serializer: toml::basic_value "
+            "does not have any valid type.", v.location(), "here"), v.location());
+    }
+
+  private:
+
+    string_type operator()(const boolean_type& b, const boolean_format_info&, const source_location&) // {{{
+    {
+        if(b)
+        {
+            return string_conv<string_type>("true");
+        }
+        else
+        {
+            return string_conv<string_type>("false");
+        }
+    } // }}}
+
+    string_type operator()(const integer_type i, const integer_format_info& fmt, const source_location& loc) // {{{
+    {
+        std::ostringstream oss;
+        this->set_locale(oss);
+
+        const auto insert_spacer = [&fmt](std::string s) -> std::string {
+            if(fmt.spacer == 0) {return s;}
+
+            std::string sign;
+            if( ! s.empty() && (s.at(0) == '+' || s.at(0) == '-'))
+            {
+                sign += s.at(0);
+                s.erase(s.begin());
+            }
+
+            std::string spaced;
+            std::size_t counter = 0;
+            for(auto iter = s.rbegin(); iter != s.rend(); ++iter)
+            {
+                if(counter != 0 && counter % fmt.spacer == 0)
+                {
+                    spaced += '_';
+                }
+                spaced += *iter;
+                counter += 1;
+            }
+            if(!spaced.empty() && spaced.back() == '_') {spaced.pop_back();}
+
+            s.clear();
+            std::copy(spaced.rbegin(), spaced.rend(), std::back_inserter(s));
+            return sign + s;
+        };
+
+        std::string retval;
+        if(fmt.fmt == integer_format::dec)
+        {
+            oss << std::setw(static_cast<int>(fmt.width)) << std::dec << i;
+            retval = insert_spacer(oss.str());
+
+            if(this->spec_.ext_num_suffix && ! fmt.suffix.empty())
+            {
+                retval += '_';
+                retval += fmt.suffix;
+            }
+        }
+        else
+        {
+            if(i < 0)
+            {
+                throw serialization_error(format_error("binary, octal, hexadecimal "
+                    "integer does not allow negative value", loc, "here"), loc);
+            }
+            switch(fmt.fmt)
+            {
+                case integer_format::hex:
+                {
+                    oss << std::noshowbase
+                        << std::setw(static_cast<int>(fmt.width))
+                        << std::setfill('0')
+                        << std::hex;
+                    if(fmt.uppercase)
+                    {
+                        oss << std::uppercase;
+                    }
+                    else
+                    {
+                        oss << std::nouppercase;
+                    }
+                    oss << i;
+                    retval = std::string("0x") + insert_spacer(oss.str());
+                    break;
+                }
+                case integer_format::oct:
+                {
+                    oss << std::setw(static_cast<int>(fmt.width)) << std::setfill('0') << std::oct << i;
+                    retval = std::string("0o") + insert_spacer(oss.str());
+                    break;
+                }
+                case integer_format::bin:
+                {
+                    integer_type x{i};
+                    std::string tmp;
+                    std::size_t bits(0);
+                    while(x != 0)
+                    {
+                        if(fmt.spacer != 0)
+                        {
+                            if(bits != 0 && (bits % fmt.spacer) == 0) {tmp += '_';}
+                        }
+                        if(x % 2 == 1) { tmp += '1'; } else { tmp += '0'; }
+                        x >>= 1;
+                        bits += 1;
+                    }
+                    for(; bits < fmt.width; ++bits)
+                    {
+                        if(fmt.spacer != 0)
+                        {
+                            if(bits != 0 && (bits % fmt.spacer) == 0) {tmp += '_';}
+                        }
+                        tmp += '0';
+                    }
+                    for(auto iter = tmp.rbegin(); iter != tmp.rend(); ++iter)
+                    {
+                        oss << *iter;
+                    }
+                    retval = std::string("0b") + oss.str();
+                    break;
+                }
+                default:
+                {
+                    throw serialization_error(format_error(
+                        "none of dec, hex, oct, bin: " + to_string(fmt.fmt),
+                        loc, "here"), loc);
+                }
+            }
+        }
+        return string_conv<string_type>(retval);
+    } // }}}
+
+    string_type operator()(const floating_type f, const floating_format_info& fmt, const source_location&) // {{{
+    {
+        using std::isnan;
+        using std::isinf;
+        using std::signbit;
+
+        std::ostringstream oss;
+        this->set_locale(oss);
+
+        if(isnan(f))
+        {
+            if(signbit(f))
+            {
+                oss << '-';
+            }
+            oss << "nan";
+            if(this->spec_.ext_num_suffix && ! fmt.suffix.empty())
+            {
+                oss << '_';
+                oss << fmt.suffix;
+            }
+            return string_conv<string_type>(oss.str());
+        }
+
+        if(isinf(f))
+        {
+            if(signbit(f))
+            {
+                oss << '-';
+            }
+            oss << "inf";
+            if(this->spec_.ext_num_suffix && ! fmt.suffix.empty())
+            {
+                oss << '_';
+                oss << fmt.suffix;
+            }
+            return string_conv<string_type>(oss.str());
+        }
+
+        switch(fmt.fmt)
+        {
+            case floating_format::defaultfloat:
+            {
+                if(fmt.prec != 0)
+                {
+                    oss << std::setprecision(static_cast<int>(fmt.prec));
+                }
+                oss << f;
+                // since defaultfloat may omit point, we need to add it
+                std::string s = oss.str();
+                if (s.find('.') == std::string::npos &&
+                    s.find('e') == std::string::npos &&
+                    s.find('E') == std::string::npos )
+                {
+                    s += ".0";
+                }
+                if(this->spec_.ext_num_suffix && ! fmt.suffix.empty())
+                {
+                    s += '_';
+                    s += fmt.suffix;
+                }
+                return string_conv<string_type>(s);
+            }
+            case floating_format::fixed:
+            {
+                if(fmt.prec != 0)
+                {
+                    oss << std::setprecision(static_cast<int>(fmt.prec));
+                }
+                oss << std::fixed << f;
+                if(this->spec_.ext_num_suffix && ! fmt.suffix.empty())
+                {
+                    oss << '_' << fmt.suffix;
+                }
+                return string_conv<string_type>(oss.str());
+            }
+            case floating_format::scientific:
+            {
+                if(fmt.prec != 0)
+                {
+                    oss << std::setprecision(static_cast<int>(fmt.prec));
+                }
+                oss << std::scientific << f;
+                if(this->spec_.ext_num_suffix && ! fmt.suffix.empty())
+                {
+                    oss << '_' << fmt.suffix;
+                }
+                return string_conv<string_type>(oss.str());
+            }
+            case floating_format::hex:
+            {
+                if(this->spec_.ext_hex_float)
+                {
+                    oss << std::hexfloat << f;
+                    // suffix is only for decimal numbers.
+                    return string_conv<string_type>(oss.str());
+                }
+                else // no hex allowed. output with max precision.
+                {
+                    oss << std::setprecision(std::numeric_limits<floating_type>::max_digits10)
+                        << std::scientific << f;
+                    // suffix is only for decimal numbers.
+                    return string_conv<string_type>(oss.str());
+                }
+            }
+            default:
+            {
+                if(this->spec_.ext_num_suffix && ! fmt.suffix.empty())
+                {
+                    oss << '_' << fmt.suffix;
+                }
+                return string_conv<string_type>(oss.str());
+            }
+        }
+    } // }}}
+
+    string_type operator()(string_type s, const string_format_info& fmt, const source_location& loc) // {{{
+    {
+        string_type retval;
+        switch(fmt.fmt)
+        {
+            case string_format::basic:
+            {
+                retval += char_type('"');
+                retval += this->escape_basic_string(s);
+                retval += char_type('"');
+                return retval;
+            }
+            case string_format::literal:
+            {
+                if(std::find(s.begin(), s.end(), char_type('\n')) != s.end())
+                {
+                    throw serialization_error(format_error("toml::serializer: "
+                        "(non-multiline) literal string cannot have a newline",
+                        loc, "here"), loc);
+                }
+                retval += char_type('\'');
+                retval += s;
+                retval += char_type('\'');
+                return retval;
+            }
+            case string_format::multiline_basic:
+            {
+                retval += string_conv<string_type>("\"\"\"");
+                if(fmt.start_with_newline)
+                {
+                    retval += char_type('\n');
+                }
+
+                retval += this->escape_ml_basic_string(s);
+
+                retval += string_conv<string_type>("\"\"\"");
+                return retval;
+            }
+            case string_format::multiline_literal:
+            {
+                retval += string_conv<string_type>("'''");
+                if(fmt.start_with_newline)
+                {
+                    retval += char_type('\n');
+                }
+                retval += s;
+                retval += string_conv<string_type>("'''");
+                return retval;
+            }
+            default:
+            {
+                throw serialization_error(format_error(
+                    "[error] toml::serializer::operator()(string): "
+                    "invalid string_format value", loc, "here"), loc);
+            }
+        }
+    } // }}}
+
+    string_type operator()(const local_date_type& d, const local_date_format_info&, const source_location&) // {{{
+    {
+        std::ostringstream oss;
+        oss << d;
+        return string_conv<string_type>(oss.str());
+    } // }}}
+
+    string_type operator()(const local_time_type& t, const local_time_format_info& fmt, const source_location&) // {{{
+    {
+        return this->format_local_time(t, fmt.has_seconds, fmt.subsecond_precision);
+    } // }}}
+
+    string_type operator()(const local_datetime_type& dt, const local_datetime_format_info& fmt, const source_location&) // {{{
+    {
+        std::ostringstream oss;
+        oss << dt.date;
+        switch(fmt.delimiter)
+        {
+            case datetime_delimiter_kind::upper_T: { oss << 'T'; break; }
+            case datetime_delimiter_kind::lower_t: { oss << 't'; break; }
+            case datetime_delimiter_kind::space:   { oss << ' '; break; }
+            default:                               { oss << 'T'; break; }
+        }
+        return string_conv<string_type>(oss.str()) +
+            this->format_local_time(dt.time, fmt.has_seconds, fmt.subsecond_precision);
+    } // }}}
+
+    string_type operator()(const offset_datetime_type& odt, const offset_datetime_format_info& fmt, const source_location&) // {{{
+    {
+        std::ostringstream oss;
+        oss << odt.date;
+        switch(fmt.delimiter)
+        {
+            case datetime_delimiter_kind::upper_T: { oss << 'T'; break; }
+            case datetime_delimiter_kind::lower_t: { oss << 't'; break; }
+            case datetime_delimiter_kind::space:   { oss << ' '; break; }
+            default:                               { oss << 'T'; break; }
+        }
+        oss << string_conv<std::string>(this->format_local_time(odt.time, fmt.has_seconds, fmt.subsecond_precision));
+        oss << odt.offset;
+        return string_conv<string_type>(oss.str());
+    } // }}}
+
+    string_type operator()(const array_type& a, const array_format_info& fmt, const comment_type& com, const source_location& loc) // {{{
+    {
+        array_format f = fmt.fmt;
+        if(fmt.fmt == array_format::default_format)
+        {
+            // [[in.this.form]], you cannot add a comment to the array itself
+            // (but you can add a comment to each table).
+            // To keep comments, we need to avoid multiline array-of-tables
+            // if array itself has a comment.
+            if( ! this->keys_.empty() &&
+                ! a.empty() &&
+                com.empty() &&
+                std::all_of(a.begin(), a.end(), [](const value_type& e) {return e.is_table();}))
+            {
+                f = array_format::array_of_tables;
+            }
+            else
+            {
+                f = array_format::oneline;
+
+                // check if it becomes long
+                std::size_t approx_len = 0;
+                for(const auto& e : a)
+                {
+                    // have a comment. cannot be inlined
+                    if( ! e.comments().empty())
+                    {
+                        f = array_format::multiline;
+                        break;
+                    }
+                    // possibly long types ...
+                    if(e.is_array() || e.is_table() || e.is_offset_datetime() || e.is_local_datetime())
+                    {
+                        f = array_format::multiline;
+                        break;
+                    }
+                    else if(e.is_boolean())
+                    {
+                        approx_len += (*this)(e.as_boolean(), e.as_boolean_fmt(), e.location()).size();
+                    }
+                    else if(e.is_integer())
+                    {
+                        approx_len += (*this)(e.as_integer(), e.as_integer_fmt(), e.location()).size();
+                    }
+                    else if(e.is_floating())
+                    {
+                        approx_len += (*this)(e.as_floating(), e.as_floating_fmt(), e.location()).size();
+                    }
+                    else if(e.is_string())
+                    {
+                        if(e.as_string_fmt().fmt == string_format::multiline_basic ||
+                           e.as_string_fmt().fmt == string_format::multiline_literal)
+                        {
+                            f = array_format::multiline;
+                            break;
+                        }
+                        approx_len += 2 + (*this)(e.as_string(), e.as_string_fmt(), e.location()).size();
+                    }
+                    else if(e.is_local_date())
+                    {
+                        approx_len += 10; // 1234-56-78
+                    }
+                    else if(e.is_local_time())
+                    {
+                        approx_len += 15; // 12:34:56.789012
+                    }
+
+                    if(approx_len > 60) // key, ` = `, `[...]` < 80
+                    {
+                        f = array_format::multiline;
+                        break;
+                    }
+                    approx_len += 2; // `, `
+                }
+            }
+        }
+        if(this->force_inline_ && f == array_format::array_of_tables)
+        {
+            f = array_format::multiline;
+        }
+        if(a.empty() && f == array_format::array_of_tables)
+        {
+            f = array_format::oneline;
+        }
+
+        // --------------------------------------------------------------------
+
+        if(f == array_format::array_of_tables)
+        {
+            if(this->keys_.empty())
+            {
+                throw serialization_error("array of table must have its key. "
+                        "use format(key, v)", loc);
+            }
+            string_type retval;
+            for(const auto& e : a)
+            {
+                assert(e.is_table());
+
+                this->current_indent_ += e.as_table_fmt().name_indent;
+                retval += this->format_comments(e.comments(), e.as_table_fmt().indent_type);
+                retval += this->format_indent(e.as_table_fmt().indent_type);
+                this->current_indent_ -= e.as_table_fmt().name_indent;
+
+                retval += string_conv<string_type>("[[");
+                retval += this->format_keys(this->keys_).value();
+                retval += string_conv<string_type>("]]\n");
+
+                retval += this->format_ml_table(e.as_table(), e.as_table_fmt());
+            }
+            return retval;
+        }
+        else if(f == array_format::oneline)
+        {
+            // ignore comments. we cannot emit comments
+            string_type retval;
+            retval += char_type('[');
+            for(const auto& e : a)
+            {
+                this->force_inline_ = true;
+                retval += (*this)(e);
+                retval += string_conv<string_type>(", ");
+            }
+            if( ! a.empty())
+            {
+                retval.pop_back(); // ` `
+                retval.pop_back(); // `,`
+            }
+            retval += char_type(']');
+            this->force_inline_ = false;
+            return retval;
+        }
+        else
+        {
+            assert(f == array_format::multiline);
+
+            string_type retval;
+            retval += string_conv<string_type>("[\n");
+
+            for(const auto& e : a)
+            {
+                this->current_indent_ += fmt.body_indent;
+                retval += this->format_comments(e.comments(), fmt.indent_type);
+                retval += this->format_indent(fmt.indent_type);
+                this->current_indent_ -= fmt.body_indent;
+
+                this->force_inline_ = true;
+                retval += (*this)(e);
+                retval += string_conv<string_type>(",\n");
+            }
+            this->force_inline_ = false;
+
+            this->current_indent_ += fmt.closing_indent;
+            retval += this->format_indent(fmt.indent_type);
+            this->current_indent_ -= fmt.closing_indent;
+
+            retval += char_type(']');
+            return retval;
+        }
+    } // }}}
+
+    string_type operator()(const table_type& t, const table_format_info& fmt, const comment_type& com, const source_location& loc) // {{{
+    {
+        if(this->force_inline_)
+        {
+            if(fmt.fmt == table_format::multiline_oneline)
+            {
+                return this->format_ml_inline_table(t, fmt);
+            }
+            else
+            {
+                return this->format_inline_table(t, fmt);
+            }
+        }
+        else
+        {
+            if(fmt.fmt == table_format::multiline)
+            {
+                string_type retval;
+                // comment is emitted inside format_ml_table
+                if(auto k = this->format_keys(this->keys_))
+                {
+                    this->current_indent_ += fmt.name_indent;
+                    retval += this->format_comments(com, fmt.indent_type);
+                    retval += this->format_indent(fmt.indent_type);
+                    this->current_indent_ -= fmt.name_indent;
+                    retval += char_type('[');
+                    retval += k.value();
+                    retval += string_conv<string_type>("]\n");
+                }
+                // otherwise, its the root.
+
+                retval += this->format_ml_table(t, fmt);
+                return retval;
+            }
+            else if(fmt.fmt == table_format::oneline)
+            {
+                return this->format_inline_table(t, fmt);
+            }
+            else if(fmt.fmt == table_format::multiline_oneline)
+            {
+                return this->format_ml_inline_table(t, fmt);
+            }
+            else if(fmt.fmt == table_format::dotted)
+            {
+                std::vector<string_type> keys;
+                if(this->keys_.empty())
+                {
+                    throw serialization_error(format_error("toml::serializer: "
+                        "dotted table must have its key. use format(key, v)",
+                        loc, "here"), loc);
+                }
+                keys.push_back(this->keys_.back());
+
+                const auto retval = this->format_dotted_table(t, fmt, loc, keys);
+                keys.pop_back();
+                return retval;
+            }
+            else
+            {
+                assert(fmt.fmt == table_format::implicit);
+
+                string_type retval;
+                for(const auto& kv : t)
+                {
+                    const auto& k = kv.first;
+                    const auto& v = kv.second;
+
+                    if( ! v.is_table() && ! v.is_array_of_tables())
+                    {
+                        throw serialization_error(format_error("toml::serializer: "
+                            "an implicit table cannot have non-table value.",
+                            v.location(), "here"), v.location());
+                    }
+                    if(v.is_table())
+                    {
+                        if(v.as_table_fmt().fmt != table_format::multiline &&
+                           v.as_table_fmt().fmt != table_format::implicit)
+                        {
+                            throw serialization_error(format_error("toml::serializer: "
+                                "an implicit table cannot have non-multiline table",
+                                v.location(), "here"), v.location());
+                        }
+                    }
+                    else
+                    {
+                        assert(v.is_array());
+                        for(const auto& e : v.as_array())
+                        {
+                            if(e.as_table_fmt().fmt != table_format::multiline &&
+                               v.as_table_fmt().fmt != table_format::implicit)
+                            {
+                                throw serialization_error(format_error("toml::serializer: "
+                                    "an implicit table cannot have non-multiline table",
+                                    e.location(), "here"), e.location());
+                            }
+                        }
+                    }
+
+                    keys_.push_back(k);
+                    retval += (*this)(v);
+                    keys_.pop_back();
+                }
+                return retval;
+            }
+        }
+    } // }}}
+
+  private:
+
+    string_type escape_basic_string(const string_type& s) const // {{{
+    {
+        string_type retval;
+        for(const char_type c : s)
+        {
+            switch(c)
+            {
+                case char_type('\\'): {retval += string_conv<string_type>("\\\\"); break;}
+                case char_type('\"'): {retval += string_conv<string_type>("\\\""); break;}
+                case char_type('\b'): {retval += string_conv<string_type>("\\b" ); break;}
+                case char_type('\t'): {retval += string_conv<string_type>("\\t" ); break;}
+                case char_type('\f'): {retval += string_conv<string_type>("\\f" ); break;}
+                case char_type('\n'): {retval += string_conv<string_type>("\\n" ); break;}
+                case char_type('\r'): {retval += string_conv<string_type>("\\r" ); break;}
+                default  :
+                {
+                    if(c == char_type(0x1B) && spec_.v1_1_0_add_escape_sequence_e)
+                    {
+                        retval += string_conv<string_type>("\\e");
+                    }
+                    else if((char_type(0x00) <= c && c <= char_type(0x08)) ||
+                            (char_type(0x0A) <= c && c <= char_type(0x1F)) ||
+                             c == char_type(0x7F))
+                    {
+                        if(spec_.v1_1_0_add_escape_sequence_x)
+                        {
+                            retval += string_conv<string_type>("\\x");
+                        }
+                        else
+                        {
+                            retval += string_conv<string_type>("\\u00");
+                        }
+                        const auto c1 = c / 16;
+                        const auto c2 = c % 16;
+                        retval += static_cast<char_type>('0' + c1);
+                        if(c2 < 10)
+                        {
+                            retval += static_cast<char_type>('0' + c2);
+                        }
+                        else // 10 <= c2
+                        {
+                            retval += static_cast<char_type>('A' + (c2 - 10));
+                        }
+                    }
+                    else
+                    {
+                        retval += c;
+                    }
+                }
+            }
+        }
+        return retval;
+    } // }}}
+
+    string_type escape_ml_basic_string(const string_type& s) // {{{
+    {
+        string_type retval;
+        for(const char_type c : s)
+        {
+            switch(c)
+            {
+                case char_type('\\'): {retval += string_conv<string_type>("\\\\"); break;}
+                case char_type('\b'): {retval += string_conv<string_type>("\\b" ); break;}
+                case char_type('\t'): {retval += string_conv<string_type>("\\t" ); break;}
+                case char_type('\f'): {retval += string_conv<string_type>("\\f" ); break;}
+                case char_type('\n'): {retval += string_conv<string_type>("\n"  ); break;}
+                case char_type('\r'): {retval += string_conv<string_type>("\\r" ); break;}
+                default  :
+                {
+                    if(c == char_type(0x1B) && spec_.v1_1_0_add_escape_sequence_e)
+                    {
+                        retval += string_conv<string_type>("\\e");
+                    }
+                    else if((char_type(0x00) <= c && c <= char_type(0x08)) ||
+                            (char_type(0x0A) <= c && c <= char_type(0x1F)) ||
+                            c == char_type(0x7F))
+                    {
+                        if(spec_.v1_1_0_add_escape_sequence_x)
+                        {
+                            retval += string_conv<string_type>("\\x");
+                        }
+                        else
+                        {
+                            retval += string_conv<string_type>("\\u00");
+                        }
+                        const auto c1 = c / 16;
+                        const auto c2 = c % 16;
+                        retval += static_cast<char_type>('0' + c1);
+                        if(c2 < 10)
+                        {
+                            retval += static_cast<char_type>('0' + c2);
+                        }
+                        else // 10 <= c2
+                        {
+                            retval += static_cast<char_type>('A' + (c2 - 10));
+                        }
+                    }
+                    else
+                    {
+                        retval += c;
+                    }
+                }
+            }
+        }
+        // Only 1 or 2 consecutive `"`s are allowed in multiline basic string.
+        // 3 consecutive `"`s are considered as a closing delimiter.
+        // We need to check if there are 3 or more consecutive `"`s and insert
+        // backslash to break them down into several short `"`s like the `str6`
+        // in the following example.
+        // ```toml
+        // str4 = """Here are two quotation marks: "". Simple enough."""
+        // # str5 = """Here are three quotation marks: """."""  # INVALID
+        // str5 = """Here are three quotation marks: ""\"."""
+        // str6 = """Here are fifteen quotation marks: ""\"""\"""\"""\"""\"."""
+        // ```
+        auto found_3_quotes = retval.find(string_conv<string_type>("\"\"\""));
+        while(found_3_quotes != string_type::npos)
+        {
+            retval.replace(found_3_quotes, 3, string_conv<string_type>("\"\"\\\""));
+            found_3_quotes = retval.find(string_conv<string_type>("\"\"\""));
+        }
+        return retval;
+    } // }}}
+
+    string_type format_local_time(const local_time_type& t, const bool has_seconds, const std::size_t subsec_prec) // {{{
+    {
+        std::ostringstream oss;
+        oss << std::setfill('0') << std::setw(2) << static_cast<int>(t.hour);
+        oss << ':';
+        oss << std::setfill('0') << std::setw(2) << static_cast<int>(t.minute);
+        if(has_seconds)
+        {
+            oss << ':';
+            oss << std::setfill('0') << std::setw(2) << static_cast<int>(t.second);
+            if(subsec_prec != 0)
+            {
+                std::ostringstream subsec;
+                subsec << std::setfill('0') << std::setw(3) << static_cast<int>(t.millisecond);
+                subsec << std::setfill('0') << std::setw(3) << static_cast<int>(t.microsecond);
+                subsec << std::setfill('0') << std::setw(3) << static_cast<int>(t.nanosecond);
+                std::string subsec_str = subsec.str();
+                oss << '.' << subsec_str.substr(0, subsec_prec);
+            }
+        }
+        return string_conv<string_type>(oss.str());
+    } // }}}
+
+    string_type format_ml_table(const table_type& t, const table_format_info& fmt) // {{{
+    {
+        const auto format_later = [](const value_type& v) -> bool {
+
+            const bool is_ml_table = v.is_table() &&
+                v.as_table_fmt().fmt != table_format::oneline           &&
+                v.as_table_fmt().fmt != table_format::multiline_oneline &&
+                v.as_table_fmt().fmt != table_format::dotted ;
+
+            const bool is_ml_array_table = v.is_array_of_tables() &&
+                v.as_array_fmt().fmt != array_format::oneline &&
+                v.as_array_fmt().fmt != array_format::multiline;
+
+            return is_ml_table || is_ml_array_table;
+        };
+
+        string_type retval;
+        this->current_indent_ += fmt.body_indent;
+        for(const auto& kv : t)
+        {
+            const auto& key = kv.first;
+            const auto& val = kv.second;
+            if(format_later(val))
+            {
+                continue;
+            }
+            this->keys_.push_back(key);
+
+            retval += format_comments(val.comments(), fmt.indent_type);
+            retval += format_indent(fmt.indent_type);
+            if(val.is_table() && val.as_table_fmt().fmt == table_format::dotted)
+            {
+                retval += (*this)(val);
+            }
+            else
+            {
+                retval += format_key(key);
+                retval += string_conv<string_type>(" = ");
+                retval += (*this)(val);
+                retval += char_type('\n');
+            }
+            this->keys_.pop_back();
+        }
+        this->current_indent_ -= fmt.body_indent;
+
+        if( ! retval.empty())
+        {
+            retval += char_type('\n'); // for readability, add empty line between tables
+        }
+        for(const auto& kv : t)
+        {
+            if( ! format_later(kv.second))
+            {
+                continue;
+            }
+            // must be a [multiline.table] or [[multiline.array.of.tables]].
+            // comments will be generated inside it.
+            this->keys_.push_back(kv.first);
+            retval += (*this)(kv.second);
+            this->keys_.pop_back();
+        }
+        return retval;
+    } // }}}
+
+    string_type format_inline_table(const table_type& t, const table_format_info&) // {{{
+    {
+        // comments are ignored because we cannot write without newline
+        string_type retval;
+        retval += char_type('{');
+        for(const auto& kv : t)
+        {
+            this->force_inline_ = true;
+            retval += this->format_key(kv.first);
+            retval += string_conv<string_type>(" = ");
+            retval += (*this)(kv.second);
+            retval += string_conv<string_type>(", ");
+        }
+        if( ! t.empty())
+        {
+            retval.pop_back(); // ' '
+            retval.pop_back(); // ','
+        }
+        retval += char_type('}');
+        this->force_inline_ = false;
+        return retval;
+    } // }}}
+
+    string_type format_ml_inline_table(const table_type& t, const table_format_info& fmt) // {{{
+    {
+        string_type retval;
+        retval += string_conv<string_type>("{\n");
+        this->current_indent_ += fmt.body_indent;
+        for(const auto& kv : t)
+        {
+            this->force_inline_ = true;
+            retval += format_comments(kv.second.comments(), fmt.indent_type);
+            retval += format_indent(fmt.indent_type);
+            retval += kv.first;
+            retval += string_conv<string_type>(" = ");
+
+            this->force_inline_ = true;
+            retval += (*this)(kv.second);
+
+            retval += string_conv<string_type>(",\n");
+        }
+        if( ! t.empty())
+        {
+            retval.pop_back(); // '\n'
+            retval.pop_back(); // ','
+        }
+        this->current_indent_ -= fmt.body_indent;
+        this->force_inline_ = false;
+
+        this->current_indent_ += fmt.closing_indent;
+        retval += format_indent(fmt.indent_type);
+        this->current_indent_ -= fmt.closing_indent;
+
+        retval += char_type('}');
+        return retval;
+    } // }}}
+
+    string_type format_dotted_table(const table_type& t, const table_format_info& fmt, // {{{
+            const source_location&, std::vector<string_type>& keys)
+    {
+        // lets say we have: `{"a": {"b": {"c": {"d": "foo", "e": "bar"} } }`
+        // and `a` and `b` are `dotted`.
+        //
+        // - in case if `c` is `oneline`:
+        // ```toml
+        // a.b.c = {d = "foo", e = "bar"}
+        // ```
+        //
+        // - in case if and `c` is `dotted`:
+        // ```toml
+        // a.b.c.d = "foo"
+        // a.b.c.e = "bar"
+        // ```
+
+        string_type retval;
+
+        for(const auto& kv : t)
+        {
+            const auto& key = kv.first;
+            const auto& val = kv.second;
+
+            keys.push_back(key);
+
+            // format recursive dotted table?
+            if (val.is_table() &&
+                val.as_table_fmt().fmt != table_format::oneline &&
+                val.as_table_fmt().fmt != table_format::multiline_oneline)
+            {
+                retval += this->format_dotted_table(val.as_table(), val.as_table_fmt(), val.location(), keys);
+            }
+            else // non-table or inline tables. format normally
+            {
+                retval += format_comments(val.comments(), fmt.indent_type);
+                retval += format_indent(fmt.indent_type);
+                retval += format_keys(keys).value();
+                retval += string_conv<string_type>(" = ");
+                this->force_inline_ = true; // sub-table must be inlined
+                retval += (*this)(val);
+                retval += char_type('\n');
+                this->force_inline_ = false;
+            }
+            keys.pop_back();
+        }
+        return retval;
+    } // }}}
+
+    string_type format_key(const key_type& key) // {{{
+    {
+        if(key.empty())
+        {
+            return string_conv<string_type>("\"\"");
+        }
+
+        // check the key can be a bare (unquoted) key
+        auto loc = detail::make_temporary_location(string_conv<std::string>(key));
+        auto reg = detail::syntax::unquoted_key(this->spec_).scan(loc);
+        if(reg.is_ok() && loc.eof())
+        {
+            return key;
+        }
+
+        //if it includes special characters, then format it in a "quoted" key.
+        string_type formatted = string_conv<string_type>("\"");
+        for(const char_type c : key)
+        {
+            switch(c)
+            {
+                case char_type('\\'): {formatted += string_conv<string_type>("\\\\"); break;}
+                case char_type('\"'): {formatted += string_conv<string_type>("\\\""); break;}
+                case char_type('\b'): {formatted += string_conv<string_type>("\\b" ); break;}
+                case char_type('\t'): {formatted += string_conv<string_type>("\\t" ); break;}
+                case char_type('\f'): {formatted += string_conv<string_type>("\\f" ); break;}
+                case char_type('\n'): {formatted += string_conv<string_type>("\\n" ); break;}
+                case char_type('\r'): {formatted += string_conv<string_type>("\\r" ); break;}
+                default  :
+                {
+                    // ASCII ctrl char
+                    if( (char_type(0x00) <= c && c <= char_type(0x08)) ||
+                        (char_type(0x0A) <= c && c <= char_type(0x1F)) ||
+                        c == char_type(0x7F))
+                    {
+                        if(spec_.v1_1_0_add_escape_sequence_x)
+                        {
+                            formatted += string_conv<string_type>("\\x");
+                        }
+                        else
+                        {
+                            formatted += string_conv<string_type>("\\u00");
+                        }
+                        const auto c1 = c / 16;
+                        const auto c2 = c % 16;
+                        formatted += static_cast<char_type>('0' + c1);
+                        if(c2 < 10)
+                        {
+                            formatted += static_cast<char_type>('0' + c2);
+                        }
+                        else // 10 <= c2
+                        {
+                            formatted += static_cast<char_type>('A' + (c2 - 10));
+                        }
+                    }
+                    else
+                    {
+                        formatted += c;
+                    }
+                    break;
+                }
+            }
+        }
+        formatted += string_conv<string_type>("\"");
+        return formatted;
+    } // }}}
+    cxx::optional<string_type> format_keys(const std::vector<key_type>& keys) // {{{
+    {
+        if(keys.empty())
+        {
+            return cxx::make_nullopt();
+        }
+
+        string_type formatted;
+        for(const auto& ky : keys)
+        {
+            formatted += format_key(ky);
+            formatted += char_type('.');
+        }
+        formatted.pop_back(); // remove the last dot '.'
+        return formatted;
+    } // }}}
+
+    string_type format_comments(const discard_comments&, const indent_char) const // {{{
+    {
+        return string_conv<string_type>("");
+    } // }}}
+    string_type format_comments(const preserve_comments& comments, const indent_char indent_type) const // {{{
+    {
+        string_type retval;
+        for(const auto& c : comments)
+        {
+            if(c.empty()) {continue;}
+            retval += format_indent(indent_type);
+            if(c.front() != '#') {retval += char_type('#');}
+            retval += string_conv<string_type>(c);
+            if(c.back() != '\n') {retval += char_type('\n');}
+        }
+        return retval;
+    } // }}}
+
+    string_type format_indent(const indent_char indent_type) const // {{{
+    {
+        const auto indent = static_cast<std::size_t>((std::max)(0, this->current_indent_));
+        if(indent_type == indent_char::space)
+        {
+            return string_conv<string_type>(make_string(indent, ' '));
+        }
+        else if(indent_type == indent_char::tab)
+        {
+            return string_conv<string_type>(make_string(indent, '\t'));
+        }
+        else
+        {
+            return string_type{};
+        }
+    } // }}}
+
+    std::locale set_locale(std::ostream& os) const
+    {
+        return os.imbue(std::locale::classic());
+    }
+
+  private:
+
+    spec spec_;
+    bool force_inline_; // table inside an array without fmt specification
+    std::int32_t current_indent_;
+    std::vector<key_type> keys_;
+};
+} // detail
+
+template<typename TC>
+typename basic_value<TC>::string_type
+format(const basic_value<TC>& v, const spec s = spec::default_version())
+{
+    detail::serializer<TC> ser(s);
+    return ser(v);
+}
+template<typename TC>
+typename basic_value<TC>::string_type
+format(const typename basic_value<TC>::key_type& k,
+       const basic_value<TC>& v,
+       const spec s = spec::default_version())
+{
+    detail::serializer<TC> ser(s);
+    return ser(k, v);
+}
+template<typename TC>
+typename basic_value<TC>::string_type
+format(const std::vector<typename basic_value<TC>::key_type>& ks,
+       const basic_value<TC>& v,
+       const spec s = spec::default_version())
+{
+    detail::serializer<TC> ser(s);
+    return ser(ks, v);
+}
+
+template<typename TC>
+std::ostream& operator<<(std::ostream& os, const basic_value<TC>& v)
+{
+    os << format(v);
+    return os;
+}
+
+} // toml
+
+#if defined(TOML11_COMPILE_SOURCES)
+namespace toml
+{
+struct type_config;
+struct ordered_type_config;
+
+extern template typename basic_value<type_config>::string_type
+format<type_config>(const basic_value<type_config>&, const spec);
+
+extern template typename basic_value<type_config>::string_type
+format<type_config>(const typename basic_value<type_config>::key_type& k,
+                    const basic_value<type_config>& v, const spec);
+
+extern template typename basic_value<type_config>::string_type
+format<type_config>(const std::vector<typename basic_value<type_config>::key_type>& ks,
+                    const basic_value<type_config>& v, const spec s);
+
+extern template typename basic_value<type_config>::string_type
+format<ordered_type_config>(const basic_value<ordered_type_config>&, const spec);
+
+extern template typename basic_value<type_config>::string_type
+format<ordered_type_config>(const typename basic_value<ordered_type_config>::key_type& k,
+                            const basic_value<ordered_type_config>& v, const spec);
+
+extern template typename basic_value<type_config>::string_type
+format<ordered_type_config>(const std::vector<typename basic_value<ordered_type_config>::key_type>& ks,
+                            const basic_value<ordered_type_config>& v, const spec s);
+
+namespace detail
+{
+extern template class serializer<::toml::type_config>;
+extern template class serializer<::toml::ordered_type_config>;
+} // detail
+} // toml
+#endif // TOML11_COMPILE_SOURCES
+
+
+#endif // TOML11_SERIALIZER_HPP
+#ifndef TOML11_TOML_HPP
+#define TOML11_TOML_HPP
+
+// The MIT License (MIT)
+//
+// Copyright (c) 2017-now Toru Niina
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+// IWYU pragma: begin_exports
+// IWYU pragma: end_exports
+
+#endif// TOML11_TOML_HPP
diff --git a/tile/base/config/json_configuration_test.cc b/tile/base/config/json_configuration_test.cc
index eee5327..1a26478 100644
--- a/tile/base/config/json_configuration_test.cc
+++ b/tile/base/config/json_configuration_test.cc
@@ -1,5 +1,6 @@
 #include "tile/base/config/json_configuration.h"
 
+#include "gmock/gmock-matchers.h"
 #include "gtest/gtest.h"
 
 namespace tile {
@@ -85,16 +86,11 @@ TEST(json_configuration, Enumerate)
     ASSERT_TRUE(config.load(istr));
     auto keys = config.keys("");
     ASSERT_EQ(5, keys.size());
-    ASSERT_EQ("key1", keys[0]);
-    ASSERT_EQ("key2", keys[1]);
-    ASSERT_EQ("key3", keys[2]);
-    ASSERT_EQ("key4", keys[3]);
-    ASSERT_EQ("key5", keys[4]);
+    ASSERT_THAT(keys, ::testing::UnorderedElementsAre("key1", "key2", "key3", "key4", "key5"));
 
     keys = config.keys("key5");
     ASSERT_EQ(2, keys.size());
-    ASSERT_EQ("key5.key51", keys[0]);
-    ASSERT_EQ("key5.key52", keys[1]);
+    ASSERT_THAT(keys, ::testing::UnorderedElementsAre("key5.key51", "key5.key52"));
 
     config.Remove("key5.key51");
     keys = config.keys("key5");
diff --git a/tile/base/config/toml_configuration.cc b/tile/base/config/toml_configuration.cc
new file mode 100644
index 0000000..87ea4f3
--- /dev/null
+++ b/tile/base/config/toml_configuration.cc
@@ -0,0 +1,219 @@
+#include "tile/base/config/toml_configuration.h"
+
+#include "tile/base/logging.h"
+#include "tile/base/string.h"
+#include "toml.hpp"
+
+namespace tile {
+class TomlConfiguration::Impl {
+public:
+    Impl() {}
+
+    ~Impl() = default;
+
+    bool load(std::istream &istr)
+    {
+        try {
+            value_ = toml::parse(istr);
+            return true;
+        } catch (...) {
+            return false;
+        }
+    }
+
+    bool load(const std::string &path)
+    {
+        try {
+            value_ = toml::parse(path);
+            return true;
+        } catch (...) {
+            return false;
+        }
+    }
+
+    toml::value *operator->() { return &value_; }
+
+    toml::value &operator*() { return value_; }
+
+private:
+    toml::value value_;
+};
+
+TomlConfiguration::TomlConfiguration() : impl_(new Impl) {}
+
+TomlConfiguration::~TomlConfiguration() {}
+
+bool
+TomlConfiguration::load(std::istream &istr)
+{
+    return impl_->load(istr);
+}
+
+bool
+TomlConfiguration::load(const std::string &path)
+{
+    return impl_->load(path);
+}
+
+void
+TomlConfiguration::SetInt(const Slice &key, int value)
+{
+    Configuration::SetInt(key, value);
+}
+
+void
+TomlConfiguration::SetBool(const Slice &key, bool value)
+{
+    Configuration::SetBool(key, value);
+}
+
+void
+TomlConfiguration::SetDouble(const Slice &key, double value)
+{
+    Configuration::SetDouble(key, value);
+}
+
+void
+TomlConfiguration::SetString(const Slice &key, const std::string &value)
+{
+    Configuration::SetString(key, value);
+}
+
+std::string
+TomlConfiguration::Dump() const
+{
+    try {
+        return toml::format(**impl_);
+    } catch (const std::exception &e) {
+        TILE_LOG_WARNING_EVERY_SECOND("{}", e.what());
+        return "";
+    }
+}
+
+bool
+TomlConfiguration::GetRaw(const Slice &key, std::string *value) const
+{
+    if (key.empty()) { return false; }
+    auto keys = Split(key, '.');
+
+    try {
+        auto cur = **impl_;
+        for (const auto &k : keys) {
+            auto next = toml::find(cur, k);
+            cur       = next;
+        }
+        std::stringstream ss;
+        if (cur.is_string()) {
+            ss << cur.as_string();
+        } else if (cur.is_integer()) {
+            ss << cur.as_integer();
+        } else if (cur.is_boolean()) {
+            ss << cur.as_boolean();
+        } else if (cur.is_floating()) {
+            ss << cur.as_floating();
+        } else if (cur.is_empty()) {
+            ss << "";
+        } else {
+            ss << toml::format(cur);
+        }
+        *value = ss.str();
+        return true;
+    } catch (const std::exception &e) {
+        TILE_LOG_WARNING_EVERY_SECOND("{}", e.what());
+        return false;
+    }
+}
+
+bool
+TomlConfiguration::SetRaw(const Slice &key, const Slice &value)
+{
+    if (key.empty()) { return false; }
+    auto keys = Split(key, '.');
+    try {
+        auto &root = **impl_;
+        for (size_t i = 0; i < keys.size() - 1; ++i) {
+            auto &next = toml::find(root, keys[i]);
+            root       = next;
+        }
+        root[keys.back()] = value.ToString();
+        return true;
+    } catch (const std::exception &e) {
+        TILE_LOG_WARNING_EVERY_SECOND("{}", e.what());
+        return false;
+    }
+}
+
+void
+TomlConfiguration::RemoveRaw(const Slice &key)
+{
+    if (key.empty()) { return; }
+    auto keys = Split(key, '.');
+    while (!keys.empty() && keys.back() == "") { keys.pop_back(); }
+    try {
+        if (keys.empty()) {
+            auto &root = **impl_;
+            root       = toml::table();
+            return;
+        }
+
+        auto root = **impl_;
+        for (size_t i = 0; i + 1 < keys.size(); ++i) {
+            if (!root.contains(keys[i])) { return; }
+            root = root.at(keys[i]);
+        }
+
+        if (!root.contains(keys.back())) { return; }
+        auto last_root = root.at(key.back());
+
+        // remove the last key
+        toml::value new_node = toml::table();
+        for (const auto &p : last_root.as_table()) {
+            if (p.first != keys.back()) { new_node[p.first] = p.second; }
+        }
+        last_root = new_node;
+    } catch (...) {}
+}
+
+Configuration::Keys
+TomlConfiguration::Enumerate(const Slice &range) const
+{
+    Configuration::Keys keys;
+    auto split_keys    = Split(range, '.');
+    auto last_key      = split_keys.empty() ? "" : split_keys.back();
+    std::string prefix = range;
+    if (!prefix.empty() && prefix.back() != '.') { prefix += "."; }
+
+    auto root = **impl_;
+    try {
+        // if (!root.is_empty()) {
+        for (int i = 0; i < split_keys.size(); ++i) {
+            auto next = toml::find(root, split_keys[i]);
+            root      = next;
+        }
+        // }
+
+        // if (root.is_empty()) { return keys; }
+
+        // for (const auto &k : keys_) {
+        //     auto next = toml::find(root, k);
+        //     root      = next;
+        // }
+
+        auto visitor = [&](const toml::value &node) {
+            if (node.is_table()) {
+                for (const auto &p : node.as_table()) {
+                    /*if (EndsWith(p.first, prefix)) */ {
+                        keys.push_back(prefix + p.first);
+                    }
+                }
+            }
+        };
+        toml::visit(visitor, root);
+        // TILE_LOG_INFO("{}", toml::format(root));
+    } catch (const std::exception &e) {
+        TILE_LOG_WARNING_EVERY_SECOND("{}\n{}\n", e.what(), Dump());
+    }
+    return keys;
+}
+
+}// namespace tile
diff --git a/tile/base/config/toml_configuration.h b/tile/base/config/toml_configuration.h
new file mode 100644
index 0000000..20d9b22
--- /dev/null
+++ b/tile/base/config/toml_configuration.h
@@ -0,0 +1,40 @@
+#ifndef TILE_BASE_CONFIG_TOML_CONFIGURATION_H
+#define TILE_BASE_CONFIG_TOML_CONFIGURATION_H
+
+#pragma once
+
+#include "tile/base/config/configuration.h"
+#include <map>
+
+namespace tile {
+class TomlConfiguration : public Configuration {
+public:
+    using Ptr = RefPtr<TomlConfiguration>;
+
+    TomlConfiguration();
+    ~TomlConfiguration() override;
+
+    bool load(std::istream &istr);
+    bool load(const std::string &path);
+
+    void SetInt(const Slice &key, int value) override;
+    void SetBool(const Slice &key, bool value) override;
+    void SetDouble(const Slice &key, double value) override;
+    void SetString(const Slice &key, const std::string &value) override;
+
+    void RemoveRaw(const Slice &key) override;
+    std::string Dump() const;
+
+protected:
+    bool GetRaw(const Slice &key, std::string *value) const override;
+    bool SetRaw(const Slice &key, const Slice &value) override;
+    Keys Enumerate(const Slice &range) const override;
+
+private:
+    class Impl;
+
+    std::unique_ptr<Impl> impl_;
+};
+}// namespace tile
+
+#endif// TILE_BASE_CONFIG_TOML_CONFIGURATION_H
diff --git a/tile/base/config/toml_configuration_test.cc b/tile/base/config/toml_configuration_test.cc
new file mode 100644
index 0000000..21511e8
--- /dev/null
+++ b/tile/base/config/toml_configuration_test.cc
@@ -0,0 +1,71 @@
+#include "tile/base/config/toml_configuration.h"
+
+#include "gmock/gmock-matchers.h"
+#include "gtest/gtest.h"
+
+namespace tile {
+namespace {
+const char *kTomlConfig = R"(
+key1=1
+key2=2
+key3=1.9
+key4=true
+
+[key5]
+key51="value51"
+key52=52
+)";
+}
+
+TEST(TomlConfiguration, Load)
+{
+    TomlConfiguration config;
+    std::istringstream istr(kTomlConfig);
+    ASSERT_TRUE(config.load(istr));
+}
+
+TEST(TomlConfiguration, Has)
+{
+    TomlConfiguration config;
+    std::istringstream istr(kTomlConfig);
+    ASSERT_TRUE(config.load(istr));
+    ASSERT_TRUE(config.Has("key1"));
+    ASSERT_TRUE(config.Has("key2"));
+    ASSERT_TRUE(config.Has("key3"));
+    ASSERT_TRUE(config.Has("key4"));
+    ASSERT_TRUE(config.Has("key5"));
+    ASSERT_TRUE(config.Has("key5.key51"));
+    ASSERT_TRUE(config.Has("key5.key52"));
+}
+
+TEST(TomlConfiguration, SampleSet)
+{
+    TomlConfiguration config;
+    std::istringstream istr(kTomlConfig);
+    ASSERT_TRUE(config.load(istr));
+    ASSERT_TRUE(config.GetInt32("key2"));
+    ASSERT_EQ(*config.GetInt32("key2"), 2);
+
+    config.SetInt("key2", 20);
+}
+
+TEST(TomlConfiguration, Enumerate)
+{
+    TomlConfiguration config;
+    std::istringstream istr(kTomlConfig);
+    ASSERT_TRUE(config.load(istr));
+    auto keys = config.keys("");
+    ASSERT_EQ(5, keys.size());
+    ASSERT_THAT(keys, ::testing::UnorderedElementsAre("key1", "key2", "key3", "key4", "key5"));
+
+    keys = config.keys("key5");
+    // for (const auto &key : keys) { TILE_LOG_INFO("key5: {}", key); }
+    ASSERT_EQ(2, keys.size());
+    ASSERT_THAT(keys, ::testing::UnorderedElementsAre("key5.key51", "key5.key52"));
+
+    config.Remove("key5.key51");
+    keys = config.keys("key5");
+    ASSERT_EQ("key5.key52", keys[0]);
+}
+
+}// namespace tile
diff --git a/tile/base/slice.h b/tile/base/slice.h
index f17ceec..8d130f9 100644
--- a/tile/base/slice.h
+++ b/tile/base/slice.h
@@ -175,8 +175,8 @@ public:
     inline operator string_t() const { return ToString(); }
 
 private:
-    const char *data_;
-    size_t len_;
+    const char *data_{nullptr};
+    size_t len_{0};
 };
 
 inline bool

From 729ee8b86c450e610214e174ba4faed29c0942be Mon Sep 17 00:00:00 2001
From: tqcq <99722391+tqcq@users.noreply.github.com>
Date: Mon, 30 Sep 2024 10:05:50 +0800
Subject: [PATCH 16/25] fix(string) Trim error

---
 CMakeLists.txt      | 10 +++++-----
 tile/base/string.cc | 20 --------------------
 tile/base/string.h  | 27 ++++++++++++++++++++++++---
 3 files changed, 29 insertions(+), 28 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 80a5fb2..c2a1bee 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -75,11 +75,11 @@ include(cmake/BuildInfo.cmake)
 check_symbol_exists("getifaddrs" "ifaddrs.h" TILE_HAVE_GETIFADDRS)
 check_symbol_exists("freeifaddrs" "ifaddrs.h" TILE_HAVE_FREEIFADDRS)
 
-find_package(Git REQUIRED)
-
-get_git_commit_hash(GIT_COMMIT_HASH)
-get_git_commit_date(GIT_COMMIT_DATE)
-get_git_commit_subject(GIT_COMMIT_SUBJECT)
+# find_package(Git REQUIRED)
+#
+# get_git_commit_hash(GIT_COMMIT_HASH)
+# get_git_commit_date(GIT_COMMIT_DATE)
+# get_git_commit_subject(GIT_COMMIT_SUBJECT)
 
 set(THIRD_PARTY_INCLUDE_DIRS
     # "third_party/json" "third_party/inja" 
diff --git a/tile/base/string.cc b/tile/base/string.cc
index 82c3b15..deb2c90 100644
--- a/tile/base/string.cc
+++ b/tile/base/string.cc
@@ -139,26 +139,6 @@ Trim(Slice s, Slice cutset)
     return Trim(s, [&cutset](char c) { return cutset.find(Slice(&c, 1)) != Slice::npos; });
 }
 
-Slice
-TrimLeft(Slice s, std::function<bool(char)> pred)
-{
-    while (!s.empty() && pred(s[0])) { s.RemovePrefix(1); }
-    return s;
-}
-
-Slice
-TrimRight(Slice s, std::function<bool(char)> pred)
-{
-    while (!s.empty() && pred(s[s.size() - 1])) { s.RemoveSuffix(1); }
-    return s;
-}
-
-Slice
-Trim(Slice s, std::function<bool(char)> pred)
-{
-    return TrimRight(TrimLeft(s, pred), pred);
-}
-
 template<typename T>
 void
 JoinImpl(const T &parts, Slice delim, std::string *result)
diff --git a/tile/base/string.h b/tile/base/string.h
index 267ed5d..067e737 100644
--- a/tile/base/string.h
+++ b/tile/base/string.h
@@ -8,6 +8,7 @@
 #include "tile/base/optional.h"
 #include "tile/base/slice.h"
 
+#include <cctype>
 #include <limits>
 #include <string>
 #include <vector>
@@ -41,9 +42,29 @@ std::string Replace(Slice str, Slice from, Slice to, std::size_t count = std::nu
 Slice TrimLeft(Slice s, Slice cutset);
 Slice TrimRight(Slice s, Slice cutset);
 Slice Trim(Slice s, Slice cutset);
-Slice TrimLeft(Slice s, std::function<bool(char)> pred = isspace);
-Slice TrimRight(Slice s, std::function<bool(char)> pred = isspace);
-Slice Trim(Slice s, std::function<bool(char)> pred = isspace);
+
+template<typename Pred = decltype(isspace)>
+Slice
+TrimLeft(Slice s, Pred pred = isspace)
+{
+    while (!s.empty() && pred(s[0])) { s.RemovePrefix(1); }
+    return s;
+}
+
+template<typename Pred = decltype(isspace)>
+Slice
+TrimRight(Slice s, Pred pred = isspace)
+{
+    while (!s.empty() && pred(s[s.size() - 1])) { s.RemoveSuffix(1); }
+    return s;
+}
+
+template<typename Pred = decltype(isspace)>
+Slice
+Trim(Slice s, Pred pred = isspace)
+{
+    return TrimRight(TrimLeft(s, pred), pred);
+}
 
 std::vector<Slice> Split(Slice s,
                          char delim,

From 64b25815a27ad78719e7a77cfca49e827a294d6a Mon Sep 17 00:00:00 2001
From: tqcq <99722391+tqcq@users.noreply.github.com>
Date: Mon, 30 Sep 2024 10:07:56 +0800
Subject: [PATCH 17/25] fix(string): use custom type

---
 tile/base/string.h | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/tile/base/string.h b/tile/base/string.h
index 067e737..45c865b 100644
--- a/tile/base/string.h
+++ b/tile/base/string.h
@@ -43,7 +43,7 @@ Slice TrimLeft(Slice s, Slice cutset);
 Slice TrimRight(Slice s, Slice cutset);
 Slice Trim(Slice s, Slice cutset);
 
-template<typename Pred = decltype(isspace)>
+template<typename Pred = int(int)>
 Slice
 TrimLeft(Slice s, Pred pred = isspace)
 {
@@ -51,7 +51,7 @@ TrimLeft(Slice s, Pred pred = isspace)
     return s;
 }
 
-template<typename Pred = decltype(isspace)>
+template<typename Pred = int(int)>
 Slice
 TrimRight(Slice s, Pred pred = isspace)
 {
@@ -59,7 +59,7 @@ TrimRight(Slice s, Pred pred = isspace)
     return s;
 }
 
-template<typename Pred = decltype(isspace)>
+template<typename Pred = int(int)>
 Slice
 Trim(Slice s, Pred pred = isspace)
 {

From 80eb00711bd5f46e147ead7e2a6fee26c8b6340c Mon Sep 17 00:00:00 2001
From: tqcq <99722391+tqcq@users.noreply.github.com>
Date: Mon, 30 Sep 2024 17:10:22 +0800
Subject: [PATCH 18/25] fix(variant): use mpark:xxx

---
 tile/base/future/boxed.h | 4 ++--
 tile/base/future/core.h  | 2 +-
 tile/base/variant.h      | 8 --------
 3 files changed, 3 insertions(+), 11 deletions(-)

diff --git a/tile/base/future/boxed.h b/tile/base/future/boxed.h
index 8ad461f..d168e75 100644
--- a/tile/base/future/boxed.h
+++ b/tile/base/future/boxed.h
@@ -89,7 +89,7 @@ private:
     }
 
 private:
-    std::variant<mpark::monostate, value_type> holding_;
+    mpark::variant<mpark::monostate, value_type> holding_;
 };
 
 static_assert(std::is_void<decltype(std::declval<Boxed<>>().Get())>::value, "");
@@ -110,7 +110,7 @@ RetrieveBoxed()
 
 template<typename... Ts>
 template<typename... Us, typename>
-Boxed<Ts...>::Boxed(box_values_t, Us &&...imms) : holding_(std::in_place_index_t<kValue>(), std::forward<Us>(imms)...)
+Boxed<Ts...>::Boxed(box_values_t, Us &&...imms) : holding_(mpark::in_place_index_t<kValue>(), std::forward<Us>(imms)...)
 {}
 
 template<typename... Ts>
diff --git a/tile/base/future/core.h b/tile/base/future/core.h
index e10e8db..97b4829 100644
--- a/tile/base/future/core.h
+++ b/tile/base/future/core.h
@@ -43,7 +43,7 @@ private:
 private:
     // std::mutex lock_;
     Mutex lock_;
-    std::variant<WaitingForSingleObject, Satisfied> state_;
+    mpark::variant<WaitingForSingleObject, Satisfied> state_;
     Executor executor_;
 };
 
diff --git a/tile/base/variant.h b/tile/base/variant.h
index a764f46..894971f 100644
--- a/tile/base/variant.h
+++ b/tile/base/variant.h
@@ -3,14 +3,6 @@
 
 #pragma once
 
-#if __cplusplus >= 201703L
-#include <variant>
-#else
 #include "tile/base/internal/variant.h"
 
-namespace std {
-using namespace mpark;
-}
-#endif
-
 #endif// TILE_BASE_VARIANT_H

From dc02ceb9b06f601d0d1ea6b167b028e994f2f98a Mon Sep 17 00:00:00 2001
From: tqcq <99722391+tqcq@users.noreply.github.com>
Date: Wed, 2 Oct 2024 09:32:05 +0800
Subject: [PATCH 19/25] feat(configuration): add toml config

---
 tile/base/configuration.h |  1 +
 tile/base/slice.h         |  2 ++
 tile/tile.h               | 12 ++++++++++++
 3 files changed, 15 insertions(+)

diff --git a/tile/base/configuration.h b/tile/base/configuration.h
index 50cf5f3..af53510 100644
--- a/tile/base/configuration.h
+++ b/tile/base/configuration.h
@@ -7,5 +7,6 @@
 #include "tile/base/config/configuration.h"
 #include "tile/base/config/ini_file_configuration.h"
 #include "tile/base/config/layered_configuration.h"
+#include "tile/base/config/toml_configuration.h"
 
 #endif// TILE_BASE_CONFIGURATION_H
diff --git a/tile/base/slice.h b/tile/base/slice.h
index 8d130f9..8ec1435 100644
--- a/tile/base/slice.h
+++ b/tile/base/slice.h
@@ -75,6 +75,8 @@ public:
     // const char*
     Slice(const char *c_str) : data_(c_str), len_(strlen(c_str)) {}
 
+    Slice(const void *data, size_t len) : data_(reinterpret_cast<const char *>(data)), len_(len) {}
+
     constexpr Slice(const char *begin, const char *end) : data_(begin), len_(end - begin) {}
 
     constexpr Slice(const char *data, size_t len) : data_(data), len_(len) {}
diff --git a/tile/tile.h b/tile/tile.h
index 7d72a4c..de94d47 100644
--- a/tile/tile.h
+++ b/tile/tile.h
@@ -38,6 +38,15 @@
 #include "tile/base/variant.h"
 #include "tile/base/write_mostly.h"
 
+// Sync
+#include "tile/base/thread/cond_var.h"
+#include "tile/base/thread/event.h"
+#include "tile/base/thread/latch.h"
+#include "tile/base/thread/mutex.h"
+#include "tile/base/thread/rw_mutex.h"
+#include "tile/base/thread/scoped_lock.h"
+#include "tile/base/thread/unique_lock.h"
+
 // util
 #include "tile/base/configuration.h"
 
@@ -49,4 +58,7 @@
 // Tile Init
 #include "tile/init.h"
 
+// sigslot
+#include "sigslot/sigslot.h"
+
 #endif// TILE_TILE_H

From 791125454a662bef98753cc019534248b5e77f82 Mon Sep 17 00:00:00 2001
From: tqcq <99722391+tqcq@users.noreply.github.com>
Date: Wed, 2 Oct 2024 11:33:08 +0800
Subject: [PATCH 20/25] fix(event): template error

---
 tile/base/thread/cond_var.h | 1 +
 tile/base/thread/event.h    | 5 ++---
 tile/tile.h                 | 1 -
 3 files changed, 3 insertions(+), 4 deletions(-)

diff --git a/tile/base/thread/cond_var.h b/tile/base/thread/cond_var.h
index 9118a03..41e1d73 100644
--- a/tile/base/thread/cond_var.h
+++ b/tile/base/thread/cond_var.h
@@ -113,6 +113,7 @@ private:
     }
 
 private:
+    friend class ScopedLock;
     CondVarProxy proxy_;
 };
 }// namespace cond_var
diff --git a/tile/base/thread/event.h b/tile/base/thread/event.h
index 61f9c2b..8386191 100644
--- a/tile/base/thread/event.h
+++ b/tile/base/thread/event.h
@@ -3,7 +3,6 @@
 
 #pragma once
 
-#include "tile/base/thread/cond_var.h"
 #include "tile/base/thread/mutex.h"
 #include "tile/base/thread/scoped_lock.h"
 
@@ -30,7 +29,7 @@ public:
     inline void Wait()
     {
         ScopedLock _(m_);
-        cv_.Wait(m_, [this] { return signaled_; });
+        cv_.Wait(_, [this] { return signaled_; });
         ResetIfNeeded();
     }
 
@@ -49,7 +48,7 @@ public:
     bool WaitUntil(const std::chrono::time_point<Clock, Duration> &timeout_time)
     {
         ScopedLock _(m_);
-        if (cv_.WaitUntil(m_, timeout_time, [this] { return signaled_; })) {
+        if (cv_.WaitUntil(_, timeout_time, [this] { return signaled_; })) {
             ResetIfNeeded();
             return true;
         }
diff --git a/tile/tile.h b/tile/tile.h
index de94d47..e05523a 100644
--- a/tile/tile.h
+++ b/tile/tile.h
@@ -39,7 +39,6 @@
 #include "tile/base/write_mostly.h"
 
 // Sync
-#include "tile/base/thread/cond_var.h"
 #include "tile/base/thread/event.h"
 #include "tile/base/thread/latch.h"
 #include "tile/base/thread/mutex.h"

From 471fcca5b7874adf6eeb94f68a8ac47abc64d2e5 Mon Sep 17 00:00:00 2001
From: tqcq <99722391+tqcq@users.noreply.github.com>
Date: Wed, 2 Oct 2024 14:48:53 +0800
Subject: [PATCH 21/25] fix(curl): disable lto

---
 third_party/curl/CMakeLists.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/third_party/curl/CMakeLists.txt b/third_party/curl/CMakeLists.txt
index f4a42d1..8e7297e 100644
--- a/third_party/curl/CMakeLists.txt
+++ b/third_party/curl/CMakeLists.txt
@@ -107,7 +107,7 @@ if(WIN32)
     endif()
   endif()
 endif()
-option(CURL_LTO "Turn on compiler Link Time Optimizations" ON)
+option(CURL_LTO "Turn on compiler Link Time Optimizations" OFF)
 
 cmake_dependent_option(ENABLE_THREADED_RESOLVER "Set to ON to enable threaded DNS lookup"
         ON "NOT ENABLE_ARES"

From 6f68f497f4b62d17b5bdb4facef8914b82430895 Mon Sep 17 00:00:00 2001
From: tqcq <99722391+tqcq@users.noreply.github.com>
Date: Thu, 3 Oct 2024 14:32:30 +0800
Subject: [PATCH 22/25] feat(tile.h): add aux

---
 tile/init.h | 3 +++
 tile/tile.h | 3 +++
 2 files changed, 6 insertions(+)

diff --git a/tile/init.h b/tile/init.h
index f81d892..a7ea234 100644
--- a/tile/init.h
+++ b/tile/init.h
@@ -20,4 +20,7 @@ void TerminateBasicRuntime();
 
 }// namespace tile
 
+#define TILE_MAIN(func)                                                                                                \
+    int main(int argc, char *argv[]) { return ::tile::Start(argc, argv, func); }
+
 #endif// TILE_INIT_H
diff --git a/tile/tile.h b/tile/tile.h
index e05523a..18271fa 100644
--- a/tile/tile.h
+++ b/tile/tile.h
@@ -60,4 +60,7 @@
 // sigslot
 #include "sigslot/sigslot.h"
 
+// gflags
+#include "gflags/gflags.h"
+
 #endif// TILE_TILE_H

From 7c4395e897a4a434f17433cc9744d2300a08b336 Mon Sep 17 00:00:00 2001
From: tqcq <99722391+tqcq@users.noreply.github.com>
Date: Sun, 6 Oct 2024 15:25:22 +0800
Subject: [PATCH 23/25] feat add console sink

---
 tile/base/internal/logging.cc           | 54 +++++++++++++++++++++----
 tile/base/internal/logging.h            |  1 +
 tile/base/internal/logging_test.cc      | 16 ++++----
 tile/base/logging/basic_file_sink.h     |  3 ++
 tile/base/logging/console_sink.cc       |  8 +---
 tile/base/logging/console_sink.h        |  2 +
 tile/base/logging/splitter_sink.h       |  2 +
 tile/base/logging/splitter_sink_test.cc |  2 +
 8 files changed, 68 insertions(+), 20 deletions(-)

diff --git a/tile/base/internal/logging.cc b/tile/base/internal/logging.cc
index da17c4c..f14e07e 100644
--- a/tile/base/internal/logging.cc
+++ b/tile/base/internal/logging.cc
@@ -1,5 +1,6 @@
 #include "tile/base/internal/logging.h"
 #include <cassert>
+#include <cstdio>
 #include <iostream>
 #include <map>
 #include <mutex>
@@ -9,6 +10,14 @@ namespace tile {
 namespace internal {
 namespace logging {
 
+static const char *LOG_CONST_TABLE[][3] = {
+    {"\033[46;37m", "\033[36m", "I"},
+    {"\033[43;37m", "\033[33m", "W"},
+    {"\033[41;37m", "\033[31m", "E"},
+    {"\033[44;37m", "\033[34m", "T"},
+    {"\033[42;37m", "\033[32m", "D"},
+};
+
 namespace {
 std::vector<PrefixAppender *> *
 GetProviers()
@@ -97,7 +106,12 @@ public:
     {
         if (has_been_flushed_) { return; }
 
-        num_chars_to_log_         = stream_.pcount();
+        num_chars_to_log_ = stream_.pcount();
+        if (num_chars_to_log_ == 0) {
+            message_text_[0] = '\n';
+            ++num_chars_to_log_;
+        }
+
         const bool append_newline = message_text_[num_chars_to_log_ - 1] != '\n';
         char original_final_char  = '\0';
 
@@ -108,11 +122,18 @@ public:
         message_text_[num_chars_to_log_] = '\0';
 
         {
-            std::lock_guard<std::mutex> _{g_log_mutex};
+            std::lock_guard<std::mutex> _(g_log_mutex);
             (this->*(send_method_))();
             ++g_num_messages[severity_];
             WaitForSinks();
-            if (sink_) { sink_->Flush(); }
+            if (sink_) {
+                try {
+                    sink_->Flush();
+                } catch (const std::exception &e) {
+                    fprintf(stderr, "\nLogSink[name=%s], reason=%s\n", sink_->name(), e.what());
+                    assert(false);
+                }
+            }
         }
 
         if (append_newline) { message_text_[num_chars_to_log_ - 1] = original_final_char; }
@@ -163,8 +184,10 @@ private:
         if (g_sink_count.load(std::memory_order_relaxed) == 0) {
             ColoredWriteToStdout(severity_, message_text_ + num_prefix_chars_, num_chars_to_log_ - num_chars_to_log_);
         }
-        LogToSinks(severity_, fullname(), basename(), line(), time(), message_text_ + num_prefix_chars_,
-                   num_chars_to_log_ - num_prefix_chars_ - 1);
+        // HACK: temp fix
+        auto msg_len = num_chars_to_log_ - num_prefix_chars_ - 1;
+        msg_len      = msg_len > (LogMessage::kMaxLogMessageLen + 1) ? 0 : msg_len;
+        LogToSinks(severity_, fullname(), basename(), line(), time(), message_text_ + num_prefix_chars_, msg_len);
     }
 
     void SendToSinkAndLog()
@@ -392,6 +415,11 @@ LogSink::ToString(LogSeverity severity,
 static void
 ColoredWriteToStderrOrStdout(FILE *output, LogSeverity severity, const char *message, size_t len)
 {
+    char buf[30];
+    {
+        int n = snprintf(buf, 30, "%s", internal::logging::LOG_CONST_TABLE[severity][1]);
+        fwrite(buf, n, 1, output);
+    }
     fwrite(message, len, 1, output);
     fflush(output);
 }
@@ -446,7 +474,12 @@ LogToSinks(LogSeverity severity,
     std::lock_guard<std::mutex> _(g_sink_mutex);
     for (auto &&sink : g_sinks) {
         if (sink->ShouldLog(severity)) {
-            sink->Send(severity, full_filename, base_filename, line, time, message, message_len);
+            try {
+                sink->Send(severity, full_filename, base_filename, line, time, message, message_len);
+            } catch (const std::exception &e) {
+                fprintf(stderr, "\nLogSink[name=%s], reason=%s\n", sink->name(), e.what());
+                assert(false);
+            }
         }
     }
 }
@@ -455,7 +488,14 @@ void
 WaitForSinks()
 {
     std::lock_guard<std::mutex> _(g_sink_mutex);
-    for (auto &&sink : g_sinks) { sink->Flush(); }
+    for (auto &&sink : g_sinks) {
+        try {
+            sink->Flush();
+        } catch (const std::exception &e) {
+            fprintf(stderr, "\nLogSink[name=%s], reason=%s\n", sink->name(), e.what());
+            assert(false);
+        }
+    }
 }
 
 const char *
diff --git a/tile/base/internal/logging.h b/tile/base/internal/logging.h
index 5bcc717..ef9c6a5 100644
--- a/tile/base/internal/logging.h
+++ b/tile/base/internal/logging.h
@@ -610,6 +610,7 @@ public:
     using Ptr = std::shared_ptr<LogSink>;
 
     virtual ~LogSink();
+    virtual const char *name() const = 0;
     virtual bool ShouldLog(LogSeverity severity);
     virtual void Send(LogSeverity severity,
                       const char *full_filename,
diff --git a/tile/base/internal/logging_test.cc b/tile/base/internal/logging_test.cc
index 6592036..8c05296 100644
--- a/tile/base/internal/logging_test.cc
+++ b/tile/base/internal/logging_test.cc
@@ -11,13 +11,15 @@
 struct AwesomeLogSink : public tile::LogSink {
     static std::shared_ptr<AwesomeLogSink> Create() { return std::make_shared<AwesomeLogSink>(); }
 
-    virtual void Send(tile::LogSeverity severity,
-                      const char *full_filename,
-                      const char *base_filename,
-                      int line,
-                      const tile::LogMessageTime &logmsgtime,
-                      const char *message,
-                      size_t message_len) override
+    const char *name() const override { return "AwesomeLogSink"; }
+
+    void Send(tile::LogSeverity severity,
+              const char *full_filename,
+              const char *base_filename,
+              int line,
+              const tile::LogMessageTime &logmsgtime,
+              const char *message,
+              size_t message_len) override
     {
         msgs.emplace_back(std::string(message, message_len));
     }
diff --git a/tile/base/logging/basic_file_sink.h b/tile/base/logging/basic_file_sink.h
index b0d4d18..03cf5f0 100644
--- a/tile/base/logging/basic_file_sink.h
+++ b/tile/base/logging/basic_file_sink.h
@@ -14,6 +14,9 @@ public:
     static Ptr Create(const std::string &filepath);
 
     ~BasicFileSink() override;
+
+    const char *name() const override { return "BasicFileSink"; }
+
     void Send(LogSeverity severity,
               const char *full_filename,
               const char *base_filename,
diff --git a/tile/base/logging/console_sink.cc b/tile/base/logging/console_sink.cc
index c1f353f..453c62e 100644
--- a/tile/base/logging/console_sink.cc
+++ b/tile/base/logging/console_sink.cc
@@ -22,12 +22,8 @@ ConsoleSink::Send(LogSeverity severity,
                   size_t message_len)
 {
     auto msg = ToString(severity, full_filename, base_filename, line, logmsgtime, message, message_len);
-    while (!msg.empty() && msg.back() == '\n') { msg.pop_back(); }
-    if (severity >= TILE_FATAL) {
-        fprintf(stderr, "%s\n", msg.c_str());
-    } else {
-        fprintf(stdout, "%s\n", msg.c_str());
-    }
+    while (!msg.empty() && msg.back() != '\n') { msg.push_back('\n'); }
+    ColoredWriteToStdout(severity, msg.c_str(), msg.size());
 }
 
 void
diff --git a/tile/base/logging/console_sink.h b/tile/base/logging/console_sink.h
index 73d7c39..10abf1f 100644
--- a/tile/base/logging/console_sink.h
+++ b/tile/base/logging/console_sink.h
@@ -11,6 +11,8 @@ public:
     using Ptr = std::shared_ptr<ConsoleSink>;
     static Ptr Create();
 
+    const char *name() const override { return "ConsoleSink"; }
+
     ~ConsoleSink() override;
     void Send(LogSeverity severity,
               const char *full_filename,
diff --git a/tile/base/logging/splitter_sink.h b/tile/base/logging/splitter_sink.h
index 58b45e8..1cd814c 100644
--- a/tile/base/logging/splitter_sink.h
+++ b/tile/base/logging/splitter_sink.h
@@ -14,6 +14,8 @@ public:
     static Ptr Create();
     static Ptr Create(std::initializer_list<std::shared_ptr<LogSink>> init_list);
 
+    const char *name() const override { return "SplitterSink"; }
+
     ~SplitterSink() override;
 
     void Send(LogSeverity severity,
diff --git a/tile/base/logging/splitter_sink_test.cc b/tile/base/logging/splitter_sink_test.cc
index 1728026..1e7e0af 100644
--- a/tile/base/logging/splitter_sink_test.cc
+++ b/tile/base/logging/splitter_sink_test.cc
@@ -8,6 +8,8 @@ public:
 
     static Ptr Create() { return std::shared_ptr<SimpleSink>(new SimpleSink()); }
 
+    const char *name() const override { return "SimpleSink"; }
+
     void Send(LogSeverity severity,
               const char *full_filename,
               const char *base_filename,

From f5d3fcdf63737d19395a1ff8781998d4cdff03f2 Mon Sep 17 00:00:00 2001
From: tqcq <99722391+tqcq@users.noreply.github.com>
Date: Mon, 7 Oct 2024 17:40:29 +0800
Subject: [PATCH 24/25] fix(date): file log add date, month start with 1

---
 tile/base/internal/logging.cc        | 2 +-
 tile/base/logging/basic_file_sink.cc | 2 ++
 2 files changed, 3 insertions(+), 1 deletion(-)

diff --git a/tile/base/internal/logging.cc b/tile/base/internal/logging.cc
index f14e07e..e04c4b7 100644
--- a/tile/base/internal/logging.cc
+++ b/tile/base/internal/logging.cc
@@ -389,7 +389,7 @@ LogSink::ToString(LogSeverity severity,
 {
     std::stringstream ss;
     char date_time[64];
-    sprintf(date_time, "%4d-%02d-%02dT%02d:%02d:%02d.%06d", logmsgtime.year() + 1900, logmsgtime.month(),
+    sprintf(date_time, "%4d-%02d-%02dT%02d:%02d:%02d.%06d", logmsgtime.year() + 1900, logmsgtime.month() + 1,
             logmsgtime.day(), logmsgtime.hour(), logmsgtime.min(), logmsgtime.sec(), logmsgtime.usec());
 
     ss << date_time;
diff --git a/tile/base/logging/basic_file_sink.cc b/tile/base/logging/basic_file_sink.cc
index 38d5210..6648d0b 100644
--- a/tile/base/logging/basic_file_sink.cc
+++ b/tile/base/logging/basic_file_sink.cc
@@ -23,6 +23,8 @@ BasicFileSink::Send(LogSeverity severity,
                     size_t message_len)
 {
     TILE_CHECK(!filepath_.empty(), "filepath is empty");
+    auto msg = ToString(severity, full_filename, base_filename, line, logmsgtime, message, message_len);
+    while (!msg.empty() && msg.back() != '\n') { msg.push_back('\n'); }
     ofs_ << std::string(message, message_len) << std::endl;
 }
 

From c4fd274e6620a8756ace090ec4879476ea2e9fb6 Mon Sep 17 00:00:00 2001
From: tqcq <99722391+tqcq@users.noreply.github.com>
Date: Sat, 12 Oct 2024 16:04:18 +0800
Subject: [PATCH 25/25] feat: support static

---
 CMakeLists.txt | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index c2a1bee..e2d0272 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -27,7 +27,6 @@ option(TILE_BUILD_TESTS "Build tests" OFF)
 option(TILE_BUILD_BENCHMARKS "Build tests" OFF)
 option(TILE_WITH_OPENSSL "Build with openssl" OFF)
 option(TILE_BUILD_SHARED "Build shared library" ON)
-option(TILE_BUILD_STATIC "Build static library" ON)
 
 if(CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_SOURCE_DIR)
   set(TILE_BUILD_TESTS ON)
@@ -226,7 +225,11 @@ if((NOT TILE_HAVE_GETIFADDRS) OR (NOT TILE_HAVE_FREEIFADDRS))
   list(APPEND TILE_SRCS "tile/base/net/detail/android/ifaddrs.c")
 endif()
 
-add_library(tile SHARED ${TILE_SRCS})
+if (TILE_BUILD_SHARED)
+    add_library(tile SHARED ${TILE_SRCS})
+else()
+    add_library(tile STATIC ${TILE_SRCS})
+endif()
 set_target_properties(tile PROPERTIES VERSION ${PROJECT_VERSION}
 target_precompile_headers(tile PUBLIC inja/inja.h)
 target_precompile_headers(tile PUBLIC inja/string_view.h)