std::variant<int, float, bool, std::string>

[iwasz]

Dear all

How to tackle a variant type as in the title? I tried various contracts such as this one:

using Variant = std::variant<int, float, bool, std::string>;

namespace daw::json {
template <> struct json_data_contract<Variant> {
     using type = json_type_alias<
             json_variant_no_name<Variant, json_variant_type_list<int, json_number_no_name<float>, bool, json_string_no_name<>>>>;
     static constexpr auto to_json_data (Variant const &value) { return value; }
};
} // namespace daw::json

and to my despair it parses either ints or floats, but not both (the last line throws from the JSON lib):

CHECK (std::get<int> (from_json<Variant> (R"(67)")) == 67);
CHECK (std::get<std::string> (from_json<Variant> (R"("test")")) == "test");
CHECK (std::get<bool> (from_json<Variant> ("true")) == true);
CHECK (std::get<bool> (from_json<Variant> ("false")) == false);
CHECK (std::get<float> from_json<Variant> ("67.8")); Expression threw an exception `Did not find \",}]" at end of value`
}

Thanks

PS. I know I can remove int from the list and it parses OK, but then all numbers will be stored as a float field of my Variant. I'm on a microcontroller and want to avoid floats when not necessary.

[beached]

If this is representative and there is no tag member to dispatch with, then I would look into json_raw and a custom constructor where you can inspect the data.

struct FooConstructor {
std::variant<...> operaetor( )( char const * s, size_t sz ) const {
auto jv = daw:::json::json_value( string_view( s, sz ) );
...
}
};

Then a mapping type like `json_raw<json_value, FooConstructor>`.  

But this is similar to the variant_on_members.cpp example where what members exist are used to determine the type.  But most JSON that has typing like that also has a member to tell the reader of the document what type to interpret it as.  

As for the error, I can double check that later.  Seems like it shouldn't give that error.

[beached]

I will add a better error in that case, on further thought, what is going on is you have tried to map 2 number types and it is taking the first one. So it parsed the integer part of 67.8 and then when it was trying to move to the next value it ran into a . and not one of the expected things after a value is parsed. I am going to add a check earlier in the json_variant code that looks for duplicate categories as only one of each is allowed in that mapping type. Thanks for pointing that out. The error makes sense in why, but it's not a good one and should have happened earlier before parsing even happened.

[iwasz]

Thanks. The problem with this JSON is that it is kinda legacy and we can't change it. We should've made it more tidy from the start. Now we can get every type everywhere, and we have tons of "dictionary" like types here keys can be different. I'll try this "raw" approach.

[beached]

The variant_on_members example may help

daw_json_link/tests/src/variant_on_members.cpp

Line 88 in ec31c80

json_raw_no_name<std::variant<A, B>, FooConstructor>>>;

. It shows how to inspect the members in order to determine what type of parser to use.

[iwasz]

Thanks to your suggestion I'm able to parse my variant, but I can't serialize it now :( Let me paste my whole "unit test" :

#include <catch2/catch_test_macros.hpp>
#include <daw/json/daw_json_link.h>
#include <string>

namespace my {
using Var2 = std::variant<int, float, std::string>;

struct Var2Constructor {
        Var2 operator() () const { return Var2{}; }

        Var2 operator() (char const *ptr, std::size_t sz) const
        {
                using namespace daw::json;
                auto jv = daw::json::json_value (ptr, sz);

                try {
                        auto foo = as<int> (jv);
                        return {foo};
                }
                catch (...) {
                }

                try {
                        auto foo = as<float> (jv);
                        return {foo};
                }
                catch (...) {
                }

                try {
                        auto foo = as<bool> (jv);
                        return {foo};
                }
                catch (...) {
                }

                return std::string{ptr, sz};
        }
};

} // namespace my

namespace daw::json {
template <> struct json_data_contract<my::Var2> {
        using type = json_type_alias<json_raw_no_name<my::Var2, my::Var2Constructor>>;
        static constexpr auto to_json_data (my::Var2 const &value) { return value; }
};

} // namespace daw::json

TEST_CASE ("variant 2 numbers", "[json]")
{
        using namespace daw::json;

        {
                auto kx = from_json<my::Var2> (R"(67)");
                CHECK (std::get<int> (kx) == 67);
        }
        {
                auto kx = from_json<my::Var2> (R"(67.8)");
                CHECK (std::get<float> (kx) == 67.8F);
        }
        {
                auto kx = from_json<my::Var2> (R"("test")");
                CHECK (std::get<std::string> (kx) == "test");
        }

        my::Var2 v = 1;
        CHECK (to_json<my::Var2> (v) == "1");
}

It complaints about not finding correct overload of utils::copy_to_iterator:

...
to_daw_json_string.h:942:63: error: no matching function for call to ‘copy_to_iterator(daw::json::v3_23_0d::serialization_policy<std::__cxx11::basic_string<char>, 20>&, const std::variant<int, float, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >&)’
[build]   942 |                                 return utils::copy_to_iterator( it, value );
...

and

...
to_daw_json_string.h:301:47: error: no type named ‘type’ in ‘struct std::enable_if<false, std::nullptr_t>’
[build]   301 |                             std::nullptr_t> = nullptr>
...

This second one is probably because my type (the variant itself) is not traits::is_container_like_v. I tried quickly to provide my own copy_to_iterator version, but this is probably not the way to go :( Maybe my to_json_data is off? But it kind worked before when I used json_variant_no_name instead of json_raw_no_name (like in the original question).

[beached]

You will want something like

#include <catch2/catch_test_macros.hpp>
#include <daw/json/daw_json_link.h>
#include <string>

namespace my {
using Var2 = std::variant<int, float, std::string>;

struct Var2Constructor {
        Var2 operator() () const { return Var2{}; }

        Var2 operator() (char const *ptr, std::size_t sz) const
        {
                using namespace daw::json;
                auto jv = daw::json::json_value (ptr, sz);

                try {
                        auto foo = as<int> (jv);
                        return {foo};
                }
                catch (...) {
                }

                try {
                        auto foo = as<float> (jv);
                        return {foo};
                }
                catch (...) {
                }

                try {
                        auto foo = as<bool> (jv);
                        return {foo};
                }
                catch (...) {
                }

                return std::string{ptr, sz};
        }
};

} // namespace my

namespace daw::json {
template <> struct json_data_contract<my::Var2> {
        using type = json_type_alias<json_raw_no_name<my::Var2, my::Var2Constructor>>;
        static auto to_json_data (my::Var2 const &value) { 
           return std::visit( []( auto const & alt ) { return to_json( alt ); }, value ); 
        }
};

} // namespace daw::json

TEST_CASE ("variant 2 numbers", "[json]")
{
        using namespace daw::json;

        {
                auto kx = from_json<my::Var2> (R"(67)");
                CHECK (std::get<int> (kx) == 67);
        }
        {
                auto kx = from_json<my::Var2> (R"(67.8)");
                CHECK (std::get<float> (kx) == 67.8F);
        }
        {
                auto kx = from_json<my::Var2> (R"("test")");
                CHECK (std::get<std::string> (kx) == "test");
        }

        my::Var2 v = 1;
        CHECK (to_json<my::Var2> (v) == "1");
}

[beached]

Another thing, you may want to consider doing something like

	auto jv = daw::json::json_value( ptr, sz );
			switch( jv.type( ) ) {
			case daw::json::JsonBaseParseTypes::Number:
				if( auto sv = jv.get_string_view( );
				    std::find_if_not( sv.begin( ), sv.end( ), []( char c ) {
					    return '0' <= c and c <= '9';
				    } ) == sv.end( ) ) {
					// Only digits
					return as<int>( jv );
				}
				return as<float>( jv );
			case daw::json::JsonBaseParseTypes::Bool:
				return as<bool>( jv );
			case daw::json::JsonBaseParseTypes::String:
				return std::string{ ptr, sz };
			case daw::json::JsonBaseParseTypes::Array:
			case daw::json::JsonBaseParseTypes::Class:
			case daw::json::JsonBaseParseTypes::None:
			case daw::json::JsonBaseParseTypes::Null:
			default:
				std::abort( );
			}

inside the Var2Constructor. Why throw when you can avoid it.

[iwasz]

Thanks, sure. I tried to do that without exceptions but gave up :D Last one thing : was finally able to both parse and serialize on our ESP32 based thingy, with small exception. I had to comment out #include <iostream> in include/daw/json/concepts/daw_writable_output.h. On MCUs iostreams sometimes do not link at all (this is my case - the libc implementation I'm using lacks some posix functions like open/lseek etc.), on others I saw, resulting binary grows by 100% by simply including <iostream>. What would you recommend? Could I open a PR with some macro to disable it? Or maybe there is some option to avoid this problem?

[beached]

I think it is reasonable that the ostream writer is in a separate header with a disable option

[beached]

b4fd667 should allow using cmake/compile flags to disable the ostream and/or the FILE * writers

[iwasz]

Works perfectly. THANKS!