From 1633268d57f7b0713bc6564af725c3a8506f8eb1 Mon Sep 17 00:00:00 2001
From: ToruNiina <niina.toru.68u@gmail.com>
Date: Thu, 30 May 2019 14:39:15 +0900
Subject: [PATCH] refactor: use snake_case typename only

---
 toml/get.hpp   |  2 +-
 toml/types.hpp | 40 ++++++++++++++++-----------------
 toml/value.hpp | 60 +++++++++++++++++++++++++-------------------------
 3 files changed, 51 insertions(+), 51 deletions(-)

diff --git a/toml/get.hpp b/toml/get.hpp
index c326846..cf2cec4 100644
--- a/toml/get.hpp
+++ b/toml/get.hpp
@@ -276,7 +276,7 @@ namespace detail
 {
 
 template<typename T, std::size_t ...I>
-T get_tuple_impl(const toml::Array& a, index_sequence<I...>)
+T get_tuple_impl(const toml::array& a, index_sequence<I...>)
 {
     return std::make_tuple(
         ::toml::get<typename std::tuple_element<I, T>::type>(a.at(I))...);
diff --git a/toml/types.hpp b/toml/types.hpp
index b879176..a221d84 100644
--- a/toml/types.hpp
+++ b/toml/types.hpp
@@ -131,30 +131,30 @@ template<> struct toml_default_type<value_t::Table   >      {typedef table
 template<> struct toml_default_type<value_t::Empty   >      {typedef void            type;};
 template<> struct toml_default_type<value_t::Unknown >      {typedef void            type;};
 
-template<typename T> struct toml_value_t      {static constexpr value_t value = value_t::Unknown       ;};
-template<> struct toml_value_t<Boolean       >{static constexpr value_t value = value_t::Boolean       ;};
-template<> struct toml_value_t<Integer       >{static constexpr value_t value = value_t::Integer       ;};
-template<> struct toml_value_t<Float         >{static constexpr value_t value = value_t::Float         ;};
-template<> struct toml_value_t<String        >{static constexpr value_t value = value_t::String        ;};
-template<> struct toml_value_t<OffsetDatetime>{static constexpr value_t value = value_t::OffsetDatetime;};
-template<> struct toml_value_t<LocalDatetime >{static constexpr value_t value = value_t::LocalDatetime ;};
-template<> struct toml_value_t<LocalDate     >{static constexpr value_t value = value_t::LocalDate     ;};
-template<> struct toml_value_t<LocalTime     >{static constexpr value_t value = value_t::LocalTime     ;};
-template<> struct toml_value_t<Array         >{static constexpr value_t value = value_t::Array         ;};
-template<> struct toml_value_t<Table         >{static constexpr value_t value = value_t::Table         ;};
+template<typename T> struct toml_value_t       {static constexpr value_t value = value_t::Unknown       ;};
+template<> struct toml_value_t<boolean        >{static constexpr value_t value = value_t::Boolean       ;};
+template<> struct toml_value_t<integer        >{static constexpr value_t value = value_t::Integer       ;};
+template<> struct toml_value_t<floating       >{static constexpr value_t value = value_t::Float         ;};
+template<> struct toml_value_t<string         >{static constexpr value_t value = value_t::String        ;};
+template<> struct toml_value_t<offset_datetime>{static constexpr value_t value = value_t::OffsetDatetime;};
+template<> struct toml_value_t<local_datetime >{static constexpr value_t value = value_t::LocalDatetime ;};
+template<> struct toml_value_t<local_date     >{static constexpr value_t value = value_t::LocalDate     ;};
+template<> struct toml_value_t<local_time     >{static constexpr value_t value = value_t::LocalTime     ;};
+template<> struct toml_value_t<array          >{static constexpr value_t value = value_t::Array         ;};
+template<> struct toml_value_t<table          >{static constexpr value_t value = value_t::Table         ;};
 
 template<typename T>
 struct is_exact_toml_type : disjunction<
-    std::is_same<T, Boolean >,
-    std::is_same<T, Integer >,
-    std::is_same<T, Float   >,
-    std::is_same<T, String  >,
+    std::is_same<T, boolean        >,
+    std::is_same<T, integer        >,
+    std::is_same<T, floating       >,
+    std::is_same<T, string         >,
     std::is_same<T, offset_datetime>,
-    std::is_same<T, local_datetime>,
-    std::is_same<T, local_date>,
-    std::is_same<T, local_time>,
-    std::is_same<T, Array   >,
-    std::is_same<T, Table   >
+    std::is_same<T, local_datetime >,
+    std::is_same<T, local_date     >,
+    std::is_same<T, local_time     >,
+    std::is_same<T, array          >,
+    std::is_same<T, table          >
     >{};
 template<typename T> struct is_exact_toml_type<T&>               : is_exact_toml_type<T>{};
 template<typename T> struct is_exact_toml_type<T const&>         : is_exact_toml_type<T>{};
diff --git a/toml/value.hpp b/toml/value.hpp
index 7f6f42b..e42e6f5 100644
--- a/toml/value.hpp
+++ b/toml/value.hpp
@@ -759,72 +759,72 @@ struct switch_cast;
 template<>
 struct switch_cast<value_t::Boolean>
 {
-    static Boolean&       invoke(value&       v) {return v.as_boolean();}
-    static Boolean const& invoke(value const& v) {return v.as_boolean();}
-    static Boolean&&      invoke(value&&      v) {return std::move(v).as_boolean();}
+    static ::toml::boolean&       invoke(value&       v) {return v.as_boolean();}
+    static ::toml::boolean const& invoke(value const& v) {return v.as_boolean();}
+    static ::toml::boolean&&      invoke(value&&      v) {return std::move(v).as_boolean();}
 };
 template<>
 struct switch_cast<value_t::Integer>
 {
-    static Integer&       invoke(value&       v) {return v.as_integer();}
-    static Integer const& invoke(value const& v) {return v.as_integer();}
-    static Integer&&      invoke(value&&      v) {return std::move(v).as_integer();}
+    static ::toml::integer&       invoke(value&       v) {return v.as_integer();}
+    static ::toml::integer const& invoke(value const& v) {return v.as_integer();}
+    static ::toml::integer&&      invoke(value&&      v) {return std::move(v).as_integer();}
 };
 template<>
 struct switch_cast<value_t::Float>
 {
-    static Float&       invoke(value&       v) {return v.as_float();}
-    static Float const& invoke(value const& v) {return v.as_float();}
-    static Float&&      invoke(value&&      v) {return std::move(v).as_float();}
+    static ::toml::floating&       invoke(value&       v) {return v.as_float();}
+    static ::toml::floating const& invoke(value const& v) {return v.as_float();}
+    static ::toml::floating&&      invoke(value&&      v) {return std::move(v).as_float();}
 };
 template<>
 struct switch_cast<value_t::String>
 {
-    static String&       invoke(value&       v) {return v.as_string();}
-    static String const& invoke(value const& v) {return v.as_string();}
-    static String&&      invoke(value&&      v) {return std::move(v).as_string();}
+    static ::toml::string&       invoke(value&       v) {return v.as_string();}
+    static ::toml::string const& invoke(value const& v) {return v.as_string();}
+    static ::toml::string&&      invoke(value&&      v) {return std::move(v).as_string();}
 };
 template<>
 struct switch_cast<value_t::OffsetDatetime>
 {
-    static OffsetDatetime&       invoke(value&       v) {return v.as_offset_datetime();}
-    static OffsetDatetime const& invoke(value const& v) {return v.as_offset_datetime();}
-    static OffsetDatetime&&      invoke(value&&      v) {return std::move(v).as_offset_datetime();}
+    static ::toml::offset_datetime&       invoke(value&       v) {return v.as_offset_datetime();}
+    static ::toml::offset_datetime const& invoke(value const& v) {return v.as_offset_datetime();}
+    static ::toml::offset_datetime&&      invoke(value&&      v) {return std::move(v).as_offset_datetime();}
 };
 template<>
 struct switch_cast<value_t::LocalDatetime>
 {
-    static LocalDatetime&       invoke(value&       v) {return v.as_local_datetime();}
-    static LocalDatetime const& invoke(value const& v) {return v.as_local_datetime();}
-    static LocalDatetime&&      invoke(value&&      v) {return std::move(v).as_local_datetime();}
+    static ::toml::local_datetime&       invoke(value&       v) {return v.as_local_datetime();}
+    static ::toml::local_datetime const& invoke(value const& v) {return v.as_local_datetime();}
+    static ::toml::local_datetime&&      invoke(value&&      v) {return std::move(v).as_local_datetime();}
 };
 template<>
 struct switch_cast<value_t::LocalDate>
 {
-    static LocalDate&       invoke(value&       v) {return v.as_local_date();}
-    static LocalDate const& invoke(value const& v) {return v.as_local_date();}
-    static LocalDate&&      invoke(value&&      v) {return std::move(v).as_local_date();}
+    static ::toml::local_date&       invoke(value&       v) {return v.as_local_date();}
+    static ::toml::local_date const& invoke(value const& v) {return v.as_local_date();}
+    static ::toml::local_date&&      invoke(value&&      v) {return std::move(v).as_local_date();}
 };
 template<>
 struct switch_cast<value_t::LocalTime>
 {
-    static LocalTime&       invoke(value&       v) {return v.as_local_time();}
-    static LocalTime const& invoke(value const& v) {return v.as_local_time();}
-    static LocalTime&&      invoke(value&&      v) {return std::move(v).as_local_time();}
+    static ::toml::local_time&       invoke(value&       v) {return v.as_local_time();}
+    static ::toml::local_time const& invoke(value const& v) {return v.as_local_time();}
+    static ::toml::local_time&&      invoke(value&&      v) {return std::move(v).as_local_time();}
 };
 template<>
 struct switch_cast<value_t::Array>
 {
-    static Array&       invoke(value&       v) {return v.as_array();}
-    static Array const& invoke(value const& v) {return v.as_array();}
-    static Array&&      invoke(value&&      v) {return std::move(v).as_array();}
+    static ::toml::array&       invoke(value&       v) {return v.as_array();}
+    static ::toml::array const& invoke(value const& v) {return v.as_array();}
+    static ::toml::array&&      invoke(value&&      v) {return std::move(v).as_array();}
 };
 template<>
 struct switch_cast<value_t::Table>
 {
-    static Table&       invoke(value&       v) {return v.as_table();}
-    static Table const& invoke(value const& v) {return v.as_table();}
-    static Table&&      invoke(value&&      v) {return std::move(v).as_table();}
+    static ::toml::table&       invoke(value&       v) {return v.as_table();}
+    static ::toml::table const& invoke(value const& v) {return v.as_table();}
+    static ::toml::table&&      invoke(value&&      v) {return std::move(v).as_table();}
 };
 }// detail