GNOME.org
 

[libsigcplusplus/variadic_mem_fun3: 83/148] Put tuple-utils into sigc::internal namespace.

commit 520bc824be55140746a92df6c5a21a22f0b0267f
Author: Murray Cumming <murrayc murrayc com>
Date:   Wed Mar 2 21:24:37 2016 +0100

    Put tuple-utils into sigc::internal namespace.
    
    To discourage people from using libsigc++ just for the tuple utils.

 sigc++/adaptors/bind.h                    |   18 +++++++++---------
 sigc++/adaptors/hide.h                    |   10 +++++-----
 sigc++/adaptors/track_obj.h               |    2 +-
 sigc++/tuple-utils/tuple_cat.h            |    4 ++++
 sigc++/tuple-utils/tuple_cdr.h            |    4 ++++
 sigc++/tuple-utils/tuple_end.h            |    6 +++++-
 sigc++/tuple-utils/tuple_for_each.h       |    4 ++++
 sigc++/tuple-utils/tuple_start.h          |    6 +++++-
 sigc++/tuple-utils/tuple_transform_each.h |    4 ++++
 tests/test_tuple_cat.cc                   |    2 +-
 tests/test_tuple_cdr.cc                   |    6 +++---
 tests/test_tuple_end.cc                   |   14 +++++++-------
 tests/test_tuple_for_each.cc              |   20 ++++++++++----------
 tests/test_tuple_start.cc                 |   14 +++++++-------
 tests/test_tuple_transform_each.cc        |   16 ++++++++--------
 15 files changed, 77 insertions(+), 53 deletions(-)
---
diff --git a/sigc++/adaptors/bind.h b/sigc++/adaptors/bind.h
index 9b4ef4e..3a39647 100644
--- a/sigc++/adaptors/bind.h
+++ b/sigc++/adaptors/bind.h
@@ -136,19 +136,19 @@ struct bind_functor : public adapts<T_functor>
       auto t_args = std::tuple<T_arg...>(std::forward<T_arg>(_A_arg)...);
       constexpr auto t_args_size = std::tuple_size<tuple_type_args>::value;
       
-      auto t_start = tuple_start<I_location>(t_args);
-      auto t_bound = tuple_transform_each<internal::TransformEachInvoker>(bound_);
-      auto t_end = tuple_end<t_args_size - I_location>(t_args);
+      auto t_start = internal::tuple_start<I_location>(t_args);
+      auto t_bound = internal::tuple_transform_each<internal::TransformEachInvoker>(bound_);
+      auto t_end = internal::tuple_end<t_args_size - I_location>(t_args);
       auto t_with_bound = std::tuple_cat(t_start, t_bound, t_end);
 
       //TODO: Avoid needing to specify the type when calling operator()?
-      using t_type_start = typename tuple_type_start<tuple_type_args, I_location>::type;
+      using t_type_start = typename internal::tuple_type_start<tuple_type_args, I_location>::type;
       using t_type_bound = std::tuple<type_trait_pass_t<typename unwrap_reference<T_bound>::type>...>;
 
       //using tuple_type_args_pass = std::tuple<type_trait_pass_t<T_arg>...>;
       //using t_type_end = typename tuple_type_end<tuple_type_args_pass  t_args_size - I_location>::type;
-      using t_type_end = typename tuple_type_end<tuple_type_args, t_args_size - I_location>::type;
-      using t_type_with_bound = typename tuple_type_cat<typename tuple_type_cat<t_type_start, 
t_type_bound>::type, t_type_end>::type;
+      using t_type_end = typename internal::tuple_type_end<tuple_type_args, t_args_size - I_location>::type;
+      using t_type_with_bound = typename internal::tuple_type_cat<typename 
internal::tuple_type_cat<t_type_start, t_type_bound>::type, t_type_end>::type;
 
       const auto seq = std::make_index_sequence<std::tuple_size<decltype(t_with_bound)>::value>();
       return call_functor_operator_parentheses<t_type_with_bound>(
@@ -202,13 +202,13 @@ struct bind_functor<-1, T_functor, T_type...> : public adapts<T_functor>
       //we would want to call operator() with (_A_arg0, _A_arg1, _A_arg2, bound).
       
       auto t_args = std::tuple<T_arg...>(std::forward<T_arg>(_A_arg)...);
-      auto t_bound = tuple_transform_each<internal::TransformEachInvoker>(bound_);
+      auto t_bound = internal::tuple_transform_each<internal::TransformEachInvoker>(bound_);
       auto t_with_bound = std::tuple_cat(t_args, t_bound);
 
       //TODO: Avoid needing to specify the type when calling operator()?
       using t_type_args = std::tuple<type_trait_pass_t<T_arg>...>;
       using t_type_bound = std::tuple<type_trait_pass_t<typename unwrap_reference<T_type>::type>...>;
-      using t_type_with_bound = typename tuple_type_cat<t_type_args, t_type_bound>::type;
+      using t_type_with_bound = typename internal::tuple_type_cat<t_type_args, t_type_bound>::type;
 
       const auto seq = std::make_index_sequence<std::tuple_size<decltype(t_with_bound)>::value>();
       return call_functor_operator_parentheses<t_type_with_bound>(t_with_bound, seq);
@@ -289,7 +289,7 @@ struct visitor<bind_functor<-1, T_functor, T_type...> >
   {
     sigc::visit_each(_A_action, _A_target.functor_);
 
-    sigc::tuple_for_each<TupleVisitorVisitEach>(_A_target.bound_, _A_action);
+    sigc::internal::tuple_for_each<TupleVisitorVisitEach>(_A_target.bound_, _A_action);
   }
 };
 
diff --git a/sigc++/adaptors/hide.h b/sigc++/adaptors/hide.h
index 20ad588..03056a6 100644
--- a/sigc++/adaptors/hide.h
+++ b/sigc++/adaptors/hide.h
@@ -83,17 +83,17 @@ struct hide_functor : public adapts<T_functor>
        constexpr auto index_ignore = (I_location == -1 ? size - 1 : I_location);
        const auto t = std::make_tuple(_A_a...);
 
-       const auto t_start = tuple_start<index_ignore>(t);
-       const auto t_end = tuple_end<size - index_ignore - 1>(t);
+       const auto t_start = internal::tuple_start<index_ignore>(t);
+       const auto t_end = internal::tuple_end<size - index_ignore - 1>(t);
        auto t_used = std::tuple_cat(t_start, t_end); //TODO: Let this be const?
 
        //This is so we can specify a particular instantiation of the functor's
        //operator().
        //TODO: Avoid this if it no longer necessary.
        using t_type = std::tuple<type_trait_pass_t<T_arg>...>;
-       using t_type_start = typename tuple_type_start<t_type, index_ignore>::type;
-       using t_type_end = typename tuple_type_end<t_type, size - index_ignore - 1>::type;
-       using t_type_used = typename tuple_type_cat<t_type_start, t_type_end>::type;
+       using t_type_start = typename internal::tuple_type_start<t_type, index_ignore>::type;
+       using t_type_end = typename internal::tuple_type_end<t_type, size - index_ignore - 1>::type;
+       using t_type_used = typename internal::tuple_type_cat<t_type_start, t_type_end>::type;
 
        constexpr auto size_used = size - 1;
 
diff --git a/sigc++/adaptors/track_obj.h b/sigc++/adaptors/track_obj.h
index 2e15ccd..bc2a888 100644
--- a/sigc++/adaptors/track_obj.h
+++ b/sigc++/adaptors/track_obj.h
@@ -111,7 +111,7 @@ struct visitor<track_obj_functor<T_functor, T_obj...>>
 
     //Call sigc::visit_each(_A_action, element) on each element in the 
     //_A_target.obj_ tuple:
-    sigc::tuple_for_each<TrackObjVisitForEach>(_A_target.obj_, _A_action);
+    sigc::internal::tuple_for_each<TrackObjVisitForEach>(_A_target.obj_, _A_action);
   }
 
 private:
diff --git a/sigc++/tuple-utils/tuple_cat.h b/sigc++/tuple-utils/tuple_cat.h
index 8cb8d25..0a8c8cd 100644
--- a/sigc++/tuple-utils/tuple_cat.h
+++ b/sigc++/tuple-utils/tuple_cat.h
@@ -23,6 +23,8 @@
 
 namespace sigc {
 
+namespace internal {
+
 namespace detail {
 
 template <typename T1, typename T2, typename Seq1, typename Seq2>
@@ -49,6 +51,8 @@ struct tuple_type_cat
 // There is no tuple_cat() here because std::tuple_cat() exists already in
 // the C++ standard library.
 
+} // namespace internal
+
 } // namespace sigc
 
 #endif //SIGC_TUPLE_UTILS_TUPLE_CAT_H
diff --git a/sigc++/tuple-utils/tuple_cdr.h b/sigc++/tuple-utils/tuple_cdr.h
index 580296b..eab31a6 100644
--- a/sigc++/tuple-utils/tuple_cdr.h
+++ b/sigc++/tuple-utils/tuple_cdr.h
@@ -23,6 +23,8 @@
 
 namespace sigc {
 
+namespace internal {
+
 /**
  * Get the type of a tuple without the first item.
  */
@@ -63,6 +65,8 @@ tuple_cdr(T&& t) {
   return detail::tuple_cdr_impl(std::forward<T>(t), seq{});
 }
 
+} // namespace internal
+
 } // namespace sigc
 
 #endif //SIGC_TUPLE_UTILS_TUPLE_CDR_H
diff --git a/sigc++/tuple-utils/tuple_end.h b/sigc++/tuple-utils/tuple_end.h
index 1f9a073..c8eb1ad 100644
--- a/sigc++/tuple-utils/tuple_end.h
+++ b/sigc++/tuple-utils/tuple_end.h
@@ -21,6 +21,8 @@
 
 namespace sigc {
 
+namespace internal {
+
 namespace detail {
 
 template <typename T, std::size_t remove_from_start>
@@ -88,6 +90,8 @@ decltype(auto) // typename tuple_type_end<T, len>::type
   return detail::tuple_end_impl<T, size_start>::tuple_end(std::forward<T>(t));
 }
 
-} // namespace sigc;
+} // namespace internal
+
+} // namespace sigc
 
 #endif //SIGC_TUPLE_UTILS_TUPLE_END_H
diff --git a/sigc++/tuple-utils/tuple_for_each.h b/sigc++/tuple-utils/tuple_for_each.h
index 1bf98bd..760b52d 100644
--- a/sigc++/tuple-utils/tuple_for_each.h
+++ b/sigc++/tuple-utils/tuple_for_each.h
@@ -21,6 +21,8 @@
 
 namespace sigc {
 
+namespace internal {
+
 namespace detail {
 
 template <template <typename> class T_visitor, std::size_t size_from_index,
@@ -98,6 +100,8 @@ tuple_for_each(T&& t, T_extras&&... extras) {
     std::forward<T>(t), std::forward<T_extras>(extras)...);
 }
 
+} // namespace internal
+
 } // namespace sigc
 
 #endif //SIGC_TUPLE_UTILS_TUPLE_FOR_EACH_H
diff --git a/sigc++/tuple-utils/tuple_start.h b/sigc++/tuple-utils/tuple_start.h
index 95fda2e..04f738d 100644
--- a/sigc++/tuple-utils/tuple_start.h
+++ b/sigc++/tuple-utils/tuple_start.h
@@ -22,6 +22,8 @@
 
 namespace sigc {
 
+namespace internal {
+
 namespace detail {
 
 template <typename T, typename Seq>
@@ -75,6 +77,8 @@ decltype(auto) // typename tuple_type_end<T, len>::type
     std::forward<T>(t));
 }
 
-} // namespace sigc;
+} // namespace internal
+
+} // namespace sigc
 
 #endif //SIGC_TUPLE_UTILS_TUPLE_START_H
diff --git a/sigc++/tuple-utils/tuple_transform_each.h b/sigc++/tuple-utils/tuple_transform_each.h
index 0558333..abd3977 100644
--- a/sigc++/tuple-utils/tuple_transform_each.h
+++ b/sigc++/tuple-utils/tuple_transform_each.h
@@ -25,6 +25,8 @@
 
 namespace sigc {
 
+namespace internal {
+
 namespace detail {
 
 template <typename T, template <typename> class T_transformer,
@@ -152,6 +154,8 @@ tuple_transform_each(T&& t) {
     size - 1>::tuple_transform_each(std::forward<T>(t), t);
 }
 
+} // namespace internal
+
 } // namespace sigc
 
 #endif //SIGC_TUPLE_UTILS_TUPLE_TRANSFORM_EACH_H
diff --git a/tests/test_tuple_cat.cc b/tests/test_tuple_cat.cc
index fb40867..d5f1af5 100644
--- a/tests/test_tuple_cat.cc
+++ b/tests/test_tuple_cat.cc
@@ -25,7 +25,7 @@ test_tuple_type_cat() {
   using type_tuple_is = std::tuple<int, short>;
   using type_tuple_dc = std::tuple<double, char>;
   using type_tuple_cat =
-    sigc::tuple_type_cat<type_tuple_is, type_tuple_dc>::type;
+    sigc::internal::tuple_type_cat<type_tuple_is, type_tuple_dc>::type;
   using type_tuple_expected = std::tuple<int, short, double, char>;
 
   static_assert(std::tuple_size<type_tuple_cat>::value == 4,
diff --git a/tests/test_tuple_cdr.cc b/tests/test_tuple_cdr.cc
index 3c142dc..12c9650 100644
--- a/tests/test_tuple_cdr.cc
+++ b/tests/test_tuple_cdr.cc
@@ -24,7 +24,7 @@ void
 test_tuple_type_cdr() {
   using type_tuple_isd = std::tuple<int, short, double>;
   using type_tuple_sd = std::tuple<short, double>;
-  using type_tuple_suffix = sigc::tuple_type_cdr<type_tuple_isd>::type;
+  using type_tuple_suffix = sigc::internal::tuple_type_cdr<type_tuple_isd>::type;
 
   static_assert(std::tuple_size<type_tuple_suffix>::value == 2,
     "unexpected tuple_cdr()ed tuple size.");
@@ -36,7 +36,7 @@ void
 test_tuple_cdr() {
   auto t_larger =
     std::make_tuple(nullptr, std::string("hello"), std::string("world"));
-  auto t_suffix = sigc::tuple_cdr(t_larger);
+  auto t_suffix = sigc::internal::tuple_cdr(t_larger);
   assert(std::get<0>(t_suffix) == "hello");
   assert(std::get<1>(t_suffix) == "world");
 
@@ -56,7 +56,7 @@ test_tuple_cdr_stdref() {
 
   //std::cout << "debug: " << type(std::get<1>(t_larger)) << std::endl;
 
-  auto t_suffix = sigc::tuple_cdr(t_larger);
+  auto t_suffix = sigc::internal::tuple_cdr(t_larger);
   b = "hello";
   c = "world";
   //This works, but it's not what we are testing here:
diff --git a/tests/test_tuple_end.cc b/tests/test_tuple_end.cc
index 86c018a..31d3f77 100644
--- a/tests/test_tuple_end.cc
+++ b/tests/test_tuple_end.cc
@@ -23,7 +23,7 @@ void
 test_tuple_type_end() {
   {
     using type_tuple = std::tuple<int, short, double>;
-    using type_tuple_end = sigc::tuple_type_end<type_tuple, 1>::type;
+    using type_tuple_end = sigc::internal::tuple_type_end<type_tuple, 1>::type;
     using type_tuple_expected = std::tuple<double>;
 
     static_assert(std::tuple_size<type_tuple_end>::value == 1,
@@ -34,7 +34,7 @@ test_tuple_type_end() {
 
   {
     using type_tuple = std::tuple<int, short, double>;
-    using type_tuple_end = sigc::tuple_type_end<type_tuple, 2>::type;
+    using type_tuple_end = sigc::internal::tuple_type_end<type_tuple, 2>::type;
     using type_tuple_expected = std::tuple<short, double>;
 
     static_assert(std::tuple_size<type_tuple_end>::value == 2,
@@ -45,7 +45,7 @@ test_tuple_type_end() {
 
   {
     using type_tuple = std::tuple<int, short, double>;
-    using type_tuple_end = sigc::tuple_type_end<type_tuple, 3>::type;
+    using type_tuple_end = sigc::internal::tuple_type_end<type_tuple, 3>::type;
     using type_tuple_expected = std::tuple<int, short, double>;
 
     static_assert(std::tuple_size<type_tuple_end>::value == 3,
@@ -60,7 +60,7 @@ test_tuple_end() {
   {
     auto t_original =
       std::make_tuple(nullptr, std::string("hello"), std::string("world"));
-    auto t_suffix = sigc::tuple_end<3>(t_original);
+    auto t_suffix = sigc::internal::tuple_end<3>(t_original);
 
     static_assert(std::tuple_size<decltype(t_suffix)>::value == 3,
       "unexpected tuple_end()ed tuple size.");
@@ -76,7 +76,7 @@ test_tuple_end() {
   {
     auto t_original =
       std::make_tuple(nullptr, std::string("hello"), std::string("world"));
-    auto t_suffix = sigc::tuple_end<2>(t_original);
+    auto t_suffix = sigc::internal::tuple_end<2>(t_original);
 
     static_assert(std::tuple_size<decltype(t_suffix)>::value == 2,
       "unexpected tuple_end()ed tuple size.");
@@ -92,7 +92,7 @@ test_tuple_end() {
   {
     auto t_original =
       std::make_tuple(nullptr, std::string("hello"), std::string("world"));
-    auto t_suffix = sigc::tuple_end<1>(t_original);
+    auto t_suffix = sigc::internal::tuple_end<1>(t_original);
 
     static_assert(std::tuple_size<decltype(t_suffix)>::value == 1,
       "unexpected tuple_end()ed tuple size.");
@@ -111,7 +111,7 @@ test_tuple_end_stdref() {
   std::string d = "yaddayadda";
   auto t_larger = std::make_tuple(1, 2, std::ref(c), std::ref(d));
 
-  auto t_suffix = sigc::tuple_end<2>(t_larger);
+  auto t_suffix = sigc::internal::tuple_end<2>(t_larger);
   c = "hello";
   d = "world";
   //This works, but it's not what we are testing here:
diff --git a/tests/test_tuple_for_each.cc b/tests/test_tuple_for_each.cc
index b7607ef..2c6ab3c 100644
--- a/tests/test_tuple_for_each.cc
+++ b/tests/test_tuple_for_each.cc
@@ -35,12 +35,12 @@ void
 test_tuple_for_each_same_types() {
   {
     auto t_original = std::make_tuple(1, 2, 3);
-    sigc::tuple_for_each<for_each_simple>(t_original);
+    sigc::internal::tuple_for_each<for_each_simple>(t_original);
   }
 
   {
     auto t_original = std::make_tuple(1, (double)2.1f, 3);
-    sigc::tuple_for_each<for_each_simple>(t_original);
+    sigc::internal::tuple_for_each<for_each_simple>(t_original);
   }
 }
 
@@ -58,7 +58,7 @@ void
 test_tuple_for_each_same_types_with_extras() {
   {
     auto t_original = std::make_tuple(1, (double)2.1f, 3);
-    sigc::tuple_for_each<for_each_simple_with_extras>(
+    sigc::internal::tuple_for_each<for_each_simple_with_extras>(
       t_original, 89, "eightynine");
   }
 }
@@ -78,7 +78,7 @@ test_tuple_for_each_same_types_with_nonconst_extras() {
     auto t_original = std::make_tuple(1, (double)2.1f, 3);
     int extra = 0;
 
-    sigc::tuple_for_each<for_each_simple_with_nonconst_extras>(t_original, extra);
+    sigc::internal::tuple_for_each<for_each_simple_with_nonconst_extras>(t_original, extra);
     // std::cout << "extra: " << extra << std::endl;
     assert(extra == 6);
   }
@@ -126,7 +126,7 @@ public:
 void
 test_tuple_for_each_multiple_types() {
   auto t_original = std::make_tuple(1, (double)2.1f, std::string("3"));
-  sigc::tuple_for_each<visitor_with_specializations>(t_original);
+  sigc::internal::tuple_for_each<visitor_with_specializations>(t_original);
 }
 
 template <class T_element_from>
@@ -142,7 +142,7 @@ public:
 void
 test_tuple_for_each_nonconst() {
   auto t = std::make_tuple(1, 2, 3);
-  sigc::tuple_for_each<for_each_nonconst, decltype(t)&>(t);
+  sigc::internal::tuple_for_each<for_each_nonconst, decltype(t)&>(t);
   std::cout << std::get<0>(t) << std::endl;
   assert(std::get<0>(t) == 2);
   assert(std::get<1>(t) == 4);
@@ -156,7 +156,7 @@ test_tuple_for_each_stdref() {
     int b = 2;
     int c = 3;
     auto t_original = std::make_tuple(std::ref(a), std::ref(b), std::ref(c));
-    sigc::tuple_for_each<for_each_simple>(t_original);
+    sigc::internal::tuple_for_each<for_each_simple>(t_original);
   }
 
   {
@@ -164,7 +164,7 @@ test_tuple_for_each_stdref() {
     int b = 2;
     int c = 3;
     auto t_original = std::make_tuple(std::ref(a), std::ref(b), std::ref(c));
-    sigc::tuple_for_each<for_each_nonconst>(t_original);
+    sigc::internal::tuple_for_each<for_each_nonconst>(t_original);
     assert(a == 2);
     assert(b == 4);
     assert(c == 6);
@@ -187,7 +187,7 @@ void
 test_tuple_for_each_correct_sequence() {
   correct_sequence_output.clear();
   auto t = std::make_tuple(1, 2, 3);
-  sigc::tuple_for_each<for_each_correct_sequence>(t);
+  sigc::internal::tuple_for_each<for_each_correct_sequence>(t);
   //std::cout << "correct_sequence_output: " << correct_sequence_output << std::endl;
   assert(correct_sequence_output == "123");
 }
@@ -195,7 +195,7 @@ test_tuple_for_each_correct_sequence() {
 void
 test_tuple_for_each_empty_tuple() {
   auto t = std::tuple<>();
-  sigc::tuple_for_each<for_each_simple>(t);
+  sigc::internal::tuple_for_each<for_each_simple>(t);
 }
 
 
diff --git a/tests/test_tuple_start.cc b/tests/test_tuple_start.cc
index 7add8a0..6d68714 100644
--- a/tests/test_tuple_start.cc
+++ b/tests/test_tuple_start.cc
@@ -23,7 +23,7 @@ void
 test_tuple_type_start() {
   {
     using type_tuple = std::tuple<int, short, double>;
-    using type_tuple_start = sigc::tuple_type_start<type_tuple, 1>::type;
+    using type_tuple_start = sigc::internal::tuple_type_start<type_tuple, 1>::type;
     using type_tuple_expected = std::tuple<int>;
 
     static_assert(std::is_same<type_tuple_start, type_tuple_expected>::value,
@@ -32,7 +32,7 @@ test_tuple_type_start() {
 
   {
     using type_tuple = std::tuple<int, short, double>;
-    using type_tuple_start = sigc::tuple_type_start<type_tuple, 2>::type;
+    using type_tuple_start = sigc::internal::tuple_type_start<type_tuple, 2>::type;
     using type_tuple_expected = std::tuple<int, short>;
 
     static_assert(std::is_same<type_tuple_start, type_tuple_expected>::value,
@@ -41,7 +41,7 @@ test_tuple_type_start() {
 
   {
     using type_tuple = std::tuple<int, short, double>;
-    using type_tuple_start = sigc::tuple_type_start<type_tuple, 3>::type;
+    using type_tuple_start = sigc::internal::tuple_type_start<type_tuple, 3>::type;
     using type_tuple_expected = std::tuple<int, short, double>;
 
     static_assert(std::is_same<type_tuple_start, type_tuple_expected>::value,
@@ -54,7 +54,7 @@ test_tuple_start() {
   {
     auto t_original =
       std::make_tuple(nullptr, std::string("hello"), std::string("world"));
-    auto t_prefix = sigc::tuple_start<3>(t_original);
+    auto t_prefix = sigc::internal::tuple_start<3>(t_original);
 
     static_assert(std::tuple_size<decltype(t_prefix)>::value == 3,
       "unexpected tuple_start()ed tuple size.");
@@ -70,7 +70,7 @@ test_tuple_start() {
   {
     auto t_original =
       std::make_tuple(nullptr, std::string("hello"), std::string("world"));
-    auto t_prefix = sigc::tuple_start<2>(t_original);
+    auto t_prefix = sigc::internal::tuple_start<2>(t_original);
 
     static_assert(std::tuple_size<decltype(t_prefix)>::value == 2,
       "unexpected tuple_start()ed tuple size.");
@@ -86,7 +86,7 @@ test_tuple_start() {
   {
     auto t_original =
       std::make_tuple(nullptr, std::string("hello"), std::string("world"));
-    auto t_prefix = sigc::tuple_start<1>(t_original);
+    auto t_prefix = sigc::internal::tuple_start<1>(t_original);
 
     static_assert(std::tuple_size<decltype(t_prefix)>::value == 1,
       "unexpected tuple_start()ed tuple size.");
@@ -105,7 +105,7 @@ test_tuple_start_stdref() {
   std::string b = "yaddayadda";
   auto t_larger = std::make_tuple(std::ref(a), std::ref(b), 1);
 
-  auto t_prefix = sigc::tuple_start<2>(t_larger);
+  auto t_prefix = sigc::internal::tuple_start<2>(t_larger);
   a = "hello";
   b = "world";
   //This works, but it's not what we are testing here:
diff --git a/tests/test_tuple_transform_each.cc b/tests/test_tuple_transform_each.cc
index 21f1d5a..00e76a0 100644
--- a/tests/test_tuple_transform_each.cc
+++ b/tests/test_tuple_transform_each.cc
@@ -33,7 +33,7 @@ void
 test_tuple_type_transform_each_same_types() {
   using type_tuple_original = std::tuple<int, int>;
   using type_tuple_transformed =
-    sigc::tuple_type_transform_each<type_tuple_original,
+    sigc::internal::tuple_type_transform_each<type_tuple_original,
       transform_to_string>::type;
   using type_tuple_expected = std::tuple<std::string, std::string>;
 
@@ -48,7 +48,7 @@ test_tuple_transform_each_same_types() {
   {
     auto t_original = std::make_tuple(1, 2, 3);
     auto t_transformed =
-      sigc::tuple_transform_each<transform_to_string>(t_original);
+      sigc::internal::tuple_transform_each<transform_to_string>(t_original);
     auto t_expected =
       std::make_tuple(std::string("1"), std::string("2"), std::string("3"));
 
@@ -67,7 +67,7 @@ test_tuple_transform_each_same_types() {
   {
     auto t_original = std::make_tuple(1, (double)2.1f, 3);
     auto t_transformed =
-      sigc::tuple_transform_each<transform_to_string>(t_original);
+      sigc::internal::tuple_transform_each<transform_to_string>(t_original);
     auto t_expected =
       std::make_tuple(std::string("1"), std::string("2"), std::string("3"));
 
@@ -124,7 +124,7 @@ void
 test_tuple_type_transform_each_multiple_types() {
   using type_tuple_original = std::tuple<int, double, std::string>;
   using type_tuple_transformed =
-    sigc::tuple_type_transform_each<type_tuple_original,
+    sigc::internal::tuple_type_transform_each<type_tuple_original,
       transform_to_something>::type;
   using type_tuple_expected = std::tuple<std::string, char, int>;
 
@@ -138,7 +138,7 @@ void
 test_tuple_transform_each_multiple_types() {
   auto t_original = std::make_tuple(1, (double)2.1f, std::string("3"));
   auto t_transformed =
-    sigc::tuple_transform_each<transform_to_something>(t_original);
+    sigc::internal::tuple_transform_each<transform_to_something>(t_original);
   auto t_expected = std::make_tuple(std::string("1"), '2', 3);
 
   static_assert(std::tuple_size<decltype(t_transformed)>::value == 3,
@@ -169,7 +169,7 @@ void
 test_tuple_transform_each_nonconst() {
   auto t = std::make_tuple(1, 2, 3);
   auto t_transformed =
-    sigc::tuple_transform_each<transform_each_nonconst>(t);
+    sigc::internal::tuple_transform_each<transform_each_nonconst>(t);
 
   // Check that t was changed (from * 2):
   assert(std::get<0>(t) == 2);
@@ -189,7 +189,7 @@ test_tuple_transform_each_stdref() {
   int c = 3;
   auto t_original = std::make_tuple(std::ref(a), std::ref(b), std::ref(c));
   auto t_transformed =
-    sigc::tuple_transform_each<transform_to_string>(t_original);
+    sigc::internal::tuple_transform_each<transform_to_string>(t_original);
   auto t_expected =
     std::make_tuple(std::string("1"), std::string("2"), std::string("3"));
 
@@ -245,7 +245,7 @@ test_tuple_transform_each_stdref_non_copyable() {
   NonCopyable c(3);
   auto t_original = std::make_tuple(std::ref(a), std::ref(b), std::ref(c));
   auto t_transformed =
-    sigc::tuple_transform_each<transform_noncopyable_to_string>(t_original);
+    sigc::internal::tuple_transform_each<transform_noncopyable_to_string>(t_original);
   auto t_expected =
     std::make_tuple(std::string("1"), std::string("2"), std::string("3"));
[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]