Struct EndpointId 

pub struct EndpointId {
    pub namespace: String,
    pub component: String,
    pub name: String,
}

Represents an endpoint with a namespace, component, and name.

An EndpointId is defined by a three-part string separated by / or a ‘.’:

• namespace
• component
• name

Example format: "namespace/component/endpoint"

Fields

namespace: String

component: String

name: String

Implementations

impl EndpointId

pub fn as_url(&self) -> String

As a String like dyn://dynamo.internal.worker

Trait Implementations

impl Clone for EndpointId

fn clone(&self) -> EndpointId

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for EndpointId

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

Formats the value using the given formatter.

impl Default for EndpointId

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for EndpointId

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<&str> for EndpointId

fn from(s: &str) -> Self

Creates an EndpointId from a string.

Arguments

• path: A string in the format "namespace/component/endpoint".

The first two parts become the first two elements of the vector. The third and subsequent parts are joined with ‘_’ and become the third element. Default values are used for missing parts.

Examples:

• “component” -> [“DEFAULT_NAMESPACE”, “component”, “DEFAULT_ENDPOINT”]
• “namespace.component” -> [“namespace”, “component”, “DEFAULT_ENDPOINT”]
• “namespace.component.endpoint” -> [“namespace”, “component”, “endpoint”]
• “namespace/component” -> [“namespace”, “component”, “DEFAULT_ENDPOINT”]
• “namespace.component.endpoint.other.parts” -> [“namespace”, “component”, “endpoint_other_parts”]

Examples

use dynamo_runtime::protocols::EndpointId;

let endpoint = EndpointId::from("namespace/component/endpoint");
assert_eq!(endpoint.namespace, "namespace");
assert_eq!(endpoint.component, "component");
assert_eq!(endpoint.name, "endpoint");

impl FromStr for EndpointId

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses an EndpointId from a string using the standard Rust .parse::<T>() pattern.

This is implemented in terms of From<&str>.

Errors

Does not fail

Examples

use std::str::FromStr;
use dynamo_runtime::protocols::EndpointId;

let endpoint: EndpointId = "namespace/component/endpoint".parse().unwrap();
assert_eq!(endpoint.namespace, "namespace");
assert_eq!(endpoint.component, "component");
assert_eq!(endpoint.name, "endpoint");
let endpoint: EndpointId = "dyn://namespace/component/endpoint".parse().unwrap();
// same as above
assert_eq!(endpoint.name, "endpoint");

type Err = Infallible

The associated error which can be returned from parsing.

impl PartialEq<[&str; 3]> for EndpointId

fn eq(&self, other: &[&str; 3]) -> 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<EndpointId> for [&str; 3]

fn eq(&self, other: &EndpointId) -> 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<EndpointId> for Vec<&str>

fn eq(&self, other: &EndpointId) -> 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<Vec<&str>> for EndpointId

fn eq(&self, other: &Vec<&str>) -> 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 EndpointId

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

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for EndpointId

impl StructuralPartialEq for EndpointId