Struct Tag

pub struct Tag { /* private fields */ }

Tag

Implementations

impl Tag

pub fn parse<I, S>(tag: I) -> Result<Self, Error>

where I: IntoIterator<Item = S>, S: Into<String>,

Parse tag

Return error if the tag is empty!

pub fn from_standardized(standardized: TagStandard) -> Self

Construct from standardized tag

pub fn from_standardized_without_cell(standardized: TagStandard) -> Self

Construct from standardized tag without initialize cell (avoid a clone)

pub fn kind(&self) -> TagKind<'_>

Get tag kind

pub fn content(&self) -> Option<&str>

Return the first tag value (index 1), if exists.

pub fn single_letter_tag(&self) -> Option<SingleLetterTag>

Get SingleLetterTag

pub fn as_standardized(&self) -> Option<&TagStandard>

Get reference of standardized tag

pub fn to_standardized(self) -> Option<TagStandard>

Consume tag and get standardized tag

pub fn len(&self) -> usize

Get tag len

pub fn push<S>(&mut self, value: S)

where S: Into<String>,

Appends a value to the back of the Tag.

Check Vec::push doc to learn more.

This erases the TagStandard cell, if any.

pub fn pop(&mut self) -> Option<String>

Removes the last value and returns it. If the Tag has only one value, returns None, since it can’t be empty.

Check Vec::pop doc to learn more.

This erases the TagStandard cell, if any.

pub fn insert<S>(&mut self, index: usize, value: S) -> bool

where S: Into<String>,

Inserts a value at position index within the vector, shifting all other values after it to the right.

The value at index 0 and 1 can’t be empty. If an empty string is passed for those indexes, false is returned.

Returns true if the value has been inserted or updated successfully. Returns false if index > len.

Check Vec::insert doc to learn more.

This erases the TagStandard cell, if any.

pub fn extend<I, S>(&mut self, iter: I)

where I: IntoIterator<Item = S>, S: Into<String>,

Extends the collection.

Check Vec::extend doc to learn more.

This erases the TagStandard cell, if any.

pub fn as_slice(&self) -> &[String]

Get as slice of strings

pub fn to_vec(self) -> Vec<String>

Consume tag and return array of strings

pub fn event(event_id: EventId) -> Self

Compose ["e", "<event-id">]

https://github.com/nostr-protocol/nips/blob/master/01.md

pub fn public_key(public_key: PublicKey) -> Self

Compose ["p", "<public-key>"] tag

https://github.com/nostr-protocol/nips/blob/master/01.md

pub fn identifier<T>(identifier: T) -> Self

where T: Into<String>,

Compose ["d", "<identifier>"] tag

https://github.com/nostr-protocol/nips/blob/master/01.md

pub fn coordinate(coordinate: Coordinate, relay_url: Option<RelayUrl>) -> Self

Compose ["a", "<coordinate>", "<optional-relay-url>"] tag

https://github.com/nostr-protocol/nips/blob/master/01.md

pub fn pow(nonce: u128, difficulty: u8) -> Self

Compose ["nonce", "<nonce>", "<difficulty>"] tag

https://github.com/nostr-protocol/nips/blob/master/13.md

pub fn client<S>(name: S) -> Self

where S: Into<String>,

Construct ["client", "<name>"] tag

https://github.com/nostr-protocol/nips/blob/master/89.md

pub fn expiration(timestamp: Timestamp) -> Self

Compose ["expiration", "<timestamp>"] tag

https://github.com/nostr-protocol/nips/blob/master/40.md

pub fn event_report(event_id: EventId, report: Report) -> Self

Compose ["e", "<event-id>", "<report>"] tag

https://github.com/nostr-protocol/nips/blob/master/56.md

pub fn public_key_report(public_key: PublicKey, report: Report) -> Self

Compose ["p", "<public-key>", "<report>"] tag

https://github.com/nostr-protocol/nips/blob/master/56.md

pub fn relay_metadata( relay_url: RelayUrl, metadata: Option<RelayMetadata>, ) -> Self

Compose ["r", "<relay-url>", "<metadata>"] tag

https://github.com/nostr-protocol/nips/blob/master/65.md

pub fn relay(url: RelayUrl) -> Self

Relay url

JSON: ["relay", "<relay-url>"]

pub fn relays<I>(urls: I) -> Self

where I: IntoIterator<Item = RelayUrl>,

Relay URLs

JSON: ["relays", "<relay-url>", "<relay-url>"]

pub fn all_relays() -> Self

All relays

JSON: ["relay", "ALL_RELAYS"]

https://github.com/nostr-protocol/nips/blob/master/62.md

pub fn hashtag<T>(hashtag: T) -> Self

where T: AsRef<str>,

Compose ["t", "<hashtag>"] tag

This will convert the hashtag to lowercase.

pub fn reference<T>(reference: T) -> Self

where T: Into<String>,

Compose ["r", "<value>"] tag

pub fn title<T>(title: T) -> Self

where T: Into<String>,

Compose ["title", "<title>"] tag

pub fn image(url: Url, dimensions: Option<ImageDimensions>) -> Self

Compose image tag

pub fn description<T>(description: T) -> Self

where T: Into<String>,

Compose ["description", "<description>"] tag

pub fn protected() -> Self

Protected event

https://github.com/nostr-protocol/nips/blob/master/70.md

pub fn alt<T>(summary: T) -> Self

where T: Into<String>,

A short human-readable plaintext summary of what that event is about

JSON: ["alt", "<summary>"]

https://github.com/nostr-protocol/nips/blob/master/31.md

pub fn custom<I, S>(kind: TagKind<'_>, values: I) -> Self

where I: IntoIterator<Item = S>, S: Into<String>,

Compose custom tag

JSON: ["<kind>", "<value-1>", "<value-2>", ...]

pub fn is_root(&self) -> bool

Check if is a standard event tag with root marker

pub fn is_reply(&self) -> bool

Check if is a standard event tag with reply marker

pub fn is_protected(&self) -> bool

Check if it’s a protected event tag

https://github.com/nostr-protocol/nips/blob/master/70.md

Trait Implementations

impl Clone for Tag

fn clone(&self) -> Tag

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Tag

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Tag

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

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<Coordinate> for Tag

fn from(coordinate: Coordinate) -> Self

Converts to this type from the input type.

impl From<EventId> for Tag

fn from(event_id: EventId) -> Self

Converts to this type from the input type.

impl From<TagStandard> for Tag

fn from(standard: TagStandard) -> Self

Converts to this type from the input type.

impl FromIterator<Tag> for Tags

fn from_iter<T>(iter: T) -> Self

where T: IntoIterator<Item = Tag>,

Creates a value from an iterator.

impl Hash for Tag

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 IntoIterator for Tag

type Item = String

The type of the elements being iterated over.

type IntoIter = IntoIter<<Tag as IntoIterator>::Item>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl Ord for Tag

fn cmp(&self, other: &Self) -> 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 for Tag

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

fn partial_cmp(&self, other: &Self) -> 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 Serialize for Tag

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 Tag