class_file.hpp

Go to the documentation of this file.

// AI Generated 2026 Ryan P. Nicholl  <rnicholl@protonmail.com>
// SPDX-License-Identifier: Apache-2.0

 
#ifndef RPNX_CORTADO_CLASS_FILE_HPP
#define RPNX_CORTADO_CLASS_FILE_HPP
 
#include <cstddef>
#include <iterator>
#include <rpnx/cortado/attributes.hpp>
#include <rpnx/cortado/errors.hpp>
#include <rpnx/cortado/validation.hpp>
#include <span>
#include <stdexcept>
#include <utility>
#include <vector>
 
namespace rpnx::cortado
{
    struct class_file_read_options
    {
        processing_mode mode{processing_mode::strict}; 
        std::size_t maximum_attribute_length{256U * 1024U * 1024U}; 
        std::size_t maximum_total_attribute_bytes{1024U * 1024U * 1024U}; 
        std::size_t maximum_nesting_depth{256}; 
        std::size_t maximum_structure_nodes{1'000'000}; 
        RPNX_MEMBER_METADATA(class_file_read_options, mode, maximum_attribute_length, maximum_total_attribute_bytes, maximum_nesting_depth, maximum_structure_nodes);
    };

    struct class_file_write_options
    {
        processing_mode mode{processing_mode::strict}; 
        RPNX_MEMBER_METADATA(class_file_write_options, mode);
    };

    template < typename T >
    struct deserialization_result
    {
        T value; 
        std::size_t bytes_read{}; 
    };

    [[nodiscard]] std::vector< std::byte > serialize_class_file(class_file const& value, class_file_write_options const& options = {});

    [[nodiscard]] class_file deserialize_class_file(std::span< std::byte const > bytes, class_file_read_options const& options = {});

    [[nodiscard]] deserialization_result< class_file > deserialize_class_file_prefix(std::span< std::byte const > bytes, class_file_read_options const& options = {});

    template < typename OutputIt >
    auto serialize_iter(class_file const& value, OutputIt output, class_file_write_options const& options = {}) -> OutputIt
    {
        std::vector< std::byte > const bytes = serialize_class_file(value, options);
        for (std::byte const byte : bytes)
        {
            *output = byte;
            ++output;
        }
        return output;
    }

    template < typename OutputIt >
    auto serialize_iter(class_file const& value, OutputIt output, OutputIt end, class_file_write_options const& options = {}) -> OutputIt
    {
        std::vector< std::byte > const bytes = serialize_class_file(value, options);
        for (std::byte const byte : bytes)
        {
            if (output == end)
            {
                throw std::length_error("output range is too small for the JVM class file");
            }
            *output = byte;
            ++output;
        }
        return output;
    }

    template < std::forward_iterator InputIt, std::sentinel_for< InputIt > Sentinel >
    auto deserialize_iter(class_file& value, InputIt input, Sentinel end, class_file_read_options const& options = {}) -> InputIt
    {
        std::vector< std::byte > bytes;
        for (InputIt cursor = input; cursor != end; ++cursor)
        {
            bytes.push_back(static_cast< std::byte >(*cursor));
        }
        deserialization_result< class_file > result = deserialize_class_file_prefix(bytes, options);
        value = std::move(result.value);
        std::advance(input, static_cast< std::iter_difference_t< InputIt > >(result.bytes_read));
        return input;
    }
} // namespace rpnx::cortado
 
#endif // RPNX_CORTADO_CLASS_FILE_HPP