Struct activitystreams::base::AnyBase

pub struct AnyBase(_);

A type that can represent Any ActivityStreams type

A type in activitystreams can be four things

• An Object
• A Link
• The ID of that Link or Object
• A string representing that Link or Object

Implementations

impl AnyBase

pub fn from_extended<T, Kind>(extended: T) -> Result<Self, T::Error> where
    T: Extends<Kind>,
    T::Error: From<Error>,
    Kind: Serialize, 

Convert any type that is extended from Base<Kind> into an AnyBase for storing

let any_base = AnyBase::from_extended(video)?;

pub fn is_xsd_any_uri(&self) -> bool

Check if this object is a Url

let any_base = AnyBase::from_xsd_any_uri(uri!("https://example.com"));
assert!(any_base.is_xsd_any_uri());

pub fn is_xsd_string(&self) -> bool

Check if this object is a String

let any_base = AnyBase::from_xsd_string("Profile".into());
assert!(any_base.is_xsd_string());

pub fn is_base(&self) -> bool

Check if this object is a Base<serde_json::Value>

let any_base = AnyBase::from_extended(video)?;
assert!(any_base.is_base());

pub fn id(&self) -> Option<&Url>

Get the id from the current object

This method checks if the current object is an ID, and then falls back on the id field within the Base<serde_json::Value> if that exists

Get the ID from the nested video

let id = uri!("https://example.com");

video.set_id(id.clone());

let any_base = AnyBase::from_extended(video)?;
assert!(any_base.id().unwrap() == &id);

Get the ID from the AnyBase

let id = uri!("https://example.com");

let any_base = AnyBase::from_xsd_any_uri(id.clone());
assert!(any_base.id().unwrap() == &id);

pub fn is_id(&self, id: &Url) -> bool

Check if the current object's id matches the provided id

video.set_id(uri!("https://example.com"));

let any_base = AnyBase::from_extended(video)?;

assert!(any_base.is_id(&uri!("https://example.com")));

pub fn kind(&self) -> Option<&Value>

Get the kind from the current object

This method only produces a value if the current object is a Base<serde_json::Value>

video.set_kind(VideoType::Video);

let any_base = AnyBase::from_extended(video)?;

match any_base.kind().and_then(|k| k.as_str()) {
    Some("Video") => println!("yay!"),
    _ => return Err(anyhow::Error::msg("invalid type found")),
}

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

Get the kind from the current object as an &str

This method only produces a value if the current object is a Base<serde_json::Value>, and the kind is present, and a string

video.set_kind(VideoType::Video);

let any_base = AnyBase::from_extended(video)?;

match any_base.kind_str() {
    Some("Video") => println!("yay!"),
    _ => return Err(anyhow::Error::msg("invalid type found")),
}

pub fn is_kind(&self, kind: &str) -> bool

Check if the current object's kind matches the provided kind

video.set_kind(VideoType::Video);

let any_base = AnyBase::from_extended(video)?;

assert!(any_base.is_kind("Video"));

pub fn as_xsd_any_uri(&self) -> Option<&Url>

Get the object as a Url

let any_base = AnyBase::from_xsd_any_uri(uri!("https://example.com"));

assert!(any_base.as_xsd_any_uri().is_some());

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

Get the object as an &str

let any_base = AnyBase::from_xsd_string("hi".into());

assert!(any_base.as_xsd_string().is_some());

pub fn as_base(&self) -> Option<&Base<Value>>

Get the object as a Base<serde_json::Value>

let any_base = AnyBase::from_extended(video)?;

assert!(any_base.as_base().is_some());

pub fn take_xsd_any_uri(self) -> Option<Url>

Take the Url from the Object

let any_base = AnyBase::from_xsd_any_uri(uri!("https://example.com"));

assert!(any_base.take_xsd_any_uri().is_some());

pub fn take_xsd_string(self) -> Option<String>

Take the String from the Object

let any_base = AnyBase::from_xsd_string("hi".into());

assert!(any_base.take_xsd_string().is_some());

pub fn take_base(self) -> Option<Base<Value>>

Take the Base<serde_json::Value> from the Object

let any_base = AnyBase::from_extended(video)?;

assert!(any_base.take_base().is_some());

pub fn set_xsd_any_uri(&mut self, id: Url)

Replace the object with the provided Url

let mut any_base = AnyBase::from_xsd_string("hi".into());

any_base.set_xsd_any_uri(uri!("https://example.com"));

assert!(any_base.take_xsd_any_uri().is_some());

pub fn set_xsd_string<T>(&mut self, xsd_string: T) where
    T: Into<String>, 

Replace the object with the provided String

let mut any_base = AnyBase::from_xsd_any_uri(uri!("https://example.com"));

any_base.set_xsd_string("hi");

assert!(any_base.take_xsd_string().is_some());

pub fn set_base(&mut self, base: Base<Value>)

Replace the object with the provided Base<serde_json::Value>

let mut any_base = AnyBase::from_xsd_string("hi".into());

let base = Base::retract(video)?.into_generic()?;
any_base.set_base(base);

assert!(any_base.take_base().is_some());

pub fn from_xsd_any_uri(id: Url) -> Self

Create an AnyBase from a Url

use activitystreams::{base::AnyBase, uri};
let any_base = AnyBase::from_xsd_any_uri(uri!("https://example.com"));

pub fn from_xsd_string(xsd_string: String) -> Self

Create an AnyBase from an String

use activitystreams::base::AnyBase;
let any_base = AnyBase::from_xsd_string("hi".into());

pub fn from_base(base: Base<Value>) -> Self

Create an AnyBase from a Base<serde_json::Value>

use activitystreams::base::{AnyBase, Base};

let base = Base::retract(video)?.into_generic()?;
let any_base = AnyBase::from_base(base);

Trait Implementations

impl Clone for AnyBase

fn clone(&self) -> AnyBase

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for AnyBase

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for AnyBase

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

Deserialize this value from the given Serde deserializer.

impl From<Base<Value>> for AnyBase

fn from(o: Base<Value>) -> Self

Performs the conversion.

impl From<String> for AnyBase

fn from(xsd_string: String) -> Self

Performs the conversion.

impl From<Url> for AnyBase

fn from(id: Url) -> Self

Performs the conversion.

impl Serialize for AnyBase

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

Serialize this value into the given Serde serializer.