adapter_for.hpp

Go to the documentation of this file.

/// \file jsonv/serialization/adapter_for.hpp
///
/// Copyright (c) 2015-2026 by Travis Gockel. All rights reserved.
///
/// This program is free software: you can redistribute it and/or modify it under the terms of the Apache License
/// as published by the Apache Software Foundation, either version 2 of the License, or (at your option) any later
/// version.
///
/// \author Travis Gockel (travis@gockelhut.com)
#pragma once
 
#include <jsonv/config.hpp>
#include <jsonv/serialization/adapter.hpp>
#include <jsonv/serialization/serialize.hpp>
#include <jsonv/value.hpp>
 
#include <expected>
#include <new>
#include <utility>
 
namespace jsonv
{
 
/// \addtogroup Serialization
/// \{
 
/// An adapter for the type \c T. This is a utility class which converts the `void*`s used in the \c deserializer and
/// \c serializer interfaces into the more-friendly \c T.
///
/// \see deserializer_for
/// \see serializer_for
/// \see value_adapter_for
template <typename T>
class adapter_for :
        public adapter
{
public:
    /// \see deserializer::get_type
    /// \see serializer::get_type
    JSONV_NODISCARD
    virtual const std::type_info& get_type() const noexcept override
    {
        return typeid(T);
    }
 
    /// \see deserializer::deserialize
    JSONV_NODISCARD
    virtual std::expected<void, ast_node_type>
    deserialize(deserialization_context& context, reader& from, void* into) const override
    {
        if (auto created = create(context, from))
        {
            try
            {
                new(into) T(std::move(created).value());
            }
            catch (...)
            {
                // `create` succeeded, so the cursor is already one past the value this was built from. Moving it
                // into place is the last thing which can fail, and `T` is the caller's type; a loop recovering from
                // that failure must not step over the value a second time.
                context.note_value_consumed(from);
                throw;
            }
            return {};
        }
        else
        {
            return std::unexpected(created.error());
        }
    }
 
    /// \see serializer::serialize
    virtual void serialize(const serialization_context& context, const void* from, writer& to) const override
    {
        serialize(context, *static_cast<const T*>(from), to);
    }
 
protected:
    /// Create an instance of \c T by reading \a from.
    ///
    /// \param context Extra information to help you decode sub-objects, such as looking up other \c deserializer
    ///                implementations via \c formats. Record any problem you encounter with
    ///                \c deserialization_context::problem.
    /// \param from The JSON \c reader to deserialize from. On a successful return it should sit one position past the
    ///             value which was read, as \c reader::next_value would have left it.
    ///
    /// \returns The created instance; otherwise a \c std::unexpected carrying the \c ast_node_type actually found
    ///          when the failure was a type mismatch, or \c ast_node_type::error otherwise.
    JSONV_NODISCARD
    virtual std::expected<T, ast_node_type> create(deserialization_context& context, reader& from) const = 0;
 
    /// Write \a from into \a to.
    ///
    /// \see serializer::serialize
    virtual void serialize(const serialization_context& context, const T& from, writer& to) const = 0;
};
 
/// A base for adapters written against the older \c value -based interface, in both directions.
///
/// Reading, the subtree under the reader is materialised with \c read_value and handed to the subclass, whose
/// \c create runs unchanged. Writing, the \c value the subclass's \c to_json builds is written whole into the writer
/// with \c writer::write. Both cost the tree the \c reader and the \c writer exist to avoid -- so it is a stepping
/// stone for ports, not a destination. New adapters should derive from \c adapter_for, walk the \c reader and write
/// into the \c writer.
template <typename T>
class value_adapter_for :
        public adapter_for<T>
{
protected:
    JSONV_NODISCARD
    virtual std::expected<T, ast_node_type>
    create(deserialization_context& context, reader& from) const final override
    {
        // A deserialization_error thrown by the subclass is deliberately left to propagate:
        // deserialization_context::deserialize folds its problem list onto the context, which is how the path and
        // message an older adapter throws with survive into the pipeline's std::expected channel.
        detail::borrowed_subtree subtree(context, from);
        T                        out = create(context, subtree.get());
 
        // Only once the older body is through: a throw out of it leaves the cursor on the value which failed, so the
        // problem names that rather than whatever follows it.
        subtree.commit();
 
        // Committing steps the cursor past the value, so the return -- which moves the result into the `std::expected`
        // with the caller's own move constructor -- fails with that value behind it. `borrowed_subtree` cannot say so
        // on our behalf here: it has committed, which is the state it takes to mean the body succeeded.
        try
        {
            return out;
        }
        catch (...)
        {
            context.note_value_consumed(from);
            throw;
        }
    }
 
    virtual void serialize(const serialization_context& context, const T& from, writer& to) const final override
    {
        to.write(to_json(context, from));
    }
 
    /// Create an instance of \c T from the materialised \a from.
    ///
    /// \throws deserialization_error if \a from cannot be converted to a \c T.
    JSONV_NODISCARD
    virtual T create(deserialization_context& context, const value& from) const = 0;
 
    /// Convert \a from into a \c value.
    JSONV_NODISCARD
    virtual value to_json(const serialization_context& context, const T& from) const = 0;
};
 
/// \}
 
}