Enum DataValue 

pub enum DataValue {
    Null,
    Bool {
        value: bool,
    },
    Int {
        value: i64,
    },
    Float {
        value: f64,
    },
    Text {
        value: String,
    },
    Bytes {
        value: Vec<u8>,
    },
    Attachment {
        hash: String,
        size: u64,
        name: Option<String>,
        mime: Option<String>,
    },
}

A value stored in a map or list.

Deliberately flat. Structured values go in as JSON strings and merge whole (last write wins per key), which is the honest description of what v1 replicates: whole collections within a space, no nested container addressing and no query language. DataValue::Attachment is the one composite, and it is composite because it is a reference rather than a value: see its own documentation.

The engine’s own value type never appears here. That is what lets the engine be replaced without a breaking change to any caller, the FFI, or any binding.

Variants

Null

An explicit null.

Bool

A boolean.

Fields

value: bool

The value.

Int

A signed 64-bit integer.

Fields

value: i64

The value.

Float

A double.

Fields

value: f64

The value.

Text

A UTF-8 string.

Fields

value: String

The value.

Bytes

Opaque bytes.

Fields

value: Vec<u8>

The value.

Attachment

A reference to a blob that is not in the document.

The only value whose payload never enters the CRDT. The document holds the hash, the size, and enough to show the thing; the bytes travel on the media path that already carries files.

The failure this prevents is a document that has to hold a photo. A document is bounded by one sealed record, so a layer that inlined blobs would be a layer that could not carry the blobs people actually send, and would discover that at commit time with the picture already on screen.

A reference is replaced, never edited. Two members who attach different blobs to the same key resolve the way every other map value resolves, and neither replica is left holding half of each. That is what the “no multi-writer attachment mutation” non-goal means in practice, and it is a property of this shape rather than a rule anyone has to remember.

Fields

hash: String

Lowercase hex SHA-256 of the whole blob, exactly 64 characters.

This is the address, not a checksum carried alongside one. The same bytes attached twice are the same attachment, and a blob arriving from a peer is accepted only if it hashes to the reference that asked for it, which is what makes fetching from an authenticated peer safe without trusting that peer.

size: u64

Length of the blob in bytes.

Carried so an application can decide whether it wants the thing before asking for it over a radio that may be Bluetooth.

name: Option<String>

Display name, if the writer had one.

mime: Option<String>

Media type, if the writer knew it.

Implementations

impl DataValue

pub fn text(value: impl Into<String>) -> Self

Convenience constructor for a string value.

pub fn int(value: i64) -> Self

Convenience constructor for an integer value.

pub fn bool(value: bool) -> Self

Convenience constructor for a boolean value.

pub fn float(value: f64) -> Self

Convenience constructor for a float value.

pub fn bytes(value: impl Into<Vec<u8>>) -> Self

Convenience constructor for a byte value.

pub fn attachment(hash: impl Into<String>, size: u64) -> Self

Convenience constructor for an attachment reference with no display name and no media type.

The hash is not checked here. It is checked where every other value is checked, at the operation that writes it, so a bad one is refused with the same error as a bad key rather than panicking at a constructor.

Trait Implementations

impl Clone for DataValue

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for DataValue

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for DataValue

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for DataValue

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for DataValue

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for DataValue