sub_binary builder and integration with core

Author: Micah Scott

src/bsoncxx/include/bsoncxx/v_noabi/bsoncxx/builder/basic/impl.hpp

@@ -15,6 +15,7 @@
 #pragma once
 
 #include <bsoncxx/builder/basic/sub_array.hpp>
+#include <bsoncxx/builder/basic/sub_binary.hpp>
 #include <bsoncxx/builder/basic/sub_document.hpp>
 #include <bsoncxx/stdx/type_traits.hpp>
 
@@ -40,10 +41,19 @@ detail::requires_t<void, detail::is_invocable<T, sub_array>> generic_append(core
     core->close_array();
 }
 
+template <typename T>
+detail::requires_t<void, detail::is_invocable<T, sub_binary>> generic_append(core* core, T&& func) {
+    detail::invoke(std::forward<T>(func), sub_binary(core));
+    core->close_binary();
+}
+
 template <typename T, typename = void, typename = void>
-detail::requires_not_t<void, detail::is_invocable<T, sub_document>, detail::is_invocable<T, sub_array>> generic_append(
-    core* core,
-    T&& t) {
+detail::requires_not_t<
+    void,
+    detail::is_invocable<T, sub_document>,
+    detail::is_invocable<T, sub_array>,
+    detail::is_invocable<T, sub_binary>>
+generic_append(core* core, T&& t) {
     core->append(std::forward<T>(t));
 }
 

src/bsoncxx/include/bsoncxx/v_noabi/bsoncxx/builder/basic/sub_binary-fwd.hpp

@@ -0,0 +1,42 @@
+// Copyright 2009-present MongoDB, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+namespace bsoncxx {
+namespace v_noabi {
+namespace builder {
+namespace basic {
+
+class sub_binary;
+
+} // namespace basic
+} // namespace builder
+} // namespace v_noabi
+} // namespace bsoncxx
+
+namespace bsoncxx {
+namespace builder {
+namespace basic {
+
+using ::bsoncxx::v_noabi::builder::basic::sub_binary;
+
+} // namespace basic
+} // namespace builder
+} // namespace bsoncxx
+
+///
+/// @file
+/// Declares @ref bsoncxx::builder::basic::sub_binary, for constructing BSON Binary values in-place.
+///

src/bsoncxx/include/bsoncxx/v_noabi/bsoncxx/builder/basic/sub_binary.hpp

@@ -0,0 +1,86 @@
+// Copyright 2009-present MongoDB, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include <bsoncxx/builder/basic/sub_binary-fwd.hpp>
+
+#include <bsoncxx/builder/core.hpp>
+#include <bsoncxx/types.hpp>
+#include <bsoncxx/vector/formats.hpp>
+#include <bsoncxx/vector/impl.hpp>
+#include <bsoncxx/vector/view.hpp>
+
+#include <bsoncxx/config/prelude.hpp>
+
+namespace bsoncxx {
+namespace v_noabi {
+namespace builder {
+namespace basic {
+
+///
+/// Represents a BSON Binary element being constructed during an append operation.
+///
+class sub_binary {
+   public:
+    ///
+    /// Default constructor
+    ///
+    sub_binary(core* core) : _core(core) {}
+
+    /// @brief Allocate space for an un-initialized BSON Binary element of any subtype.
+    /// @param sub_type BSON binary subtype code, identifying the format of the data within.
+    /// @param length Number of bytes to allocate
+    /// @return Pointer to uninitialized memory within the bson_t, valid only during this sub_binary builder's lifetime.
+    ///      The caller must overwrite every byte if the resulting BSON document is to be used.
+    /// @throws bsoncxx::v_noabi::exception if this sub_binary has already allocated.
+    ///         bsoncxx::v_noabi::exception if the binary fails to append due to the BSON size limit.
+    uint8_t* allocate(binary_sub_type sub_type, uint32_t length) {
+        return _core->append(sub_type, length);
+    }
+
+    /// @brief Allocate and format space for a BSON Binary Vector with uninitialized elements.
+    /// @param fmt Instance of a format type from @ref bsoncxx::v_noabi::vector::formats
+    /// @param element_count Number of elements to allocate space for.
+    /// @return A vector::view, valid during the lifetime of this sub_binary builder. Every element must be overwritten
+    /// before that element is read or the resulting document is used.
+    /// @throws bsoncxx::v_noabi::exception if this sub_binary has already allocated.
+    ///         bsoncxx::v_noabi::exception if the binary fails to append due to the BSON size limit.
+    ///         bsoncxx::v_noabi::exception if a vector of the requested size would be too large to represent.
+    template <typename Format, typename SFINAE = typename vector::impl::format_traits<Format>::value_type>
+    vector::view<Format> allocate(Format, std::size_t element_count) {
+        using format_traits = typename vector::impl::format_traits<Format>;
+        uint32_t binary_data_length = format_traits::length_for_append(element_count);
+        uint8_t* binary_data = allocate(binary_sub_type::k_vector, binary_data_length);
+        return {
+            {binary_data,
+             binary_data_length,
+             format_traits::write_frame(binary_data, binary_data_length, element_count)}};
+    }
+
+   private:
+    core* _core;
+};
+
+} // namespace basic
+} // namespace builder
+} // namespace v_noabi
+} // namespace bsoncxx
+
+#include <bsoncxx/config/postlude.hpp>
+
+///
+/// @file
+/// Declares @ref bsoncxx::v_noabi::builder::basic::sub_binary, for constructing BSON Binary values in-place.
+///

src/bsoncxx/include/bsoncxx/v_noabi/bsoncxx/builder/core.hpp

@@ -237,6 +237,20 @@ class core {
     ///
     BSONCXX_ABI_EXPORT_CDECL(core&) append(types::b_binary const& value);
 
+    ///
+    /// Appends a BSON binary datum by allocating space that the caller must fill with content.
+    ///
+    /// @return
+    ///   A pointer to the allocated binary data block. The caller must write to every
+    ///   byte or discard the builder.
+    ///
+    /// @throws
+    ///   bsoncxx::v_noabi::exception if the current BSON datum is a document that is waiting for a
+    ///   key to be appended to start a new key/value pair.
+    ///   bsoncxx::v_noabi::exception if the binary fails to append.
+    ///
+    BSONCXX_ABI_EXPORT_CDECL(uint8_t*) append(binary_sub_type sub_type, uint32_t length);
+
     ///
     /// Appends a BSON undefined.
     ///
@@ -693,6 +707,17 @@ class core {
     ///
     BSONCXX_ABI_EXPORT_CDECL(void) clear();
 
+    ///
+    /// Closes the current sub-binary within this BSON datum.
+    ///
+    /// @return
+    ///   A reference to the object on which this member function is being called.  This facilitates
+    ///   method chaining.
+    ///
+    /// @throws bsoncxx::v_noabi::exception if the binary contents were never allocated.
+    ///
+    BSONCXX_ABI_EXPORT_CDECL(core&) close_binary();
+
    private:
     std::unique_ptr<impl> _impl;
 };

src/bsoncxx/lib/bsoncxx/v_noabi/bsoncxx/builder/core.cpp

@@ -351,6 +351,23 @@ core& core::append(types::b_binary const& value) {
     return *this;
 }
 
+uint8_t* core::append(binary_sub_type sub_type, uint32_t length) {
+    stdx::string_view key = _impl->next_key();
+    uint8_t* allocated_bytes;
+
+    if (!bson_append_binary_uninit(
+            _impl->back(),
+            key.data(),
+            static_cast<std::int32_t>(key.length()),
+            static_cast<bson_subtype_t>(sub_type),
+            &allocated_bytes,
+            length)) {
+        throw bsoncxx::v_noabi::exception{error_code::k_cannot_append_binary};
+    }
+
+    return allocated_bytes;
+}
+
 core& core::append(types::b_undefined const&) {
     stdx::string_view key = _impl->next_key();
 
@@ -685,6 +702,13 @@ core& core::close_array() {
     return *this;
 }
 
+core& core::close_binary() {
+    if (!_impl->is_viewable()) {
+        throw bsoncxx::v_noabi::exception{error_code::k_unmatched_key_in_builder};
+    }
+    return *this;
+}
+
 bsoncxx::v_noabi::document::view core::view_document() const {
     if (!_impl->is_viewable()) {
         throw bsoncxx::v_noabi::exception{error_code::k_unmatched_key_in_builder};