Enum ContainerID 

pub enum ContainerID {
    Root {
        name: InternalString,
        container_type: ContainerType,
    },
    Normal {
        peer: PeerID,
        counter: Counter,
        container_type: ContainerType,
    },
}

ContainerID includes the Op’s ID and the type. So it’s impossible to have the same ContainerID with conflict ContainerType.

This structure is really cheap to clone.

String representation:

• Root Container: /<name>:<type>
• Normal Container: <counter>@<client>:<type>

Note: It will be encoded into binary format, so the order of its fields should not be changed.

Variants

Root

Root container does not need an op to create. It can be created implicitly.

Fields

name: InternalString

container_type: ContainerType

Normal

Fields

peer: PeerID

counter: Counter

container_type: ContainerType

Implementations

impl ContainerID

pub fn new_normal(id: ID, container_type: ContainerType) -> Self

pub fn new_root(name: &str, container_type: ContainerType) -> Self

pub fn name(&self) -> &InternalString

pub fn container_type(&self) -> ContainerType

pub fn is_unknown(&self) -> bool

pub fn new_mergeable( parent: &ContainerID, key: &str, container_type: ContainerType, ) -> Self

Create a mergeable container ID for the given parent, key, and container type.

The cid is a Root container with a reserved namespace prefix and a flattened map-path payload, so two peers calling this with the same arguments produce the identical ContainerID.

The container kind is intentionally not encoded into the name: it already lives in ContainerID::Root::container_type, so encoding it twice would waste two bytes per cid, and ContainerID equality already keeps two (parent, key) mergeable cids of different kinds distinct.

Only maps can be mergeable parents. The encoded payload records the nearest non-mergeable map ancestor ($root-name or @peer:counter) once, then appends escaped map keys separated by >. This keeps nested mergeable map names linear in path length instead of recursively embedding the full parent cid.

pub fn is_mergeable(&self) -> bool

Returns true if this is a valid mergeable container ID (i.e. created via new_mergeable).

A Root whose name merely starts with the reserved mergeable prefix but does not decode to a valid path payload is an ordinary root, not a mergeable container. The check is structural; a fabricated "🤝:not-valid" Root is not treated as mergeable.

Constant-time short-circuit when the name doesn’t start with the mergeable prefix (most container ids). For names that do match the prefix, validates segment escaping and the compact base-parent encoding.

pub fn parse_mergeable(&self) -> Option<(ContainerID, String, ContainerType)>

Decode a mergeable container ID back into its (parent, key, container_type) components.

Returns None if this is not a valid mergeable container ID. The returned container_type is the type carried on the Root itself; the encoded payload only carries (parent, key).

impl ContainerID

pub fn is_root(&self) -> bool

Returns true if this is a ContainerID::Root, otherwise false

pub fn as_root_mut( &mut self, ) -> Option<(&mut InternalString, &mut ContainerType)>

Optionally returns mutable references to the inner fields if this is a ContainerID::Root, otherwise None

pub fn as_root(&self) -> Option<(&InternalString, &ContainerType)>

Optionally returns references to the inner fields if this is a ContainerID::Root, otherwise None

pub fn into_root(self) -> Result<(InternalString, ContainerType), Self>

Returns the inner fields if this is a ContainerID::Root, otherwise returns back the enum in the Err case of the result

pub fn is_normal(&self) -> bool

Returns true if this is a ContainerID::Normal, otherwise false

pub fn as_normal_mut( &mut self, ) -> Option<(&mut PeerID, &mut Counter, &mut ContainerType)>

Optionally returns mutable references to the inner fields if this is a ContainerID::Normal, otherwise None

pub fn as_normal(&self) -> Option<(&PeerID, &Counter, &ContainerType)>

Optionally returns references to the inner fields if this is a ContainerID::Normal, otherwise None

pub fn into_normal(self) -> Result<(PeerID, Counter, ContainerType), Self>

Returns the inner fields if this is a ContainerID::Normal, otherwise returns back the enum in the Err case of the result

impl ContainerID

pub fn encode<W: Write>(&self, writer: &mut W) -> Result<(), Error>

pub fn to_bytes(&self) -> Vec<u8>

pub fn from_bytes(bytes: &[u8]) -> Self

pub fn try_from_bytes(bytes: &[u8]) -> LoroResult<Self>

pub fn to_loro_value_string(&self) -> String

pub fn try_from_loro_value_string(s: &str) -> Option<Self>

Trait Implementations

impl Clone for ContainerID

fn clone(&self) -> ContainerID

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ContainerID

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ContainerID

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for ContainerID

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

Formats the value using the given formatter.

impl Eq for ContainerID

impl From<ContainerID> for LoroValue

fn from(v: ContainerID) -> Self

Converts to this type from the input type.

impl Hash for ContainerID

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for ContainerID

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for ContainerID

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 ContainerID

impl TryFrom<&str> for ContainerID

type Error = ()

The type returned in the event of a conversion error.

fn try_from(s: &str) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<LoroValue> for ContainerID

type Error = &'static str

The type returned in the event of a conversion error.

fn try_from(value: LoroValue) -> Result<Self, Self::Error>

Performs the conversion.