Added scl namespacing

Author: drowaudio

include/scl/sync_send.h

@@ -8,6 +8,7 @@
 #include <mutex>
 #include <atomic>
 
+namespace scl {
 /**
     A wrapper that can be used around pointers to allow the this pointer to be passed.
     There's nothing special about this, it's just a dump pointer but means we can
@@ -231,3 +232,5 @@ static_assert(! is_sync_v<const int&>);
 static_assert(! is_sync_v<std::string&>);
 static_assert(! is_sync_v<const std::string&>);
 static_assert(is_sync_v<std::atomic<int>>);
+
+}

include/scl/synchronized_value.h

@@ -7,7 +7,7 @@
 
 #include "sync_send.h"
 
-
+namespace scl {
 template<typename Type>
 class synchronized_value
 {
@@ -43,3 +43,5 @@ struct is_send<synchronized_value<T>&> : std::true_type {};
 
 template<typename T>
 struct is_sync<synchronized_value<T>> : std::true_type {};
+
+}

include/scl/syncronized_value.test.cpp

@@ -2,7 +2,7 @@
 #include <cassert>
 #include "synchronized_value.h"
 
-synchronized_value<std::string> s;
+scl::synchronized_value<std::string> s;
 
 std::string read_value() {
     return apply([](auto &x) {  return x; }, s);
@@ -18,7 +18,7 @@ void test_single() {
 }
 
 void test_multi() {
-    synchronized_value<int> a(1), b(2), c(3);
+    scl::synchronized_value<int> a(1), b(2), c(3);
     int sum = apply([](auto &...ints) { return (ints++ + ...); }, a, b, c);
     assert(sum == 6);
     auto get = [](int &i) { return i; };
@@ -37,9 +37,9 @@ struct person
 };
 
 template<>
-struct is_sync<person> : std::true_type {};
+struct scl::is_sync<person> : std::true_type {};
 
-static_assert(is_send_v<person>);
+static_assert(scl::is_send_v<person>);
 
 int main()
 {

tests/pass_copy_reference.cpp

@@ -16,9 +16,9 @@ static_assert(! std::is_object_v<decltype(entry_point)>);
 static_assert(! std::is_member_function_pointer_v<decltype(entry_point)>);
 static_assert(! std::is_pointer_v<decltype(entry_point)>);
 
-static_assert(is_function_pointer_v<std::decay_t<decltype(entry_point)>>
+static_assert(scl::is_function_pointer_v<std::decay_t<decltype(entry_point)>>
                 && ! std::is_member_function_pointer_v<decltype(entry_point)>);
-static_assert(is_function_pointer_v<std::decay_t<decltype(entry_point)>>
+static_assert(scl::is_function_pointer_v<std::decay_t<decltype(entry_point)>>
                 && ! std::is_member_function_pointer_v<decltype(entry_point)>);
 
 int main()

tests/pass_move_reference.cpp

@@ -13,15 +13,15 @@ void entry_point (int tid)
 
 using T = decltype(entry_point);
 static_assert (std::is_pointer_v<std::remove_extent_t<std::decay_t<T>>>);
-static_assert (is_function_pointer_v<std::decay_t<T>>);
+static_assert (scl::is_function_pointer_v<std::decay_t<T>>);
 static_assert (! (std::is_pointer_v<std::remove_extent_t<std::decay_t<T>>>
-                  && ! is_function_pointer_v<std::decay_t<T>>));
+                  && ! scl::is_function_pointer_v<std::decay_t<T>>));
 static_assert (! std::is_member_function_pointer_v<T>);
 
 static_assert (! std::is_move_constructible_v<T>);
-static_assert (is_function_pointer_v<std::decay_t<T>>
+static_assert (scl::is_function_pointer_v<std::decay_t<T>>
                && ! std::is_member_function_pointer_v<std::decay_t<T>>);
-static_assert (! is_sync_v<T>);
+static_assert (! scl::is_sync_v<T>);
 
 static_assert(std::is_function_v<void (int)>);
 static_assert(std::is_function_v<std::remove_cvref_t<void (&)(int)>>);

tests/pass_shared_syncronised_string.cpp

@@ -7,7 +7,7 @@
 
 using namespace std::literals;
 
-void entry_point (std::shared_ptr<synchronized_value<std::string>> sync_s, int tid)
+void entry_point (std::shared_ptr<scl::synchronized_value<std::string>> sync_s, int tid)
 {
     apply ( [tid] (auto& s) {
         s.append ("🔥");
@@ -17,18 +17,18 @@ void entry_point (std::shared_ptr<synchronized_value<std::string>> sync_s, int t
     *sync_s);
 }
 
-static_assert(is_function_pointer_v<std::decay_t<decltype(entry_point)>>);
+static_assert(scl::is_function_pointer_v<std::decay_t<decltype(entry_point)>>);
 static_assert(! std::is_member_function_pointer_v<std::decay_t<decltype(entry_point)>>);
 static_assert(! std::is_member_function_pointer_v<decltype(entry_point)>);
-static_assert(is_send_v<decltype(entry_point)>);
+static_assert(scl::is_send_v<decltype(entry_point)>);
 
 int main()
 {
     std::vector<scl::thread> threads { };
 
     {
         //s dies before the threads join, so possible
-        auto s = std::make_shared<synchronized_value<std::string>> ("Hello threads");
+        auto s = std::make_shared<scl::synchronized_value<std::string>> ("Hello threads");
 
         // Launch all threads.
         const int num_threads = 15;

tests/pass_thread_runner.cpp

@@ -5,18 +5,16 @@
 
 using namespace std::literals;
 
-
-
 class thread_runner
 {
 public:
     thread_runner()
     {
-        std::mem_fn (&thread_runner::run) (unchecked_pointer<thread_runner> (this));
+        std::mem_fn (&thread_runner::run) (scl::unchecked_pointer<thread_runner> (this));
 
         // static_assert(is_send_v<decltype(std::mem_fn (&thread_runner::run))>);
         // static_assert(is_send_v<std::decay_t<decltype(std::mem_fn (&thread_runner::run))>>);
-        thread = std::make_unique<scl::thread> (std::mem_fn (&thread_runner::run), unchecked_pointer (this));
+        thread = std::make_unique<scl::thread> (std::mem_fn (&thread_runner::run), scl::unchecked_pointer (this));
         // thread = std::make_unique<safe_thread> (std::mem_fn (&thread_runner::run), this_wrapper<const thread_runner> (const_cast<const thread_runner*> (this)));
         // thread = std::make_unique<safe_thread> (std::mem_fn (&thread_runner::run), const_cast<const thread_runner*> (this));
     }