Added support for atomic flags

Author: liuzicheng1987

include/rfl/atomic/is_atomic.hpp

@@ -3,12 +3,9 @@
 
 #include <array>
 #include <atomic>
-#include <memory>
 #include <type_traits>
 
-#include "../Box.hpp"
 #include "../NamedTuple.hpp"
-#include "../Ref.hpp"
 #include "../Tuple.hpp"
 #include "../named_tuple_t.hpp"
 #include "../to_view.hpp"
@@ -34,6 +31,19 @@ struct is_atomic<std::atomic<T>> {
   };
 };
 
+template <>
+struct is_atomic<std::atomic_flag> {
+  static constexpr bool value = true;
+  using RemoveAtomicT = bool;
+  static void set(RemoveAtomicT&& val, std::atomic_flag* _t) {
+    if (val) {
+      _t->test_and_set(std::memory_order_relaxed);
+    } else {
+      _t->clear(std::memory_order_relaxed);
+    }
+  }
+};
+
 template <class T, size_t N>
 struct is_atomic<std::array<T, N>> {
   using Type = std::remove_cvref_t<T>;
@@ -58,7 +68,7 @@ struct is_atomic<T[N]> {
   static void set(RemoveAtomicT&& val, T (*_t)[N]) {
     for (size_t i = 0; i < N; ++i) {
       is_atomic<T>::set(
-          std::forward<typename is_atomic<T>::RemoveAtomicT>(val[i]),
+          std::forward<typename is_atomic<Type>::RemoveAtomicT>(val[i]),
           &((*_t)[i]));
     }
   }
@@ -75,16 +85,16 @@ struct is_atomic<NamedTuple<Fields...>> {
 
   static void set(RemoveAtomicT&& val, NamedTuple<Fields...>* _t) {
     (is_atomic<typename Fields::Type>::set(
-         std::forward<typename is_atomic<typename Fields::Type>::RemoveAtomicT>(
+         std::forward<typename is_atomic<
+             std::remove_cvref_t<typename Fields::Type>>::RemoveAtomicT>(
              val.template get<Fields::name_>()),
          &(_t->template get<Fields::name_>())),
      ...);
   }
 };
 
 template <class T>
-  requires(std::is_class_v<T> && std::is_aggregate_v<T> &&
-           !std::is_move_constructible_v<T>)
+  requires(std::is_class_v<T> && std::is_aggregate_v<T>)
 struct is_atomic<T> {
   static constexpr bool value = is_atomic<named_tuple_t<T>>::value;
 

include/rfl/parsing/Parser.hpp

@@ -3,6 +3,7 @@
 
 #include "Parser_array.hpp"
 #include "Parser_atomic.hpp"
+#include "Parser_atomic_flag.hpp"
 #include "Parser_base.hpp"
 #include "Parser_basic_type.hpp"
 #include "Parser_box.hpp"

include/rfl/parsing/Parser_atomic.hpp

@@ -18,11 +18,7 @@ template <class R, class W, class T, class ProcessorsType>
 struct Parser<R, W, std::atomic<T>, ProcessorsType> {
   using InputVarType = typename R::InputVarType;
 
-  using ParentType = Parent<W>;
-
-  static Result<T> read(const R& _r, const InputVarType& _var) noexcept {
-    return Parser<R, W, std::remove_cvref_t<T>, ProcessorsType>::read(_r, _var);
-  }
+  /// Read is not supported for atomic types - we must used rfl::atomic instead.
 
   template <class P>
   static void write(const W& _w, const std::atomic<T>& _a, const P& _parent) {

include/rfl/parsing/Parser_atomic_flag.hpp

@@ -0,0 +1,38 @@
+#ifndef RFL_PARSING_PARSER_ATOMIC_FLAG_HPP_
+#define RFL_PARSING_PARSER_ATOMIC_FLAG_HPP_
+
+#include <atomic>
+#include <map>
+#include <type_traits>
+
+#include "../DefaultVal.hpp"
+#include "AreReaderAndWriter.hpp"
+#include "Parent.hpp"
+#include "Parser_base.hpp"
+#include "schema/Type.hpp"
+
+namespace rfl::parsing {
+
+template <class R, class W, class ProcessorsType>
+  requires AreReaderAndWriter<R, W, std::atomic_flag>
+struct Parser<R, W, std::atomic_flag, ProcessorsType> {
+  using InputVarType = typename R::InputVarType;
+
+  /// Read is not supported for atomic types - we must used rfl::atomic instead.
+
+  template <class P>
+  static void write(const W& _w, const std::atomic_flag& _a, const P& _parent) {
+    Parser<R, W, bool, ProcessorsType>::write(
+        _w, _a.test(std::memory_order_relaxed), _parent);
+  }
+
+  static schema::Type to_schema(
+      std::map<std::string, schema::Type>* _definitions) {
+    return schema::Type{
+        Parser<R, W, bool, ProcessorsType>::to_schema(_definitions)};
+  }
+};
+
+}  // namespace rfl::parsing
+
+#endif

tests/json/test_atomic.cpp

@@ -11,6 +11,7 @@ namespace test_atomic {
 struct Stats {
   std::atomic<std::uint64_t> bytes_downloaded;
   std::atomic<bool> finished;
+  std::atomic_flag atomic_flag;
   rfl::Ref<std::atomic<int>> ref_atomic_int;
   rfl::Box<std::atomic<int>> box_atomic_int;
   std::shared_ptr<std::atomic<int>> shared_atomic_int;
@@ -21,6 +22,7 @@ TEST(json, test_atomic) {
   auto stats =
       Stats{.bytes_downloaded = 123456789,
             .finished = true,
+            .atomic_flag = ATOMIC_FLAG_INIT,
             .ref_atomic_int = rfl::make_ref<std::atomic<int>>(42),
             .box_atomic_int = rfl::Box<std::atomic<int>>::make(7),
             .shared_atomic_int = std::make_shared<std::atomic<int>>(13),
@@ -40,6 +42,6 @@ TEST(json, test_atomic) {
   EXPECT_EQ(rfl::json::write(stats2), json_str);
   EXPECT_EQ(
       json_str,
-      R"({"bytes_downloaded":123456789,"finished":true,"ref_atomic_int":42,"box_atomic_int":7,"shared_atomic_int":13,"unique_atomic_int":21})");
+      R"({"bytes_downloaded":123456789,"finished":true,"atomic_flag":false,"ref_atomic_int":42,"box_atomic_int":7,"shared_atomic_int":13,"unique_atomic_int":21})");
 }
 }  // namespace test_atomic

tests/json/test_atomic_array.cpp

@@ -10,17 +10,20 @@ namespace test_atomic_array {
 struct Stats {
   std::atomic<std::uint64_t> bytes_downloaded;
   std::atomic<bool> finished;
+  std::atomic_flag atomic_flag = ATOMIC_FLAG_INIT;
 };
 
 TEST(json, test_atomic_array) {
   auto arr = rfl::Ref<std::array<Stats, 2>>{};
   (*arr)[0].bytes_downloaded = 123456789;
   (*arr)[0].finished = true;
+  (*arr)[0].atomic_flag.test_and_set();
   (*arr)[1].bytes_downloaded = 987654321;
   (*arr)[1].finished = false;
+  (*arr)[1].atomic_flag.clear();
 
   write_and_read(
       arr,
-      R"([{"bytes_downloaded":123456789,"finished":true},{"bytes_downloaded":987654321,"finished":false}])");
+      R"([{"bytes_downloaded":123456789,"finished":true,"atomic_flag":true},{"bytes_downloaded":987654321,"finished":false,"atomic_flag":false}])");
 }
 }  // namespace test_atomic_array

tests/json/test_atomic_box.cpp

@@ -5,16 +5,16 @@
 
 #include "write_and_read.hpp"
 
-namespace test_atomic_ref {
+namespace test_atomic_box {
 
 struct Stats {
   std::atomic<std::uint64_t> bytes_downloaded;
   std::atomic<bool> finished;
 };
 
-TEST(json, test_atomic_ref) {
-  auto stats = rfl::make_ref<Stats>(123456789, true);
+TEST(json, test_atomic_box) {
+  auto stats = rfl::make_box<Stats>(123456789, true);
 
   write_and_read(stats, R"({"bytes_downloaded":123456789,"finished":true})");
 }
-}  // namespace test_atomic_ref
+}  // namespace test_atomic_box

tests/json/test_atomic_ref.cpp

@@ -5,16 +5,16 @@
 
 #include "write_and_read.hpp"
 
-namespace test_atomic_box {
+namespace test_atomic_ref {
 
 struct Stats {
   std::atomic<std::uint64_t> bytes_downloaded;
   std::atomic<bool> finished;
 };
 
-TEST(json, test_atomic_box) {
-  auto stats = rfl::make_box<Stats>(123456789, true);
+TEST(json, test_atomic_ref) {
+  auto stats = rfl::make_ref<Stats>(123456789, true);
 
   write_and_read(stats, R"({"bytes_downloaded":123456789,"finished":true})");
 }
-}  // namespace test_atomic_box
+}  // namespace test_atomic_ref