adl_serializer and objects sharing an abstract interface.

[jcracine-cimeq]

I've been dabbling a lot with with serialization lately and I wanted more inputs on how to tackle it when you have have a few implementation classes inheriting from a common abstract interface. I've succeeded with the following setup, but as I'm not really proficient with templates yet, I'm sure there's a more elegant and/or efficient way of doing it.

Interface & Implementations

enum class ImplementationType{
    UNKNOWN = -1,
    IMPLEMENTATION_A,
    IMPLEMENTATION_B,
};

class AbstractInterface {
    public:
        virtual unsigned int foobar() = 0;
};

class ImplementationA : public AbstractInterface {
    public:
        ImplementationA(unsigned int value): value(value){};
        virtual ~ImplementationA() = default;
    
        virtual unsigned int foobar(){ return value * 2;};

    private:
        unsigned int value;
};

class ImplementationB : public AbstractInterface {
    public:
        ImplementationB(unsigned int value): value(value){};
        virtual ~ImplementationB() = default;
    
        virtual unsigned int foobar(){ return value + 2;};

    private:
        unsigned int value;
};

Json Serializer

NLOHMANN_JSON_SERIALIZE_ENUM(ImplementationType,{
    {ImplementationType::UNKNOWN, nullptr},
    {ImplementationType::IMPLEMENTATION_A, "IMPL_A"},
    {ImplementationType::IMPLEMENTATION_B, "IMPL_B"},
})

namespace nlohmann{
    template<>
    struct adl_serializer<std::shared_ptr<AbstractInterface>>{
        static void from_json(const json& j, std::shared_ptr<AbstractInterface>& p){
            if(!j.empty() && j.is_object()){
                if(j.contains("type") && j.contains("value")){
                    auto type = j.at("type").template get<ImplementationType>();
                    switch(type){
                        case ImplementationType::IMPLEMENTATION_A:{
                            auto value = j.at("value");
                            if(value.is_number_integer()){
                                p = std::make_shared<ImplementationA>(value.get<int>());
                            }
                            else{
                                p = nullptr;
                            }
                            break;
                        }
                        case ImplementationType::IMPLEMENTATION_B:{
                            auto value = j.at("value");
                            if(value.is_number_integer()){
                                p = std::make_shared<ImplementationB>(value.get<int>());
                            }
                            else{
                                p = nullptr;
                            }
                            break;
                        }
                        default:{
                            p = nullptr;
                            break;
                        }
                    }
                }
                else{
                    p = nullptr;
                }
            }
            else{
                p = nullptr;
            }
        }
    };
}

Unit Tests using Doctest

using json = nlohmann::json;

TEST_CASE("TestSerializer"){
    
    json test_a = {
        {"type","IMPL_A"},
        {"value", 10}
    };

    json test_b = {
        {"type","IMPL_B"},
        {"value", 10}
    };

    auto ptra = test_a.template get<std::shared_ptr<AbstractInterface>>();
    REQUIRE(ptra != nullptr);
    auto rca = ptra->foobar();
    REQUIRE_EQ(rca, 20);

    auto ptrb = test_b.template get<std::shared_ptr<AbstractInterface>>();
    REQUIRE(ptrb != nullptr);
    auto rcb = ptrb->foobar();
    REQUIRE_EQ(rcb, 12);
}

[gregmarr]

A couple notes that aren't specific to the library:

class AbstractInterface {
    public:
        virtual unsigned int foobar() = 0;
};

class ImplementationA : public AbstractInterface {
    public:
        // No ; needed after a function body.  This actually creates a separate empty statement
        ImplementationA(unsigned int value): value(value){}; 
        // You need the virtual destructor in AbstractInterface or you won't be able to delete the objects correctly.  Then you don't need to add them explicitly to the derived classes unless you need some special handling.
        virtual ~ImplementationA() = default; 

This is very defensive, but also verbose:

namespace nlohmann{
    template<>
    struct adl_serializer<std::shared_ptr<AbstractInterface>>{
        static void from_json(const json& j, std::shared_ptr<AbstractInterface>& p){
            if(!j.empty() && j.is_object()){
                if(j.contains("type") && j.contains("value")){
                    auto type = j.at("type").template get<ImplementationType>();
                    switch(type){
                        case ImplementationType::IMPLEMENTATION_A:{
                            auto value = j.at("value");
                            if(value.is_number_integer()){
                                p = std::make_shared<ImplementationA>(value.get<int>());
                            }
                            else{
                                p = nullptr;
                            }
                            break;
                        }
                        case ImplementationType::IMPLEMENTATION_B:{
                            auto value = j.at("value");
                            if(value.is_number_integer()){
                                p = std::make_shared<ImplementationB>(value.get<int>());
                            }
                            else{
                                p = nullptr;
                            }
                            break;
                        }
                        default:{
                            p = nullptr;
                            break;
                        }
                    }
                }
                else{
                    p = nullptr;
                }
            }
            else{
                p = nullptr;
            }
        }
    };
}

You can cut out a lot of duplicated code. Writing it more than once means that you have more than one chance to get it wrong, and more chance for it to get out of sync later:

namespace nlohmann{
    template<>
    struct adl_serializer<std::shared_ptr<AbstractInterface>>{
        static void from_json(const json& j, std::shared_ptr<AbstractInterface>& p){
            p = nullptr;

            if(j.is_object() && j.contains("type") && j.contains("value")){
                auto type = j.at("type").template get<ImplementationType>();
                auto value = j.at("value");
                switch(type){
                    case ImplementationType::IMPLEMENTATION_A:{
                        if(value.is_number_integer()){
                            p = std::make_shared<ImplementationA>(value.get<int>());
                        }
                        break;
                    }
                    case ImplementationType::IMPLEMENTATION_B:{
                        if(value.is_number_integer()){
                            p = std::make_shared<ImplementationB>(value.get<int>());
                        }
                        break;
                    }
                }
            }
        }
    };
}

Back to the original question, yes, in general, that's how you want to do polymorphic reading. However, you can separate the creation of the polymorphic object from the reading of the object data if they're default constructible.

namespace nlohmann{
    template<>
    struct adl_serializer<std::shared_ptr<AbstractInterface>>{
        static void from_json(const json& j, std::shared_ptr<AbstractInterface>& p){
            p = nullptr;

            if(j.is_object() && j.contains("type")){
                auto type = j.at("type").template get<ImplementationType>();
                switch(type){
                    case ImplementationType::IMPLEMENTATION_A:{
                        auto obj = std::make_shared<ImplementationA>();
                        nlohmann::from_json(j, *obj.get());
                        p = obj;
                        break;
                    }
                    case ImplementationType::IMPLEMENTATION_B:{
                        auto obj = std::make_shared<ImplementationB>();
                        nlohmann::from_json(j, *obj.get());
                        p = obj;
                        break;
                    }
                }
            }
        }
    };
}

https://www.godbolt.org/z/4o8rd17zY

[jcracine-cimeq]

Thank you for taking the time to answer my question! It really more neatly done than what I had, as I never thought to use the NLOHMANN_DEFINE_TYPE_INTRUSIVE macro instead of using the static from_json/to_json functions. At the same time, one of the reason why I never used them is that I separated the implementation classes and the json serialization code in different files. Would it be possible to keep the dependency outside of the classes?

Update: I guess I could use NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE to do that as long as I declare it in the same namespace as my class if I understood correctly.

[gregmarr]

I guess I could use NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE to do that as long as I declare it in the same namespace as my class if I understood correctly.

That's correct.