CToon Documentation

# CMakeLists.txt
include(FetchContent)
FetchContent_Declare(
  ctoon
  GIT_REPOSITORY https://github.com/MohammadRaziei/ctoon.git
  GIT_TAG        main
)
FetchContent_MakeAvailable(ctoon)

# Link the C target
target_link_libraries(my_app PRIVATE ctoon::ctoon)

# CMakeLists.txt
include(FetchContent)
FetchContent_Declare(
  ctoon
  GIT_REPOSITORY https://github.com/MohammadRaziei/ctoon.git
  GIT_TAG        main
)
FetchContent_MakeAvailable(ctoon)

# Link the C++ target
target_link_libraries(my_app PRIVATE ctoon::ctoonpp)

go get github.com/mohammadraziei/ctoon

import Pkg
Pkg.add(url="https://github.com/mohammadraziei/ctoon.git", subdir="src/bindings/julia")

cd src/bindings/matlab
ctoon_install

pip install ctoon

[dependencies]
ctoon = { git = "https://github.com/mohammadraziei/ctoon.git" }

zig fetch --save git+https://github.com/mohammadraziei/ctoon.git

#include "ctoon.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(void) {
    const char *src = "name: Alice\nage: 30";
    ctoon_doc *doc  = ctoon_read(src, strlen(src), 0);
    ctoon_val *root = ctoon_doc_get_root(doc);

    /* Access fields */
    ctoon_val *name = ctoon_obj_get(root, "name");
    printf("%s\n", ctoon_get_str(name));   /* Alice */

    /* Serialise back to TOON */
    size_t len;
    char *toon = ctoon_write(doc, &len);
    free(toon);

    /* Export as JSON (on by default; define CTOON_DISABLE_JSON to turn off) */
    char *json = ctoon_doc_to_json(doc, 2,
                     CTOON_WRITE_NOFLAG, NULL, &len, NULL);
    printf("%s\n", json);
    free(json);

    ctoon_doc_free(doc);
    return 0;
}

#include "ctoon.hpp"
#include <iostream>

int main() {
    // Parse a TOON document
    auto doc  = ctoon::document::parse("name: Alice\nage: 30");
    auto root = doc.root();
    std::cout << root["name"].get_str().str() << "\n";  // Alice
    std::cout << root["age"].get_uint()        << "\n";  // 30

    // Serialise to TOON and JSON
    std::cout << doc.to_string().c_str()    << "\n";
    std::cout << doc.to_json(2).c_str() << "\n";

    // Build a document programmatically
    auto mdoc = ctoon::make_document();
    auto obj  = mdoc.make_obj();
    mdoc.set_root(obj);
    obj.obj_put(mdoc.make_str("city"), mdoc.make_str("Tehran"));
    obj.obj_put(mdoc.make_str("pop"),  mdoc.make_uint(9000000));
    std::cout << mdoc.to_json(0).c_str() << "\n";

    // Parse from JSON
    auto jdoc = ctoon::document::from_json(R"({"x":1,"y":2})");
    std::cout << jdoc.root()["x"].get_uint() << "\n";  // 1
}

package main

import (
    "fmt"
    ctoon "github.com/mohammadraziei/ctoon"
)

func main() {
    data := map[string]interface{}{
        "name": "Alice",
        "age":  int64(30),
    }

    // Encode → TOON
    toon, _ := ctoon.Dumps(data)
    fmt.Println(toon)

    // Decode ← TOON
    val, _ := ctoon.Loads(toon)
    fmt.Println(val)

    // File I/O
    ctoon.EncodeToFile(data, "out.toon", ctoon.DefaultEncodeOptions())
    val, _ = ctoon.DecodeFromFile("out.toon", ctoon.DefaultDecodeOptions())

    // JSON interop
    json, _ := ctoon.DumpsJSON(data, 2)
    fmt.Println(json)
    ctoon.DumpJSON(data, "out.json")
}

using CToon

# Parse JSON → native Julia data
data = CToon.parse("""{"name": "Alice", "age": 30}""")
println(data["name"])   # Alice
println(data["age"])    # 30

# Objects decode as order-preserving OrderedDict{String,Any},
# arrays as Vector{Any}
nested = CToon.parse("""{"items": [1, 2, 3]}""")
println(nested["items"])   # Any[1, 2, 3]

% Encode a MATLAB struct → TOON string
s = ctoon.encode(struct('name', 'Alice', 'age', uint64(30), 'active', true));
% name: Alice
% age: 30
% active: true

% Decode TOON string → MATLAB struct
v = ctoon.decode(s);
v.name    % 'Alice'
v.age     % uint64(30)
v.active  % true

% File I/O
ctoon.write(v, 'data.toon');
v = ctoon.read('data.toon');

% Python-style aliases
s = ctoon.dumps(v);   % same as ctoon.encode
v = ctoon.loads(s);   % same as ctoon.decode

import ctoon

# Encode Python dict → TOON string
toon = ctoon.dumps({"name": "Alice", "age": 30})
# name: Alice
# age: 30

# Decode TOON string → Python dict
data = ctoon.loads(toon)

# File I/O — path strings or file-like objects
ctoon.dump(data, "out.toon")
data = ctoon.load("out.toon")

# JSON interop
json_str = ctoon.dumps_json(data, indent=2)
data     = ctoon.loads_json(json_str)
ctoon.dump_json(data, "out.json")

# Advanced encode flags
from ctoon import WriteFlag, Delimiter
toon = ctoon.dumps(data,
    indent=4,
    delimiter=Delimiter.PIPE,
    flags=WriteFlag.LENGTH_MARKER | WriteFlag.NEWLINE_AT_END)

fn main() -> ctoon::Result<()> {
    // Decode ← TOON
    let val = ctoon::loads("name: Alice\nage: 30")?;
    println!("{}", val["name"].as_str().unwrap()); // Alice

    // Encode → TOON
    let toon = ctoon::dumps(&val)?;
    println!("{toon}");

    // JSON interop
    let json = ctoon::dumps_json(&val, 2)?;
    let back = ctoon::loads_json(&json)?;
    println!("{}", back["age"].as_u64().unwrap()); // 30

    Ok(())
}

const std = @import("std");
const ctoon = @import("ctoon");

pub fn main() !void {
    const gpa = std.heap.page_allocator;

    // Decode ← TOON
    var val = try ctoon.loads(gpa, "name: Alice\nage: 30");
    defer val.deinit(gpa);
    std.debug.print("{s}\n", .{val.get("name").?.asStr().?}); // Alice

    // Encode → TOON
    const toon = try ctoon.dumps(gpa, val);
    defer gpa.free(toon);

    // JSON interop
    const json = try ctoon.dumpsJson(gpa, val, 2);
    defer gpa.free(json);
    var back = try ctoon.loadsJson(gpa, json);
    defer back.deinit(gpa);
    std.debug.print("{}\n", .{back.get("age").?.asU64().?}); // 30
}