Struct NodeId

pub struct NodeId(/* private fields */);

A unique string identifying a server for all time. The maximum length of an id is 512 bytes.

Implementations

impl NodeId

pub const MAX_SIZE: usize = 512usize

The maximum length of an id is 512 bytes.

pub fn new<T>(src: T) -> Result<NodeId, NodeIdTransformError>

where T: AsRef<str>,

Creates a new Id from the source.

pub fn as_str(&self) -> &str

converts the Id into a &str.

pub fn as_bytes(&self) -> &[u8]

Returns a byte slice. To convert the byte slice back into a string slice, use the core::str::from_utf8 function.

Trait Implementations

impl Archive for NodeId

where SmolStr: Archive,

const COPY_OPTIMIZATION: CopyOptimization<NodeId>

An optimization flag that allows the bytes of this type to be copied directly to a writer instead of calling serialize.

type Archived = ArchivedNodeId

The archived representation of this type.

type Resolver = NodeIdResolver

The resolver for this type. It must contain all the additional information from serializing needed to make the archived type from the normal type.

fn resolve( &self, resolver: <NodeId as Archive>::Resolver, out: Place<<NodeId as Archive>::Archived>, )

Creates the archived version of this value at the given position and writes it to the given output.

impl AsRef<str> for NodeId

fn as_ref(&self) -> &str

Converts this type into a shared reference of the (usually inferred) input type.

impl Borrow<str> for NodeId

fn borrow(&self) -> &str

Immutably borrows from an owned value.

impl CheapClone for NodeId

fn cheap_clone(&self) -> Self

Returns a copy of the value.

impl Clone for NodeId

fn clone(&self) -> NodeId

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for NodeId

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for NodeId

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<__D> Deserialize<NodeId, __D> for <NodeId as Archive>::Archived

where __D: Fallible + ?Sized, SmolStr: Archive, <SmolStr as Archive>::Archived: Deserialize<SmolStr, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<NodeId, <__D as Fallible>::Error>

Deserializes using the given deserializer

impl Display for NodeId

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

Formats the value using the given formatter.

impl FromStr for NodeId

type Err = NodeIdTransformError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<NodeId, <NodeId as FromStr>::Err>

Parses a string s to return a value of this type.

impl Hash for NodeId

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 Ord for NodeId

fn cmp(&self, other: &NodeId) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq<ArchivedNodeId> for NodeId

where SmolStr: Archive, <SmolStr as Archive>::Archived: PartialEq<SmolStr>,

fn eq(&self, other: &ArchivedNodeId) -> 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 PartialEq for NodeId

fn eq(&self, other: &NodeId) -> 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 PartialOrd for NodeId

fn partial_cmp(&self, other: &NodeId) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<__S> Serialize<__S> for NodeId

where __S: Fallible + ?Sized, SmolStr: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<NodeId as Archive>::Resolver, <__S as Fallible>::Error>

Writes the dependencies for the object and returns a resolver that can create the archived type.

impl Serialize for NodeId

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 Transformable for NodeId

fn encode_to_writer<W>(&self, writer: &mut W) -> Result<usize, Error>

where W: Write,

Encodes the value into the given writer.

Note

The implementation of this method is not optimized, which means if your writer is expensive (e.g. TcpStream, File), it is better to use a BufWriter to wrap your orginal writer to cut down the number of I/O times.

async fn encode_to_async_writer<W>( &self, writer: &mut W, ) -> Result<usize, Error>

where W: AsyncWrite + Send + Unpin, <NodeId as Transformable>::Error: Send + Sync + 'static,

Encodes the value into the given async writer.

Note

The implementation of this method is not optimized, which means if your writer is expensive (e.g. TcpStream, File), it is better to use a BufWriter to wrap your orginal writer to cut down the number of I/O times.

fn decode_from_reader<R>(reader: &mut R) -> Result<(usize, NodeId), Error>

where R: Read, NodeId: Sized,

Decodes the value from the given reader.

Note

The implementation of this method is not optimized, which means if your reader is expensive (e.g. TcpStream, File), it is better to use a BufReader to wrap your orginal reader to cut down the number of I/O times.

async fn decode_from_async_reader<R>( reader: &mut R, ) -> Result<(usize, NodeId), Error>

where R: AsyncRead + Send + Unpin, NodeId: Sized, <NodeId as Transformable>::Error: Send + Sync + 'static,

Decodes the value from the given async reader.

Note

The implementation of this method is not optimized, which means if your reader is expensive (e.g. TcpStream, File), it is better to use a BufReader to wrap your orginal reader to cut down the number of I/O times.

type Error = NodeIdTransformError

The error type returned when encoding or decoding fails.

fn encode( &self, dst: &mut [u8], ) -> Result<usize, <NodeId as Transformable>::Error>

Encodes the value into the given buffer for transmission.

fn encoded_len(&self) -> usize

Returns the encoded length of the value. This is used to pre-allocate a buffer for encoding.

fn decode( src: &[u8], ) -> Result<(usize, NodeId), <NodeId as Transformable>::Error>

where NodeId: Sized,

Decodes the value from the given buffer received over the wire.

fn encode_to_vec(&self) -> Result<Vec<u8>, Self::Error>

Encodes the value into a vec for transmission.

impl TryFrom<&[u8]> for NodeId

type Error = NodeIdTransformError

The type returned in the event of a conversion error.

fn try_from(value: &[u8]) -> Result<NodeId, <NodeId as TryFrom<&[u8]>>::Error>

Performs the conversion.

impl TryFrom<String> for NodeId

type Error = NodeIdTransformError

The type returned in the event of a conversion error.

fn try_from(s: String) -> Result<NodeId, <NodeId as TryFrom<String>>::Error>

Performs the conversion.

impl TryFrom<Vec<u8>> for NodeId

type Error = NodeIdTransformError

The type returned in the event of a conversion error.

fn try_from( value: Vec<u8>, ) -> Result<NodeId, <NodeId as TryFrom<Vec<u8>>>::Error>

Performs the conversion.

impl Eq for NodeId

impl Id for NodeId

impl StructuralPartialEq for NodeId