Began developing an atomic wrapper

Author: liuzicheng1987

include/rfl/parsing/Parser.hpp

@@ -2,6 +2,7 @@
 #define RFL_PARSING_PARSER_HPP_
 
 #include "Parser_array.hpp"
+#include "Parser_atomic.hpp"
 #include "Parser_base.hpp"
 #include "Parser_basic_type.hpp"
 #include "Parser_box.hpp"

include/rfl/parsing/Parser_atomic.hpp

@@ -0,0 +1,43 @@
+#ifndef RFL_PARSING_PARSER_ATOMIC_HPP_
+#define RFL_PARSING_PARSER_ATOMIC_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 T, class ProcessorsType>
+  requires AreReaderAndWriter<R, W, std::atomic<T>>
+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);
+  }
+
+  template <class P>
+  static void write(const W& _w, const std::atomic<T>& _a, const P& _parent) {
+    Parser<R, W, std::remove_cvref_t<T>, ProcessorsType>::write(
+        _w, _a.load(std::memory_order_relaxed), _parent);
+  }
+
+  static schema::Type to_schema(
+      std::map<std::string, schema::Type>* _definitions) {
+    using U = std::remove_cvref_t<T>;
+    return schema::Type{
+        Parser<R, W, U, ProcessorsType>::to_schema(_definitions)};
+  }
+};
+
+}  // namespace rfl::parsing
+
+#endif

tests/json/test_atomic.cpp

@@ -0,0 +1,37 @@
+#include <atomic>
+#include <rfl.hpp>
+#include <rfl/json.hpp>
+#include <string>
+
+#include "write_and_read.hpp"
+
+namespace test_atomic {
+
+struct Stats {
+  std::atomic<std::uint64_t> bytes_downloaded;
+  std::atomic<bool> finished;
+
+  Stats(Stats&& other) noexcept
+      : bytes_downloaded(
+            other.bytes_downloaded.load(std::memory_order_relaxed)),
+        finished(other.finished.load(std::memory_order_relaxed)) {}
+
+  Stats& operator=(Stats&& other) noexcept {
+    bytes_downloaded.store(
+        other.bytes_downloaded.load(std::memory_order_relaxed),
+        std::memory_order_relaxed);
+    finished.store(other.finished.load(std::memory_order_relaxed),
+                   std::memory_order_relaxed);
+    return *this;
+  }
+
+  Stats(const std::uint64_t _bytes_downloaded, const bool _finished)
+      : bytes_downloaded(_bytes_downloaded), finished(_finished) {}
+};
+
+TEST(json, test_atomic) {
+  auto stats = Stats(123456789, true);
+
+  write_and_read(stats, R"({"bytes_downloaded":123456789,"finished":true})");
+}
+}  // namespace test_atomic