How to serialize/deserialize custom scalar type?

[krishna116]

For example, I defined a custom email type (email_t) here, but it cannot compile,
I'm not very familiar with C++ template, here is the code:

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

using namespace nlohmann;

// A custom scalar type.
class email_t
{
    std::string email_;

public:
    email_t(const std::string &str)
    {
        email_ = str;
    }

    email_t &operator=(const std::string &str)
    {
        email_ = str;
        return *this;
    }

    std::string str() const
    {
        return email_;
    }

    bool empty() const
    {
        return email_.empty();
    }
};

// Add custom scalar type support for serializing and deserializing.
namespace nlohmann
{
    template <>
    struct adl_serializer<email_t>
    {
        static void to_json(json &j, email_t &e)
        {
            if (e.empty())
            {
                j = nullptr;
            }
            else
            {
                j = e.str();
            }
        }

        static void from_json(const json &j, email_t &e)
        {
            if (j.is_null())
            {
                e = {};
            }
            else
            {
                e = j.get<std::string>();
            }
        }
    };
}

int main()
{
    // json j= std::string("[email protected]");
    json j = email_t("[email protected]");

    printf("%s\n", j.dump().c_str());
    return 0;
}

please help, thank you.

[falbrechtskirchinger]

You'll either need to add a default constructor to your type or use a different signature for the deserialization function (see https://json.nlohmann.me/features/arbitrary_types/#how-can-i-use-get-for-non-default-constructiblenon-copyable-types).

Additionally, this is ambiguous.

if (j.is_null())
{
    e = {}; // <-- ambiguous
}
else
{
    e = j.get<std::string>();
}

Rewriting it this way should do what you want:

if (!j.is_null())
{
    e = j.get<std::string>();
}

[gregmarr]

You shouldn't need this adl_serializer part unless you are not in control of the namespace containing email_t. You just create the to_json and from_json free functions in the same namespace as email_t.

// Add custom scalar type support for serializing and deserializing.
namespace nlohmann
{
    template <>
    struct adl_serializer<email_t>
    {

[krishna116]

Thanks for the advice, I modified the code as below, but it still cannot compile, can anybody show me a correct example?

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

using namespace nlohmann;

// A custom scalar type.
class email_t
{
    std::string email_;

public:
    email_t()=default;
    email_t(const std::string &str)
    {
        email_ = str;
    }

    email_t &operator=(const std::string &str)
    {
        email_ = str;
        return *this;
    }

    std::string str() const
    {
        return email_;
    }

    bool empty() const
    {
        return email_.empty();
    }

    void to_json(json &j, email_t &e)
    {
        if (!e.empty())
        {
            j = e.str();
        }
    }

    void from_json(const json &j, email_t &e)
    {
        if (!j.is_null())
        {
            e = j.get<std::string>();
        }
    }
};

int main()
{
    // json j= std::string("[email protected]");
    json j = email_t("[email protected]");

    printf("%s\n", j.dump().c_str());
    return 0;
}

The error is:

error: conversion from 'email_t' to non-scalar type 'nlohmann::json' {aka 'nlohmann::basic_json<>'} requested.

[gregmarr]

Thanks for the advice, I modified the code as below, but it still cannot compile, can anybody show me a correct example?

You put the functions in the class, which is incorrect. They're free functions.

class email_t
{
    ...
};

void to_json(json &j, email_t &e)
{
    ...
}

void from_json(const json &j, email_t &e)
{
    ...
}

[krishna116]

After some test, finally I got the working solution, It may be an example for other people.

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

// A custom scalar type.
class email_t
{
    std::string email_;
public:
    email_t()=default;
    email_t(const std::string &str){ email_ = str; }
    email_t(const char* str){ email_ = str; }
    email_t &operator=(const std::string &str){ email_ = str; return *this; }
    email_t &operator=(const char* str){ email_ = str; return *this; }
    std::string str() const{ return email_; }
    bool empty() const{ return email_.empty(); }
};

// Add custom scalar type support for serializing and deserializing.
namespace nlohmann {
    template <>
    struct adl_serializer<email_t> {
        static void to_json(json& j, const email_t& e) 
        {
            (!e.empty()) ? j = e.str() : j = nullptr;
        }

        static void from_json(const json& j, email_t& e) 
        {
            (!j.is_null()) ? e = j.get<email_t>() : e = std::string{};
        }
    };
}

// Using internal scalar type and custom scalar type.
struct Person
{
    std::size_t id = 0;
    std::string name;
    email_t email;
    NLOHMANN_DEFINE_TYPE_INTRUSIVE(Person, id, name, email)
};

using namespace nlohmann;

int main()
{
    // using internal scalar type.
    json j1 = std::string("[email protected]");
    // using custom scalar type.
    json j2 = email_t{"[email protected]"};
    // Using internal scalar type and custom scalar type.
    json j3 = Person{1, "jack", "[email protected]"};

    printf("%s\n", j1.dump().c_str());
    printf("%s\n", j2.dump().c_str());
    printf("%s\n", j3.dump().c_str());

    return 0;
}

thanks.