implement indexed_tuple with different get method (#58)

* implement indexed_tuple with different get method

* workaround clang bug with base class pack

* fix indexed_tuple.cpp includes

* replace all usage of std::tuple with indexed_tuple

* replace ordered_set with indexed_tuple

* cleanup tuple

* make cib::detail::tuple cib::tuple

* cleanup cib::tuple

* multi index testcase for tuple

* remove unused tuple_details.hpp

* add support for cib::tuple set operations

* workarounds for gcc

* fully qualify calls to cib::make_tuple

* add test case for cib::detail::name

* fix test case

Author: lukevalenty

Diff for: include/cib/cib.hpp

@@ -43,6 +43,8 @@
 #include "built.hpp"
 #include "config.hpp"
 #include "builder_meta.hpp"
+#include "set.hpp"
+#include "tuple.hpp"
 
 
 #endif //COMPILE_TIME_INIT_BUILD_CIB_HPP

Diff for: include/cib/config.hpp

@@ -10,7 +10,6 @@
 #include "detail/extend.hpp"
 #include "detail/config_item.hpp"
 
-#include <tuple>
 #include <type_traits>
 
 

Diff for: include/cib/detail/components.hpp

@@ -1,7 +1,7 @@
 #include "compiler.hpp"
 #include "config_item.hpp"
 #include "meta.hpp"
-#include "ordered_set.hpp"
+#include "../tuple.hpp"
 #include "type_list.hpp"
 
 #include <type_traits>
@@ -19,7 +19,7 @@ namespace cib::detail {
             Builders const & builders_tuple,
             Args const & ... args
         ) const {
-            return detail::fold_right(ordered_set{Components{}...}, builders_tuple, [&](auto const & c, auto const & builders){
+            return detail::fold_right(cib::make_tuple(Components{}...), builders_tuple, [&](auto const & c, auto const & builders){
                 return c.config.init(builders, args...);
             });
         }

Diff for: include/cib/detail/conditional.hpp

@@ -1,10 +1,8 @@
 #include "compiler.hpp"
 #include "config_item.hpp"
 #include "config_details.hpp"
-#include "ordered_set.hpp"
 #include "type_list.hpp"
-
-#include <tuple>
+#include "../tuple.hpp"
 
 
 #ifndef COMPILE_TIME_INIT_BUILD_CONDITIONAL_HPP
@@ -72,7 +70,7 @@ namespace cib::detail {
 
         template<typename... Args>
         CIB_CONSTEVAL auto operator()(Args... args) const {
-            return detail::fold_right(std::make_tuple(args...), detail::int_<0>, [=](auto elem, [[maybe_unused]] auto state){
+            return detail::fold_right(cib::make_tuple(self_type_index, args...), detail::int_<0>, [=](auto elem, [[maybe_unused]] auto state){
                 using ElemType = typename std::remove_cv_t<std::remove_reference_t<decltype(elem)>>::value_type;
 
                 if constexpr (std::is_same_v<ElemType, MatchType>) {

Diff for: include/cib/detail/config_details.hpp

@@ -1,11 +1,9 @@
 #include "compiler.hpp"
 #include "config_item.hpp"
 #include "meta.hpp"
-#include "ordered_set.hpp"
+#include "../tuple.hpp"
 #include "type_list.hpp"
 
-#include <tuple>
-
 
 #ifndef COMPILE_TIME_INIT_BUILD_DETAIL_CONFIG_HPP
 #define COMPILE_TIME_INIT_BUILD_DETAIL_CONFIG_HPP
@@ -17,18 +15,18 @@ namespace cib::detail {
 
     template<auto... Args>
     struct args {
-        static CIB_CONSTEXPR auto value = ordered_set{as_constant_v<Args>...};
+        static CIB_CONSTEXPR auto value = cib::make_tuple(self_type_index, as_constant_v<Args>...);
     };
 
     template<typename ConfigArgs, typename... ConfigTs>
     struct config : public detail::config_item {
-        std::tuple<ConfigTs...> configs_tuple;
+        cib::tuple<ConfigTs...> configs_tuple;
 
         CIB_CONSTEVAL explicit config(
             ConfigArgs,
             ConfigTs const & ... configs
         )
-            : configs_tuple{configs...}
+            : configs_tuple{cib::make_tuple(configs...)}
         {
             // pass
         }

Diff for: include/cib/detail/config_item.hpp

@@ -1,9 +1,6 @@
 #include "compiler.hpp"
-#include "ordered_set.hpp"
 #include "type_list.hpp"
 
-#include <tuple>
-
 
 #ifndef COMPILE_TIME_INIT_BUILD_CONFIG_DETAIL_HPP
 #define COMPILE_TIME_INIT_BUILD_CONFIG_DETAIL_HPP

Diff for: include/cib/detail/exports.hpp

@@ -3,7 +3,6 @@
 #include "type_list.hpp"
 #include "builder_traits.hpp"
 
-#include <tuple>
 #include <utility>
 
 

Diff for: include/cib/detail/extend.hpp

@@ -1,7 +1,6 @@
 #include "config_item.hpp"
-#include "ordered_set.hpp"
+#include "../tuple.hpp"
 
-#include <tuple>
 #include <utility>
 
 
@@ -14,12 +13,12 @@ namespace cib::detail {
         typename ExtensionPath,
         typename... Args>
     struct extend : public config_item {
-        ordered_set<Args...> args_tuple;
+        cib::tuple<Args...> args_tuple;
 
         CIB_CONSTEVAL explicit extend(
             Args const & ... args
         )
-            : args_tuple{args...}
+            : args_tuple{cib::make_tuple(args...)}
         {
             // pass
         }
@@ -76,7 +75,7 @@ namespace cib::detail {
                     (is_same_v<typename ExtensionPath::First, typename std::remove_cv_t<std::remove_reference_t<decltype(builders)>>::Service> + ... + 0) <= 1,
                     "Extension matched more than 1 service");
 
-                return detail::ordered_set(add(ExtensionPath{}, builders)...);
+                return cib::make_tuple(index_metafunc_<extract_service_tag>, add(ExtensionPath{}, builders)...);
             }, builders_tuple);
         }
 

Diff for: include/cib/detail/find.hpp

@@ -1,7 +1,6 @@
 #include "compiler.hpp"
-#include "ordered_set.hpp"
+#include "../tuple.hpp"
 
-#include <tuple>
 #include <type_traits>
 
 
@@ -55,7 +54,7 @@ namespace cib::detail {
     };
 
     /**
-     * fold_right a ordered_set of elements.
+     * fold_right a tuple of elements.
      *
      * Fold operations are sometimes called accumulate or reduce in other
      * languages or libraries.
@@ -66,7 +65,7 @@ namespace cib::detail {
      *      A callable that takes the current element being processed
      *      and the current state, and returns the state to be used
      *      to process the next element. Called for each element in
-     *      the ordered_set.
+     *      the tuple.
      *
      * @return
      *      The final state of all of the operations.
@@ -76,7 +75,7 @@ namespace cib::detail {
         typename InitType,
         typename CallableType>
     [[nodiscard]] CIB_CONSTEXPR inline static auto fold_right(
-        std::tuple<ElementTypes...> const & elements,
+        tuple_impl<ElementTypes...> const & elements,
         InitType const & initial_state,
         CallableType const & operation
     ) {
@@ -85,37 +84,6 @@ namespace cib::detail {
         }, elements);
     }
 
-    /**
-     * fold_right a ordered_set of elements.
-     *
-     * Fold operations are sometimes called accumulate or reduce in other
-     * languages or libraries.
-     *
-     * https://en.wikipedia.org/wiki/Fold_%28higher-order_function%29
-     *
-     * @param operation
-     *      A callable that takes the current element being processed
-     *      and the current state, and returns the state to be used
-     *      to process the next element. Called for each element in
-     *      the ordered_set.
-     *
-     * @return
-     *      The final state of all of the operations.
-     */
-    template<
-        typename... ElementTypes,
-        typename InitType,
-        typename CallableType>
-    [[nodiscard]] CIB_CONSTEXPR inline static auto fold_right(
-            ordered_set<ElementTypes...> const & elements,
-            InitType const & initial_state,
-            CallableType const & operation
-    ) {
-        return apply([&](auto const & ... element_pack){
-            return (fold_helper{element_pack, operation} + ... + initial_state);
-        }, elements);
-    }
-
     /**
      * Perform an operation on each element of an integral sequence.
      *
@@ -153,7 +121,7 @@ namespace cib::detail {
     }
 
     /**
-     * Perform an operation on each element of a ordered_set.
+     * Perform an operation on each element of a tuple.
      *
      * @param operation
      *      The operation to perform. Must be a callable that accepts a single parameter.
@@ -162,31 +130,13 @@ namespace cib::detail {
         typename... ElementTypes,
         typename CallableType>
     CIB_CONSTEXPR inline void for_each(
-        std::tuple<ElementTypes...> const & elements,
+        tuple_impl<ElementTypes...> const & elements,
         CallableType const & operation
     ) {
         apply([&](auto const & ... element_pack){
             (operation(element_pack) , ...);
         }, elements);
     }
-
-    /**
-     * Perform an operation on each element of a ordered_set.
-     *
-     * @param operation
-     *      The operation to perform. Must be a callable that accepts a single parameter.
-     */
-    template<
-        typename... ElementTypes,
-        typename CallableType>
-    CIB_CONSTEXPR inline void for_each(
-            ordered_set<ElementTypes...> const & elements,
-            CallableType const & operation
-    ) {
-        apply([&](auto const & ... element_pack){
-            (operation(element_pack) , ...);
-        }, elements);
-    }
 }