Added exceptions to BSON

Author: liuzicheng1987

include/rfl/bson/Reader.hpp

@@ -9,10 +9,9 @@
 #include <string>
 #include <type_traits>
 
-#include "../Bytestring.hpp"
 #include "../Result.hpp"
-#include "../Vectorstring.hpp"
 #include "../always_false.hpp"
+#include "../concepts.hpp"
 #include "../internal/ptr_cast.hpp"
 
 namespace rfl {
@@ -102,10 +101,8 @@ struct Reader {
               "Could not cast to string. The type must be UTF8 or symbol.");
       }
 
-    } else if constexpr (std::is_same<std::remove_cvref_t<T>,
-                                      rfl::Bytestring>() ||
-                         std::is_same<std::remove_cvref_t<T>,
-                                      rfl::Vectorstring>()) {
+    } else if constexpr (concepts::MutableContiguousByteContainer<
+                             std::remove_cvref_t<T>>) {
       using VectorType = std::remove_cvref_t<T>;
       using ValueType = typename VectorType::value_type;
       if (btype != BSON_TYPE_BINARY) {

include/rfl/bson/Writer.hpp

@@ -11,13 +11,11 @@
 #include <vector>
 
 #include "../Box.hpp"
-#include "../Bytestring.hpp"
 #include "../Ref.hpp"
-//#include "../Result.hpp"
-#include "../Vectorstring.hpp"
 #include "../always_false.hpp"
-#include "../internal/ptr_cast.hpp"
 #include "../common.hpp"
+#include "../concepts.hpp"
+#include "../internal/ptr_cast.hpp"
 
 namespace rfl {
 namespace bson {
@@ -79,43 +77,65 @@ class RFL_API Writer {
   }
 
   OutputArrayType add_array_to_array(const size_t _size,
-                                     OutputArrayType* _parent) const noexcept;
+                                     OutputArrayType* _parent) const;
 
   OutputArrayType add_array_to_object(const std::string_view& _name,
                                       const size_t _size,
-                                      OutputObjectType* _parent) const noexcept;
+                                      OutputObjectType* _parent) const;
 
   OutputObjectType add_object_to_array(const size_t _size,
-                                       OutputArrayType* _parent) const noexcept;
+                                       OutputArrayType* _parent) const;
 
-  OutputObjectType add_object_to_object(
-      const std::string_view& _name, const size_t _size,
-      OutputObjectType* _parent) const noexcept;
+  OutputObjectType add_object_to_object(const std::string_view& _name,
+                                        const size_t _size,
+                                        OutputObjectType* _parent) const;
 
   template <class T>
   OutputVarType add_value_to_array(const T& _var,
-                                   OutputArrayType* _parent) const noexcept {
+                                   OutputArrayType* _parent) const {
     if constexpr (std::is_same<std::remove_cvref_t<T>, std::string>()) {
-      bson_array_builder_append_utf8(_parent->val_, _var.c_str(),
-                                     static_cast<int>(_var.size()));
-    } else if constexpr (std::is_same<std::remove_cvref_t<T>,
-                                      rfl::Bytestring>() ||
-                         std::is_same<std::remove_cvref_t<T>,
-                                      rfl::Vectorstring>()) {
-      bson_array_builder_append_binary(
+      const bool ok = bson_array_builder_append_utf8(
+          _parent->val_, _var.c_str(), static_cast<int>(_var.size()));
+      if (!ok) {
+        throw std::runtime_error("Could not append utf-8 to array.");
+      }
+
+    } else if constexpr (concepts::MutableContiguousByteContainer<
+                             std::remove_cvref_t<T>>) {
+      const bool ok = bson_array_builder_append_binary(
           _parent->val_, BSON_SUBTYPE_BINARY,
           internal::ptr_cast<const uint8_t*>(_var.data()),
           static_cast<uint32_t>(_var.size()));
+      if (!ok) {
+        throw std::runtime_error("Could not append binary to array.");
+      }
+
     } else if constexpr (std::is_same<std::remove_cvref_t<T>, bool>()) {
-      bson_array_builder_append_bool(_parent->val_, _var);
+      const bool ok = bson_array_builder_append_bool(_parent->val_, _var);
+      if (!ok) {
+        throw std::runtime_error("Could not append bool to array.");
+      }
+
     } else if constexpr (std::is_floating_point<std::remove_cvref_t<T>>()) {
-      bson_array_builder_append_double(_parent->val_,
-                                       static_cast<double>(_var));
+      const bool ok = bson_array_builder_append_double(
+          _parent->val_, static_cast<double>(_var));
+      if (!ok) {
+        throw std::runtime_error("Could not append float to array.");
+      }
+
     } else if constexpr (std::is_integral<std::remove_cvref_t<T>>()) {
-      bson_array_builder_append_int64(_parent->val_,
-                                      static_cast<std::int64_t>(_var));
+      const bool ok = bson_array_builder_append_int64(
+          _parent->val_, static_cast<std::int64_t>(_var));
+      if (!ok) {
+        throw std::runtime_error("Could not append integer to array.");
+      }
+
     } else if constexpr (std::is_same<std::remove_cvref_t<T>, bson_oid_t>()) {
-      bson_array_builder_append_oid(_parent->val_, &_var);
+      const bool ok = bson_array_builder_append_oid(_parent->val_, &_var);
+      if (!ok) {
+        throw std::runtime_error("Could not append OID to array.");
+      }
+
     } else {
       static_assert(rfl::always_false_v<T>, "Unsupported type.");
     }
@@ -125,47 +145,75 @@ class RFL_API Writer {
   template <class T>
   OutputVarType add_value_to_object(const std::string_view& _name,
                                     const T& _var,
-                                    OutputObjectType* _parent) const noexcept {
+                                    OutputObjectType* _parent) const {
     if constexpr (std::is_same<std::remove_cvref_t<T>, std::string>()) {
-      bson_append_utf8(_parent->val_, _name.data(),
-                       static_cast<int>(_name.size()), _var.c_str(),
-                       static_cast<int>(_var.size()));
-    } else if constexpr (std::is_same<std::remove_cvref_t<T>,
-                                      rfl::Bytestring>() ||
-                         std::is_same<std::remove_cvref_t<T>,
-                                      rfl::Vectorstring>()) {
-      bson_append_binary(_parent->val_, _name.data(),
-                         static_cast<int>(_name.size()), BSON_SUBTYPE_BINARY,
-                         internal::ptr_cast<const uint8_t*>(_var.data()),
-                         static_cast<uint32_t>(_var.size()));
+      const bool ok = bson_append_utf8(
+          _parent->val_, _name.data(), static_cast<int>(_name.size()),
+          _var.c_str(), static_cast<int>(_var.size()));
+      if (!ok) {
+        throw std::runtime_error("Could not utf-8 field '" +
+                                 std::string(_name) + "' to object.");
+      }
+
+    } else if constexpr (concepts::MutableContiguousByteContainer<
+                             std::remove_cvref_t<T>>) {
+      const bool ok = bson_append_binary(
+          _parent->val_, _name.data(), static_cast<int>(_name.size()),
+          BSON_SUBTYPE_BINARY, internal::ptr_cast<const uint8_t*>(_var.data()),
+          static_cast<uint32_t>(_var.size()));
+      if (!ok) {
+        throw std::runtime_error("Could not binary field '" +
+                                 std::string(_name) + "' to object.");
+      }
+
     } else if constexpr (std::is_same<std::remove_cvref_t<T>, bool>()) {
-      bson_append_bool(_parent->val_, _name.data(),
-                       static_cast<int>(_name.size()), _var);
+      const bool ok = bson_append_bool(_parent->val_, _name.data(),
+                                       static_cast<int>(_name.size()), _var);
+      if (!ok) {
+        throw std::runtime_error("Could not boolean field '" +
+                                 std::string(_name) + "' to object.");
+      }
+
     } else if constexpr (std::is_floating_point<std::remove_cvref_t<T>>()) {
-      bson_append_double(_parent->val_, _name.data(),
-                         static_cast<int>(_name.size()),
-                         static_cast<double>(_var));
+      const bool ok = bson_append_double(_parent->val_, _name.data(),
+                                         static_cast<int>(_name.size()),
+                                         static_cast<double>(_var));
+      if (!ok) {
+        throw std::runtime_error("Could not floating point field '" +
+                                 std::string(_name) + "' to object.");
+      }
+
     } else if constexpr (std::is_integral<std::remove_cvref_t<T>>()) {
-      bson_append_int64(_parent->val_, _name.data(),
-                        static_cast<int>(_name.size()),
-                        static_cast<std::int64_t>(_var));
+      const bool ok = bson_append_int64(_parent->val_, _name.data(),
+                                        static_cast<int>(_name.size()),
+                                        static_cast<std::int64_t>(_var));
+      if (!ok) {
+        throw std::runtime_error("Could not int field '" + std::string(_name) +
+                                 "' to object.");
+      }
+
     } else if constexpr (std::is_same<std::remove_cvref_t<T>, bson_oid_t>()) {
-      bson_append_oid(_parent->val_, _name.data(),
-                      static_cast<int>(_name.size()), &_var);
+      const bool ok = bson_append_oid(_parent->val_, _name.data(),
+                                      static_cast<int>(_name.size()), &_var);
+      if (!ok) {
+        throw std::runtime_error("Could not oid field '" + std::string(_name) +
+                                 "' to object.");
+      }
+
     } else {
       static_assert(rfl::always_false_v<T>, "Unsupported type.");
     }
     return OutputVarType{};
   }
 
-  OutputVarType add_null_to_array(OutputArrayType* _parent) const noexcept;
+  OutputVarType add_null_to_array(OutputArrayType* _parent) const;
 
   OutputVarType add_null_to_object(const std::string_view& _name,
-                                   OutputObjectType* _parent) const noexcept;
+                                   OutputObjectType* _parent) const;
 
-  void end_array(OutputArrayType* _arr) const noexcept;
+  void end_array(OutputArrayType* _arr) const;
 
-  void end_object(OutputObjectType* _obj) const noexcept;
+  void end_object(OutputObjectType* _obj) const;
 
  private:
   /// Pointer to the main document. In BSON, documents are what are usually

include/rfl/bson/write.hpp

@@ -17,7 +17,7 @@ namespace bson {
 /// Returns BSON bytes. Careful: It is the responsibility of the caller to call
 /// bson_free on the returned pointer.
 template <class... Ps>
-std::pair<uint8_t*, size_t> to_buffer(const auto& _obj) noexcept {
+std::pair<uint8_t*, size_t> to_buffer(const auto& _obj) {
   using T = std::remove_cvref_t<decltype(_obj)>;
   using ParentType = parsing::Parent<Writer>;
   bson_t* doc = nullptr;
@@ -41,7 +41,7 @@ std::pair<uint8_t*, size_t> to_buffer(const auto& _obj) noexcept {
 
 /// Returns BSON bytes.
 template <class... Ps>
-std::vector<char> write(const auto& _obj) noexcept {
+std::vector<char> write(const auto& _obj) {
   auto [buf, len] = to_buffer<Ps...>(_obj);
   const auto result = std::vector<char>(internal::ptr_cast<char*>(buf),
                                         internal::ptr_cast<char*>(buf) + len);
@@ -51,7 +51,7 @@ std::vector<char> write(const auto& _obj) noexcept {
 
 /// Writes a BSON into an ostream.
 template <class... Ps>
-std::ostream& write(const auto& _obj, std::ostream& _stream) noexcept {
+std::ostream& write(const auto& _obj, std::ostream& _stream) {
   auto [buf, len] = to_buffer<Ps...>(_obj);
   _stream.write(internal::ptr_cast<const char*>(buf), len);
   bson_free(buf);

src/rfl/bson/Writer.cpp

@@ -23,74 +23,116 @@ Writer::OutputVarType Writer::null_as_root() const noexcept {
 }
 
 Writer::OutputArrayType Writer::add_array_to_array(
-    const size_t /*_size*/, OutputArrayType* _parent) const noexcept {
+    const size_t /*_size*/, OutputArrayType* _parent) const {
   bson_array_builder_t* val;
-  bson_array_builder_append_array_builder_begin(_parent->val_, &val);
+  const bool ok =
+      bson_array_builder_append_array_builder_begin(_parent->val_, &val);
+  if (!ok) {
+    throw std::runtime_error("Could not array to array.");
+  }
   return OutputArrayType(val, IsArray{_parent->val_});
 }
 
 Writer::OutputArrayType Writer::add_array_to_object(
     const std::string_view& _name, const size_t /*_size*/,
-    OutputObjectType* _parent) const noexcept {
+    OutputObjectType* _parent) const {
   bson_array_builder_t* val;
-  bson_append_array_builder_begin(_parent->val_, _name.data(),
-                                  static_cast<int>(_name.size()), &val);
+  const bool ok = bson_append_array_builder_begin(
+      _parent->val_, _name.data(), static_cast<int>(_name.size()), &val);
+  if (!ok) {
+    throw std::runtime_error("Could not array to array.");
+  }
   return OutputArrayType(val, IsObject{_parent->val_});
 }
 
 Writer::OutputObjectType Writer::add_object_to_array(
-    const size_t /*_size*/, OutputArrayType* _parent) const noexcept {
+    const size_t /*_size*/, OutputArrayType* _parent) const {
   subdocs_->emplace_back(rfl::Box<BSONType>());
-  bson_array_builder_append_document_begin(_parent->val_,
-                                           &(subdocs_->back()->val_));
+  const bool ok = bson_array_builder_append_document_begin(
+      _parent->val_, &(subdocs_->back()->val_));
+  if (!ok) {
+    throw std::runtime_error("Could not object to array.");
+  }
   return OutputObjectType(&subdocs_->back()->val_, IsArray{_parent->val_});
 }
 
 Writer::OutputObjectType Writer::add_object_to_object(
     const std::string_view& _name, const size_t /*_size*/,
-    OutputObjectType* _parent) const noexcept {
+    OutputObjectType* _parent) const {
   subdocs_->emplace_back(rfl::Box<BSONType>());
-  bson_append_document_begin(_parent->val_, _name.data(),
-                             static_cast<int>(_name.size()),
-                             &(subdocs_->back()->val_));
+  const bool ok = bson_append_document_begin(_parent->val_, _name.data(),
+                                             static_cast<int>(_name.size()),
+                                             &(subdocs_->back()->val_));
+  if (!ok) {
+    throw std::runtime_error("Could not add object to object.");
+  }
   return OutputObjectType(&subdocs_->back()->val_, IsObject{_parent->val_});
 }
 
 Writer::OutputVarType Writer::add_null_to_array(
-    OutputArrayType* _parent) const noexcept {
-  bson_array_builder_append_null(_parent->val_);
+    OutputArrayType* _parent) const {
+  const bool ok = bson_array_builder_append_null(_parent->val_);
+  if (!ok) {
+    throw std::runtime_error("Could not add null to array.");
+  }
   return OutputVarType{};
 }
 
 Writer::OutputVarType Writer::add_null_to_object(
-    const std::string_view& _name, OutputObjectType* _parent) const noexcept {
-  bson_append_null(_parent->val_, _name.data(), static_cast<int>(_name.size()));
+    const std::string_view& _name, OutputObjectType* _parent) const {
+  const bool ok = bson_append_null(_parent->val_, _name.data(),
+                                   static_cast<int>(_name.size()));
+  if (!ok) {
+    throw std::runtime_error("Could not add null to object.");
+  }
   return OutputVarType{};
 }
 
-void Writer::end_array(OutputArrayType* _arr) const noexcept {
+void Writer::end_array(OutputArrayType* _arr) const {
   const auto handle = [&](const auto _parent) {
     using Type = std::remove_cvref_t<decltype(_parent)>;
     if constexpr (std::is_same<Type, IsArray>()) {
-      bson_array_builder_append_array_builder_end(_parent.ptr_, _arr->val_);
+      const bool ok =
+          bson_array_builder_append_array_builder_end(_parent.ptr_, _arr->val_);
+      if (!ok) {
+        throw std::runtime_error("Could not end array.");
+      }
+
     } else if constexpr (std::is_same<Type, IsObject>()) {
-      bson_append_array_builder_end(_parent.ptr_, _arr->val_);
+      const bool ok = bson_append_array_builder_end(_parent.ptr_, _arr->val_);
+      if (!ok) {
+        throw std::runtime_error("Could not end array.");
+      }
+
     } else if constexpr (std::is_same<Type, IsRoot>()) {
-      bson_array_builder_build(_arr->val_, doc_);
+      const bool ok = bson_array_builder_build(_arr->val_, doc_);
+      if (!ok) {
+        throw std::runtime_error("Could not end array.");
+      }
+
     } else {
       static_assert(rfl::always_false_v<Type>, "Unsupported type.");
     }
   };
   std::visit(handle, _arr->parent_);
 }
 
-void Writer::end_object(OutputObjectType* _obj) const noexcept {
+void Writer::end_object(OutputObjectType* _obj) const {
   const auto handle = [&](const auto _parent) {
     using Type = std::remove_cvref_t<decltype(_parent)>;
     if constexpr (std::is_same<Type, IsArray>()) {
-      bson_array_builder_append_document_end(_parent.ptr_, _obj->val_);
+      const bool ok =
+          bson_array_builder_append_document_end(_parent.ptr_, _obj->val_);
+      if (!ok) {
+        throw std::runtime_error("Could not end object.");
+      }
+
     } else if constexpr (std::is_same<Type, IsObject>()) {
-      bson_append_document_end(_parent.ptr_, _obj->val_);
+      const bool ok = bson_append_document_end(_parent.ptr_, _obj->val_);
+      if (!ok) {
+        throw std::runtime_error("Could not end object.");
+      }
+
     } else if constexpr (std::is_same<Type, IsRoot>()) {
     } else {
       static_assert(rfl::always_false_v<Type>, "Unsupported type.");