pub struct JsonValueEncoder { /* private fields */ }Expand description
Projects serializable values into strict materialized JSON.
The encoder accepts the full signed and unsigned 64-bit JSON integer range,
rejects wider numeric values and non-finite floats, validates map keys, and
rejects duplicate object keys. It owns no resource budget; use
crate::encode::JsonEncoder when encoded text and resource accounting are
required. Self::encode_in_transaction stages native JSON measurements
and returns a SafeJsonValue protected until the caller explicitly
unwraps it. This construction-time protection does not extend to recursive
cloning or destruction of a bare Value, and taking ownership of a bare
value does not grant budget admission.
§Examples
use qubit_json::value::JsonValueEncoder;
use serde_json::json;
let encoder = JsonValueEncoder::new();
let value = encoder.encode(&json!({"ok": true}))?;
assert_eq!(value, json!({"ok": true}));Implementations§
Source§impl JsonValueEncoder
impl JsonValueEncoder
Sourcepub const fn new() -> Self
pub const fn new() -> Self
Creates a strict encoder with the default immutable policy.
§Returns
A reusable encoder that performs no resource accounting.
Sourcepub fn encode<T>(&self, value: &T) -> Result<Value, JsonSerializationError>
pub fn encode<T>(&self, value: &T) -> Result<Value, JsonSerializationError>
Projects one serializable value into strict JSON.
§Type Parameters
T- Source type traversed through its Serde representation.
§Parameters
value- Borrowed value to project without taking ownership.
§Returns
The fully materialized, bare Value. Any protection used while
constructing it does not extend to recursive destruction or cloning of
this tree, and taking ownership of it does not mean it passed a caller’s
resource budget. Use SafeJsonValue::new to immediately take over the
returned tree when protected ownership is needed, or use
Self::encode_in_transaction when budget admission is required. The
transaction-aware entry point still cannot guarantee protection around
every recursive action performed internally by an arbitrary third-party
Serde serializer.
§Errors
Returns a strict value error whose precise kind distinguishes number, object-key, RawValue, capacity, serializer-contract, and opaque custom failures without retaining arbitrary diagnostic text.
§Examples
use qubit_json::value::JsonValueEncoder;
use qubit_json::value::SafeJsonValue;
use serde_json::value::RawValue;
let text = format!("{}0{}", "[".repeat(129), "]".repeat(129));
let raw = RawValue::from_string(text)?;
let owner = SafeJsonValue::new(JsonValueEncoder::new().encode(&raw)?);
assert!(owner.as_value().is_array());Sourcepub fn encode_in_transaction<T, R, Q>(
&self,
value: &T,
transaction: &mut JsonValueTransaction<'_, R, Q>,
) -> Result<SafeJsonValue, JsonValueEncodeError<R, Q>>
pub fn encode_in_transaction<T, R, Q>( &self, value: &T, transaction: &mut JsonValueTransaction<'_, R, Q>, ) -> Result<SafeJsonValue, JsonValueEncodeError<R, Q>>
Projects one value while staging native measurements in a caller-owned transaction.
The transaction remains borrowed and uncommitted. Repeated successful calls may be committed together by the caller. If this method returns an error or unwinds, the caller must drop the entire transaction rather than committing its staged state.
§Type Parameters
T- Serde source type; it may be dynamically sized.R- Resource identity retained in measured budget failures.Q- Exact unsigned quantity type used by the budget.
§Parameters
value- Borrowed value to project.transaction- Caller-owned value transaction receiving native measurements.
§Returns
A protected JSON owner when serialization and all measurements succeed.
§Errors
Returns the first measured budget error or serialization failure.
Sourcepub fn encode_in_transaction_with_private_text_limit<T, R, Q>(
&self,
value: &T,
transaction: &mut JsonValueTransaction<'_, R, Q>,
max_private_text_bytes: usize,
) -> Result<SafeJsonValue, JsonValueEncodeError<R, Q>>
pub fn encode_in_transaction_with_private_text_limit<T, R, Q>( &self, value: &T, transaction: &mut JsonValueTransaction<'_, R, Q>, max_private_text_bytes: usize, ) -> Result<SafeJsonValue, JsonValueEncodeError<R, Q>>
Projects one value while bounding each private RawValue or Number text payload before it is copied or appended.
The limit counts UTF-8 bytes in each payload independently and includes the exact boundary. It does not limit ordinary strings or consume the transaction’s native value budget. If this method fails, drop the whole transaction rather than committing staged state.
§Parameters
value- Borrowed Serde value to project.transaction- Caller-owned transaction receiving native value measurements.max_private_text_bytes- Inclusive UTF-8 byte limit for each private RawValue or Number payload.
§Returns
A protected JSON owner when serialization and measurement succeed.
§Errors
Returns the first budget or serialization failure, or
PrivateTextLimitExceeded when a private text payload exceeds the
configured byte limit. The limit error does not contain payload text.