Experimental support for BSON (de)serialization

include/nlohmann/detail/exceptions.hpp

@@ -220,6 +220,7 @@ json.exception.type_error.313 | invalid value to unflatten | The @ref unflatten
 json.exception.type_error.314 | only objects can be unflattened | The @ref unflatten function only works for an object whose keys are JSON Pointers.
 json.exception.type_error.315 | values in object must be primitive | The @ref unflatten function only works for an object whose keys are JSON Pointers and whose values are primitive.
 json.exception.type_error.316 | invalid UTF-8 byte at index 10: 0x7E | The @ref dump function only works with UTF-8 encoded strings; that is, if you assign a `std::string` to a JSON value, make sure it is UTF-8 encoded. |
+json.exception.type_error.317 | JSON value cannot be serialized to requested format | The dynamic type of the object cannot be represented in the requested serialization format (e.g. a raw `true` or `null` JSON object cannot be serialized to BSON) |
 
 @liveexample{The following code shows how a `type_error` exception can be
 caught.,type_error}

include/nlohmann/detail/input/binary_reader.hpp

@@ -80,6 +80,10 @@ class binary_reader
                 result = parse_ubjson_internal();
                 break;
 
+            case input_format_t::bson:
+                result = parse_bson_internal();
+                break;
+
             // LCOV_EXCL_START
             default:
                 assert(false);
@@ -120,6 +124,139 @@ class binary_reader
     }
 
   private:
+
+    /*!
+    @return whether array creation completed
+    */
+    bool get_bson_cstr(string_t& result)
+    {
+        auto out = std::back_inserter(result);
+        while (true)
+        {
+            get();
+            if (JSON_UNLIKELY(not unexpect_eof()))
+            {
+                return false;
+            }
+            if (current == 0x00)
+            {
+                return true;
+            }
+            *out++ = static_cast<char>(current);
+        }
+
+        return true;
+    }
+
+    bool parse_bson_entries(bool is_array)
+    {
+        while (auto entry_type = get())
+        {
+            string_t key;
+            if (!get_bson_cstr(key))
+            {
+                return false;
+            }
+
+            if (!is_array)
+            {
+                sax->key(key);
+            }
+
+            switch (entry_type)
+            {
+                case 0x01: // double
+                {
+                    double number;
+                    get_number<double, true>(number);
+                    sax->number_float(static_cast<number_float_t>(number), "");
+                }
+                break;
+                case 0x02: // string
+                {
+                    std::int32_t len;
+                    string_t value;
+                    get_number<std::int32_t, true>(len);
+                    get_string(len - 1ul, value);
+                    get();
+                    sax->string(value);
+                }
+                break;
+                case 0x08: // boolean
+                {
+                    sax->boolean(static_cast<bool>(get()));
+                }
+                break;
+                case 0x10: // int32
+                {
+                    std::int32_t value;
+                    get_number<std::int32_t, true>(value);
+                    sax->number_integer(static_cast<std::int32_t>(value));
+                }
+                break;
+                case 0x12: // int64
+                {
+                    std::int64_t value;
+                    get_number<std::int64_t, true>(value);
+                    sax->number_integer(static_cast<std::int64_t>(value));
+                }
+                break;
+                case 0x0A: // null
+                {
+                    sax->null();
+                }
+                break;
+                case 0x03: // object
+                {
+                    parse_bson_internal();
+                }
+                break;
+                case 0x04: // array
+                {
+                    parse_bson_array();
+                }
+                break;
+            }
+        }
+        return true;
+    }
+
+    bool parse_bson_array()
+    {
+        std::int32_t documentSize;
+        get_number<std::int32_t, true>(documentSize);
+
+        if (JSON_UNLIKELY(not sax->start_array(-1)))
+        {
+            return false;
+        }
+
+        if (!parse_bson_entries(/*is_array*/true))
+        {
+            return false;
+        }
+
+        return sax->end_array();
+    }
+
+    bool parse_bson_internal()
+    {
+        std::int32_t documentSize;
+        get_number<std::int32_t, true>(documentSize);
+
+        if (JSON_UNLIKELY(not sax->start_object(-1)))
+        {
+            return false;
+        }
+
+        if (!parse_bson_entries(/*is_array*/false))
+        {
+            return false;
+        }
+
+        return sax->end_object();
+    }
+
     /*!
     @param[in] get_char  whether a new character should be retrieved from the
                          input (true, default) or whether the last read
@@ -870,7 +1007,7 @@ class binary_reader
           bytes in CBOR, MessagePack, and UBJSON are stored in network order
           (big endian) and therefore need reordering on little endian systems.
     */
-    template<typename NumberType>
+    template<typename NumberType, bool InputIsLittleEndian = false>
     bool get_number(NumberType& result)
     {
         // step 1: read input into array with system's byte order
@@ -884,7 +1021,7 @@ class binary_reader
             }
 
             // reverse byte order prior to conversion if necessary
-            if (is_little_endian)
+            if (is_little_endian && !InputIsLittleEndian)
             {
                 vec[sizeof(NumberType) - i - 1] = static_cast<uint8_t>(current);
             }
@@ -899,6 +1036,7 @@ class binary_reader
         return true;
     }
 
+
     /*!
     @brief create a string by reading characters from the input
 

include/nlohmann/detail/input/input_adapters.hpp

@@ -18,7 +18,7 @@ namespace nlohmann
 namespace detail
 {
 /// the supported input formats
-enum class input_format_t { json, cbor, msgpack, ubjson };
+enum class input_format_t { json, cbor, msgpack, ubjson, bson };
 
 ////////////////////
 // input adapters //