Transform classes and package a JAR

Cortado uses the same owning class-file model for parsed and generated input. This makes transformation a continuation of code generation rather than a separate API.

Start from a parsed class

rpnx::cortado::class_file parsed =
    rpnx::cortado::deserialize_class_file(class_bytes);
rpnx::cortado::class_file_builder builder(std::move(parsed));

The builder initializes its interner from the exact existing pool. Equal new constants reuse their first existing indexes, while unrelated existing entries retain their order. The following mutable accessors expose the exact model:

• access_flags() and version();
• fields() and methods();
• attributes(); and
• constant_pool().

References returned from member vectors follow ordinary std::vector invalidation rules. Prefer finishing one mutation before appending another member if you retain references.

add_field and add_method use the same shared interner as parsed members. When directly constructing an attribute, intern its predefined name and every referenced value through constant_pool() before inserting it into the context-appropriate attribute variant.

Validate the transformed model

The validation and serialization boundary is unchanged:

    rpnx::cortado::class_file const generated_class = builder.build();
    rpnx::cortado::validation_report const report = rpnx::cortado::validate_class_file(generated_class);
    if (!report.valid())
    {
        throw std::runtime_error(report.diagnostics.front().message);
    }
    std::vector< std::byte > const class_bytes = rpnx::cortado::serialize_class_file(generated_class);

Strict serialization rejects misplaced standard attributes, incompatible constant kinds, version-gated features, bad descriptors, invalid code offsets, and other model inconsistencies. Unknown attributes remain byte-for-byte payloads and can be retained during transformations.

Package classes and resources

A jar_entry always owns uncompressed data. Its compression member chooses stored or raw-DEFLATE encoding when serialize_jar is called.

    std::string const manifest_text = "Manifest-Version: 1.0\n\n";
    std::vector< std::byte > manifest_bytes;
    manifest_bytes.reserve(manifest_text.size());
    for (char const character : manifest_text)
    {
        manifest_bytes.push_back(static_cast< std::byte >(static_cast< std::uint8_t >(character)));
    }
 
    rpnx::cortado::jar_file archive;
    archive.entries.push_back(rpnx::cortado::jar_entry{
        .name = "META-INF/MANIFEST.MF",
        .data = std::move(manifest_bytes),
        .compression = rpnx::cortado::compression_method::stored,
        .flags = rpnx::cortado::jar_entry_flags::utf8_names,
        .modification_date = rpnx::cortado::zip_dos_date{0x0021}});
    archive.entries.push_back(rpnx::cortado::jar_entry{
        .name = "tutorial/Generated.class",
        .data = class_bytes,
        .compression = rpnx::cortado::compression_method::deflated,
        .flags = rpnx::cortado::jar_entry_flags::utf8_names,
        .modification_date = rpnx::cortado::zip_dos_date{0x0021}});
    std::vector< std::byte > const jar_bytes = rpnx::cortado::serialize_jar(archive);

Keep JAR names slash-separated. A manifest belongs at the case-sensitive path META-INF/MANIFEST.MF; executable archives also need a correctly formatted Main-Class header and a generated static main method with descriptor ([Ljava/lang/String;)V.

The JAR writer preserves entry order, comments, supported flags, timestamps, and attributes. It emits an ordinary single-disk, non-Zip64 ZIP archive. It rejects unsupported flags, compression methods, field sizes, and entry counts rather than silently changing format.

After generation, validate the artifact with the real JVM tools appropriate to your target version:

javap -verbose -classpath tutorial-codegen.jar tutorial.Generated
java -Xverify:all -classpath tutorial-codegen.jar your.MainClass

The tutorial archive intentionally contains a library class rather than a Main-Class, so the first command applies directly. The repository's Hello World example demonstrates the executable-JAR shape.

Return to the tutorial index or consult the complete rpnx::cortado API reference.