Decoding empty php associative arrays

[patternoia]

Describe the proposed feature

In php the objects are often represented by associative arrays. Serializing them produces valid json object.

>>> $object = ["key" => "value"]
=> [
     "key" => "value",
   ]
>>> json_encode($object)
=> "{"key":"value"}"

However if this object becomes empty the associative array becomes normal empty array and serializing it produces an empty json array.

>>> unset($object["key"])
>>> json_encode($object)
=> "[]"

If this happens then my map<string, string> can not be deserialized from "[]" to an empty map with an exception.

Can this be handled so that empty map or an empty class instance will be created from "[]"?

Thanks.

What other libraries (C++ or other) have this feature?
Unaware, since I stick to jsoncons.

Include a code fragment with sample data that illustrates the use of this feature

jsoncons::ojson::parse("[]").as<std::vector<int>>()
(std::enable_if<true, std::vector<int, std::allocator<int> > >::type) {}

jsoncons::ojson::parse("[]").as<std::map<std::string,std::string>>()
jsoncons::json_runtime_error<std::domain_error, void> caught: Not an object

[danielaparker]

You can use a filter for that, i.e.

#include <jsoncons/json.hpp>
#include <iostream>

class php_json_filter : public jsoncons::json_filter
{
    bool is_empty_array_;
    jsoncons::semantic_tag begin_array_tag_;
public:
    using string_view_type = jsoncons::json_filter::string_view_type;
    using jsoncons::json_filter::destination;

    php_json_filter(jsoncons::json_visitor& visitor)
        : jsoncons::json_filter(visitor), is_empty_array_(false), begin_array_tag_(jsoncons::semantic_tag::none)
    {
    }

    void check_array(const jsoncons::ser_context& context,
                     std::error_code& ec)
    {
        if (is_empty_array_)
        {
            destination().begin_array(begin_array_tag_, context, ec);
            is_empty_array_ = false;
        }
    }

private:
    bool visit_begin_object(jsoncons::semantic_tag tag, 
                            const jsoncons::ser_context& context, 
                            std::error_code& ec) override
    {
        check_array(context, ec);
        return destination().begin_object(tag, context, ec);
    }

    bool visit_end_object(const jsoncons::ser_context& context, 
                          std::error_code& ec) override
    {
        check_array(context, ec);
        return destination().end_object(context, ec);
    }

    bool visit_begin_array(jsoncons::semantic_tag tag, 
                           const jsoncons::ser_context& context, 
                           std::error_code& ec) override
    {
        check_array(context, ec);
        is_empty_array_ = true;
        begin_array_tag_ = tag;
        return true;
    }

    bool visit_end_array(const jsoncons::ser_context& context, 
                         std::error_code& ec) override
    {
        if (is_empty_array_)
        {
            is_empty_array_ = false;
            destination().begin_object(jsoncons::semantic_tag::none, context, ec);
            return destination().end_object(context, ec);
        }
        else
        {
            return destination().end_array(context, ec);
        }
    }

    bool visit_key(const string_view_type& name, 
                   const jsoncons::ser_context& context,
                   std::error_code& ec) override
    {
        check_array(context, ec);
        return destination().key(name, context, ec);
    }

    bool visit_string(const string_view_type& s, 
                      jsoncons::semantic_tag tag,
                      const jsoncons::ser_context& context,
                      std::error_code& ec) override
    {
        check_array(context, ec);
        return destination().string_value(s, tag, context, ec);
    }

    bool visit_uint64(uint64_t value, 
                      jsoncons::semantic_tag tag, 
                      const jsoncons::ser_context& context, 
                      std::error_code& ec) override
    {
        check_array(context, ec);
        return destination().uint64_value(value, tag, context, ec);
    }

    bool visit_int64(int64_t value, 
                     jsoncons::semantic_tag tag, 
                     const jsoncons::ser_context& context, 
                     std::error_code& ec) override
    {
        check_array(context, ec);
        return destination().int64_value(value, tag, context, ec);
    }

    bool visit_double(double value, 
                      jsoncons::semantic_tag tag, 
                      const jsoncons::ser_context& context, 
                      std::error_code& ec) override
    {
        check_array(context, ec);
        return destination().double_value(value, tag, context, ec);
    }

    bool visit_bool(bool value, 
                    jsoncons::semantic_tag tag, 
                    const jsoncons::ser_context& context, 
                    std::error_code& ec) override
    {
        check_array(context, ec);
        return destination().bool_value(value, tag, context, ec);
    }

    bool visit_null(jsoncons::semantic_tag tag, 
                    const jsoncons::ser_context& context, 
                    std::error_code& ec) override
    {
        check_array(context, ec);
        return destination().null_value(tag, context, ec);
    }
};


int main()
{
    std::string input = "[{\"a\":[]},[[]]]";

    try
    {
        jsoncons::json_decoder<jsoncons::ojson> decoder;

        php_json_filter filter(decoder);
        jsoncons::json_reader reader(input, filter);
        reader.read();

        auto j = decoder.get_result();
        std::cout << j << "\n";    
    }
    catch (const std::exception& e)
    {
        std::cerr << e.what() << "\n";
    }
}

Output:

[{"a":{}},[{}]]

[patternoia]

Wow, very nice! I will try this out.