Struct XdrWriter 

struct XdrWriter {
    buf: Vec<u8>,
}

Cursor-based writer for big-endian (XDR) binary data.

Fields

buf: Vec<u8>

Implementations

impl XdrWriter

fn new() -> Self

fn write_int(&mut self, val: i32)

Write a big-endian i32.

fn write_double(&mut self, val: f64)

Write a big-endian f64.

fn write_flags(&mut self, sxp_type: u8, has_attr: bool, has_tag: bool)

Write flags for an object: SEXPTYPE in bits 0:7, has-attr in bit 9, has-tag in bit 10.

fn write_charsxp(&mut self, s: Option<&str>)

Write a CHARSXP: flags + length + raw bytes. Pass None for NA_STRING.

fn write_nilvalue(&mut self)

Write NILVALUE_SXP sentinel (end of pairlists, etc.)

fn write_length(&mut self, len: usize)

Write a length value. Uses the standard i32 encoding for lengths < 2^31.

fn write_attributes(&mut self, attrs: &Attributes)

Write attributes as a pairlist. Each entry becomes a LISTSXP node with a SYMSXP tag and the value as CAR. The chain terminates with NILVALUE_SXP.

fn write_item(&mut self, value: &RValue)

Write a single R value recursively.

fn write_symbol(&mut self, name: &str)

Write a SYMSXP (symbol): flags + CHARSXP for the name.

fn write_pairlist(&mut self, bindings: &[(String, RValue)])

Write a pairlist: a chain of LISTSXP nodes, each with a TAG (symbol) and CAR (value), terminated by NILVALUE_SXP. This is the format used by GNU R’s save() for writing workspace files (RDX2 format).

fn write_environment(&mut self, env: &Environment)

Write an environment. Singleton environments (global, base, empty) are written as their pseudo-SEXPTYPE codes. Other environments are written as ENVSXP with their bindings.

fn write_formals(&mut self, params: &[Param])

Write function formals as a pairlist.

Each parameter becomes a LISTSXP node: TAG = param name (SYMSXP), CAR = default value (or MISSINGARG_SXP if no default).

fn write_body_expr(&mut self, expr: &Expr)

Write an AST expression as a LANGSXP (language object).

Simple literals are written directly as their R serialized form. Complex expressions (calls, blocks, etc.) are deparsed to a string and written as a STRSXP with a “miniR.source” attribute, enabling re-parsing.

fn write_langsxp_expr(&mut self, expr: &Expr)

Write a Language (LANGSXP) from an Expr.

Call expressions are written as proper LANGSXP pairlists. Other expressions are deparsed and written as STRSXP with the source marker.

fn finish(self) -> Vec<u8>