Add tests for binary values

include/nlohmann/detail/input/binary_reader.hpp

@@ -1500,11 +1500,6 @@ class binary_reader
  */
  bool get_msgpack_binary(internal_binary_t& result)
  {
- if (JSON_HEDLEY_UNLIKELY(not unexpect_eof(input_format_t::msgpack, "binary")))
- {
- return false;
- }
-
  switch (current)
  {
  case 0xC4: // bin 8
@@ -1582,11 +1577,8 @@ class binary_reader
  return get_number(input_format_t::msgpack, result.subtype) and get_binary(input_format_t::msgpack, 16, result);
  }
 
- default:
- {
- auto last_token = get_token_string();
- return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format_t::msgpack, "expected binary type specification (0xC4-0xC9, 0xD4-0xD8); last byte: 0x" + last_token, "binary")));
- }
+ default: // LCOV_EXCL_LINE
+ assert(false); // LCOV_EXCL_LINE
  }
  }
 
@@ -2211,7 +2203,7 @@ class binary_reader
  {
  success = false;
  }
- return static_cast<uint8_t>(current);
+ return static_cast<std::uint8_t>(current);
  });
  return success;
  }

include/nlohmann/detail/input/json_sax.hpp

@@ -214,7 +214,7 @@ class json_sax_dom_parser
 
  bool binary(binary_t& val)
  {
- handle_binary(val);
+ handle_value(BasicJsonType::binary_array(std::move(val)));
  return true;
  }
 
@@ -327,36 +327,6 @@ class json_sax_dom_parser
  return object_element;
  }
 
- /*!
- @invariant If the ref stack is empty, then the passed value will be the new
- root.
- @invariant If the ref stack contains a value, then it is an array or an
- object to which we can add elements
- */
- template<typename BinaryValue>
- JSON_HEDLEY_RETURNS_NON_NULL
- BasicJsonType* handle_binary(BinaryValue&& v)
- {
- if (ref_stack.empty())
- {
- root = BasicJsonType::binary_array(std::forward<BinaryValue>(v));
- return &root;
- }
-
- assert(ref_stack.back()->is_array() or ref_stack.back()->is_object());
-
- if (ref_stack.back()->is_array())
- {
- ref_stack.back()->m_value.array->emplace_back(BasicJsonType::binary_array(std::forward<BinaryValue>(v)));
- return &(ref_stack.back()->m_value.array->back());
- }
-
- assert(ref_stack.back()->is_object());
- assert(object_element);
- *object_element = BasicJsonType::binary_array(std::forward<BinaryValue>(v));
- return object_element;
- }
-
  /// the parsed JSON value
  BasicJsonType& root;
  /// stack to model hierarchy of values
@@ -434,7 +404,7 @@ class json_sax_dom_callback_parser
 
  bool binary(binary_t& val)
  {
- handle_value(val);
+ handle_value(BasicJsonType::binary_array(val));
  return true;
  }
 

include/nlohmann/detail/output/serializer.hpp

@@ -251,27 +251,6 @@ class serializer
  {
  o->write_characters("b[]", 3);
  }
- else if (pretty_print)
- {
- o->write_characters("b[", 2);
- for (auto i = val.m_value.binary->cbegin();
- i != val.m_value.binary->cend() - 1; ++i)
- {
- dump_integer(*i);
- o->write_character(',');
- if (std::distance(val.m_value.binary->cbegin(), i) % 16 == 0)
- {
- o->write_character('\n');
- }
- else
- {
- o->write_character(' ');
- }
- }
-
- dump_integer(val.m_value.binary->back());
- o->write_character(']');
- }
  else
  {
  o->write_characters("b[", 2);

include/nlohmann/json.hpp

@@ -876,7 +876,6 @@ class basic_json
 
  @since version 3.8.0
  */
-
  using binary_t = BinaryType;
 
  /*!
@@ -890,9 +889,25 @@ class basic_json
  struct internal_binary_t : public BinaryType
  {
  using BinaryType::BinaryType;
- internal_binary_t() noexcept(noexcept(BinaryType())) : BinaryType() {}
- internal_binary_t(BinaryType const& bint) noexcept(noexcept(BinaryType(bint))) : BinaryType(bint) {}
- internal_binary_t(BinaryType&& bint) noexcept(noexcept(BinaryType(std::move(bint)))) : BinaryType(std::move(bint)) {}
+ internal_binary_t() noexcept(noexcept(BinaryType()))
+ : BinaryType()
+ {}
+ internal_binary_t(const BinaryType& bint) noexcept(noexcept(BinaryType(bint)))
+ : BinaryType(bint)
+ {}
+ internal_binary_t(BinaryType&& bint) noexcept(noexcept(BinaryType(std::move(bint))))
+ : BinaryType(std::move(bint))
+ {}
+ internal_binary_t(const BinaryType& bint, std::uint8_t st) noexcept(noexcept(BinaryType(bint)))
+ : BinaryType(bint)
+ , subtype(st)
+ , has_subtype(true)
+ {}
+ internal_binary_t(BinaryType&& bint, std::uint8_t st) noexcept(noexcept(BinaryType(std::move(bint))))
+ : BinaryType(std::move(bint))
+ , subtype(st)
+ , has_subtype(true)
+ {}
 
  // TOOD: If minimum C++ version is ever bumped to C++17, this field
  // deserves to be a std::optional
@@ -1099,6 +1114,18 @@ class basic_json
  binary = create<internal_binary_t>(std::move(value));
  }
 
+ /// constructor for binary arrays (internal type)
+ json_value(const internal_binary_t& value)
+ {
+ binary = create<internal_binary_t>(value);
+ }
+
+ /// constructor for rvalue binary arrays (internal type)
+ json_value(internal_binary_t&& value)
+ {
+ binary = create<internal_binary_t>(std::move(value));
+ }
+
  void destroy(value_t t) noexcept
  {
  // flatten the current json_value to a heap-allocated stack
@@ -1204,6 +1231,7 @@ class basic_json
  assert(m_type != value_t::object or m_value.object != nullptr);
  assert(m_type != value_t::array or m_value.array != nullptr);
  assert(m_type != value_t::string or m_value.string != nullptr);
+ assert(m_type != value_t::binary or m_value.binary != nullptr);
  }
 
  public:
@@ -1655,14 +1683,23 @@ class basic_json
  @since version 3.8.0
  */
  JSON_HEDLEY_WARN_UNUSED_RESULT
- static basic_json binary_array(binary_t const& init)
+ static basic_json binary_array(const binary_t& init)
  {
  auto res = basic_json();
  res.m_type = value_t::binary;
  res.m_value = init;
  return res;
  }
 
+ JSON_HEDLEY_WARN_UNUSED_RESULT
+ static basic_json binary_array(const binary_t& init, std::uint8_t subtype)
+ {
+ auto res = basic_json();
+ res.m_type = value_t::binary;
+ res.m_value = internal_binary_t(init, subtype);
+ return res;
+ }
+
  /*!
  @brief explicitly create a binary array from an already constructed rvalue
  copy of its base type
@@ -1699,6 +1736,15 @@ class basic_json
  return res;
  }
 
+ JSON_HEDLEY_WARN_UNUSED_RESULT
+ static basic_json binary_array(binary_t&& init, std::uint8_t subtype)
+ {
+ auto res = basic_json();
+ res.m_type = value_t::binary;
+ res.m_value = internal_binary_t(std::move(init), subtype);
+ return res;
+ }
+
  /*!
  @brief explicitly create an array from an initializer list
 
@@ -1956,8 +2002,7 @@ class basic_json
 
  case value_t::binary:
  {
- m_value.binary = create<internal_binary_t>(first.m_it.binary_iterator,
- last.m_it.binary_iterator);
+ m_value = *first.m_object->m_value.binary;
  break;
  }
 
@@ -2748,7 +2793,7 @@ class basic_json
  /// get a pointer to the value (binary)
  binary_t* get_impl_ptr(binary_t* /*unused*/) noexcept
  {
- return is_binary() ? m_value.binary : nullptr;
+ return is_binary() ? reinterpret_cast<binary_t*>(m_value.binary) : nullptr;
  }
 
  /// get a pointer to the value (binary)
@@ -6015,6 +6060,39 @@ class basic_json
  }
  }
 
+ /*!
+ @brief exchanges the values
+
+ Exchanges the contents of a JSON string with those of @a other. Does not
+ invoke any move, copy, or swap operations on individual elements. All
+ iterators and references remain valid. The past-the-end iterator is
+ invalidated.
+
+ @param[in,out] other binary to exchange the contents with
+
+ @throw type_error.310 when JSON value is not a string; example: `"cannot
+ use swap() with boolean"`
+
+ @complexity Constant.
+
+ @liveexample{The example below shows how strings can be swapped with
+ `swap()`.,swap__binary_t}
+
+ @since version 3.8.0
+ */
+ void swap(binary_t& other)
+ {
+ // swap only works for strings
+ if (JSON_HEDLEY_LIKELY(is_binary()))
+ {
+ std::swap(*(m_value.binary), other);
+ }
+ else
+ {
+ JSON_THROW(type_error::create(310, "cannot use swap() with " + std::string(type_name())));
+ }
+ }
+
  /// @}
 
  public:
@@ -6277,7 +6355,7 @@ class basic_json
  return (lhs.m_value.number_float) < (rhs.m_value.number_float);
 
  case value_t::binary:
- return (lhs.m_value.binary) < (rhs.m_value.binary);
+ return (*lhs.m_value.binary) < (*rhs.m_value.binary);
 
  default:
  return false;