to_json/from_json calls for typedefd types

[TheMiles]

Description

I encountered a problem, where I'm not sure whether I'm doing something wrong.

I want to create a type for a hash value. For this I use the std::array:

namespace tools {
  using Hash = std::array< uint8_t, 6 >;
}

(Note: size is actually longer, but for simplicity I chose 6)

Serialization and deserialization works fine. Hash gets converted to an array of 6 values in the json representation.

However, I would prefer to have a compact representation as a string, showing hex values. So I started custom implementations for de-/serialization (inside the namespace tools as mentioned in the docs):

namespace tools {
  void from_json( const nlohmann::json& json, Hash& hash );
  void to_json( nlohmann::json& json, const Hash& hash );
}

When I want to de-/serialize my custom implementations are only used if I add an explicit call to the functions including the namespace.
In all other cases it seems the internal implementation for arrays is called:

template < typename BasicJsonType, typename ConstructibleArrayType,
           enable_if_t <
               is_constructible_array_type<BasicJsonType, ConstructibleArrayType>::value&&
               !is_constructible_object_type<BasicJsonType, ConstructibleArrayType>::value&&
               !is_constructible_string_type<BasicJsonType, ConstructibleArrayType>::value&&
               !std::is_same<ConstructibleArrayType, typename BasicJsonType::binary_t>::value&&
               !is_basic_json<ConstructibleArrayType>::value,
               int > = 0 >
auto from_json(const BasicJsonType& j, ConstructibleArrayType& arr)
-> decltype(from_json_array_impl(j, arr, priority_tag<3> {}),
j.template get<typename ConstructibleArrayType::value_type>(),
void())

Example

I've created an example to visualize what I'm doing:

#include <iostream>
#include <array>
#include <format>
#include <charconv>
#include <nlohmann/json.hpp>

namespace tools
{
	using Hash = std::array< uint8_t, 6 >;

	void from_json( const nlohmann::json& json, Hash& hash )
	{
	    assert( json.is_string() );
	    auto hashString = json.get< std::string >();

	    assert( hashString.size() == 2*hash.size() );
	    const char* charPtr = hashString.c_str();

	    for( size_t i = 0; i < hash.size(); ++i )
	    {
	        const auto currentCharPtr = charPtr + 2*i;
	        std::from_chars( currentCharPtr, currentCharPtr+2, hash[i], 16 );
	    }
	}

	void to_json( nlohmann::json& json, const Hash& hash )
	{
	    std::string hashString;
	    hashString.reserve( 2 * hash.size() );

	    for( const auto& value: hash) 
	    {
	        std::format_to( std::back_inserter( hashString ), "{:02x}", value );
	    }

	    json = hashString;
	}

} // namespace tools

std::ostream& operator<<( std::ostream& out, const tools::Hash& hash )
{
	for( const auto h: hash ) { out << std::format("{:02x}", h); }
	return out;
}

nlohmann::json convert_to_assign( const tools::Hash& hash )
{
	nlohmann::json json;
	json = hash;
	return json;
}

nlohmann::json convert_to_call_wons( const tools::Hash& hash )
{
	nlohmann::json json;
	to_json(json,hash);
	return json;
}

nlohmann::json convert_to_call_wns( const tools::Hash& hash )
{
	nlohmann::json json;
	tools::to_json(json,hash);
	return json;
}

tools::Hash convert_from_assign( const nlohmann::json& json )
{
	tools::Hash hash;
	try{ hash = json; }
	catch( nlohmann::json::exception e ) { std::cout << "Exception during `hash = json;`: " << e.what() << std::endl; }
	return hash;
}

tools::Hash convert_from_call_wons( const nlohmann::json& json )
{
	tools::Hash hash;
	try{ from_json( json, hash ); }
	catch( nlohmann::json::exception e ) { std::cout << "Exception during `from_json( json, hash );`: " << e.what() << std::endl; }
	return hash;
}

tools::Hash convert_from_call_wns( const nlohmann::json& json )
{
	tools::Hash hash;
	try{ tools::from_json( json, hash ); }
	catch( nlohmann::json::exception e ) { std::cout << "Exception during `tools::from_json( json, hash );`: " << e.what() << std::endl; }
	return hash;
}


int main(void)
{
	tools::Hash hash{ 0xab, 0x23, 0x74, 0x00, 0x12, 0x25 };
	nlohmann::json json = "ab2374001225";

	std::cout << "******** Convert from Hash to json **********" << std::endl;
	auto jsonAssigned = convert_to_assign( hash );
	auto jsonCallWons = convert_to_call_wons( hash );
	auto jsonCallWns  = convert_to_call_wns( hash );

	std::cout << "Convert assignment            " << jsonAssigned.dump() << std::endl;
	std::cout << "Convert call to_json          " << jsonCallWons.dump() << std::endl;
	std::cout << "Convert call tools::to_json   " << jsonCallWns.dump() << std::endl;

	std::cout << std::endl;
	std::cout << "******** Convert from json to Hash **********" << std::endl;
	auto hashAssigned = convert_from_assign( json );
	auto hashCallWons = convert_from_call_wons( json );
	auto hashCallWns  = convert_from_call_wns( json );

	std::cout << "Convert from assignment       " << hashAssigned << std::endl;
	std::cout << "Convert call from_json        " << hashCallWons << std::endl;
	std::cout << "Convert call tools::from_json " << hashCallWns << std::endl;

	return 0;
}

When I run this example I get this output:

******** Convert from Hash to json **********
Convert assignment            [171,35,116,0,18,37]
Convert call to_json          [171,35,116,0,18,37]
Convert call tools::to_json   "ab2374001225"

******** Convert from json to Hash **********
Exception during `hash = json;`: [json.exception.type_error.302] type must be array, but is string
Exception during `from_json( json, hash );`: [json.exception.type_error.302] type must be array, but is string
Convert from assignment       000000000000
Convert call from_json        000000000000
Convert call tools::from_json ab2374001225

So either assignment as well as direct call to to_/from_json use the internal "std::array" version.
Yielding the json array representation or throwing an exception when a string is fed to the function.

Only by calling explicitly tools::to_json and tools::from_json will yield the intended result.

Question

Is there anything I'm missing out, or do I need to call the conversion explicitly in my case?

[kimci86]

Your problem is that tools::Hash is std::array<uint8_t, 6>. It is an alias. So the functions you wrote in tools namespace do not matter. This type actually is in namespace std.
So to achieve what you want, you could either fully specialize adl_serializer for that type (see documentation), or use a distinct type that actually is in tools namespace. A simple and lazy trick would be inheritance: struct Hash : std::array<uint8_t, 6> {};.