Struct ScopedName 

#[repr(C)]
pub struct ScopedName<Name = String> {
    pub scope: Name,
    pub name: Name,
}

Name in the format <owner>/<drop>.

Fields

scope: Name

The namespace of the drop.

name: Name

The drop’s given name.

Implementations

impl<N> ScopedName<N>

pub fn new<A, B>(scope: A, name: B) -> Self

where A: Into<N>, B: Into<N>,

Creates a new instance from scope and name.

pub fn parse<A, NE>(name: A) -> Result<Self, ParseError<NE>>

where A: TryInto<Self, Error = ParseError<NE>>,

Attempts to create a new instance by parsing name.

pub fn cast<A>(self) -> ScopedName<A>

where N: Into<A>,

Converts self into a new ScopedName by performing an Into conversion over all fields.

pub fn try_cast<A>(self) -> Result<ScopedName<A>, ParseError<N::Error>>

where N: TryInto<A>,

Converts self into a new Query by performing an Into conversion over all fields.

pub fn as_ref(&self) -> ScopedName<&N>

Takes shared references to the fields of this name.

pub fn to_ref<A>(&self) -> ScopedName<&A>

where N: AsRef<A>, A: ?Sized,

Takes a shared reference to the fields of this name as type A.

pub fn as_mut(&mut self) -> ScopedName<&mut N>

Takes mutable references to the fields of this name.

pub fn to_mut<A>(&mut self) -> ScopedName<&mut A>

where N: AsMut<A>, A: ?Sized,

Takes a mutable references to the fields of this name as type A.

pub fn map<A, F>(self, f: F) -> ScopedName<A>

where F: FnMut(N) -> A,

Creates a new ScopedName by mapping the function over the fields of self.

pub fn into_query(self) -> Query<N>

Converts self into a Query.

pub fn into_query_with<V>(self, version: V) -> Query<N, V>

Converts self into a Query with the specified version.

pub fn as_names_array(&self) -> &[N; 2]

Converts self into an array of names.

pub fn as_names_slice(&self) -> &[N]

Converts self into a slice of names.

impl<'n, N: ?Sized> ScopedName<&'n N>

pub fn cloned(&self) -> ScopedName<N>

where N: Clone,

Returns the result of calling Clone::clone on the fields of self.

pub fn to_owned(&self) -> ScopedName<N::Owned>

where N: ToOwned,

Returns the result of calling ToOwned::to_owned on the fields of self.

Examples

use oceanpkg::drop::name::ScopedName;

let name:  ScopedName<&str>   = ScopedName::new("core", "wget");
let owned: ScopedName<String> = name.to_owned();

assert_eq!(name, owned);

impl<'n> ScopedName<&'n Name>

pub const fn core(name: &'n Name) -> Self

Creates a new instance in the core namespace.

pub const fn ocean(name: &'n Name) -> Self

Creates a new instance in the ocean namespace.

pub fn from_pair<S, N>( scope: &'n S, name: &'n N, ) -> Result<Self, ParseError<ValidateError>>

where S: ?Sized + AsRef<[u8]>, N: ?Sized + AsRef<[u8]>,

Creates a new instance by verifying scope and name.

pub unsafe fn from_pair_unchecked<S, N>(scope: &'n S, name: &'n N) -> Self

where S: ?Sized + AsRef<[u8]>, N: ?Sized + AsRef<[u8]>,

Creates a new instance without attempting to verify scope or name.

Trait Implementations

impl<Name: Clone> Clone for ScopedName<Name>

fn clone(&self) -> ScopedName<Name>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<Name: Debug> Debug for ScopedName<Name>

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ScopedName

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<N: Display> Display for ScopedName<N>

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

Formats the value using the given formatter.

impl<A, B: Into<A>> From<[B; 2]> for ScopedName<A>

fn from([scope, name]: [B; 2]) -> Self

Converts to this type from the input type.

impl<N, A, B> From<(A, B)> for ScopedName<N>

where A: Into<N>, B: Into<N>,

fn from((scope, name): (A, B)) -> Self

Converts to this type from the input type.

impl<N, V> From<ScopedName<N>> for Query<N, V>

fn from(n: ScopedName<N>) -> Self

Converts to this type from the input type.

impl<Name: Hash> Hash for ScopedName<Name>

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<Name: Ord> Ord for ScopedName<Name>

fn cmp(&self, other: &ScopedName<Name>) -> 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<A: AsRef<str>> PartialEq<&str> for ScopedName<A>

fn eq(&self, s: &&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<A: AsRef<str>> PartialEq<ScopedName<A>> for &str

fn eq(&self, n: &ScopedName<A>) -> 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<A: AsRef<str>> PartialEq<ScopedName<A>> for str

fn eq(&self, n: &ScopedName<A>) -> 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<A, B> PartialEq<ScopedName<B>> for ScopedName<A>

where A: PartialEq<B>,

fn eq(&self, other: &ScopedName<B>) -> 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<A: AsRef<str>> PartialEq<str> for ScopedName<A>

fn eq(&self, s: &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<Name: PartialOrd> PartialOrd for ScopedName<Name>

fn partial_cmp(&self, other: &ScopedName<Name>) -> 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<N> Serialize for ScopedName<N>

where ScopedName<N>: Display,

fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error>

Serialize this value into the given Serde serializer.

impl<'a, N> TryFrom<&'a str> for ScopedName<N>

where &'a str: TryInto<N>,

type Error = ParseError<<&'a str as TryInto<N>>::Error>

The type returned in the event of a conversion error.

fn try_from(name: &'a str) -> Result<Self, Self::Error>

Performs the conversion.

impl<Name: Copy> Copy for ScopedName<Name>

impl<Name: Eq> Eq for ScopedName<Name>