Conversion from STL containers

[Life4gal]

https://github.com/nlohmann/json#conversion-from-stl-containers
In the link above we can see a lot of great container conversion examples, but people can never think of all the needs. . .

struct a_struct_with_vector
{
    std::string id;
    std::vector<int> data;
}

void to_json(json& j, const a_struct_with_vector& data)
{
    j[data.id] = data;
}

a_struct_with_vector data;
data.id = "hello";
data.data.push_back(1);
data.data.pus_back(2);

// then, we put the data to json and dump it
json j{data};
j.dump();
// and we got the result [{"hello": [1, 2]}]

// now there, how can I make data.data's result surrounded by braces(associative container are) instead of square brackets?
// like [{"hello": {1, 2}}]  :)

// by the way, why it surrounded by `[{ }]` instead of `{ }`

[Life4gal]

In fact, the data stored by vector is not as simple as int, but... it also has a filed named id
and use std::map<std::string, this_type_other_part> will work
but use std::vector<this_type> should be more intuitive :(

[nlohmann]

Can you replace

json j{data};

with

json j = data;

[Life4gal]

Can you replace

json j{data};

with

json j = data;

oh, I used to think that json j{data} and json j = data called the same constructor, but now I know it doesn’t.

json j{data} seems will call

basic_json(initializer_list_t init,
		bool              type_deduction = true,
		value_t           manual_type    = value_t::array)
{
			// check if each element is an array with two elements whose first
			// element is a string
			bool is_an_object = std::all_of(init.begin(),
									init.end(),
									[](const detail::json_ref<basic_json>& element_ref)
									{
										return element_ref->is_array() && element_ref->size() == 2 && (*
											element_ref)[0].is_string();
									});

			// adjust type if type deduction is not wanted
			if (!type_deduction)
			{
				// if array is wanted, do not create an object though possible
				if (manual_type == value_t::array)
				{
					is_an_object = false;
				}

				// if object is wanted but impossible, throw an exception
				if (JSON_HEDLEY_UNLIKELY(manual_type == value_t::object && !is_an_object))
				{
					JSON_THROW(type_error::create(301, "cannot create object from initializer list", basic_json()));
				}
			}

			if (is_an_object)
			{
				// the initializer list is a list of pairs -> create object
				m_type  = value_t::object;
				m_value = value_t::object;

				for (auto& element_ref : init)
				{
					auto element = element_ref.moved_or_copied();
					m_value.object->emplace(
											std::move(*((*element.m_value.array)[0].m_value.string)),
											std::move((*element.m_value.array)[1]));
				}
			}
			else
			{
				// the initializer list describes an array -> create array
				m_type        = value_t::array;
				m_value.array = create<array_t>(init.begin(), init.end());
			}

			set_parents();
			assert_invariant();
}

json j = data seems will call

template <typename CompatibleType,
				typename U = detail::uncvref_t<CompatibleType>,
				detail::enable_if_t<
					!detail::is_basic_json<U>::value && detail::is_compatible_type<basic_json_t, U>::value, int> = 0>
		basic_json(
			CompatibleType&& val) noexcept(noexcept(
			// NOLINT(bugprone-forwarding-reference-overload,bugprone-exception-escape)
			JSONSerializer<U>::to_json(std::declval<basic_json_t&>(),
										std::forward<CompatibleType>(val))))
{
			JSONSerializer<U>::to_json(*this, std::forward<CompatibleType>(val));
			set_parents();
			assert_invariant();
}

:)

[nlohmann]

Yes, this is a known issue...