Struct spotify_client::prelude::TrackId

pub struct TrackId<'a>(/* private fields */);

ID of type Type::Track. The validity of its characters is defined by the closure |id| id.chars().all(|ch| ch.is_ascii_alphanumeric()).

Refer to the module-level docs for more information.

Implementations

impl<'a> TrackId<'a>

pub fn id_is_valid(id: &str) -> bool

Only returns true in case the given string is valid according to that specific ID (e.g., some may require alphanumeric characters only).

pub unsafe fn from_id_unchecked<S>(id: S) -> TrackId<'a>

where S: Into<Cow<'a, str>>,

Initialize the ID without checking its validity.

Safety

The string passed to this method must be made out of valid characters only; otherwise undefined behaviour may occur.

pub fn from_id<S>(id: S) -> Result<TrackId<'a>, IdError>

where S: Into<Cow<'a, str>>,

Parse Spotify ID from string slice.

A valid Spotify object id must be a non-empty string with valid characters.

Errors

• IdError::InvalidId - if id contains invalid characters.

pub fn from_uri(uri: &'a str) -> Result<TrackId<'a>, IdError>

Parse Spotify URI from string slice

Spotify URI must be in one of the following formats: spotify:{type}:{id} or spotify/{type}/{id}. Where {type} is one of artist, album, track, playlist, user, show, or episode, and {id} is a non-empty valid string.

Examples: spotify:album:6IcGNaXFRf5Y1jc7QsE9O2, spotify/track/4y4VO05kYgUTo2bzbox1an.

Errors

• IdError::InvalidPrefix - if uri is not started with spotify: or spotify/,
• IdError::InvalidType - if type part of an uri is not a valid Spotify type T,
• IdError::InvalidId - if id part of an uri is not a valid id,
• IdError::InvalidFormat - if it can’t be splitted into type and id parts.

Implementation details

Unlike Self::from_id, this method takes a &str rather than an Into<Cow<str>>. This is because the inner Cow in the ID would reference a slice from the given &str (i.e., taking the ID out of the URI). The parameter wouldn’t live long enough when using Into<Cow<str>>, so the only sensible choice is to just use a &str.

pub fn from_id_or_uri(id_or_uri: &'a str) -> Result<TrackId<'a>, IdError>

Parse Spotify ID or URI from string slice

Spotify URI must be in one of the following formats: spotify:{type}:{id} or spotify/{type}/{id}. Where {type} is one of artist, album, track, playlist, user, show, or episode, and {id} is a non-empty valid string. The URI must be match with the ID’s type (Id::TYPE), otherwise IdError::InvalidType error is returned.

Examples: spotify:album:6IcGNaXFRf5Y1jc7QsE9O2, spotify/track/4y4VO05kYgUTo2bzbox1an.

If input string is not a valid Spotify URI (it’s not started with spotify: or spotify/), it must be a valid Spotify object ID, i.e. a non-empty valid string.

Errors

• IdError::InvalidType - if id_or_uri is an URI, and it’s type part is not equal to T,
• IdError::InvalidId - either if id_or_uri is an URI with invalid id part, or it’s an invalid id (id is invalid if it contains valid characters),
• IdError::InvalidFormat - if id_or_uri is an URI, and it can’t be split into type and id parts.

Implementation details

Unlike Self::from_id, this method takes a &str rather than an Into<Cow<str>>. This is because the inner Cow in the ID would reference a slice from the given &str (i.e., taking the ID out of the URI). The parameter wouldn’t live long enough when using Into<Cow<str>>, so the only sensible choice is to just use a &str.

pub fn as_ref(&'a self) -> TrackId<'a>

This creates an ID with the underlying &str variant from a reference. Useful to use an ID multiple times without having to clone it.

pub fn into_static(self) -> TrackId<'static>

An ID is a Cow after all, so this will switch to the its owned version, which has a 'static lifetime.

pub fn clone_static(&self) -> TrackId<'static>

Similar to Self::into_static, but without consuming the original ID.

Trait Implementations

impl Borrow<str> for TrackId<'_>

Ids may be borrowed as str the same way Box<T> may be borrowed as T or String as str

fn borrow(&self) -> &str

Immutably borrows from an owned value.

impl<'a> Clone for TrackId<'a>

fn clone(&self) -> TrackId<'a>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for TrackId<'a>

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for TrackId<'static>

fn deserialize<D>( deserializer: D ) -> Result<TrackId<'static>, <D as Deserializer<'de>>::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for TrackId<'_>

Displaying the ID shows its URI

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

Formats the value using the given formatter.

impl<'a> From<TrackId<'a>> for PlayableId<'a>

fn from(v: TrackId<'a>) -> PlayableId<'a>

Converts to this type from the input type.

impl<'a> Hash for TrackId<'a>

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 Id for TrackId<'_>

fn id(&self) -> &str

Returns the inner Spotify object ID, which is guaranteed to be valid for its type.

fn _type(&self) -> Type

The type of the ID, as a function.

fn uri(&self) -> String

Returns a Spotify object URI in a well-known format: spotify:type:id.

fn url(&self) -> String

Returns a full Spotify object URL that can be opened in a browser.

impl<'a> PartialEq for TrackId<'a>

fn eq(&self, other: &TrackId<'a>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<'a> Serialize for TrackId<'a>

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<'a> TryInto<TrackId<'a>> for PlayableId<'a>

type Error = &'static str

The type returned in the event of a conversion error.

fn try_into( self ) -> Result<TrackId<'a>, <PlayableId<'a> as TryInto<TrackId<'a>>>::Error>

Performs the conversion.

impl<'a> Eq for TrackId<'a>

impl<'a> StructuralPartialEq for TrackId<'a>