Enum ContainerID

pub enum ContainerID {
    Root {
        name: InternalString,
        container_type: ContainerType,
    },
    Normal {
        peer: u64,
        counter: i32,
        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: u64

counter: i32

container_type: ContainerType

Implementations

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), ContainerID>

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 u64, &mut i32, &mut ContainerType)>

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

pub fn as_normal(&self) -> Option<(&u64, &i32, &ContainerType)>

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

pub fn into_normal(self) -> Result<(u64, i32, ContainerType), ContainerID>

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>(&self, writer: &mut W) -> Result<(), Error>

where W: Write,

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

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

pub fn to_loro_value_string(&self) -> String

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

impl ContainerID

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

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

pub fn name(&self) -> &InternalString

pub fn container_type(&self) -> ContainerType

pub fn is_unknown(&self) -> bool

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<(), Error>

Formats the value using the given formatter.

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

fn deserialize<__D>( __deserializer: __D, ) -> Result<ContainerID, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for ContainerID

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

Formats the value using the given formatter.

impl From<ContainerID> for LoroValue

fn from(v: ContainerID) -> LoroValue

Converts to this type from the input type.

impl Hash for ContainerID

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

where __H: Hasher,

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 IntoContainerId for &ContainerID

fn into_container_id( self, _arena: &SharedArena, _kind: ContainerType, ) -> ContainerID

impl IntoContainerId for ContainerID

fn into_container_id( self, _arena: &SharedArena, _kind: ContainerType, ) -> ContainerID

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 as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl TryFrom<&str> for ContainerID

type Error = ()

The type returned in the event of a conversion error.

fn try_from( s: &str, ) -> Result<ContainerID, <ContainerID as TryFrom<&str>>::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<ContainerID, <ContainerID as TryFrom<LoroValue>>::Error>

Performs the conversion.

impl Eq for ContainerID

impl StructuralPartialEq for ContainerID