GNOME.org
 

[libsigc++2/variadic_bind2: 59/68] Rename the tuple utils namespace.

commit 31f460f3722859efc8ad460de46c95ba4773ad41
Author: Murray Cumming <murrayc murrayc com>
Date:   Fri Feb 19 11:23:25 2016 +0100

    Rename the tuple utils namespace.

 sigc++/tuple_cat.h                 |    4 ++--
 sigc++/tuple_cdr.h                 |    4 ++--
 sigc++/tuple_end.h                 |    6 +++---
 sigc++/tuple_start.h               |    4 ++--
 sigc++/tuple_transform_each.h      |   12 ++++++------
 tests/test_tuple_cat.cc            |    4 ++--
 tests/test_tuple_cdr.cc            |    8 ++++----
 tests/test_tuple_end.cc            |   16 ++++++++--------
 tests/test_tuple_for_each.cc       |   14 +++++++-------
 tests/test_tuple_start.cc          |   16 ++++++++--------
 tests/test_tuple_transform_each.cc |   14 +++++++-------
 11 files changed, 51 insertions(+), 51 deletions(-)
---
diff --git a/sigc++/tuple_cat.h b/sigc++/tuple_cat.h
index bb08644..922c889 100644
--- a/sigc++/tuple_cat.h
+++ b/sigc++/tuple_cat.h
@@ -21,7 +21,7 @@
 #include <type_traits>
 #include <utility>
 
-namespace tupleutils {
+namespace sigc {
 
 namespace detail {
 
@@ -49,6 +49,6 @@ struct tuple_type_cat
 // There is no tuple_cat() here because std::tuple_cat() exists already in
 // the C++ standard library.
 
-} // namespace tupleutils
+} // namespace sigc
 
 #endif //MURRAYC_TUPLE_UTILS_TUPLE_CAT_H
diff --git a/sigc++/tuple_cdr.h b/sigc++/tuple_cdr.h
index c266ef0..2aa6e50 100644
--- a/sigc++/tuple_cdr.h
+++ b/sigc++/tuple_cdr.h
@@ -21,7 +21,7 @@
 #include <type_traits>
 #include <utility>
 
-namespace tupleutils {
+namespace sigc {
 
 /**
  * Get the type of a tuple without the first item.
@@ -63,6 +63,6 @@ tuple_cdr(T&& t) {
   return detail::tuple_cdr_impl(std::forward<T>(t), seq{});
 }
 
-} // namespace tupleutils
+} // namespace sigc
 
 #endif //MURRAYC_TUPLE_UTILS_TUPLE_CDR_H
diff --git a/sigc++/tuple_end.h b/sigc++/tuple_end.h
index 528ae29..2bf6628 100644
--- a/sigc++/tuple_end.h
+++ b/sigc++/tuple_end.h
@@ -17,9 +17,9 @@
 #ifndef MURRAYC_TUPLE_UTILS_TUPLE_END_H
 #define MURRAYC_TUPLE_UTILS_TUPLE_END_H
 
-#include <tuple-utils/tuple_cdr.h>
+#include <sigc++/tuple_cdr.h>
 
-namespace tupleutils {
+namespace sigc {
 
 namespace detail {
 
@@ -88,6 +88,6 @@ decltype(auto) // typename tuple_type_end<T, len>::type
   return detail::tuple_end_impl<T, size_start>::tuple_end(std::forward<T>(t));
 }
 
-} // namespace tupleutils;
+} // namespace sigc;
 
 #endif //MURRAYC_TUPLE_UTILS_TUPLE_END_H
diff --git a/sigc++/tuple_start.h b/sigc++/tuple_start.h
index 7fe2164..dd95636 100644
--- a/sigc++/tuple_start.h
+++ b/sigc++/tuple_start.h
@@ -20,7 +20,7 @@
 #include <tuple>
 #include <utility>
 
-namespace tupleutils {
+namespace sigc {
 
 namespace detail {
 
@@ -75,6 +75,6 @@ decltype(auto) // typename tuple_type_end<T, len>::type
     std::forward<T>(t));
 }
 
-} // namespace tupleutils;
+} // namespace sigc;
 
 #endif //MURRAYC_TUPLE_UTILS_TUPLE_START_H
diff --git a/sigc++/tuple_transform_each.h b/sigc++/tuple_transform_each.h
index 7797a34..78da544 100644
--- a/sigc++/tuple_transform_each.h
+++ b/sigc++/tuple_transform_each.h
@@ -17,13 +17,13 @@
 #ifndef MURRAYC_TUPLE_UTILS_TUPLE_TRANSFORM_EACH_H
 #define MURRAYC_TUPLE_UTILS_TUPLE_TRANSFORM_EACH_H
 
-#include <tuple-utils/tuple_cat.h>
-#include <tuple-utils/tuple_cdr.h>
-#include <tuple-utils/tuple_end.h>
-#include <tuple-utils/tuple_start.h>
+#include <sigc++/tuple_cat.h>
+#include <sigc++/tuple_cdr.h>
+#include <sigc++/tuple_end.h>
+#include <sigc++/tuple_start.h>
 #include <type_traits>
 
-namespace tupleutils {
+namespace sigc {
 
 namespace detail {
 
@@ -150,6 +150,6 @@ tuple_transform_each(T&& t) {
     size - 1>::tuple_transform_each(std::forward<T>(t), t);
 }
 
-} // namespace tupleutils
+} // namespace sigc
 
 #endif //MURRAYC_TUPLE_UTILS_TUPLE_TRANSFORM_EACH_H
diff --git a/tests/test_tuple_cat.cc b/tests/test_tuple_cat.cc
index 1b4e22a..d266483 100644
--- a/tests/test_tuple_cat.cc
+++ b/tests/test_tuple_cat.cc
@@ -16,7 +16,7 @@
 
 #include <cassert>
 #include <cstdlib>
-#include <tuple-utils/tuple_cat.h>
+#include <sigc++/tuple_cat.h>
 #include <utility>
 //#include <functional>
 
@@ -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 =
-    tupleutils::tuple_type_cat<type_tuple_is, type_tuple_dc>::type;
+    sigc::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 7b73876..b0d74f3 100644
--- a/tests/test_tuple_cdr.cc
+++ b/tests/test_tuple_cdr.cc
@@ -16,7 +16,7 @@
 
 #include <cassert>
 #include <cstdlib>
-#include <tuple-utils/tuple_cdr.h>
+#include <sigc++/tuple_cdr.h>
 #include <utility>
 #include <functional>
 
@@ -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 = tupleutils::tuple_type_cdr<type_tuple_isd>::type;
+  using type_tuple_suffix = sigc::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 = tupleutils::tuple_cdr(t_larger);
+  auto t_suffix = sigc::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 = tupleutils::tuple_cdr(t_larger);
+  auto t_suffix = sigc::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 f013f95..ad4b063 100644
--- a/tests/test_tuple_end.cc
+++ b/tests/test_tuple_end.cc
@@ -16,14 +16,14 @@
 
 #include <cassert>
 #include <cstdlib>
-#include <tuple-utils/tuple_end.h>
+#include <sigc++/tuple_end.h>
 #include <functional>
 
 void
 test_tuple_type_end() {
   {
     using type_tuple = std::tuple<int, short, double>;
-    using type_tuple_end = tupleutils::tuple_type_end<type_tuple, 1>::type;
+    using type_tuple_end = sigc::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 = tupleutils::tuple_type_end<type_tuple, 2>::type;
+    using type_tuple_end = sigc::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 = tupleutils::tuple_type_end<type_tuple, 3>::type;
+    using type_tuple_end = sigc::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 = tupleutils::tuple_end<3>(t_original);
+    auto t_suffix = sigc::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 = tupleutils::tuple_end<2>(t_original);
+    auto t_suffix = sigc::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 = tupleutils::tuple_end<1>(t_original);
+    auto t_suffix = sigc::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 = tupleutils::tuple_end<2>(t_larger);
+  auto t_suffix = sigc::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 82ef268..86bc46f 100644
--- a/tests/test_tuple_for_each.cc
+++ b/tests/test_tuple_for_each.cc
@@ -16,7 +16,7 @@
 
 #include <cassert>
 #include <cstdlib>
-#include <tuple-utils/tuple_for_each.h>
+#include <sigc++/tuple_for_each.h>
 #include <utility>
 //#include <typeinfo>
 #include <iostream>
@@ -34,12 +34,12 @@ void
 test_tuple_for_each_same_types() {
   {
     auto t_original = std::make_tuple(1, 2, 3);
-    tupleutils::tuple_for_each<for_each_simple>(t_original);
+    sigc::tuple_for_each<for_each_simple>(t_original);
   }
 
   {
     auto t_original = std::make_tuple(1, (double)2.1f, 3);
-    tupleutils::tuple_for_each<for_each_simple>(t_original);
+    sigc::tuple_for_each<for_each_simple>(t_original);
   }
 }
 
@@ -57,7 +57,7 @@ void
 test_tuple_for_each_same_types_with_extras() {
   {
     auto t_original = std::make_tuple(1, (double)2.1f, 3);
-    tupleutils::tuple_for_each<for_each_simple_with_extras>(
+    sigc::tuple_for_each<for_each_simple_with_extras>(
       t_original, 89, "eightynine");
   }
 }
@@ -77,7 +77,7 @@ test_tuple_for_each_same_types_with_nonconst_extras() {
     auto t_original = std::make_tuple(1, (double)2.1f, 3);
     int extra = 0;
 
-    tupleutils::tuple_for_each<for_each_simple_with_nonconst_extras>(t_original, extra);
+    sigc::tuple_for_each<for_each_simple_with_nonconst_extras>(t_original, extra);
     // std::cout << "extra: " << extra << std::endl;
     assert(extra == 6);
   }
@@ -125,7 +125,7 @@ public:
 void
 test_tuple_for_each_multiple_types() {
   auto t_original = std::make_tuple(1, (double)2.1f, std::string("3"));
-  tupleutils::tuple_for_each<visitor_with_specializations>(t_original);
+  sigc::tuple_for_each<visitor_with_specializations>(t_original);
 }
 
 template <class T_element_from>
@@ -141,7 +141,7 @@ public:
 void
 test_tuple_for_each_nonconst() {
   auto t = std::make_tuple(1, 2, 3);
-  tupleutils::tuple_for_each<for_each_nonconst, decltype(t)&>(t);
+  sigc::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);
diff --git a/tests/test_tuple_start.cc b/tests/test_tuple_start.cc
index 8509d4b..00e4f30 100644
--- a/tests/test_tuple_start.cc
+++ b/tests/test_tuple_start.cc
@@ -16,14 +16,14 @@
 
 #include <cassert>
 #include <cstdlib>
-#include <tuple-utils/tuple_start.h>
+#include <sigc++/tuple_start.h>
 #include <functional>
 
 void
 test_tuple_type_start() {
   {
     using type_tuple = std::tuple<int, short, double>;
-    using type_tuple_start = tupleutils::tuple_type_start<type_tuple, 1>::type;
+    using type_tuple_start = sigc::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 = tupleutils::tuple_type_start<type_tuple, 2>::type;
+    using type_tuple_start = sigc::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 = tupleutils::tuple_type_start<type_tuple, 3>::type;
+    using type_tuple_start = sigc::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 = tupleutils::tuple_start<3>(t_original);
+    auto t_prefix = sigc::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 = tupleutils::tuple_start<2>(t_original);
+    auto t_prefix = sigc::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 = tupleutils::tuple_start<1>(t_original);
+    auto t_prefix = sigc::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 = tupleutils::tuple_start<2>(t_larger);
+  auto t_prefix = sigc::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 fbe7989..9b0d0e8 100644
--- a/tests/test_tuple_transform_each.cc
+++ b/tests/test_tuple_transform_each.cc
@@ -16,7 +16,7 @@
 
 #include <cassert>
 #include <cstdlib>
-#include <tuple-utils/tuple_transform_each.h>
+#include <sigc++/tuple_transform_each.h>
 #include <utility>
 
 template <class T_element_from>
@@ -32,7 +32,7 @@ void
 test_tuple_type_transform_each_same_types() {
   using type_tuple_original = std::tuple<int, int>;
   using type_tuple_transformed =
-    tupleutils::tuple_type_transform_each<type_tuple_original,
+    sigc::tuple_type_transform_each<type_tuple_original,
       transform_to_string>::type;
   using type_tuple_expected = std::tuple<std::string, std::string>;
 
@@ -47,7 +47,7 @@ test_tuple_transform_each_same_types() {
   {
     auto t_original = std::make_tuple(1, 2, 3);
     auto t_transformed =
-      tupleutils::tuple_transform_each<transform_to_string>(t_original);
+      sigc::tuple_transform_each<transform_to_string>(t_original);
     auto t_expected =
       std::make_tuple(std::string("1"), std::string("2"), std::string("3"));
 
@@ -66,7 +66,7 @@ test_tuple_transform_each_same_types() {
   {
     auto t_original = std::make_tuple(1, (double)2.1f, 3);
     auto t_transformed =
-      tupleutils::tuple_transform_each<transform_to_string>(t_original);
+      sigc::tuple_transform_each<transform_to_string>(t_original);
     auto t_expected =
       std::make_tuple(std::string("1"), std::string("2"), std::string("3"));
 
@@ -123,7 +123,7 @@ void
 test_tuple_type_transform_each_multiple_types() {
   using type_tuple_original = std::tuple<int, double, std::string>;
   using type_tuple_transformed =
-    tupleutils::tuple_type_transform_each<type_tuple_original,
+    sigc::tuple_type_transform_each<type_tuple_original,
       transform_to_something>::type;
   using type_tuple_expected = std::tuple<std::string, char, int>;
 
@@ -137,7 +137,7 @@ void
 test_tuple_transform_each_multiple_types() {
   auto t_original = std::make_tuple(1, (double)2.1f, std::string("3"));
   auto t_transformed =
-    tupleutils::tuple_transform_each<transform_to_something>(t_original);
+    sigc::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,
@@ -168,7 +168,7 @@ void
 test_tuple_transform_each_nonconst() {
   auto t = std::make_tuple(1, 2, 3);
   auto t_transformed =
-    tupleutils::tuple_transform_each<transform_each_nonconst>(t);
+    sigc::tuple_transform_each<transform_each_nonconst>(t);
 
   // Check that t was changed (from * 2):
   assert(std::get<0>(t) == 2);
[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]