Function serialize_object

std/json/src/main/serializer.rs:138–178

(value: &Handle, out: &mut String, ctx: &mut SerCtx, depth: usize)

}

fn serialize_object(value: &Handle, out: &mut String, ctx: &mut SerCtx, depth: usize) -> Result<()> {
    if ctx.opts.check_circular && depth >= MAX_DEPTH {
        return Err(Error::Value("Circular reference detected".into()));
    }
    out.push('{');
    let keys = value.iter()?;
    let n = keys.len()?;
    if n == 0 {
        out.push('}');
        return Ok(());
    }
    let mut pairs: Vec<(String, Handle)> = Vec::with_capacity(n as usize);
    for i in 0..n {
        let idx = encode(Value::Int(i as i128))?;
        let key = keys.get_item(&idx)?;
        let key_ty_handle = key.type_of()?;
        let key_ty = String::from_handle(key_ty_handle.raw())?;
        if key_ty != "str" {
            if ctx.opts.skipkeys { continue; }
            return Err(Error::Type(format!("keys must be str, not {}", key_ty)));
        }
        let key_str = match decode(key.raw())? {
            Value::Bytes(b) => String::from_utf8(b).map_err(|e| Error::Value(format!("invalid utf-8 in key: {}", e)))?,
            _ => return Err(Error::Type("str key decoded as non-bytes".into())),
        };
        pairs.push((key_str, key));
    }
    if ctx.opts.sort_keys { pairs.sort_by(|a, b| a.0.cmp(&b.0)); }
    let indent_str = ctx.opts.indent.map(|n| " ".repeat(n.max(0) as usize));
    for (i, (key_str, key)) in pairs.iter().enumerate() {
        let item = value.get_item(key)?;
        if i > 0 { out.push_str(&ctx.opts.item_sep); }
        write_indent(out, indent_str.as_deref(), depth + 1);
        escape_string(key_str, out, ctx.opts.ensure_ascii);
        out.push_str(&ctx.opts.key_sep);
        serialize_into(&item, out, ctx, depth + 1)?;
    }
    write_indent(out, indent_str.as_deref(), depth);
    out.push('}');
    Ok(())
}

fn write_indent(out: &mut String, unit: Option<&str>, depth: usize) {
    if let Some(u) = unit {