Revert "Use if constexpr to make things a lot more readable"

This reverts commit d62ca9f879.

src/database/index.hpp

@@ -8,9 +8,13 @@
 namespace
 {
 template <std::size_t N=0, typename... T>
-void add_column_name(std::string& out)
+typename std::enable_if<N == sizeof...(T), void>::type
-{
+add_column_name(std::string&)
-  if constexpr(N < sizeof...(T))
+{ }
+
+template <std::size_t N=0, typename... T>
+typename std::enable_if<N < sizeof...(T), void>::type
+add_column_name(std::string& out)
 {
   using ColumnType = typename std::remove_reference<decltype(std::get<N>(std::declval<std::tuple<T...>>()))>::type;
   out += ColumnType::name;
@@ -19,7 +23,6 @@ void add_column_name(std::string& out)
   add_column_name<N+1, T...>(out);
 }
 }
-}
 
 template <typename... Columns>
 void create_index(DatabaseEngine& db, const std::string& name, const std::string& table)

src/database/insert_query.hpp

@@ -11,16 +11,19 @@
 #include <tuple>
 
 template <std::size_t N=0, typename... T>
-void update_autoincrement_id(std::tuple<T...>& columns, Statement& statement)
+typename std::enable_if<N < sizeof...(T), void>::type
-{
+update_autoincrement_id(std::tuple<T...>& columns, Statement& statement)
-  if constexpr(N < sizeof...(T))
 {
   using ColumnType = typename std::decay<decltype(std::get<N>(columns))>::type;
   if (std::is_same<ColumnType, Id>::value)
     auto&& column = std::get<Id>(columns);
   update_autoincrement_id<N+1>(columns, statement);
 }
-}
+
+template <std::size_t N=0, typename... T>
+typename std::enable_if<N == sizeof...(T), void>::type
+update_autoincrement_id(std::tuple<T...>&, Statement&)
+{}
 
 struct InsertQuery: public Query
 {
@@ -50,19 +53,22 @@ struct InsertQuery: public Query
   }
 
   template <int N=0, typename... T>
-  void bind_param(const std::tuple<T...>& columns, Statement& statement, int index=1)
+  typename std::enable_if<N < sizeof...(T), void>::type
-  {
+  bind_param(const std::tuple<T...>& columns, Statement& statement, int index=1)
-    if constexpr(N < sizeof...(T))
   {
     auto&& column = std::get<N>(columns);
     using ColumnType = std::decay_t<decltype(column)>;
 
-        if constexpr(!std::is_same<ColumnType, Id>::value)
+    if (!std::is_same<ColumnType, Id>::value)
       actual_bind(statement, column.value, index++);
 
     this->bind_param<N+1>(columns, statement, index);
   }
-  }
+
+  template <int N=0, typename... T>
+  typename std::enable_if<N == sizeof...(T), void>::type
+  bind_param(const std::tuple<T...>&, Statement&, int)
+  {}
 
   template <typename... T>
   void insert_values(const std::tuple<T...>& columns)
@@ -73,9 +79,8 @@ struct InsertQuery: public Query
   }
 
   template <int N=0, typename... T>
-  void insert_value(const std::tuple<T...>& columns, int index=1)
+  typename std::enable_if<N < sizeof...(T), void>::type
-  {
+  insert_value(const std::tuple<T...>& columns, int index=1)
-    if constexpr(N < sizeof...(T))
   {
     using ColumnType = std::decay_t<decltype(std::get<N>(columns))>;
 
@@ -87,7 +92,10 @@ struct InsertQuery: public Query
       }
     this->insert_value<N+1>(columns, index);
   }
-  }
+  template <int N=0, typename... T>
+  typename std::enable_if<N == sizeof...(T), void>::type
+  insert_value(const std::tuple<T...>&, const int)
+  { }
 
   template <typename... T>
   void insert_col_names(const std::tuple<T...>& columns)
@@ -98,9 +106,8 @@ struct InsertQuery: public Query
   }
 
   template <int N=0, typename... T>
-  void insert_col_name(const std::tuple<T...>& columns)
+  typename std::enable_if<N < sizeof...(T), void>::type
-  {
+  insert_col_name(const std::tuple<T...>& columns)
-    if constexpr(N < sizeof...(T))
   {
     using ColumnType = std::decay_t<decltype(std::get<N>(columns))>;
 
@@ -114,5 +121,9 @@ struct InsertQuery: public Query
 
     this->insert_col_name<N+1>(columns);
   }
-  }
+
+  template <int N=0, typename... T>
+  typename std::enable_if<N == sizeof...(T), void>::type
+  insert_col_name(const std::tuple<T...>&)
+  {}
 };

src/database/query.hpp

@@ -13,12 +13,12 @@
 
 void actual_bind(Statement& statement, const std::string& value, int index);
 void actual_bind(Statement& statement, const std::int64_t& value, int index);
-void actual_bind(Statement& statement, const std::optional<bool>& value, int index);
+template <typename T, typename std::enable_if_t<std::is_integral<T>::value>* = 0>
-template <typename T>
 void actual_bind(Statement& statement, const T& value, int index)
 {
   actual_bind(statement, static_cast<std::int64_t>(value), index);
 }
+void actual_bind(Statement& statement, const std::optional<bool>& value, int index);
 
 #ifdef DEBUG_SQL_QUERIES
 #include <utils/scopetimer.hpp>
@@ -57,27 +57,38 @@ struct Query
 #endif
 };
 
-void actual_add_param(Query& query, const std::string& val);
+template <typename ColumnType>
-void actual_add_param(Query& query, const std::optional<bool>& val);
+void add_param(Query& query, const ColumnType& column)
+{
+  std::cout << "add_param<ColumnType>" << std::endl;
+  actual_add_param(query, column.value);
+}
+
 template <typename T>
 void actual_add_param(Query& query, const T& val)
 {
   query.params.push_back(std::to_string(val));
 }
 
+void actual_add_param(Query& query, const std::string& val);
+
+template <typename T>
+typename std::enable_if<!std::is_integral<T>::value, Query&>::type
+operator<<(Query& query, const T&)
+{
+  query.body += T::name;
+  return query;
+}
+void actual_add_param(Query& query, const std::optional<bool>& val);
+
 Query& operator<<(Query& query, const char* str);
 Query& operator<<(Query& query, const std::string& str);
-template <typename T>
+template <typename Integer>
-Query& operator<<(Query& query, const T& i)
+typename std::enable_if<std::is_integral<Integer>::value, Query&>::type
-{
+operator<<(Query& query, const Integer& i)
-  if constexpr(std::is_integral<T>::value)
 {
   query.body += "$" + std::to_string(query.current_param++);
   actual_add_param(query, i);
-    }
-  else
-    {
-      query.body += T::name;
-    }
   return query;
 }
+

src/database/row.hpp

@@ -29,9 +29,14 @@ struct Row
     return col.value;
   }
 
-  void save(std::unique_ptr<DatabaseEngine>& db)
+  template <bool Coucou=true>
+  void save(std::unique_ptr<DatabaseEngine>& db, typename std::enable_if<!is_one_of<Id, T...> && Coucou>::type* = nullptr)
   {
-    if constexpr(is_one_of<Id, T...>)
+    this->insert(*db);
+  }
+
+  template <bool Coucou=true>
+  void save(std::unique_ptr<DatabaseEngine>& db, typename std::enable_if<is_one_of<Id, T...> && Coucou>::type* = nullptr)
   {
     const Id& id = std::get<Id>(this->columns);
     if (id.value == Id::unset_value)
@@ -43,26 +48,23 @@ struct Row
     else
       this->update(*db);
   }
-    else
-      this->insert(*db);
-  }
 
  private:
-  void insert(DatabaseEngine& db)
+  template <bool Coucou=true>
-  {
+  void insert(DatabaseEngine& db, typename std::enable_if<is_one_of<Id, T...> && Coucou>::type* = nullptr)
-    if constexpr(is_one_of<Id, T...>)
   {
     InsertQuery query(this->table_name, this->columns);
     // Ugly workaround for non portable stuff
     query.body += db.get_returning_id_sql_string(Id::name);
     query.execute(db, this->columns);
   }
-    else
+
+  template <bool Coucou=true>
+  void insert(DatabaseEngine& db, typename std::enable_if<!is_one_of<Id, T...> && Coucou>::type* = nullptr)
   {
     InsertQuery query(this->table_name, this->columns);
     query.execute(db, this->columns);
   }
-  }
 
   void update(DatabaseEngine& db)
   {

src/database/select_query.hpp

@@ -15,27 +15,34 @@
 using namespace std::string_literals;
 
 template <typename T>
-auto extract_row_value(Statement& statement, const int i)
+typename std::enable_if<std::is_integral<T>::value, std::int64_t>::type
+extract_row_value(Statement& statement, const int i)
 {
-  if constexpr(std::is_integral<T>::value)
   return statement.get_column_int64(i);
-  else if constexpr (std::is_same<std::string, T>::value)
+}
+
+template <typename T>
+typename std::enable_if<std::is_same<std::string, T>::value, T>::type
+extract_row_value(Statement& statement, const int i)
+{
   return statement.get_column_text(i);
-  else if (std::is_same<std::optional<bool>, T>::value)
+}
+
+template <typename T>
+typename std::enable_if<std::is_same<std::optional<bool>, T>::value, T>::type
+extract_row_value(Statement& statement, const int i)
 {
   const auto integer = statement.get_column_int(i);
   if (integer > 0)
-        return std::optional<bool>{true};
+    return true;
   else if (integer < 0)
-        return std::optional<bool>{false};
+    return false;
-      return std::optional<bool>{};
+  return std::nullopt;
-    }
 }
 
 template <std::size_t N=0, typename... T>
-void extract_row_values(Row<T...>& row, Statement& statement)
+typename std::enable_if<N < sizeof...(T), void>::type
-{
+extract_row_values(Row<T...>& row, Statement& statement)
-  if constexpr(N < sizeof...(T))
 {
   using ColumnType = typename std::remove_reference<decltype(std::get<N>(row.columns))>::type;
 
@@ -44,7 +51,11 @@ void extract_row_values(Row<T...>& row, Statement& statement)
 
   extract_row_values<N+1>(row, statement);
 }
-}
+
+template <std::size_t N=0, typename... T>
+typename std::enable_if<N == sizeof...(T), void>::type
+extract_row_values(Row<T...>&, Statement&)
+{}
 
 template <typename... T>
 struct SelectQuery: public Query
@@ -58,9 +69,8 @@ struct SelectQuery: public Query
     }
 
     template <std::size_t N=0>
-    void insert_col_name()
+    typename std::enable_if<N < sizeof...(T), void>::type
-    {
+    insert_col_name()
-      if constexpr(N < sizeof...(T))
     {
       using ColumnsType = std::tuple<T...>;
       using ColumnType = typename std::remove_reference<decltype(std::get<N>(std::declval<ColumnsType>()))>::type;
@@ -72,7 +82,10 @@ struct SelectQuery: public Query
 
       this->insert_col_name<N+1>();
     }
-    }
+    template <std::size_t N=0>
+    typename std::enable_if<N == sizeof...(T), void>::type
+    insert_col_name()
+    {}
 
   SelectQuery& where()
     {

src/database/table.hpp

@@ -93,21 +93,22 @@ class Table
  private:
 
   template <std::size_t N=0>
-  void add_column_if_not_exists(DatabaseEngine& db, const std::set<std::string>& existing_columns)
+  typename std::enable_if<N < sizeof...(T), void>::type
-  {
+  add_column_if_not_exists(DatabaseEngine& db, const std::set<std::string>& existing_columns)
-    if constexpr(N < sizeof...(T))
   {
     using ColumnType = typename std::remove_reference<decltype(std::get<N>(std::declval<ColumnTypes>()))>::type;
     if (existing_columns.count(ColumnType::name) == 0)
       add_column_to_table<ColumnType>(db, this->name);
     add_column_if_not_exists<N+1>(db, existing_columns);
   }
-  }
+  template <std::size_t N=0>
+  typename std::enable_if<N == sizeof...(T), void>::type
+  add_column_if_not_exists(DatabaseEngine&, const std::set<std::string>&)
+  {}
 
   template <std::size_t N=0>
-  void add_column_create(DatabaseEngine& db, std::string& str)
+  typename std::enable_if<N < sizeof...(T), void>::type
-  {
+  add_column_create(DatabaseEngine& db, std::string& str)
-    if constexpr(N < sizeof...(T))
   {
     using ColumnType = typename std::remove_reference<decltype(std::get<N>(std::declval<ColumnTypes>()))>::type;
     str += ColumnType::name;
@@ -118,7 +119,10 @@ class Table
 
     add_column_create<N+1>(db, str);
   }
-  }
+  template <std::size_t N=0>
+  typename std::enable_if<N == sizeof...(T), void>::type
+  add_column_create(DatabaseEngine&, std::string&)
+  { }
 
   const std::string name;
 };

src/database/update_query.hpp

@@ -39,16 +39,14 @@ struct UpdateQuery: public Query
   }
 
   template <int N=0, typename... T>
-  void insert_col_name_and_value(const std::tuple<T...>& columns)
+  typename std::enable_if<N < sizeof...(T), void>::type
-  {
+  insert_col_name_and_value(const std::tuple<T...>& columns)
-    if constexpr(N < sizeof...(T))
   {
     using ColumnType = std::decay_t<decltype(std::get<N>(columns))>;
 
     if (!std::is_same<ColumnType, Id>::value)
       {
-            this->body += ColumnType::name + "=$"s
+        this->body += ColumnType::name + "=$"s + std::to_string(this->current_param);
-                          + std::to_string(this->current_param);
         this->current_param++;
 
         if (N < (sizeof...(T) - 1))
@@ -57,7 +55,11 @@ struct UpdateQuery: public Query
 
     this->insert_col_name_and_value<N+1>(columns);
   }
-  }
+  template <int N=0, typename... T>
+  typename std::enable_if<N == sizeof...(T), void>::type
+  insert_col_name_and_value(const std::tuple<T...>&)
+  {}
+
 
   template <typename... T>
   void execute(DatabaseEngine& db, const std::tuple<T...>& columns)
@@ -74,9 +76,8 @@ struct UpdateQuery: public Query
   }
 
   template <int N=0, typename... T>
-  void bind_param(const std::tuple<T...>& columns, Statement& statement, int index=1)
+  typename std::enable_if<N < sizeof...(T), void>::type
-  {
+  bind_param(const std::tuple<T...>& columns, Statement& statement, int index=1)
-    if constexpr(N < sizeof...(T))
   {
     auto&& column = std::get<N>(columns);
     using ColumnType = std::decay_t<decltype(column)>;
@@ -86,7 +87,11 @@ struct UpdateQuery: public Query
 
     this->bind_param<N+1>(columns, statement, index);
   }
-  }
+
+  template <int N=0, typename... T>
+  typename std::enable_if<N == sizeof...(T), void>::type
+  bind_param(const std::tuple<T...>&, Statement&, int)
+  {}
 
   template <typename... T>
   void bind_id(const std::tuple<T...>& columns, Statement& statement)