Is it possible to skip write null for json_type_trails ?

[sarahlydia9868]

Example

static Json to_json(const class_type &class_instance, allocator_type alloc = allocator_type()) {
      if (class_instance.has_value()) {
        return Json(*class_instance, semantic_tag::none, alloc);
      }
      return nullptr; // result -> { "a": null }
    }

Is it possible skip write null then result like { } . Thanks.

[danielaparker]

@hiepsahplydia, I'm not sure I understand your question. If you want to return a result like {} (an empty object), you can return Json{}.

[sarahlydia9868]

@danielaparker This is my code example:

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

using namespace jsoncons;

struct OptionalV {

    std::string value;
    bool has_value;

    explicit OptionalV() = default;
    explicit OptionalV(std::string value) : value(value), has_value(true) {}
    ~OptionalV() = default;
};

struct OptionalExample {

    std::string text;
    OptionalV optional;
    OptionalV optional_skip;

    explicit OptionalExample() = default;
    ~OptionalExample() = default;
};

namespace jsoncons
{
    template <typename Json>
    struct json_type_traits<Json, OptionalV>
    {
        static bool is(const Json& val) noexcept
        {
            return true; // always true, this value can nul or empty.
        }

        static OptionalV as(const Json& val)
        {
            if (!val.has_value()) {
                return OptionalV();
            }
            else {
                return Optional{
                    .value = val.value()
                    .has_value = true
                  };
            }

        }

        static Json to_json(OptionalV const &val)
        {
            if (val.has_value) {
                return Json(val.value);
            }
            else {
                return nullptr;
            }
        }
    };
}

JSONCONS_ALL_MEMBER_TRAITS(OptionalExample, text, optional, optional_skip);

int main()
{
    std::error_code ec;

    OptionalExample val;
    val.text = "Sample!";
    val.optional = OptionalV("Available Value");
    val.optional_skip = OptionalV(); // this optional doesn't have value will skip when encode json.
    std::string buffer;
    json_string_encoder encoder{buffer};
    encode_traits<OptionalExample, char>::encode(val, encoder, ojson{}, ec);
    std::cout << buffer << "\n";
}

Result:

{
        "text": "Sample!",
        "optional": "Available Value",
        "optional_skip": null
}

I want the value to be null or some way for the json to not write that value anymore.
Result:

{
        "text": "Sample!",
        "optional": "Available Value"
}

[danielaparker]

@hiepsahplydia, I made two changes to your code, replacing OptionalV with std::optional, and

JSONCONS_ALL_MEMBER_TRAITS(OptionalExample, text, optional, optional_skip);

with

JSONCONS_N_MEMBER_TRAITS(OptionalExample, 1, text, optional, optional_skip);

(1 is the number of mandatory parameters). Then your example becomes:

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

using namespace jsoncons;

struct OptionalExample {

    std::string text;
    std::optional<std::string> optional;
    std::optional<std::string> optional_skip;

    explicit OptionalExample() = default;
    ~OptionalExample() = default;
};

namespace jsoncons
{
template <typename Json>
struct json_type_traits<Json, std::optional<std::string>>
{
    static bool is(const Json& val) noexcept
    {
        return true; // always true, this value can nul or empty.
    }

    static std::optional<std::string> as(const Json& val)
    {
        if (!val.has_value()) {
            return std::optional<std::string>();
        }
        else {
            return std::optional(val.as_string());
        }

    }

    static Json to_json(std::optional<std::string> const& val)
    {
        if (val.has_value()) {
            return Json(val.value());
        }
        else {
            return nullptr;
        }
    }
};
}

JSONCONS_N_MEMBER_TRAITS(OptionalExample, 1, text, optional, optional_skip);

int main()
{
    std::error_code ec;

    OptionalExample val;
    val.text = "Sample!";
    val.optional = "Available Value";
    std::string buffer;
    json_string_encoder encoder{ buffer };
    encode_traits<OptionalExample, char>::encode(val, encoder, ojson{}, ec);
    std::cout << buffer << "\n";
}

Output:

{
    "text": "Sample!",
    "optional": "Available Value"
}

See also this example, Serialize non-mandatory std::optional values using the convenience macros

[sarahlydia9868]

Thank Daniel, it worked.