//! Types and traits for dealing with Object attributes
//!
//! ```rust
//! # fn main() -> Result<(), anyhow::Error> {
//! use activitystreams::{
//! object::Image,
//! prelude::*,
//! iri,
//! };
//!
//! let mut image = Image::new();
//!
//! image
//! .set_url(iri!("https://example.com/image.png"))
//! .set_attributed_to(iri!("https://example.com/actor"))
//! .set_generator(iri!("https://example.com/image-generator"))
//! .set_icon(iri!("https://example.com/icon.png"));
//! #
//! # Ok(())
//! # }
//! ```
use crate::{
base::{AnyBase, AsBase, Base, Extends},
markers,
primitives::{AnyString, OneOrMany, Unit, XsdDateTime, XsdDuration},
unparsed::{Unparsed, UnparsedMut, UnparsedMutExt},
};
use iri_string::types::IriString;
use std::convert::TryFrom;
use time::{Duration, OffsetDateTime};
pub use activitystreams_kinds::object as kind;
use self::kind::*;
/// Implementation trait for deriving Object methods for a type
///
/// Any type implementing AsObject will automatically gain methods provided by ObjectExt
pub trait AsObject: markers::Object {
type Kind;
/// Immutable borrow of `Object<Kind>`
fn object_ref(&self) -> &Object<Self::Kind>;
/// Mutable borrow of `Object<Kind>`
fn object_mut(&mut self) -> &mut Object<Self::Kind>;
}
/// Implementation trait for deriving ActivityPub Object methods for a type
///
/// Any type implementing AsApObject will automatically gain methods provided by ApObjectExt
pub trait AsApObject: markers::Object {
type Inner;
/// Immutable borrow of `ApObject<Inner>`
fn ap_object_ref(&self) -> &ApObject<Self::Inner>;
/// Mutable borrow of `ApObject<Inner>`
fn ap_object_mut(&mut self) -> &mut ApObject<Self::Inner>;
}
/// Implementation trait for deriving Place methods for a type
///
/// Any type implementing AsPlace will automatically gain methods provided by PlaceExt
pub trait AsPlace: markers::Object {
/// Immutable borrow of `Place`
fn place_ref(&self) -> &Place;
/// Mutable borrow of `Place`
fn place_mut(&mut self) -> &mut Place;
}
/// Implementation trait for deriving Profile methods for a type
///
/// Any type implementing AsProfile will automatically gain methods provided by ProfileExt
pub trait AsProfile: markers::Object {
/// Immutable borrow of `Profile`
fn profile_ref(&self) -> &Profile;
/// Mutable borrow of `Profile`
fn profile_mut(&mut self) -> &mut Profile;
}
/// Implementation trait for deriving Relationship methods for a type
///
/// Any type implementing AsRelationship will automatically gain methods provided by
/// RelationshipExt
pub trait AsRelationship: markers::Object {
/// Immutable borrow of `Relationship`
fn relationship_ref(&self) -> &Relationship;
/// Mutable borrow of `Relationship`
fn relationship_mut(&mut self) -> &mut Relationship;
}
/// Implementation trait for deriving Tombstone methods for a type
///
/// Any type implementing AsTombstone will automatically gain methods provided by TombstoneExt
pub trait AsTombstone: markers::Object {
/// Immutable borrow of `Tombstone`
fn tombstone_ref(&self) -> &Tombstone;
/// Mutable borrow of `Tombstone`
fn tombstone_mut(&mut self) -> &mut Tombstone;
}
/// Helper methods for interacting with Object types
///
/// This trait represents methods valid for any ActivityStreams Object.
///
/// Documentation for the fields related to these methods can be found on the `Object` struct
pub trait ObjectExt: AsObject {
/// Fetch the attachment for the current object
///
/// ```rust
/// # use activitystreams::object::Video;
/// # let mut video = Video::new();
/// #
/// use activitystreams::prelude::*;
///
/// if let Some(attachment) = video.attachment() {
/// println!("{:?}", attachment);
/// }
/// ```
fn attachment<'a>(&'a self) -> Option<&'a OneOrMany<AnyBase>>
where
Self::Kind: 'a,
{
self.object_ref().attachment.as_ref()
}
/// Set the attachment for the current object
///
/// This overwrites the contents of attachment
///
/// ```rust
/// # fn main() -> Result<(), anyhow::Error> {
/// use activitystreams::prelude::*;
/// # use activitystreams::{object::Video, iri};
/// # let mut video = Video::new();
///
/// video.set_attachment(iri!("https://example.com"));
/// # Ok(())
/// # }
/// ```
fn set_attachment<T>(&mut self, attachment: T) -> &mut Self
where
T: Into<AnyBase>,
{
self.object_mut().attachment = Some(attachment.into().into());
self
}
/// Set many attachments for the current object
///
/// This overwrites the contents of attachment
///
/// ```rust
/// # fn main() -> Result<(), anyhow::Error> {
/// use activitystreams::prelude::*;
/// # use activitystreams::{object::Video, iri};
/// # let mut video = Video::new();
///
/// video.set_many_attachments(vec![
/// iri!("https://example.com/one"),
/// iri!("https://example.com/two"),
/// ]);
/// # Ok(())
/// # }
/// ```
fn set_many_attachments<I, T>(&mut self, items: I) -> &mut Self
where
I: IntoIterator<Item = T>,
T: Into<AnyBase>,
{
let v: Vec<_> = items.into_iter().map(Into::into).collect();
self.object_mut().attachment = Some(v.into());
self
}
/// Add a attachment to the current object
///
/// This does not overwrite the contents of attachment, only appends an item
///
/// ```rust
/// # fn main() -> Result<(), anyhow::Error> {
/// use activitystreams::prelude::*;
/// # use activitystreams::{object::Video, iri};
/// # let mut video = Video::new();
///
/// video
/// .add_attachment(iri!("https://example.com/one"))
/// .add_attachment(iri!("https://example.com/two"));
/// # Ok(())
/// # }
/// ```
fn add_attachment<T>(&mut self, attachment: T) -> &mut Self
where
T: Into<AnyBase>,
{
let a = match self.object_mut().attachment.take() {
Some(mut a) => {
a.add(attachment.into());
a
}
None => vec![attachment.into()].into(),
};
self.object_mut().attachment = Some(a);
self
}
/// Take the attachment from the current object, leaving nothing
///
/// ```rust
/// # use activitystreams::object::Video;
/// # let mut video = Video::new();
/// #
/// use activitystreams::prelude::*;
///
/// if let Some(attachment) = video.take_attachment() {
/// println!("{:?}", attachment);
/// }
/// ```
fn take_attachment(&mut self) -> Option<OneOrMany<AnyBase>> {
self.object_mut().attachment.take()
}
/// Delete the attachment from the current object
///
/// ```rust
/// # fn main() -> Result<(), anyhow::Error> {
/// # use activitystreams::{object::Video, iri};
/// # let mut video = Video::new();
/// # video.set_attachment(iri!("https://example.com"));
/// #
/// use activitystreams::prelude::*;
///
/// assert!(video.attachment().is_some());
/// video.delete_attachment();
/// assert!(video.attachment().is_none());
/// # Ok(())
/// # }
/// ```
fn delete_attachment(&mut self) -> &mut Self {
self.object_mut().attachment = None;
self
}
/// Fetch the attributed_to for the current object
///
/// ```rust
/// # use activitystreams::object::Video;
/// # let mut video = Video::new();
/// #
/// use activitystreams::prelude::*;
///
/// if let Some(attributed_to) = video.attributed_to() {
/// println!("{:?}", attributed_to);
/// }
/// ```
fn attributed_to<'a>(&'a self) -> Option<&'a OneOrMany<AnyBase>>
where
Self::Kind: 'a,
{
self.object_ref().attributed_to.as_ref()
}
/// Set the attributed_to for the current object
///
/// This overwrites the contents of attributed_to
///
/// ```rust
/// # fn main() -> Result<(), anyhow::Error> {
/// use activitystreams::prelude::*;
/// # use activitystreams::{object::Video, iri};
/// # let mut video = Video::new();
///
/// video.set_attributed_to(iri!("https://example.com"));
/// # Ok(())
/// # }
/// ```
fn set_attributed_to<T>(&mut self, attributed_to: T) -> &mut Self
where
T: Into<AnyBase>,
{
self.object_mut().attributed_to = Some(attributed_to.into().into());
self
}
/// Set many attributed_tos for the current object
///
/// This overwrites the contents of attributed_to
///
/// ```rust
/// # fn main() -> Result<(), anyhow::Error> {
/// use activitystreams::prelude::*;
/// # use activitystreams::{object::Video, iri};
/// # let mut video = Video::new();
///
/// video.set_many_attributed_tos(vec![
/// iri!("https://example.com/one"),
/// iri!("https://example.com/two"),
/// ]);
/// # Ok(())
/// # }
/// ```
fn set_many_attributed_tos<I, T>(&mut self, items: I) -> &mut Self
where
I: IntoIterator<Item = T>,
T: Into<AnyBase>,
{
let v: Vec<_> = items.into_iter().map(Into::into).collect();
self.object_mut().attributed_to = Some(v.into());
self
}
/// Add a attributed_to to the current object
///
/// This does not overwrite the contents of attributed_to, only appends an item
///
/// ```rust
/// # fn main() -> Result<(), anyhow::Error> {
/// use activitystreams::prelude::*;
/// # use activitystreams::{object::Video, iri};
/// # let mut video = Video::new();
///
/// video
/// .add_attributed_to(iri!("https://example.com/one"))
/// .add_attributed_to(iri!("https://example.com/two"));
/// # Ok(())
/// # }
/// ```
fn add_attributed_to<T>(&mut self, attributed_to: T) -> &mut Self
where
T: Into<AnyBase>,
{
let a = match self.object_mut().attributed_to.take() {
Some(mut a) => {
a.add(attributed_to.into());
a
}
None => vec![attributed_to.into()].into(),
};
self.object_mut().attributed_to = Some(a);
self
}
/// Take the attributed_to from the current object, leaving nothing
///
/// ```rust
/// # use activitystreams::object::Video;
/// # let mut video = Video::new();
/// #
/// use activitystreams::prelude::*;
///
/// if let Some(attributed_to) = video.take_attributed_to() {
/// println!("{:?}", attributed_to);
/// }
/// ```
fn take_attributed_to(&mut self) -> Option<OneOrMany<AnyBase>> {
self.object_mut().attributed_to.take()
}
/// Delete the attributed_to from the current object
///
/// ```rust
/// # fn main() -> Result<(), anyhow::Error> {
/// # use activitystreams::{object::Video, iri};
/// # let mut video = Video::new();
/// # video.set_attributed_to(iri!("https://example.com"));
/// #
/// use activitystreams::prelude::*;
///
/// assert!(video.attributed_to().is_some());
/// video.delete_attributed_to();
/// assert!(video.attributed_to().is_none());
/// # Ok(())
/// # }
/// ```
fn delete_attributed_to(&mut self) -> &mut Self {
self.object_mut().attributed_to = None;
self
}
/// Fetch the audience for the current object
///
/// ```rust
/// # use activitystreams::object::Video;
/// # let mut video = Video::new();
/// #
/// use activitystreams::prelude::*;
///
/// if let Some(audience) = video.audience() {
/// println!("{:?}", audience);
/// }
/// ```
fn audience<'a>(&'a self) -> Option<&'a OneOrMany<AnyBase>>
where
Self::Kind: 'a,
{
self.object_ref().audience.as_ref()
}
/// Set the audience for the current object
///
/// This overwrites the contents of audience
///
/// ```rust
/// # fn main() -> Result<(), anyhow::Error> {
/// use activitystreams::prelude::*;
/// # use activitystreams::{object::Video, iri};
/// # let mut video = Video::new();
///
/// video.set_audience(iri!("https://example.com"));
/// # Ok(())
/// # }
/// ```
fn set_audience<T>(&mut self, audience: T) -> &mut Self
where
T: Into<AnyBase>,
{
self.object_mut().audience = Some(audience.into().into());
self
}
/// This overwrites the contents of audience
///
/// ```rust
/// # fn main() -> Result<(), anyhow::Error> {
/// use activitystreams::prelude::*;
/// # use activitystreams::{object::Video, iri};
/// # let mut video = Video::new();
///
/// video.set_many_audiences(vec![
/// iri!("https://example.com/one"),
/// iri!("https://example.com/two"),
/// ]);
/// # Ok(())
/// # }
/// ```
fn set_many_audiences<I, T>(&mut self, items: I) -> &mut Self
where
I: IntoIterator<Item = T>,
T: Into<AnyBase>,
{
let v: Vec<_> = items.into_iter().map(Into::into).collect();
self.object_mut().audience = Some(v.into());
self
}
/// Add a audience to the current object
///
/// This does not overwrite the contents of audience, only appends an item
///
/// ```rust
/// # fn main() -> Result<(), anyhow::Error> {
/// use activitystreams::prelude::*;
/// # use activitystreams::{object::Video, iri};
/// # let mut video = Video::new();
///
/// video
/// .add_audience(iri!("https://example.com/one"))
/// .add_audience(iri!("https://example.com/two"));
/// # Ok(())
/// # }
/// ```
fn add_audience<T>(&mut self, audience: T) -> &mut Self
where
T: Into<AnyBase>,
{
let a = match self.object_mut().audience.take() {
Some(mut a) => {
a.add(audience.into());
a
}
None => vec![audience.into()].into(),
};
self.object_mut().audience = Some(a);
self
}
/// Take the audience from the current object, leaving nothing
///
/// ```rust
/// # use activitystreams::object::Video;
/// # let mut video = Video::new();
/// #
/// use activitystreams::prelude::*;
///
/// if let Some(audience) = video.take_audience() {
/// println!("{:?}", audience);
/// }
/// ```
fn take_audience(&mut self) -> Option<OneOrMany<AnyBase>> {
self.object_mut().audience.take()
}
/// Delete the audience from the current object
///
/// ```rust
/// # fn main() -> Result<(), anyhow::Error> {
/// # use activitystreams::{object::Video, iri};
/// # let mut video = Video::new();
/// # video.set_audience(iri!("https://example.com"));
/// #
/// use activitystreams::prelude::*;
///
/// assert!(video.audience().is_some());
/// video.delete_audience();
/// assert!(video.audience().is_none());
/// # Ok(())
/// # }
/// ```
fn delete_audience(&mut self) -> &mut Self {
self.object_mut().audience = None;
self
}
/// Fetch the content for the current object
///
/// ```rust
/// # use activitystreams::object::Video;
/// # let mut video = Video::new();
/// #
/// use activitystreams::prelude::*;
///
/// if let Some(content) = video.content() {
/// println!("{:?}", content);
/// }
/// ```
fn content<'a>(&'a self) -> Option<OneOrMany<&'a AnyString>>
where
Self::Kind: 'a,
{
self.object_ref().content.as_ref().map(|o| o.as_ref())
}
/// Set the content for the current object
///
/// This overwrites the contents of content
///
/// ```rust
/// use activitystreams::prelude::*;
/// # use activitystreams::object::Video;
/// # let mut video = Video::new();
///
/// video.set_content("hi");
/// ```
fn set_content<T>(&mut self, content: T) -> &mut Self
where
T: Into<AnyString>,
{
self.object_mut().content = Some(content.into().into());
self
}
/// Set many contents for the current object
///
/// This overwrites the contents of content
///
/// ```rust
/// use activitystreams::prelude::*;
/// # use activitystreams::object::Video;
/// # let mut video = Video::new();
///
/// video.set_many_contents(vec!["hi", "hello"]);
/// ```
fn set_many_contents<I, T>(&mut self, items: I) -> &mut Self
where
I: IntoIterator<Item = T>,
T: Into<AnyString>,
{
let v: Vec<_> = items.into_iter().map(Into::into).collect();
self.object_mut().content = Some(v.into());
self
}
/// Add a content to the current object
///
/// This does not overwrite the contents of content, only appends an item
///
/// ```rust
/// use activitystreams::prelude::*;
/// # use activitystreams::object::Video;
/// # let mut video = Video::new();
///
/// video
/// .add_content("hi")
/// .add_content("hello");
/// ```
fn add_content<T>(&mut self, content: T) -> &mut Self
where
T: Into<AnyString>,
{
let a = match self.object_mut().content.take() {
Some(mut a) => {
a.add(content.into());
a
}
None => vec![content.into()].into(),
};
self.object_mut().content = Some(a);
self
}
/// Take the content from the current object, leaving nothing
///
/// ```rust
/// # use activitystreams::object::Video;
/// # let mut video = Video::new();
/// #
/// use activitystreams::prelude::*;
///
/// if let Some(content) = video.take_content() {
/// println!("{:?}", content);
/// }
/// ```
fn take_content(&mut self) -> Option<OneOrMany<AnyString>> {
self.object_mut().content.take()
}
/// Delete the content from the current object
///
/// ```rust
/// # use activitystreams::object::Video;
/// # let mut video = Video::new();
/// # video.set_content("content");
/// #
/// use activitystreams::prelude::*;
///
/// assert!(video.content().is_some());
/// video.delete_content();
/// assert!(video.content().is_none());
/// ```
fn delete_content(&mut self) -> &mut Self {
self.object_mut().content = None;
self
}
/// Fetch the summary for the current object
///
/// ```rust
/// # use activitystreams::object::Video;
/// # let mut video = Video::new();
/// #
/// use activitystreams::prelude::*;
///
/// if let Some(summary) = video.summary() {
/// println!("{:?}", summary);
/// }
/// ```
fn summary<'a>(&'a self) -> Option<OneOrMany<&'a AnyString>>
where
Self::Kind: 'a,
{
self.object_ref().summary.as_ref().map(|o| o.as_ref())
}
/// Set the summary for the current object
///
/// This overwrites the contents of summary
///
/// ```rust
/// use activitystreams::prelude::*;
/// # use activitystreams::object::Video;
/// # let mut video = Video::new();
///
/// video.set_summary("hi");
/// ```
fn set_summary<T>(&mut self, summary: T) -> &mut Self
where
T: Into<AnyString>,
{
self.object_mut().summary = Some(summary.into().into());
self
}
/// Set many summaries for the current object
///
/// This overwrites the contents of summary
///
/// ```rust
/// use activitystreams::prelude::*;
/// # use activitystreams::object::Video;
/// # let mut video = Video::new();
///
/// video.set_many_summaries(vec![ "hi", "hello"]);
/// ```
fn set_many_summaries<I, T>(&mut self, items: I) -> &mut Self
where
I: IntoIterator<Item = T>,
T: Into<AnyString>,
{
let v: Vec<_> = items.into_iter().map(Into::into).collect();
self.object_mut().summary = Some(v.into());
self
}
/// Add a summary to the current object
///
/// This does not overwrite the contents of summary, only appends an item
///
/// ```rust
/// use activitystreams::prelude::*;
/// # use activitystreams::object::Video;
/// # let mut video = Video::new();
///
/// video
/// .add_summary("hi")
/// .add_summary("hello");
/// ```
fn add_summary<T>(&mut self, summary: T) -> &mut Self
where
T: Into<AnyString>,
{
let a = match self.object_mut().summary.take() {
Some(mut a) => {
a.add(summary.into());
a
}
None => vec![summary.into()].into(),
};
self.object_mut().summary = Some(a);
self
}
/// Take the summary from the current object, leaving nothing
///
/// ```rust
/// # use activitystreams::object::Video;
/// # let mut video = Video::new();
/// #
/// use activitystreams::prelude::*;
///
/// if let Some(summary) = video.take_summary() {
/// println!("{:?}", summary);
/// }
/// ```
fn take_summary(&mut self) -> Option<OneOrMany<AnyString>> {
self.object_mut().summary.take()
}
/// Delete the summary from the current object
///
/// ```rust
/// # use activitystreams::object::Video;
/// # let mut video = Video::new();
/// # video.set_summary("summary");
/// #
/// use activitystreams::prelude::*;
///
/// assert!(video.summary().is_some());
/// video.delete_summary();
/// assert!(video.summary().is_none());
/// ```
fn delete_summary(&mut self) -> &mut Self {
self.object_mut().summary = None;
self
}
/// Fetch the url for the current object
///
/// ```rust
/// # use activitystreams::object::Video;
/// # let mut video = Video::new();
/// #
/// use activitystreams::prelude::*;
///
/// if let Some(url) = video.url() {
/// println!("{:?}", url);
/// }
/// ```
fn url<'a>(&'a self) -> Option<&'a OneOrMany<AnyBase>>
where
Self::Kind: 'a,
{
self.object_ref().url.as_ref()
}
/// Set the url for the current object
///
/// This overwrites the contents of url
///
/// ```rust
/// # fn main() -> Result<(), anyhow::Error> {
/// use activitystreams::prelude::*;
/// # use activitystreams::{object::Video, iri};
/// # let mut video = Video::new();
///
/// video.set_url(iri!("https://example.com"));
/// # Ok(())
/// # }
/// ```
fn set_url<T>(&mut self, url: T) -> &mut Self
where
T: Into<AnyBase>,
{
self.object_mut().url = Some(url.into().into());
self
}
/// Set many urls for the current object
///
/// This overwrites the contents of url
///
/// ```rust
/// # fn main() -> Result<(), anyhow::Error> {
/// use activitystreams::prelude::*;
/// # use activitystreams::{object::Video, iri};
/// # let mut video = Video::new();
///
/// video.set_many_urls(vec![
/// iri!("https://example.com/one"),
/// iri!("https://example.com/two"),
/// ]);
/// # Ok(())
/// # }
/// ```
fn set_many_urls<I, T>(&mut self, items: I) -> &mut Self
where
I: IntoIterator<Item = T>,
T: Into<AnyBase>,
{
let v: Vec<_> = items.into_iter().map(Into::into).collect();
self.object_mut().url = Some(v.into());
self
}
/// Add a url to the current object
///
/// This does not overwrite the contents of url, only appends an item
///
/// ```rust
/// # fn main() -> Result<(), anyhow::Error> {
/// use activitystreams::prelude::*;
/// # use activitystreams::{object::Video, iri};
/// # let mut video = Video::new();
///
/// video
/// .add_url(iri!("https://example.com/one"))
/// .add_url(iri!("https://example.com/two"));
/// # Ok(())
/// # }
/// ```
fn add_url<T>(&mut self, url: T) -> &mut Self
where
T: Into<AnyBase>,
{
let a = match self.object_mut().url.take() {
Some(mut a) => {
a.add(url.into());
a
}
None => vec![url.into()].into(),
};
self.object_mut().url = Some(a);
self
}
/// Take the url from the current object, leaving nothing
///
/// ```rust
/// # use activitystreams::object::Video;
/// # let mut video = Video::new();
/// #
/// use activitystreams::prelude::*;
///
/// if let Some(url) = video.take_url() {
/// println!("{:?}", url);
/// }
/// ```
fn take_url(&mut self) -> Option<OneOrMany<AnyBase>> {
self.object_mut().url.take()
}
/// Delete the url from the current object
///
/// ```rust
/// # fn main() -> Result<(), anyhow::Error> {
/// # use activitystreams::{object::Video, iri};
/// # let mut video = Video::new();
/// # video.set_url(iri!("https://example.com"));
/// #
/// use activitystreams::prelude::*;
///
/// assert!(video.url().is_some());
/// video.delete_url();
/// assert!(video.url().is_none());
/// # Ok(())
/// # }
/// ```
fn delete_url(&mut self) -> &mut Self {
self.object_mut().url = None;
self
}
/// Fetch the generator for the current object
///
/// ```rust
/// # use activitystreams::object::Video;
/// # let mut video = Video::new();
/// #
/// use activitystreams::prelude::*;
///
/// if let Some(generator) = video.generator() {
/// println!("{:?}", generator);
/// }
/// ```
fn generator<'a>(&'a self) -> Option<&'a OneOrMany<AnyBase>>
where
Self::Kind: 'a,
{
self.object_ref().generator.as_ref()
}
/// Set the generator for the current object
///
/// This overwrites the contents of generator
///
/// ```rust
/// # fn main() -> Result<(), anyhow::Error> {
/// use activitystreams::prelude::*;
/// # use activitystreams::{object::Video, iri};
/// # let mut video = Video::new();
///
/// video.set_generator(iri!("https://example.com"));
/// # Ok(())
/// # }
/// ```
fn set_generator<T>(&mut self, generator: T) -> &mut Self
where
T: Into<AnyBase>,
{
self.object_mut().generator = Some(generator.into().into());
self
}
/// Set many generators for the current object
///
/// This overwrites the contents of generator
///
/// ```rust
/// # fn main() -> Result<(), anyhow::Error> {
/// use activitystreams::prelude::*;
/// # use activitystreams::{object::Video, iri};
/// # let mut video = Video::new();
///
/// video.set_many_generators(vec![
/// iri!("https://example.com/one"),
/// iri!("https://example.com/two"),
/// ]);
/// # Ok(())
/// # }
/// ```
fn set_many_generators<I, T>(&mut self, items: I) -> &mut Self
where
I: IntoIterator<Item = T>,
T: Into<AnyBase>,
{
let v: Vec<_> = items.into_iter().map(Into::into).collect();
self.object_mut().generator = Some(v.into());
self
}
/// Add a generator to the current object
///
/// This does not overwrite the contents of generator, only appends an item
///
/// ```rust
/// # fn main() -> Result<(), anyhow::Error> {
/// use activitystreams::prelude::*;
/// # use activitystreams::{object::Video, iri};
/// # let mut video = Video::new();
///
/// video
/// .add_generator(iri!("https://example.com/one"))
/// .add_generator(iri!("https://example.com/two"));
/// # Ok(())
/// # }
/// ```
fn add_generator<T>(&mut self, generator: T) -> &mut Self
where
T: Into<AnyBase>,
{
let a = match self.object_mut().generator.take() {
Some(mut a) => {
a.add(generator.into());
a
}
None => vec![generator.into()].into(),
};
self.object_mut().generator = Some(a);
self
}
/// Take the generator from the current object, leaving nothing
///
/// ```rust
/// # use activitystreams::object::Video;
/// # let mut video = Video::new();
/// #
/// use activitystreams::prelude::*;
///
/// if let Some(generator) = video.take_generator() {
/// println!("{:?}", generator);
/// }
/// ```
fn take_generator(&mut self) -> Option<OneOrMany<AnyBase>> {
self.object_mut().generator.take()
}
/// Delete the generator from the current object
///
/// ```rust
/// # fn main() -> Result<(), anyhow::Error> {
/// # use activitystreams::{object::Video, iri};
/// # let mut video = Video::new();
/// # video.set_generator(iri!("https://example.com"));
/// #
/// use activitystreams::prelude::*;
///
/// assert!(video.generator().is_some());
/// video.delete_generator();
/// assert!(video.generator().is_none());
/// # Ok(())
/// # }
/// ```
fn delete_generator(&mut self) -> &mut Self {
self.object_mut().generator = None;
self
}
/// Fetch the icon for the current object
///
/// ```rust
/// # use activitystreams::object::Video;
/// # let mut video = Video::new();
/// #
/// use activitystreams::prelude::*;
///
/// if let Some(icon) = video.icon() {
/// println!("{:?}", icon);
/// }
/// ```
fn icon<'a>(&'a self) -> Option<&'a OneOrMany<AnyBase>>
where
Self::Kind: 'a,
{
self.object_ref().icon.as_ref()
}
/// Set the icon for the current object
///
/// This overwrites the contents of icon
///
/// ```rust
/// # fn main() -> Result<(), anyhow::Error> {
/// use activitystreams::prelude::*;
/// # use activitystreams::{object::Video, iri};
/// # let mut video = Video::new();
///
/// video.set_icon(iri!("https://example.com"));
/// # Ok(())
/// # }
/// ```
fn set_icon<T>(&mut self, icon: T) -> &mut Self
where
T: Into<AnyBase>,
{
self.object_mut().icon = Some(icon.into().into());
self
}
/// Set many icons for the current object
///
/// This overwrites the contents of icon
///
/// ```rust
/// # fn main() -> Result<(), anyhow::Error> {
/// use activitystreams::prelude::*;
/// # use activitystreams::{object::Video, iri};
/// # let mut video = Video::new();
///
/// video.set_many_icons(vec![
/// iri!("https://example.com/one"),
/// iri!("https://example.com/two"),
/// ]);
/// # Ok(())
/// # }
/// ```
fn set_many_icons<I, T>(&mut self, items: I) -> &mut Self
where
I: IntoIterator<Item = T>,
T: Into<AnyBase>,
{
let v: Vec<_> = items.into_iter().map(Into::into).collect();
self.object_mut().icon = Some(v.into());
self
}
/// Add a icon to the current object
///
/// This does not overwrite the contents of icon, only appends an item
///
/// ```rust
/// # fn main() -> Result<(), anyhow::Error> {
/// use activitystreams::prelude::*;
/// # use activitystreams::{object::Video, iri};
/// # let mut video = Video::new();
///
/// video
/// .add_icon(iri!("https://example.com/one"))
/// .add_icon(iri!("https://example.com/two"));
/// # Ok(())
/// # }
/// ```
fn add_icon<T>(&mut self, icon: T) -> &mut Self
where
T: Into<AnyBase>,
{
let a = match self.object_mut().icon.take() {
Some(mut a) => {
a.add(icon.into());
a
}
None => vec![icon.into()].into(),
};
self.object_mut().icon = Some(a);
self
}
/// Take the icon from the current object, leaving nothing
///
/// ```rust
/// # use activitystreams::object::Video;
/// # let mut video = Video::new();
/// #
/// use activitystreams::prelude::*;
///
/// if let Some(icon) = video.take_icon() {
/// println!("{:?}", icon);
/// }
/// ```
fn take_icon(&mut self) -> Option<OneOrMany<AnyBase>> {
self.object_mut().icon.take()
}
/// Delete the icon from the current object
///
/// ```rust
/// # fn main() -> Result<(), anyhow::Error> {
/// # use activitystreams::{object::Video, iri};
/// # let mut video = Video::new();
/// # video.set_icon(iri!("https://example.com"));
/// #
/// use activitystreams::prelude::*;
///
/// assert!(video.icon().is_some());
/// video.delete_icon();
/// assert!(video.icon().is_none());
/// # Ok(())
/// # }
/// ```
fn delete_icon(&mut self) -> &mut Self {
self.object_mut().icon = None;
self
}
/// Fetch the image for the current object
///
/// ```rust
/// # use activitystreams::object::Video;
/// # let mut video = Video::new();
/// #
/// use activitystreams::prelude::*;
///
/// if let Some(image) = video.image() {
/// println!("{:?}", image);
/// }
/// ```
fn image<'a>(&'a self) -> Option<&'a OneOrMany<AnyBase>>
where
Self::Kind: 'a,
{
self.object_ref().image.as_ref()
}
/// Set the image for the current object
///
/// This overwrites the contents of image
///
/// ```rust
/// # fn main() -> Result<(), anyhow::Error> {
/// use activitystreams::prelude::*;
/// # use activitystreams::{object::Video, iri};
/// # let mut video = Video::new();
///
/// video.set_image(iri!("https://example.com"));
/// # Ok(())
/// # }
/// ```
fn set_image<T>(&mut self, image: T) -> &mut Self
where
T: Into<AnyBase>,
{
self.object_mut().image = Some(image.into().into());
self
}
/// Set many images for the current object
///
/// This overwrites the contents of image
///
/// ```rust
/// # fn main() -> Result<(), anyhow::Error> {
/// use activitystreams::prelude::*;
/// # use activitystreams::{object::Video, iri};
/// # let mut video = Video::new();
///
/// video.set_many_images(vec![
/// iri!("https://example.com/one"),
/// iri!("https://example.com/two"),
/// ]);
/// # Ok(())
/// # }
/// ```
fn set_many_images<I, T>(&mut self, items: I) -> &mut Self
where
I: IntoIterator<Item = T>,
T: Into<AnyBase>,
{
let v: Vec<_> = items.into_iter().map(Into::into).collect();
self.object_mut().image = Some(v.into());
self
}
/// Add a image to the current object
///
/// This does not overwrite the contents of image, only appends an item
///
/// ```rust
/// # fn main() -> Result<(), anyhow::Error> {
/// use activitystreams::prelude::*;
/// # use activitystreams::{object::Video, iri};
/// # let mut video = Video::new();
///
/// video
/// .add_image(iri!("https://example.com/one"))
/// .add_image(iri!("https://example.com/two"));
/// # Ok(())
/// # }
/// ```
fn add_image<T>(&mut self, image: T) -> &mut Self
where
T: Into<AnyBase>,
{
let a = match self.object_mut().image.take() {
Some(mut a) => {
a.add(image.into());
a
}
None => vec![image.into()].into(),
};
self.object_mut().image = Some(a);
self
}
/// Take the image from the current object, leaving nothing
///
/// ```rust
/// # use activitystreams::object::Video;
/// # let mut video = Video::new();
/// #
/// use activitystreams::prelude::*;
///
/// if let Some(image) = video.take_image() {
/// println!("{:?}", image);
/// }
/// ```
fn take_image(&mut self) -> Option<OneOrMany<AnyBase>> {
self.object_mut().image.take()
}
/// Delete the image from the current object
///
/// ```rust
/// # fn main() -> Result<(), anyhow::Error> {
/// # use activitystreams::{object::Video, iri};
/// # let mut video = Video::new();
/// # video.set_image(iri!("https://example.com"));
/// #
/// use activitystreams::prelude::*;
///
/// assert!(video.image().is_some());
/// video.delete_image();
/// assert!(video.image().is_none());
/// # Ok(())
/// # }
/// ```
fn delete_image(&mut self) -> &mut Self {
self.object_mut().image = None;
self
}
/// Fetch the location for the current object
///
/// ```rust
/// # use activitystreams::object::Video;
/// # let mut video = Video::new();
/// #
/// use activitystreams::prelude::*;
///
/// if let Some(location) = video.location() {
/// println!("{:?}", location);
/// }
/// ```
fn location<'a>(&'a self) -> Option<&'a OneOrMany<AnyBase>>
where
Self::Kind: 'a,
{
self.object_ref().location.as_ref()
}
/// Set the location for the current object
///
/// This overwrites the contents of location
///
/// ```rust
/// # fn main() -> Result<(), anyhow::Error> {
/// use activitystreams::prelude::*;
/// # use activitystreams::{object::Video, iri};
/// # let mut video = Video::new();
///
/// video.set_location(iri!("https://example.com"));
/// # Ok(())
/// # }
/// ```
fn set_location<T>(&mut self, location: T) -> &mut Self
where
T: Into<AnyBase>,
{
self.object_mut().location = Some(location.into().into());
self
}
/// Set many locations for the current object
///
/// This overwrites the contents of location
///
/// ```rust
/// # fn main() -> Result<(), anyhow::Error> {
/// use activitystreams::prelude::*;
/// # use activitystreams::{object::Video, iri};
/// # let mut video = Video::new();
///
/// video.set_many_locations(vec![
/// iri!("https://example.com/one"),
/// iri!("https://example.com/two"),
/// ]);
/// # Ok(())
/// # }
/// ```
fn set_many_locations<I, T>(&mut self, items: I) -> &mut Self
where
I: IntoIterator<Item = T>,
T: Into<AnyBase>,
{
let v: Vec<_> = items.into_iter().map(Into::into).collect();
self.object_mut().location = Some(v.into());
self
}
/// Add a location to the current object
///
/// This does not overwrite the contents of location, only appends an item
///
/// ```rust
/// # fn main() -> Result<(), anyhow::Error> {
/// use activitystreams::prelude::*;
/// # use activitystreams::{object::Video, iri};
/// # let mut video = Video::new();
///
/// video
/// .add_location(iri!("https://example.com/one"))
/// .add_location(iri!("https://example.com/two"));
/// # Ok(())
/// # }
/// ```
fn add_location<T>(&mut self, location: T) -> &mut Self
where
T: Into<AnyBase>,
{
let a = match self.object_mut().location.take() {
Some(mut a) => {
a.add(location.into());
a
}
None => vec![location.into()].into(),
};
self.object_mut().location = Some(a);
self
}
/// Take the location from the current object, leaving nothing
///
/// ```rust
/// # use activitystreams::object::Video;
/// # let mut video = Video::new();
/// #
/// use activitystreams::prelude::*;
///
/// if let Some(location) = video.take_location() {
/// println!("{:?}", location);
/// }
/// ```
fn take_location(&mut self) -> Option<OneOrMany<AnyBase>> {
self.object_mut().location.take()
}
/// Delete the location from the current object
///
/// ```rust
/// # fn main() -> Result<(), anyhow::Error> {
/// # use activitystreams::{object::Video, iri};
/// # let mut video = Video::new();
/// # video.set_location(iri!("https://example.com"));
/// #
/// use activitystreams::prelude::*;
///
/// assert!(video.location().is_some());
/// video.delete_location();
/// assert!(video.location().is_none());
/// # Ok(())
/// # }
/// ```
fn delete_location(&mut self) -> &mut Self {
self.object_mut().location = None;
self
}
/// Fetch the tag for the current object
///
/// ```rust
/// # use activitystreams::object::Video;
/// # let mut video = Video::new();
/// #
/// use activitystreams::prelude::*;
///
/// if let Some(tag) = video.tag() {
/// println!("{:?}", tag);
/// }
/// ```
fn tag<'a>(&'a self) -> Option<&'a OneOrMany<AnyBase>>
where
Self::Kind: 'a,
{
self.object_ref().tag.as_ref()
}
/// Set the tag for the current object
///
/// This overwrites the contents of tag
///
/// ```rust
/// # fn main() -> Result<(), anyhow::Error> {
/// use activitystreams::prelude::*;
/// # use activitystreams::{object::Video, iri};
/// # let mut video = Video::new();
///
/// video.set_tag(iri!("https://example.com"));
/// # Ok(())
/// # }
/// ```
fn set_tag<T>(&mut self, tag: T) -> &mut Self
where
T: Into<AnyBase>,
{
self.object_mut().tag = Some(tag.into().into());
self
}
/// Set many tags for the current object
///
/// This overwrites the contents of tag
///
/// ```rust
/// # fn main() -> Result<(), anyhow::Error> {
/// use activitystreams::prelude::*;
/// # use activitystreams::{object::Video, iri};
/// # let mut video = Video::new();
///
/// video.set_many_tags(vec![
/// iri!("https://example.com/one"),
/// iri!("https://example.com/two"),
/// ]);
/// # Ok(())
/// # }
/// ```
fn set_many_tags<I, T>(&mut self, items: I) -> &mut Self
where
I: IntoIterator<Item = T>,
T: Into<AnyBase>,
{
let v: Vec<_> = items.into_iter().map(Into::into).collect();
self.object_mut().tag = Some(v.into());
self
}
/// Add a tag to the current object
///
/// This does not overwrite the contents of tag, only appends an item
///
/// ```rust
/// # fn main() -> Result<(), anyhow::Error> {
/// use activitystreams::prelude::*;
/// # use activitystreams::{object::Video, iri};
/// # let mut video = Video::new();
///
/// video
/// .add_tag(iri!("https://example.com/one"))
/// .add_tag(iri!("https://example.com/two"));
/// # Ok(())
/// # }
/// ```
fn add_tag<T>(&mut self, tag: T) -> &mut Self
where
T: Into<AnyBase>,
{
let a = match self.object_mut().tag.take() {
Some(mut a) => {
a.add(tag.into());
a
}
None => vec![tag.into()].into(),
};
self.object_mut().tag = Some(a);
self
}
/// Take the tag from the current object, leaving nothing
///
/// ```rust
/// # use activitystreams::object::Video;
/// # let mut video = Video::new();
/// #
/// use activitystreams::prelude::*;
///
/// if let Some(tag) = video.take_tag() {
/// println!("{:?}", tag);
/// }
/// ```
fn take_tag(&mut self) -> Option<OneOrMany<AnyBase>> {
self.object_mut().tag.take()
}
/// Delete the tag from the current object
///
/// ```rust
/// # fn main() -> Result<(), anyhow::Error> {
/// # use activitystreams::{object::Video, iri};
/// # let mut video = Video::new();
/// # video.set_tag(iri!("https://example.com"));
/// #
/// use activitystreams::prelude::*;
///
/// assert!(video.tag().is_some());
/// video.delete_tag();
/// assert!(video.tag().is_none());
/// # Ok(())
/// # }
/// ```
fn delete_tag(&mut self) -> &mut Self {
self.object_mut().tag = None;
self
}
/// Fetch the start_time for the current object
///
/// ```rust
/// # use activitystreams::object::Video;
/// # let mut video = Video::new();
/// #
/// use activitystreams::prelude::*;
///
/// if let Some(start_time) = video.start_time() {
/// println!("{:?}", start_time);
/// }
/// ```
fn start_time<'a>(&'a self) -> Option<OffsetDateTime>
where
Self::Kind: 'a,
{
self.object_ref()
.start_time
.as_ref()
.map(|d| d.clone().into_inner())
}
/// Set the start_time for the current object
///
/// This overwrites the contents of start_time
///
/// ```rust
/// # fn main() -> Result<(), anyhow::Error> {
/// use activitystreams::prelude::*;
/// # use activitystreams::{object::Video, datetime};
/// # let mut video = Video::new();
///
/// video.set_start_time(datetime!("2020-04-20T04:20:00Z"));
/// # Ok(())
/// # }
/// ```
fn set_start_time(&mut self, start_time: OffsetDateTime) -> &mut Self {
self.object_mut().start_time = Some(start_time.into());
self
}
/// Take the start_time from the current object, leaving nothing
///
/// ```rust
/// # use activitystreams::object::Video;
/// # let mut video = Video::new();
/// #
/// use activitystreams::prelude::*;
///
/// if let Some(start_time) = video.take_start_time() {
/// println!("{:?}", start_time);
/// }
/// ```
fn take_start_time(&mut self) -> Option<OffsetDateTime> {
self.object_mut().start_time.take().map(|d| d.into_inner())
}
/// Delete the start_time from the current object
///
/// ```rust
/// # fn main() -> Result<(), anyhow::Error> {
/// # use activitystreams::{object::Video, datetime};
/// # let mut video = Video::new();
/// # video.set_start_time(datetime!("2020-04-20T04:20:00Z"));
/// #
/// use activitystreams::prelude::*;
///
/// assert!(video.start_time().is_some());
/// video.delete_start_time();
/// assert!(video.start_time().is_none());
/// # Ok(())
/// # }
/// ```
fn delete_start_time(&mut self) -> &mut Self {
self.object_mut().start_time = None;
self
}
/// Fetch the end_time for the current object
///
/// ```rust
/// # use activitystreams::object::Video;
/// # let mut video = Video::new();
/// #
/// use activitystreams::prelude::*;
///
/// if let Some(end_time) = video.end_time() {
/// println!("{:?}", end_time);
/// }
/// ```
fn end_time<'a>(&'a self) -> Option<OffsetDateTime>
where
Self::Kind: 'a,
{
self.object_ref()
.end_time
.as_ref()
.map(|d| d.clone().into_inner())
}
/// Set the end_time for the current object
///
/// This overwrites the contents of end_time
///
/// ```rust
/// # fn main() -> Result<(), anyhow::Error> {
/// use activitystreams::prelude::*;
/// # use activitystreams::{object::Video, datetime};
/// # let mut video = Video::new();
///
/// video.set_end_time(datetime!("2020-04-20T04:20:00-05:00"));
/// # Ok(())
/// # }
/// ```
fn set_end_time(&mut self, end_time: OffsetDateTime) -> &mut Self {
self.object_mut().end_time = Some(end_time.into());
self
}
/// Take the end_time from the current object, leaving nothing
///
/// ```rust
/// # use activitystreams::object::Video;
/// # let mut video = Video::new();
/// #
/// use activitystreams::prelude::*;
///
/// if let Some(end_time) = video.take_end_time() {
/// println!("{:?}", end_time);
/// }
/// ```
fn take_end_time(&mut self) -> Option<OffsetDateTime> {
self.object_mut().end_time.take().map(|d| d.into_inner())
}
/// Delete the end_time from the current object
///
/// ```rust
/// # fn main() -> Result<(), anyhow::Error> {
/// # use activitystreams::{object::Video, datetime};
/// # let mut video = Video::new();
/// # video.set_end_time(datetime!("2020-04-20T04:20:00Z"));
/// #
/// use activitystreams::prelude::*;
///
/// assert!(video.end_time().is_some());
/// video.delete_end_time();
/// assert!(video.end_time().is_none());
/// # Ok(())
/// # }
/// ```
fn delete_end_time(&mut self) -> &mut Self {
self.object_mut().end_time = None;
self
}
/// Fetch the duration for the current object
///
/// ```rust
/// # use activitystreams::object::Video;
/// # let mut video = Video::new();
/// #
/// use activitystreams::prelude::*;
///
/// if let Some(duration) = video.duration() {
/// println!("{:?}", duration);
/// }
/// ```
fn duration<'a>(&'a self) -> Option<Duration>
where
Self::Kind: 'a,
{
self.object_ref()
.duration
.as_ref()
.map(|d| d.clone().into_inner())
}
/// Set the duration for the current object
///
/// This overwrites the contents of duration
///
/// ```rust
/// # fn main() -> Result<(), anyhow::Error> {
/// use activitystreams::prelude::*;
/// use time::Duration;
/// # use activitystreams::object::Video;
/// # let mut video = Video::new();
///
/// video.set_duration(Duration::minutes(4) + Duration::seconds(20));
/// # Ok(())
/// # }
/// ```
fn set_duration(&mut self, duration: Duration) -> &mut Self {
self.object_mut().duration = Some(duration.into());
self
}
/// Take the duration from the current object, leaving nothing
///
/// ```rust
/// # use activitystreams::object::Video;
/// # let mut video = Video::new();
/// #
/// use activitystreams::prelude::*;
///
/// if let Some(duration) = video.take_duration() {
/// println!("{:?}", duration);
/// }
/// ```
fn take_duration(&mut self) -> Option<Duration> {
self.object_mut().duration.take().map(|d| d.into_inner())
}
/// Delete the duration from the current object
///
/// ```rust
/// # fn main() -> Result<(), anyhow::Error> {
/// # use activitystreams::object::Video;
/// # use time::Duration;
/// # let mut video = Video::new();
/// # video.set_duration(Duration::hours(1));
/// #
/// use activitystreams::prelude::*;
///
/// assert!(video.duration().is_some());
/// video.delete_duration();
/// assert!(video.duration().is_none());
/// # Ok(())
/// # }
/// ```
fn delete_duration(&mut self) -> &mut Self {
self.object_mut().duration = None;
self
}
/// Fetch the published for the current object
///
/// ```rust
/// # use activitystreams::object::Video;
/// # let mut video = Video::new();
/// #
/// use activitystreams::prelude::*;
///
/// if let Some(published) = video.published() {
/// println!("{:?}", published);
/// }
/// ```
fn published<'a>(&'a self) -> Option<OffsetDateTime>
where
Self::Kind: 'a,
{
self.object_ref()
.published
.as_ref()
.map(|d| d.clone().into_inner())
}
/// Set the published for the current object
///
/// This overwrites the contents of published
///
/// ```rust
/// # fn main() -> Result<(), anyhow::Error> {
/// use activitystreams::prelude::*;
/// # use activitystreams::{object::Video, datetime};
/// # let mut video = Video::new();
///
/// video.set_published(datetime!("2020-04-20T04:20:00Z"));
/// # Ok(())
/// # }
/// ```
fn set_published(&mut self, published: OffsetDateTime) -> &mut Self {
self.object_mut().published = Some(published.into());
self
}
/// Take the published from the current object, leaving nothing
///
/// ```rust
/// # use activitystreams::object::Video;
/// # let mut video = Video::new();
/// #
/// use activitystreams::prelude::*;
///
/// if let Some(published) = video.take_published() {
/// println!("{:?}", published);
/// }
/// ```
fn take_published(&mut self) -> Option<OffsetDateTime> {
self.object_mut().published.take().map(|d| d.into_inner())
}
/// Delete the published from the current object
///
/// ```rust
/// # fn main() -> Result<(), anyhow::Error> {
/// # use activitystreams::{object::Video, datetime};
/// # let mut video = Video::new();
/// # video.set_published(datetime!("2020-04-20T04:20:00Z"));
/// #
/// use activitystreams::prelude::*;
///
/// assert!(video.published().is_some());
/// video.delete_published();
/// assert!(video.published().is_none());
/// # Ok(())
/// # }
/// ```
fn delete_published(&mut self) -> &mut Self {
self.object_mut().published = None;
self
}
/// Fetch the updated for the current object
///
/// ```rust
/// # use activitystreams::object::Video;
/// # let mut video = Video::new();
/// #
/// use activitystreams::prelude::*;
///
/// if let Some(updated) = video.updated() {
/// println!("{:?}", updated);
/// }
/// ```
fn updated<'a>(&'a self) -> Option<OffsetDateTime>
where
Self::Kind: 'a,
{
self.object_ref()
.updated
.as_ref()
.map(|d| d.clone().into_inner())
}
/// Set the updated for the current object
///
/// This overwrites the contents of updated
///
/// ```rust
/// # fn main() -> Result<(), anyhow::Error> {
/// use activitystreams::prelude::*;
/// # use activitystreams::{object::Video, datetime};
/// # let mut video = Video::new();
///
/// video.set_updated(datetime!("2020-04-20T04:20:00Z"));
/// # Ok(())
/// # }
/// ```
fn set_updated(&mut self, updated: OffsetDateTime) -> &mut Self {
self.object_mut().updated = Some(updated.into());
self
}
/// Take the updated from the current object, leaving nothing
///
/// ```rust
/// # use activitystreams::object::Video;
/// # let mut video = Video::new();
/// #
/// use activitystreams::prelude::*;
///
/// if let Some(updated) = video.take_updated() {
/// println!("{:?}", updated);
/// }
/// ```
fn take_updated(&mut self) -> Option<OffsetDateTime> {
self.object_mut().updated.take().map(|d| d.into_inner())
}
/// Delete the updated from the current object
///
/// ```rust
/// # fn main() -> Result<(), anyhow::Error> {
/// # use activitystreams::{object::Video, datetime};
/// # let mut video = Video::new();
/// # video.set_updated(datetime!("2020-04-20T04:20:00Z"));
/// #
/// use activitystreams::prelude::*;
///
/// assert!(video.updated().is_some());
/// video.delete_updated();
/// assert!(video.updated().is_none());
/// # Ok(())
/// # }
/// ```
fn delete_updated(&mut self) -> &mut Self {
self.object_mut().updated = None;
self
}
/// Fetch the in_reply_to for the current object
///
/// ```rust
/// # use activitystreams::object::Video;
/// # let mut video = Video::new();
/// #
/// use activitystreams::prelude::*;
///
/// if let Some(in_reply_to) = video.in_reply_to() {
/// println!("{:?}", in_reply_to);
/// }
/// ```
fn in_reply_to<'a>(&'a self) -> Option<&'a OneOrMany<AnyBase>>
where
Self::Kind: 'a,
{
self.object_ref().in_reply_to.as_ref()
}
/// Set the in_reply_to for the current object
///
/// This overwrites the contents of in_reply_to
///
/// ```rust
/// # fn main() -> Result<(), anyhow::Error> {
/// use activitystreams::prelude::*;
/// # use activitystreams::{object::Video, iri};
/// # let mut video = Video::new();
///
/// video.set_in_reply_to(iri!("https://example.com"));
/// # Ok(())
/// # }
/// ```
fn set_in_reply_to<T>(&mut self, in_reply_to: T) -> &mut Self
where
T: Into<AnyBase>,
{
self.object_mut().in_reply_to = Some(in_reply_to.into().into());
self
}
/// Set many in_reply_tos for the current object
///
/// This overwrites the contents of in_reply_to
///
/// ```rust
/// # fn main() -> Result<(), anyhow::Error> {
/// use activitystreams::prelude::*;
/// # use activitystreams::{object::Video, iri};
/// # let mut video = Video::new();
///
/// video.set_many_in_reply_tos(vec![
/// iri!("https://example.com/one"),
/// iri!("https://example.com/two"),
/// ]);
/// # Ok(())
/// # }
/// ```
fn set_many_in_reply_tos<I, T>(&mut self, items: I) -> &mut Self
where
I: IntoIterator<Item = T>,
T: Into<AnyBase>,
{
let v: Vec<_> = items.into_iter().map(Into::into).collect();
self.object_mut().in_reply_to = Some(v.into());
self
}
/// Add a in_reply_to to the current object
///
/// This does not overwrite the contents of in_reply_to, only appends an item
///
/// ```rust
/// # fn main() -> Result<(), anyhow::Error> {
/// use activitystreams::prelude::*;
/// # use activitystreams::{object::Video, iri};
/// # let mut video = Video::new();
///
/// video
/// .add_in_reply_to(iri!("https://example.com/one"))
/// .add_in_reply_to(iri!("https://example.com/two"));
/// # Ok(())
/// # }
/// ```
fn add_in_reply_to<T>(&mut self, in_reply_to: T) -> &mut Self
where
T: Into<AnyBase>,
{
let a = match self.object_mut().in_reply_to.take() {
Some(mut a) => {
a.add(in_reply_to.into());
a
}
None => vec![in_reply_to.into()].into(),
};
self.object_mut().in_reply_to = Some(a);
self
}
/// Take the in_reply_to from the current object, leaving nothing
///
/// ```rust
/// # use activitystreams::object::Video;
/// # let mut video = Video::new();
/// #
/// use activitystreams::prelude::*;
///
/// if let Some(in_reply_to) = video.take_in_reply_to() {
/// println!("{:?}", in_reply_to);
/// }
/// ```
fn take_in_reply_to(&mut self) -> Option<OneOrMany<AnyBase>> {
self.object_mut().in_reply_to.take()
}
/// Delete the in_reply_to from the current object
///
/// ```rust
/// # fn main() -> Result<(), anyhow::Error> {
/// # use activitystreams::{object::Video, iri};
/// # let mut video = Video::new();
/// # video.set_in_reply_to(iri!("https://example.com"));
/// #
/// use activitystreams::prelude::*;
///
/// assert!(video.in_reply_to().is_some());
/// video.delete_in_reply_to();
/// assert!(video.in_reply_to().is_none());
/// # Ok(())
/// # }
/// ```
fn delete_in_reply_to(&mut self) -> &mut Self {
self.object_mut().in_reply_to = None;
self
}
/// Fetch the replies for the current object
///
/// ```rust
/// # use activitystreams::object::Video;
/// # let mut video = Video::new();
/// #
/// use activitystreams::prelude::*;
///
/// if let Some(replies) = video.replies() {
/// println!("{:?}", replies);
/// }
/// ```
fn replies<'a>(&'a self) -> Option<&'a OneOrMany<AnyBase>>
where
Self::Kind: 'a,
{
self.object_ref().replies.as_ref()
}
/// Set the replies for the current object
///
/// This overwrites the contents of replies
///
/// ```rust
/// # fn main() -> Result<(), anyhow::Error> {
/// use activitystreams::prelude::*;
/// # use activitystreams::{object::Video, iri};
/// # let mut video = Video::new();
///
/// video.set_reply(iri!("https://example.com"));
/// # Ok(())
/// # }
/// ```
fn set_reply<T>(&mut self, replies: T) -> &mut Self
where
T: Into<AnyBase>,
{
self.object_mut().replies = Some(replies.into().into());
self
}
/// Set many replies for the current object
///
/// This overwrites the contents of replies
///
/// ```rust
/// # fn main() -> Result<(), anyhow::Error> {
/// use activitystreams::prelude::*;
/// # use activitystreams::{object::Video, iri};
/// # let mut video = Video::new();
///
/// video.set_many_replies(vec![
/// iri!("https://example.com/one"),
/// iri!("https://example.com/two"),
/// ]);
/// # Ok(())
/// # }
/// ```
fn set_many_replies<I, T>(&mut self, items: I) -> &mut Self
where
I: IntoIterator<Item = T>,
T: Into<AnyBase>,
{
let v: Vec<_> = items.into_iter().map(Into::into).collect();
self.object_mut().replies = Some(v.into());
self
}
/// Add a replies to the current object
///
/// This does not overwrite the contents of replies, only appends an item
///
/// ```rust
/// # fn main() -> Result<(), anyhow::Error> {
/// use activitystreams::prelude::*;
/// # use activitystreams::{object::Video, iri};
/// # let mut video = Video::new();
///
/// video
/// .add_reply(iri!("https://example.com/one"))
/// .add_reply(iri!("https://example.com/two"));
/// # Ok(())
/// # }
/// ```
fn add_reply<T>(&mut self, replies: T) -> &mut Self
where
T: Into<AnyBase>,
{
let a = match self.object_mut().replies.take() {
Some(mut a) => {
a.add(replies.into());
a
}
None => vec![replies.into()].into(),
};
self.object_mut().replies = Some(a);
self
}
/// Take the replies from the current object, leaving nothing
///
/// ```rust
/// # use activitystreams::object::Video;
/// # let mut video = Video::new();
/// #
/// use activitystreams::prelude::*;
///
/// if let Some(replies) = video.take_replies() {
/// println!("{:?}", replies);
/// }
/// ```
fn take_replies(&mut self) -> Option<OneOrMany<AnyBase>> {
self.object_mut().replies.take()
}
/// Delete the replies from the current object
///
/// ```rust
/// # fn main() -> Result<(), anyhow::Error> {
/// # use activitystreams::{object::Video, iri};
/// # let mut video = Video::new();
/// # video.set_reply(iri!("https://example.com"));
/// #
/// use activitystreams::prelude::*;
///
/// assert!(video.replies().is_some());
/// video.delete_replies();
/// assert!(video.replies().is_none());
/// # Ok(())
/// # }
/// ```
fn delete_replies(&mut self) -> &mut Self {
self.object_mut().replies = None;
self
}
/// Fetch the to for the current object
///
/// ```rust
/// # use activitystreams::object::Video;
/// # let mut video = Video::new();
/// #
/// use activitystreams::prelude::*;
///
/// if let Some(to) = video.to() {
/// println!("{:?}", to);
/// }
/// ```
fn to<'a>(&'a self) -> Option<&'a OneOrMany<AnyBase>>
where
Self::Kind: 'a,
{
self.object_ref().to.as_ref()
}
/// Set the to for the current object
///
/// This overwrites the contents of to
///
/// ```rust
/// # fn main() -> Result<(), anyhow::Error> {
/// use activitystreams::prelude::*;
/// # use activitystreams::{object::Video, iri};
/// # let mut video = Video::new();
///
/// video.set_to(iri!("https://example.com"));
/// # Ok(())
/// # }
/// ```
fn set_to<T>(&mut self, to: T) -> &mut Self
where
T: Into<AnyBase>,
{
self.object_mut().to = Some(to.into().into());
self
}
/// Set many tos for the current object
///
/// This overwrites the contents of to
///
/// ```rust
/// # fn main() -> Result<(), anyhow::Error> {
/// use activitystreams::prelude::*;
/// # use activitystreams::{object::Video, iri};
/// # let mut video = Video::new();
///
/// video.set_many_tos(vec![
/// iri!("https://example.com/one"),
/// iri!("https://example.com/two"),
/// ]);
/// # Ok(())
/// # }
/// ```
fn set_many_tos<I, T>(&mut self, items: I) -> &mut Self
where
I: IntoIterator<Item = T>,
T: Into<AnyBase>,
{
let v: Vec<_> = items.into_iter().map(Into::into).collect();
self.object_mut().to = Some(v.into());
self
}
/// Add a to to the current object
///
/// This does not overwrite the contents of to, only appends an item
///
/// ```rust
/// # fn main() -> Result<(), anyhow::Error> {
/// use activitystreams::prelude::*;
/// # use activitystreams::{object::Video, iri};
/// # let mut video = Video::new();
///
/// video
/// .add_to(iri!("https://example.com/one"))
/// .add_to(iri!("https://example.com/two"));
/// # Ok(())
/// # }
/// ```
fn add_to<T>(&mut self, to: T) -> &mut Self
where
T: Into<AnyBase>,
{
let a = match self.object_mut().to.take() {
Some(mut a) => {
a.add(to.into());
a
}
None => vec![to.into()].into(),
};
self.object_mut().to = Some(a);
self
}
/// Take the to from the current object, leaving nothing
///
/// ```rust
/// # use activitystreams::object::Video;
/// # let mut video = Video::new();
/// #
/// use activitystreams::prelude::*;
///
/// if let Some(to) = video.take_to() {
/// println!("{:?}", to);
/// }
/// ```
fn take_to(&mut self) -> Option<OneOrMany<AnyBase>> {
self.object_mut().to.take()
}
/// Delete the to from the current object
///
/// ```rust
/// # fn main() -> Result<(), anyhow::Error> {
/// # use activitystreams::{object::Video, iri};
/// # let mut video = Video::new();
/// # video.set_to(iri!("https://example.com"));
/// #
/// use activitystreams::prelude::*;
///
/// assert!(video.to().is_some());
/// video.delete_to();
/// assert!(video.to().is_none());
/// # Ok(())
/// # }
/// ```
fn delete_to(&mut self) -> &mut Self {
self.object_mut().to = None;
self
}
/// Fetch the bto for the current object
///
/// ```rust
/// # use activitystreams::object::Video;
/// # let mut video = Video::new();
/// #
/// use activitystreams::prelude::*;
///
/// if let Some(bto) = video.bto() {
/// println!("{:?}", bto);
/// }
/// ```
fn bto<'a>(&'a self) -> Option<&'a OneOrMany<AnyBase>>
where
Self::Kind: 'a,
{
self.object_ref().bto.as_ref()
}
/// Set the bto for the current object
///
/// This overwrites the contents of bto
///
/// ```rust
/// # fn main() -> Result<(), anyhow::Error> {
/// use activitystreams::prelude::*;
/// # use activitystreams::{object::Video, iri};
/// # let mut video = Video::new();
///
/// video.set_bto(iri!("https://example.com"));
/// # Ok(())
/// # }
/// ```
fn set_bto<T>(&mut self, bto: T) -> &mut Self
where
T: Into<AnyBase>,
{
self.object_mut().bto = Some(bto.into().into());
self
}
/// Set many btos for the current object
///
/// This overwrites the contents of bto
///
/// ```rust
/// # fn main() -> Result<(), anyhow::Error> {
/// use activitystreams::prelude::*;
/// # use activitystreams::{object::Video, iri};
/// # let mut video = Video::new();
///
/// video.set_many_btos(vec![
/// iri!("https://example.com/one"),
/// iri!("https://example.com/two"),
/// ]);
/// # Ok(())
/// # }
/// ```
fn set_many_btos<I, T>(&mut self, items: I) -> &mut Self
where
I: IntoIterator<Item = T>,
T: Into<AnyBase>,
{
let v: Vec<_> = items.into_iter().map(Into::into).collect();
self.object_mut().bto = Some(v.into());
self
}
/// Add a bto to the current object
///
/// This does not overwrite the contents of bto, only appends an item
///
/// ```rust
/// # fn main() -> Result<(), anyhow::Error> {
/// use activitystreams::prelude::*;
/// # use activitystreams::{object::Video, iri};
/// # let mut video = Video::new();
///
/// video
/// .add_bto(iri!("https://example.com/one"))
/// .add_bto(iri!("https://example.com/two"));
/// # Ok(())
/// # }
/// ```
fn add_bto<T>(&mut self, bto: T) -> &mut Self
where
T: Into<AnyBase>,
{
let a = match self.object_mut().bto.take() {
Some(mut a) => {
a.add(bto.into());
a
}
None => vec![bto.into()].into(),
};
self.object_mut().bto = Some(a);
self
}
/// Take the bto from the current object, leaving nothing
///
/// ```rust
/// # use activitystreams::object::Video;
/// # let mut video = Video::new();
/// #
/// use activitystreams::prelude::*;
///
/// if let Some(bto) = video.take_bto() {
/// println!("{:?}", bto);
/// }
/// ```
fn take_bto(&mut self) -> Option<OneOrMany<AnyBase>> {
self.object_mut().bto.take()
}
/// Delete the bto from the current object
///
/// ```rust
/// # fn main() -> Result<(), anyhow::Error> {
/// # use activitystreams::{object::Video, iri};
/// # let mut video = Video::new();
/// # video.set_bto(iri!("https://example.com"));
/// #
/// use activitystreams::prelude::*;
///
/// assert!(video.bto().is_some());
/// video.delete_bto();
/// assert!(video.bto().is_none());
/// # Ok(())
/// # }
/// ```
fn delete_bto(&mut self) -> &mut Self {
self.object_mut().bto = None;
self
}
/// Fetch the cc for the current object
///
/// ```rust
/// # use activitystreams::object::Video;
/// # let mut video = Video::new();
/// #
/// use activitystreams::prelude::*;
///
/// if let Some(cc) = video.cc() {
/// println!("{:?}", cc);
/// }
/// ```
fn cc<'a>(&'a self) -> Option<&'a OneOrMany<AnyBase>>
where
Self::Kind: 'a,
{
self.object_ref().cc.as_ref()
}
/// Set the cc for the current object
///
/// This overwrites the contents of cc
///
/// ```rust
/// # fn main() -> Result<(), anyhow::Error> {
/// use activitystreams::prelude::*;
/// # use activitystreams::{object::Video, iri};
/// # let mut video = Video::new();
///
/// video.set_cc(iri!("https://example.com"));
/// # Ok(())
/// # }
/// ```
fn set_cc<T>(&mut self, cc: T) -> &mut Self
where
T: Into<AnyBase>,
{
self.object_mut().cc = Some(cc.into().into());
self
}
/// Set many ccs for the current object
///
/// This overwrites the contents of cc
///
/// ```rust
/// # fn main() -> Result<(), anyhow::Error> {
/// use activitystreams::prelude::*;
/// # use activitystreams::{object::Video, iri};
/// # let mut video = Video::new();
///
/// video.set_many_ccs(vec![
/// iri!("https://example.com/one"),
/// iri!("https://example.com/two"),
/// ]);
/// # Ok(())
/// # }
/// ```
fn set_many_ccs<I, T>(&mut self, items: I) -> &mut Self
where
I: IntoIterator<Item = T>,
T: Into<AnyBase>,
{
let v: Vec<_> = items.into_iter().map(Into::into).collect();
self.object_mut().cc = Some(v.into());
self
}
/// Add a cc to the current object
///
/// This does not overwrite the contents of cc, only appends an item
///
/// ```rust
/// # fn main() -> Result<(), anyhow::Error> {
/// use activitystreams::prelude::*;
/// # use activitystreams::{object::Video, iri};
/// # let mut video = Video::new();
///
/// video
/// .add_cc(iri!("https://example.com/one"))
/// .add_cc(iri!("https://example.com/two"));
/// # Ok(())
/// # }
/// ```
fn add_cc<T>(&mut self, cc: T) -> &mut Self
where
T: Into<AnyBase>,
{
let a = match self.object_mut().cc.take() {
Some(mut a) => {
a.add(cc.into());
a
}
None => vec![cc.into()].into(),
};
self.object_mut().cc = Some(a);
self
}
/// Take the cc from the current object, leaving nothing
///
/// ```rust
/// # use activitystreams::object::Video;
/// # let mut video = Video::new();
/// #
/// use activitystreams::prelude::*;
///
/// if let Some(cc) = video.take_cc() {
/// println!("{:?}", cc);
/// }
/// ```
fn take_cc(&mut self) -> Option<OneOrMany<AnyBase>> {
self.object_mut().cc.take()
}
/// Delete the cc from the current object
///
/// ```rust
/// # fn main() -> Result<(), anyhow::Error> {
/// # use activitystreams::{object::Video, iri};
/// # let mut video = Video::new();
/// # video.set_cc(iri!("https://example.com"));
/// #
/// use activitystreams::prelude::*;
///
/// assert!(video.cc().is_some());
/// video.delete_cc();
/// assert!(video.cc().is_none());
/// # Ok(())
/// # }
/// ```
fn delete_cc(&mut self) -> &mut Self {
self.object_mut().cc = None;
self
}
/// Fetch the bcc for the current object
///
/// ```rust
/// # use activitystreams::object::Video;
/// # let mut video = Video::new();
/// #
/// use activitystreams::prelude::*;
///
/// if let Some(bcc) = video.bcc() {
/// println!("{:?}", bcc);
/// }
/// ```
fn bcc<'a>(&'a self) -> Option<&'a OneOrMany<AnyBase>>
where
Self::Kind: 'a,
{
self.object_ref().bcc.as_ref()
}
/// Set the bcc for the current object
///
/// This overwrites the contents of bcc
///
/// ```rust
/// # fn main() -> Result<(), anyhow::Error> {
/// use activitystreams::prelude::*;
/// # use activitystreams::{object::Video, iri};
/// # let mut video = Video::new();
///
/// video.set_bcc(iri!("https://example.com"));
/// # Ok(())
/// # }
/// ```
fn set_bcc<T>(&mut self, bcc: T) -> &mut Self
where
T: Into<AnyBase>,
{
self.object_mut().bcc = Some(bcc.into().into());
self
}
/// Set many bcc for the current object
///
/// This overwrites the contents of bcc
///
/// ```rust
/// # fn main() -> Result<(), anyhow::Error> {
/// use activitystreams::prelude::*;
/// # use activitystreams::{object::Video, iri};
/// # let mut video = Video::new();
///
/// video.set_many_bcc(vec![
/// iri!("https://example.com/one"),
/// iri!("https://example.com/two"),
/// ]);
/// # Ok(())
/// # }
/// ```
fn set_many_bcc<I, T>(&mut self, items: I) -> &mut Self
where
I: IntoIterator<Item = T>,
T: Into<AnyBase>,
{
let v: Vec<_> = items.into_iter().map(Into::into).collect();
self.object_mut().bcc = Some(v.into());
self
}
/// Add a bcc to the current object
///
/// This does not overwrite the contents of bcc, only appends an item
///
/// ```rust
/// # fn main() -> Result<(), anyhow::Error> {
/// use activitystreams::prelude::*;
/// # use activitystreams::{object::Video, iri};
/// # let mut video = Video::new();
///
/// video
/// .add_bcc(iri!("https://example.com/one"))
/// .add_bcc(iri!("https://example.com/two"));
/// # Ok(())
/// # }
/// ```
fn add_bcc<T>(&mut self, bcc: T) -> &mut Self
where
T: Into<AnyBase>,
{
let a = match self.object_mut().bcc.take() {
Some(mut a) => {
a.add(bcc.into());
a
}
None => vec![bcc.into()].into(),
};
self.object_mut().bcc = Some(a);
self
}
/// Take the bcc from the current object, leaving nothing
///
/// ```rust
/// # use activitystreams::object::Video;
/// # let mut video = Video::new();
/// #
/// use activitystreams::prelude::*;
///
/// if let Some(bcc) = video.take_bcc() {
/// println!("{:?}", bcc);
/// }
/// ```
fn take_bcc(&mut self) -> Option<OneOrMany<AnyBase>> {
self.object_mut().bcc.take()
}
/// Delete the bcc from the current object
///
/// ```rust
/// # fn main() -> Result<(), anyhow::Error> {
/// # use activitystreams::{object::Video, iri};
/// # let mut video = Video::new();
/// # video.set_bcc(iri!("https://example.com"));
/// #
/// use activitystreams::prelude::*;
///
/// assert!(video.bcc().is_some());
/// video.delete_bcc();
/// assert!(video.bcc().is_none());
/// # Ok(())
/// # }
/// ```
fn delete_bcc(&mut self) -> &mut Self {
self.object_mut().bcc = None;
self
}
}
/// Helper methods for interacting with ActivityPub Object types
///
/// This trait represents methods valid for any ActivityPub Object.
///
/// Documentation for the fields related to these methods can be found on the `ApObject` struct
pub trait ApObjectExt: AsApObject {
/// Fetch the shares for the current object
///
/// ```rust
/// # use activitystreams::object::{ApObject, Video};
/// # let mut video = ApObject::new(Video::new());
/// #
/// use activitystreams::prelude::*;
///
/// if let Some(shares) = video.shares() {
/// println!("{:?}", shares);
/// }
/// ```
fn shares<'a>(&'a self) -> Option<&'a IriString>
where
Self::Inner: 'a,
{
self.ap_object_ref().shares.as_ref()
}
/// Set the shares for the current object
///
/// This overwrites the contents of shares
///
/// ```rust
/// # fn main() -> Result<(), anyhow::Error> {
/// # use activitystreams::object::{ApObject, Video};
/// # let mut video = ApObject::new(Video::new());
/// #
/// use activitystreams::{prelude::*, iri};
///
/// video.set_shares(iri!("https://example.com"));
/// # Ok(())
/// # }
/// ```
fn set_shares(&mut self, shares: IriString) -> &mut Self {
self.ap_object_mut().shares = Some(shares);
self
}
/// Take the shares from the current object, leaving nothing
///
/// ```rust
/// # use activitystreams::object::{ApObject, Video};
/// # let mut video = ApObject::new(Video::new());
/// #
/// use activitystreams::prelude::*;
///
/// if let Some(shares) = video.take_shares() {
/// println!("{:?}", shares);
/// }
/// ```
fn take_shares(&mut self) -> Option<IriString> {
self.ap_object_mut().shares.take()
}
/// Delete the shares from the current object
///
/// ```rust
/// # use activitystreams::{context, object::{ApObject, Video}};
/// # let mut video = ApObject::new(Video::new());
/// # video.set_shares(context());
/// #
/// use activitystreams::prelude::*;
///
/// assert!(video.shares().is_some());
/// video.delete_shares();
/// assert!(video.shares().is_none());
/// ```
fn delete_shares(&mut self) -> &mut Self {
self.ap_object_mut().shares = None;
self
}
/// Fetch the likes for the current object
///
/// ```rust
/// # use activitystreams::object::{ApObject, Video};
/// # let mut video = ApObject::new(Video::new());
/// #
/// use activitystreams::prelude::*;
///
/// if let Some(likes) = video.likes() {
/// println!("{:?}", likes);
/// }
/// ```
fn likes<'a>(&'a self) -> Option<&'a IriString>
where
Self::Inner: 'a,
{
self.ap_object_ref().likes.as_ref()
}
/// Set the likes for the current object
///
/// This overwrites the contents of likes
///
/// ```rust
/// # fn main() -> Result<(), anyhow::Error> {
/// # use activitystreams::object::{ApObject, Video};
/// # let mut video = ApObject::new(Video::new());
/// #
/// use activitystreams::{prelude::*, iri};
///
/// video.set_likes(iri!("https://example.com"));
/// # Ok(())
/// # }
/// ```
fn set_likes(&mut self, likes: IriString) -> &mut Self {
self.ap_object_mut().likes = Some(likes);
self
}
/// Take the likes from the current object, leaving nothing
///
/// ```rust
/// # use activitystreams::object::{ApObject, Video};
/// # let mut video = ApObject::new(Video::new());
/// #
/// use activitystreams::prelude::*;
///
/// if let Some(likes) = video.take_likes() {
/// println!("{:?}", likes);
/// }
/// ```
fn take_likes(&mut self) -> Option<IriString> {
self.ap_object_mut().likes.take()
}
/// Delete the likes from the current object
///
/// ```rust
/// # use activitystreams::{context, object::{ApObject, Video}};
/// # let mut video = ApObject::new(Video::new());
/// # video.set_likes(context());
/// #
/// use activitystreams::prelude::*;
///
/// assert!(video.likes().is_some());
/// video.delete_likes();
/// assert!(video.likes().is_none());
/// ```
fn delete_likes(&mut self) -> &mut Self {
self.ap_object_mut().likes = None;
self
}
/// Fetch the source for the current object
///
/// ```rust
/// # use activitystreams::object::{ApObject, Video};
/// # let mut video = ApObject::new(Video::new());
/// #
/// use activitystreams::prelude::*;
///
/// if let Some(source) = video.source() {
/// println!("{:?}", source);
/// }
/// ```
fn source<'a>(&'a self) -> Option<&'a AnyBase>
where
Self::Inner: 'a,
{
self.ap_object_ref().source.as_ref()
}
/// Set the source for the current object
///
/// This overwrites the contents of source
///
/// ```rust
/// # fn main() -> Result<(), anyhow::Error> {
/// # use activitystreams::{object::{ApObject, Video}, iri};
/// # let mut video = ApObject::new(Video::new());
/// #
/// use activitystreams::prelude::*;
///
/// video.set_source(iri!("https://example.com"));
/// # Ok(())
/// # }
/// ```
fn set_source<T>(&mut self, source: T) -> &mut Self
where
T: Into<AnyBase>,
{
self.ap_object_mut().source = Some(source.into());
self
}
/// Take the source from the current object, leaving nothing
///
/// ```rust
/// # use activitystreams::object::{ApObject, Video};
/// # let mut video = ApObject::new(Video::new());
/// #
/// use activitystreams::prelude::*;
///
/// if let Some(source) = video.take_source() {
/// println!("{:?}", source);
/// }
/// ```
fn take_source(&mut self) -> Option<AnyBase> {
self.ap_object_mut().source.take()
}
/// Delete the source from the current object
///
/// ```rust
/// # use activitystreams::{context, object::{ApObject, Video}};
/// # let mut video = ApObject::new(Video::new());
/// # video.set_source(context());
/// #
/// use activitystreams::prelude::*;
///
/// assert!(video.source().is_some());
/// video.delete_source();
/// assert!(video.source().is_none());
/// ```
fn delete_source(&mut self) -> &mut Self {
self.ap_object_mut().source = None;
self
}
/// Fetch the upload_media for the current object
///
/// ```rust
/// # use activitystreams::object::{ApObject, Video};
/// # let mut video = ApObject::new(Video::new());
/// #
/// use activitystreams::prelude::*;
///
/// if let Some(upload_media) = video.upload_media() {
/// println!("{:?}", upload_media);
/// }
/// ```
fn upload_media<'a>(&'a self) -> Option<OneOrMany<&'a IriString>>
where
Self::Inner: 'a,
{
self.ap_object_ref()
.upload_media
.as_ref()
.map(|o| o.as_ref())
}
/// Set the upload_media for the current object
///
/// This overwrites the contents of upload_media
///
/// ```rust
/// # fn main() -> Result<(), anyhow::Error> {
/// # use activitystreams::object::{ApObject, Video};
/// # let mut video = ApObject::new(Video::new());
/// #
/// use activitystreams::{prelude::*, iri};
///
/// video.set_upload_media(iri!("https://example.com"));
/// # Ok(())
/// # }
/// ```
fn set_upload_media(&mut self, upload_media: IriString) -> &mut Self {
self.ap_object_mut().upload_media = Some(upload_media.into());
self
}
/// Set many upload_medias for the current object
///
/// This overwrites the contents of upload_media
///
/// ```rust
/// # fn main() -> Result<(), anyhow::Error> {
/// # use activitystreams::object::{ApObject, Video};
/// # let mut video = ApObject::new(Video::new());
/// #
/// use activitystreams::{prelude::*, iri};
///
/// video.set_many_upload_medias(vec![
/// iri!("https://example.com/one"),
/// iri!("https://example.com/two"),
/// ]);
/// # Ok(())
/// # }
/// ```
fn set_many_upload_medias<I, U>(&mut self, items: I) -> &mut Self
where
I: IntoIterator<Item = U>,
U: Into<IriString>,
{
let v: Vec<IriString> = items.into_iter().map(|u| u.into()).collect();
self.ap_object_mut().upload_media = Some(v.into());
self
}
/// Add a upload_media to the current object
///
/// This does not overwrite the contents of upload_media, only appends an item
///
/// ```rust
/// # fn main() -> Result<(), anyhow::Error> {
/// # use activitystreams::object::{ApObject, Video};
/// # let mut video = ApObject::new(Video::new());
/// #
/// use activitystreams::{prelude::*, iri};
///
/// video
/// .add_upload_media(iri!("https://example.com/one"))
/// .add_upload_media(iri!("https://example.com/two"));
/// # Ok(())
/// # }
/// ```
fn add_upload_media(&mut self, upload_media: IriString) -> &mut Self {
let v = match self.ap_object_mut().upload_media.take() {
Some(mut v) => {
v.add(upload_media);
v
}
None => vec![upload_media].into(),
};
self.ap_object_mut().upload_media = Some(v);
self
}
/// Take the upload_media from the current object, leaving nothing
///
/// ```rust
/// # use activitystreams::object::{ApObject, Video};
/// # let mut video = ApObject::new(Video::new());
/// #
/// use activitystreams::prelude::*;
///
/// if let Some(upload_media) = video.take_upload_media() {
/// println!("{:?}", upload_media);
/// }
/// ```
fn take_upload_media(&mut self) -> Option<OneOrMany<IriString>> {
self.ap_object_mut().upload_media.take()
}
/// Delete the upload_media from the current object
///
/// ```rust
/// # use activitystreams::{context, object::{ApObject, Video}};
/// # let mut video = ApObject::new(Video::new());
/// # video.set_upload_media(context());
/// #
/// use activitystreams::prelude::*;
///
/// assert!(video.upload_media().is_some());
/// video.delete_upload_media();
/// assert!(video.upload_media().is_none());
/// ```
fn delete_upload_media(&mut self) -> &mut Self {
self.ap_object_mut().upload_media = None;
self
}
}
/// Helper methods for interacting with Place types
///
/// This trait represents methods valid for any Place.
///
/// Documentation for the fields related to these methods can be found on the `Place` struct
pub trait PlaceExt: AsPlace {
/// Fetch the accuracy of the current object
///
/// ```rust
/// # use activitystreams::object::Place;
/// # let mut place = Place::new();
/// #
/// use activitystreams::prelude::*;
///
/// if let Some(accuracy) = place.accuracy() {
/// println!("{:?}", accuracy);
/// }
/// ```
fn accuracy(&self) -> Option<f64> {
self.place_ref().accuracy
}
/// Set the accuracy for the current object
///
/// This overwrites the contents of accuracy
///
/// ```rust
/// # use activitystreams::object::Place;
/// # let mut place = Place::new();
/// #
/// use activitystreams::prelude::*;
///
/// place.set_accuracy(5f64);
/// ```
fn set_accuracy<T>(&mut self, float: T) -> &mut Self
where
T: Into<f64>,
{
self.place_mut().accuracy = Some(float.into());
self
}
/// Take the accuracy of the current object, leaving nothing
///
/// ```rust
/// # use activitystreams::object::Place;
/// # let mut place = Place::new();
/// #
/// use activitystreams::prelude::*;
///
/// if let Some(accuracy) = place.accuracy() {
/// println!("{:?}", accuracy);
/// }
/// ```
fn take_accuracy(&mut self) -> Option<f64> {
self.place_mut().accuracy.take()
}
/// Delete the accuracy from the current object
///
/// ```rust
/// # use activitystreams::object::Place;
/// # let mut place = Place::new();
/// # place.set_accuracy(5f64);
/// #
/// use activitystreams::prelude::*;
///
/// assert!(place.accuracy().is_some());
/// place.delete_accuracy();
/// assert!(place.accuracy().is_none());
/// ```
fn delete_accuracy(&mut self) -> &mut Self {
self.place_mut().accuracy = None;
self
}
/// Fetch the altitude of the current object
///
/// ```rust
/// # use activitystreams::object::Place;
/// # let mut place = Place::new();
/// #
/// use activitystreams::prelude::*;
///
/// if let Some(altitude) = place.altitude() {
/// println!("{:?}", altitude);
/// }
/// ```
fn altitude(&self) -> Option<f64> {
self.place_ref().altitude
}
/// Set the altitude for the current object
///
/// This overwrites the contents of altitude
///
/// ```rust
/// # use activitystreams::object::Place;
/// # let mut place = Place::new();
/// #
/// use activitystreams::prelude::*;
///
/// place.set_altitude(5f64);
/// ```
fn set_altitude<T>(&mut self, float: T) -> &mut Self
where
T: Into<f64>,
{
self.place_mut().altitude = Some(float.into());
self
}
/// Take the altitude of the current object, leaving nothing
///
/// ```rust
/// # use activitystreams::object::Place;
/// # let mut place = Place::new();
/// #
/// use activitystreams::prelude::*;
///
/// if let Some(altitude) = place.altitude() {
/// println!("{:?}", altitude);
/// }
/// ```
fn take_altitude(&mut self) -> Option<f64> {
self.place_mut().altitude.take()
}
/// Delete the altitude from the current object
///
/// ```rust
/// # use activitystreams::object::Place;
/// # let mut place = Place::new();
/// # place.set_altitude(5f64);
/// #
/// use activitystreams::prelude::*;
///
/// assert!(place.altitude().is_some());
/// place.delete_altitude();
/// assert!(place.altitude().is_none());
/// ```
fn delete_altitude(&mut self) -> &mut Self {
self.place_mut().altitude = None;
self
}
/// Fetch the latitude of the current object
///
/// ```rust
/// # use activitystreams::object::Place;
/// # let mut place = Place::new();
/// #
/// use activitystreams::prelude::*;
///
/// if let Some(latitude) = place.latitude() {
/// println!("{:?}", latitude);
/// }
/// ```
fn latitude(&self) -> Option<f64> {
self.place_ref().latitude
}
/// Set the latitude for the current object
///
/// This overwrites the contents of latitude
///
/// ```rust
/// # use activitystreams::object::Place;
/// # let mut place = Place::new();
/// #
/// use activitystreams::prelude::*;
///
/// place.set_latitude(5f64);
/// ```
fn set_latitude<T>(&mut self, float: T) -> &mut Self
where
T: Into<f64>,
{
self.place_mut().latitude = Some(float.into());
self
}
/// Take the latitude of the current object, leaving nothing
///
/// ```rust
/// # use activitystreams::object::Place;
/// # let mut place = Place::new();
/// #
/// use activitystreams::prelude::*;
///
/// if let Some(latitude) = place.latitude() {
/// println!("{:?}", latitude);
/// }
/// ```
fn take_latitude(&mut self) -> Option<f64> {
self.place_mut().latitude.take()
}
/// Delete the latitude from the current object
///
/// ```rust
/// # use activitystreams::object::Place;
/// # let mut place = Place::new();
/// # place.set_latitude(5f64);
/// #
/// use activitystreams::prelude::*;
///
/// assert!(place.latitude().is_some());
/// place.delete_latitude();
/// assert!(place.latitude().is_none());
/// ```
fn delete_latitude(&mut self) -> &mut Self {
self.place_mut().latitude = None;
self
}
/// Fetch the longitude of the current object
///
/// ```rust
/// # use activitystreams::object::Place;
/// # let mut place = Place::new();
/// #
/// use activitystreams::prelude::*;
///
/// if let Some(longitude) = place.longitude() {
/// println!("{:?}", longitude);
/// }
/// ```
fn longitude(&self) -> Option<f64> {
self.place_ref().longitude
}
/// Set the longitude for the current object
///
/// This overwrites the contents of longitude
///
/// ```rust
/// # use activitystreams::object::Place;
/// # let mut place = Place::new();
/// #
/// use activitystreams::prelude::*;
///
/// place.set_longitude(5f64);
/// ```
fn set_longitude<T>(&mut self, float: T) -> &mut Self
where
T: Into<f64>,
{
self.place_mut().longitude = Some(float.into());
self
}
/// Take the longitude of the current object, leaving nothing
///
/// ```rust
/// # use activitystreams::object::Place;
/// # let mut place = Place::new();
/// #
/// use activitystreams::prelude::*;
///
/// if let Some(longitude) = place.longitude() {
/// println!("{:?}", longitude);
/// }
/// ```
fn take_longitude(&mut self) -> Option<f64> {
self.place_mut().longitude.take()
}
/// Delete the longitude from the current object
///
/// ```rust
/// # use activitystreams::object::Place;
/// # let mut place = Place::new();
/// # place.set_longitude(5f64);
/// #
/// use activitystreams::prelude::*;
///
/// assert!(place.longitude().is_some());
/// place.delete_longitude();
/// assert!(place.longitude().is_none());
/// ```
fn delete_longitude(&mut self) -> &mut Self {
self.place_mut().longitude = None;
self
}
/// Fetch the radius of the current object
///
/// ```rust
/// # use activitystreams::object::Place;
/// # let mut place = Place::new();
/// #
/// use activitystreams::prelude::*;
///
/// if let Some(radius) = place.radius() {
/// println!("{:?}", radius);
/// }
/// ```
fn radius(&self) -> Option<f64> {
self.place_ref().radius
}
/// Set the radius for the current object
///
/// This overwrites the contents of radius
///
/// ```rust
/// # use activitystreams::object::Place;
/// # let mut place = Place::new();
/// #
/// use activitystreams::prelude::*;
///
/// place.set_radius(5f64);
/// ```
fn set_radius<T>(&mut self, float: T) -> &mut Self
where
T: Into<f64>,
{
self.place_mut().radius = Some(float.into());
self
}
/// Take the radius of the current object, leaving nothing
///
/// ```rust
/// # use activitystreams::object::Place;
/// # let mut place = Place::new();
/// #
/// use activitystreams::prelude::*;
///
/// if let Some(radius) = place.radius() {
/// println!("{:?}", radius);
/// }
/// ```
fn take_radius(&mut self) -> Option<f64> {
self.place_mut().radius.take()
}
/// Delete the radius from the current object
///
/// ```rust
/// # use activitystreams::object::Place;
/// # let mut place = Place::new();
/// # place.set_radius(5f64);
/// #
/// use activitystreams::prelude::*;
///
/// assert!(place.radius().is_some());
/// place.delete_radius();
/// assert!(place.radius().is_none());
/// ```
fn delete_radius(&mut self) -> &mut Self {
self.place_mut().radius = None;
self
}
/// Fetch the units of the current object
///
/// ```rust
/// # use activitystreams::object::Place;
/// # let mut place = Place::new();
/// #
/// use activitystreams::prelude::*;
///
/// if let Some(units) = place.units() {
/// println!("{:?}", units);
/// }
/// ```
fn units(&self) -> Option<&Unit> {
self.place_ref().units.as_ref()
}
/// Set the units for the current object
///
/// This overwrites the contents of units
///
/// ```rust
/// # use activitystreams::object::Place;
/// # let mut place = Place::new();
/// #
/// use activitystreams::{prelude::*, primitives::Unit};
///
/// place.set_units(Unit::centimeters());
/// ```
fn set_units<T>(&mut self, units: T) -> &mut Self
where
T: Into<Unit>,
{
self.place_mut().units = Some(units.into());
self
}
/// Take the units of the current object, leaving nothing
///
/// ```rust
/// # use activitystreams::object::Place;
/// # let mut place = Place::new();
/// #
/// use activitystreams::prelude::*;
///
/// if let Some(units) = place.units() {
/// println!("{:?}", units);
/// }
/// ```
fn take_units(&mut self) -> Option<Unit> {
self.place_mut().units.take()
}
/// Delete the units from the current object
///
/// ```rust
/// # use activitystreams::{object::Place, primitives::Unit};
/// # let mut place = Place::new();
/// # place.set_units(Unit::centimeters());
/// #
/// use activitystreams::prelude::*;
///
/// assert!(place.units().is_some());
/// place.delete_units();
/// assert!(place.units().is_none());
/// ```
fn delete_units(&mut self) -> &mut Self {
self.place_mut().units = None;
self
}
}
/// Helper methods for interacting with Profile types
///
/// This trait represents methods valid for any Profile.
///
/// Documentation for the fields related to these methods can be found on the `Profile` struct
pub trait ProfileExt: AsProfile {
/// Fetch the described object for the current object
///
/// ```rust
/// # use activitystreams::object::Profile;
/// # let mut profile = Profile::new();
/// #
/// use activitystreams::prelude::*;
///
/// if let Some(describes) = profile.describes() {
/// println!("{:?}", describes);
/// }
/// ```
fn describes(&self) -> Option<&AnyBase> {
self.profile_ref().describes.as_ref()
}
/// Set the described object for the current object
///
/// This overwrites the contents of describes
///
/// ```rust
/// # fn main() -> Result<(), anyhow::Error> {
/// # use activitystreams::{object::Profile, iri};
/// # let mut profile = Profile::new();
/// #
/// use activitystreams::prelude::*;
///
/// profile.set_describes(iri!("https://example.com"));
/// # Ok(())
/// # }
/// ```
fn set_describes<T>(&mut self, describes: T) -> &mut Self
where
T: Into<AnyBase>,
{
self.profile_mut().describes = Some(describes.into());
self
}
/// Take the described object from the current object, leaving nothing
///
/// ```rust
/// # use activitystreams::object::Profile;
/// # let mut profile = Profile::new();
/// #
/// use activitystreams::prelude::*;
///
/// if let Some(describes) = profile.take_describes() {
/// println!("{:?}", describes);
/// }
/// ```
fn take_describes(&mut self) -> Option<AnyBase> {
self.profile_mut().describes.take()
}
/// Delete the described object from the current object
///
/// ```rust
/// # use activitystreams::{context, object::Profile};
/// # let mut profile = Profile::new();
/// # profile.set_describes(context());
/// #
/// use activitystreams::prelude::*;
///
/// assert!(profile.describes().is_some());
/// profile.delete_describes();
/// assert!(profile.describes().is_none());
/// ```
fn delete_describes(&mut self) -> &mut Self {
self.profile_mut().describes = None;
self
}
}
/// Helper methods for interacting with Relationship types
///
/// This trait represents methods valid for any Relationship.
///
/// Documentation for the fields related to these methods can be found on the `Relationship` struct
pub trait RelationshipExt: AsRelationship {
/// Fetch the subject for the current object
///
/// ```rust
/// # use activitystreams::object::Relationship;
/// # let mut relationship = Relationship::new();
/// #
/// use activitystreams::prelude::*;
///
/// if let Some(subject) = relationship.subject() {
/// println!("{:?}", subject);
/// }
/// ```
fn subject(&self) -> Option<&AnyBase> {
self.relationship_ref().subject.as_ref()
}
/// Set the subject for the current object
///
/// This overwrites the contents of subject
///
/// ```rust
/// # fn main() -> Result<(), anyhow::Error> {
/// # use activitystreams::{object::Relationship, iri};
/// # let mut relationship = Relationship::new();
/// #
/// use activitystreams::prelude::*;
///
/// relationship.set_subject(iri!("https://example.com"));
/// # Ok(())
/// # }
/// ```
fn set_subject<T>(&mut self, subject: T) -> &mut Self
where
T: Into<AnyBase>,
{
self.relationship_mut().subject = Some(subject.into());
self
}
/// Take the subject from the current object, leaving nothing
///
/// ```rust
/// # use activitystreams::object::Relationship;
/// # let mut relationship = Relationship::new();
/// #
/// use activitystreams::prelude::*;
///
/// if let Some(subject) = relationship.take_subject() {
/// println!("{:?}", subject);
/// }
/// ```
fn take_subject(&mut self) -> Option<AnyBase> {
self.relationship_mut().subject.take()
}
/// Delete the subject from the current object
///
/// ```rust
/// # use activitystreams::{context, object::Relationship};
/// # let mut relationship = Relationship::new();
/// # relationship.set_subject(context());
/// #
/// use activitystreams::prelude::*;
///
/// assert!(relationship.subject().is_some());
/// relationship.delete_subject();
/// assert!(relationship.subject().is_none());
/// ```
fn delete_subject(&mut self) -> &mut Self {
self.relationship_mut().subject = None;
self
}
/// Fetch the object for the current object
///
/// ```rust
/// # use activitystreams::object::Relationship;
/// # let mut relationship = Relationship::new();
/// #
/// use activitystreams::prelude::*;
///
/// if let Some(object) = relationship.object() {
/// println!("{:?}", object);
/// }
/// ```
fn object(&self) -> Option<&OneOrMany<AnyBase>> {
self.relationship_ref().object.as_ref()
}
/// Set the object for the current object
///
/// This overwrites the contents of object
///
/// ```rust
/// # fn main() -> Result<(), anyhow::Error> {
/// use activitystreams::prelude::*;
/// # use activitystreams::{object::Relationship, iri};
/// # let mut relationship = Relationship::new();
///
/// relationship.set_object(iri!("https://example.com"));
/// # Ok(())
/// # }
/// ```
fn set_object<T>(&mut self, object: T) -> &mut Self
where
T: Into<AnyBase>,
{
self.relationship_mut().object = Some(object.into().into());
self
}
/// Set many objects for the current object
///
/// This overwrites the contents of object
///
/// ```rust
/// # fn main() -> Result<(), anyhow::Error> {
/// use activitystreams::prelude::*;
/// # use activitystreams::{object::Relationship, iri};
/// # let mut relationship = Relationship::new();
///
/// relationship.set_many_objects(vec![
/// iri!("https://example.com/one"),
/// iri!("https://example.com/two"),
/// ]);
/// # Ok(())
/// # }
/// ```
fn set_many_objects<I, T>(&mut self, items: I) -> &mut Self
where
I: IntoIterator<Item = T>,
T: Into<AnyBase>,
{
let v: Vec<_> = items.into_iter().map(Into::into).collect();
self.relationship_mut().object = Some(v.into());
self
}
/// Add a object to the current object
///
/// This does not overwrite the contents of object, only appends an item
///
/// ```rust
/// # fn main() -> Result<(), anyhow::Error> {
/// use activitystreams::prelude::*;
/// # use activitystreams::{object::Relationship, iri};
/// # let mut relationship = Relationship::new();
///
/// relationship
/// .add_object(iri!("https://example.com/one"))
/// .add_object(iri!("https://example.com/two"));
/// # Ok(())
/// # }
/// ```
fn add_object<T>(&mut self, object: T) -> &mut Self
where
T: Into<AnyBase>,
{
let v = match self.relationship_mut().object.take() {
Some(mut v) => {
v.add(object.into());
v
}
None => vec![object.into()].into(),
};
self.relationship_mut().object = Some(v);
self
}
/// Take the object from the current object, leaving nothing
///
/// ```rust
/// # use activitystreams::object::Relationship;
/// # let mut relationship = Relationship::new();
/// #
/// use activitystreams::prelude::*;
///
/// if let Some(object) = relationship.take_object() {
/// println!("{:?}", object);
/// }
/// ```
fn take_object(&mut self) -> Option<OneOrMany<AnyBase>> {
self.relationship_mut().object.take()
}
/// Delete the object from the current object
///
/// ```rust
/// # fn main() -> Result<(), anyhow::Error> {
/// # use activitystreams::{object::Relationship, iri};
/// # let mut relationship = Relationship::new();
/// # relationship.set_object(iri!("https://example.com"));
/// #
/// use activitystreams::prelude::*;
///
/// assert!(relationship.object().is_some());
/// relationship.delete_object();
/// assert!(relationship.object().is_none());
/// # Ok(())
/// # }
/// ```
fn delete_object(&mut self) -> &mut Self {
self.relationship_mut().object = None;
self
}
/// Fetch the relationship for the current object
///
/// ```rust
/// # use activitystreams::object::Relationship;
/// # let mut relationship = Relationship::new();
/// #
/// use activitystreams::prelude::*;
///
/// if let Some(relationship) = relationship.relationship() {
/// println!("{:?}", relationship);
/// }
/// ```
fn relationship(&self) -> Option<&OneOrMany<AnyBase>> {
self.relationship_ref().relationship.as_ref()
}
/// Set the relationship for the current object
///
/// This overwrites the contents of relationship
///
/// ```rust
/// # fn main() -> Result<(), anyhow::Error> {
/// use activitystreams::prelude::*;
/// # use activitystreams::{object::Relationship, iri};
/// # let mut relationship = Relationship::new();
///
/// relationship.set_relationship(iri!("https://example.com"));
/// # Ok(())
/// # }
/// ```
fn set_relationship<T>(&mut self, relationship: T) -> &mut Self
where
T: Into<AnyBase>,
{
self.relationship_mut().relationship = Some(relationship.into().into());
self
}
/// Set many relationships for the current object
///
/// This overwrites the contents of relationship
///
/// ```rust
/// # fn main() -> Result<(), anyhow::Error> {
/// use activitystreams::prelude::*;
/// # use activitystreams::{object::Relationship, iri};
/// # let mut relationship = Relationship::new();
///
/// relationship.set_many_relationships(vec![
/// iri!("https://example.com/one"),
/// iri!("https://example.com/two"),
/// ]);
/// # Ok(())
/// # }
/// ```
fn set_many_relationships<I, T>(&mut self, items: I) -> &mut Self
where
I: IntoIterator<Item = T>,
T: Into<AnyBase>,
{
let v: Vec<_> = items.into_iter().map(Into::into).collect();
self.relationship_mut().relationship = Some(v.into());
self
}
/// Add a relationship to the current object
///
/// This does not overwrite the contents of relationship, only appends an item
///
/// ```rust
/// # fn main() -> Result<(), anyhow::Error> {
/// use activitystreams::prelude::*;
/// # use activitystreams::{object::Relationship, iri};
/// # let mut relationship = Relationship::new();
///
/// relationship
/// .add_relationship(iri!("https://example.com/one"))
/// .add_relationship(iri!("https://example.com/two"));
/// # Ok(())
/// # }
/// ```
fn add_relationship<T>(&mut self, relationship: T) -> &mut Self
where
T: Into<AnyBase>,
{
let v = match self.relationship_mut().relationship.take() {
Some(mut v) => {
v.add(relationship.into());
v
}
None => vec![relationship.into()].into(),
};
self.relationship_mut().relationship = Some(v);
self
}
/// Take the relationship from the current object, leaving nothing
///
/// ```rust
/// # use activitystreams::object::Relationship;
/// # let mut relationship = Relationship::new();
/// #
/// use activitystreams::prelude::*;
///
/// if let Some(relationship) = relationship.take_relationship() {
/// println!("{:?}", relationship);
/// }
/// ```
fn take_relationship(&mut self) -> Option<OneOrMany<AnyBase>> {
self.relationship_mut().relationship.take()
}
/// Delete the relationship from the current object
///
/// ```rust
/// # fn main() -> Result<(), anyhow::Error> {
/// # use activitystreams::{object::Relationship, iri};
/// # let mut relationship = Relationship::new();
/// # relationship.set_relationship(iri!("https://example.com"));
/// #
/// use activitystreams::prelude::*;
///
/// assert!(relationship.relationship().is_some());
/// relationship.delete_relationship();
/// assert!(relationship.relationship().is_none());
/// # Ok(())
/// # }
/// ```
fn delete_relationship(&mut self) -> &mut Self {
self.relationship_mut().relationship = None;
self
}
}
/// Helper methods for interacting with Tombstone types
///
/// This trait represents methods valid for any Tombstone.
///
/// Documentation for the fields related to these methods can be found on the `Tombstone` struct
pub trait TombstoneExt: AsTombstone {
/// Fetch the former_type for the current object
///
/// ```rust
/// # use activitystreams::object::Tombstone;
/// # let mut tombstone = Tombstone::new();
/// #
/// use activitystreams::prelude::*;
///
/// if let Some(former_type) = tombstone.former_type() {
/// println!("{:?}", former_type);
/// }
/// ```
fn former_type(&self) -> Option<&OneOrMany<AnyBase>> {
self.tombstone_ref().former_type.as_ref()
}
/// Set the former_type for the current object
///
/// This overwrites the contents of former_type
///
/// ```rust
/// # fn main() -> Result<(), anyhow::Error> {
/// use activitystreams::prelude::*;
/// # use activitystreams::{object::Tombstone, iri};
/// # let mut tombstone = Tombstone::new();
///
/// tombstone.set_former_type(iri!("https://example.com"));
/// # Ok(())
/// # }
/// ```
fn set_former_type<T>(&mut self, former_type: T) -> &mut Self
where
T: Into<AnyBase>,
{
self.tombstone_mut().former_type = Some(former_type.into().into());
self
}
/// Set many former_types for the current object
///
/// This overwrites the contents of former_type
///
/// ```rust
/// # fn main() -> Result<(), anyhow::Error> {
/// use activitystreams::prelude::*;
/// # use activitystreams::{object::Tombstone, iri};
/// # let mut tombstone = Tombstone::new();
///
/// tombstone.set_many_former_types(vec![
/// iri!("https://example.com/one"),
/// iri!("https://example.com/two"),
/// ]);
/// # Ok(())
/// # }
/// ```
fn set_many_former_types<I, T>(&mut self, items: I) -> &mut Self
where
I: IntoIterator<Item = T>,
T: Into<AnyBase>,
{
let v: Vec<_> = items.into_iter().map(Into::into).collect();
self.tombstone_mut().former_type = Some(v.into());
self
}
/// Add a former_type to the current object
///
/// This does not overwrite the contents of former_type, only appends an item
///
/// ```rust
/// # fn main() -> Result<(), anyhow::Error> {
/// use activitystreams::prelude::*;
/// # use activitystreams::{object::Tombstone, iri};
/// # let mut tombstone = Tombstone::new();
///
/// tombstone
/// .add_former_type(iri!("https://example.com/one"))
/// .add_former_type(iri!("https://example.com/two"));
/// # Ok(())
/// # }
/// ```
fn add_former_type<T>(&mut self, former_type: T) -> &mut Self
where
T: Into<AnyBase>,
{
let v = match self.tombstone_mut().former_type.take() {
Some(mut v) => {
v.add(former_type.into());
v
}
None => vec![former_type.into()].into(),
};
self.tombstone_mut().former_type = Some(v);
self
}
/// Take the former_type from the current object, leaving nothing
///
/// ```rust
/// # use activitystreams::object::Tombstone;
/// # let mut tombstone = Tombstone::new();
/// #
/// use activitystreams::prelude::*;
///
/// if let Some(former_type) = tombstone.take_former_type() {
/// println!("{:?}", former_type);
/// }
/// ```
fn take_former_type(&mut self) -> Option<OneOrMany<AnyBase>> {
self.tombstone_mut().former_type.take()
}
/// Delete the former_type from the current object
///
/// ```rust
/// # fn main() -> Result<(), anyhow::Error> {
/// # use activitystreams::{object::Tombstone, iri};
/// # let mut tombstone = Tombstone::new();
/// # tombstone.set_former_type(iri!("https://example.com"));
/// #
/// use activitystreams::prelude::*;
///
/// assert!(tombstone.former_type().is_some());
/// tombstone.delete_former_type();
/// assert!(tombstone.former_type().is_none());
/// # Ok(())
/// # }
/// ```
fn delete_former_type(&mut self) -> &mut Self {
self.tombstone_mut().former_type = None;
self
}
/// Fetch the deleted for the current object
///
/// ```rust
/// # use activitystreams::object::Tombstone;
/// # let mut tombstone = Tombstone::new();
/// #
/// use activitystreams::prelude::*;
///
/// if let Some(deleted) = tombstone.deleted() {
/// println!("{:?}", deleted);
/// }
/// ```
fn deleted(&self) -> Option<OffsetDateTime> {
self.tombstone_ref()
.deleted
.as_ref()
.map(|d| d.clone().into_inner())
}
/// Set the deleted for the current object
///
/// This overwrites the contents of deleted
///
/// ```rust
/// # fn main() -> Result<(), anyhow::Error> {
/// use activitystreams::prelude::*;
/// # use activitystreams::{object::Tombstone, datetime};
/// # let mut tombstone = Tombstone::new();
///
/// tombstone.set_deleted(datetime!("2020-04-20T04:20:00Z"));
/// # Ok(())
/// # }
/// ```
fn set_deleted(&mut self, deleted: OffsetDateTime) -> &mut Self {
self.tombstone_mut().deleted = Some(deleted.into());
self
}
/// Take the deleted from the current object, leaving nothing
///
/// ```rust
/// # use activitystreams::object::Tombstone;
/// # let mut tombstone = Tombstone::new();
/// #
/// use activitystreams::prelude::*;
///
/// if let Some(deleted) = tombstone.take_deleted() {
/// println!("{:?}", deleted);
/// }
/// ```
fn take_deleted(&mut self) -> Option<OffsetDateTime> {
self.tombstone_mut().deleted.take().map(|d| d.into_inner())
}
/// Delete the deleted from the current object
///
/// ```rust
/// # fn main() -> Result<(), anyhow::Error> {
/// # use activitystreams::{object::Tombstone, datetime};
/// # let mut tombstone = Tombstone::new();
/// # tombstone.set_deleted(datetime!("2020-04-20T04:20:00Z"));
/// #
/// use activitystreams::prelude::*;
///
/// assert!(tombstone.deleted().is_some());
/// tombstone.delete_deleted();
/// assert!(tombstone.deleted().is_none());
/// # Ok(())
/// # }
/// ```
fn delete_deleted(&mut self) -> &mut Self {
self.tombstone_mut().deleted = None;
self
}
}
/// Represents any kind of multi-paragraph written work.
///
/// This is just an alias for `Object<ArticleType>` because there's no fields inherent to Article
/// that aren't already present on an Object.
pub type Article = Object<ArticleType>;
/// Represents an audio document of any kind.
///
/// This is just an alias for `Object<AudioType>` because there's no fields inherent to Audio
/// that aren't already present on an Object.
pub type Audio = Object<AudioType>;
/// Represents a document of any kind.
///
/// This is just an alias for `Object<DocumentType>` because there's no fields inherent to Document
/// that aren't already present on an Object.
pub type Document = Object<DocumentType>;
/// Represents any kind of event.
///
/// This is just an alias for `Object<EventType>` because there's no fields inherent to Event
/// that aren't already present on an Object.
pub type Event = Object<EventType>;
/// An image document of any kind.
///
/// This is just an alias for `Object<ImageType>` because there's no fields inherent to Image
/// that aren't already present on an Object.
pub type Image = Object<ImageType>;
/// Represents a short written work typically less than a single paragraph in length.
///
/// This is just an alias for `Object<NoteType>` because there's no fields inherent to Note
/// that aren't already present on an Object.
pub type Note = Object<NoteType>;
/// Represents a Web Page.
///
/// This is just an alias for `Object<PageType>` because there's no fields inherent to Page
/// that aren't already present on an Object.
pub type Page = Object<PageType>;
/// Represents a video document of any kind.
///
/// This is just an alias for `Object<VideoType>` because there's no fields inherent to Video
/// that aren't already present on an Object.
pub type Video = Object<VideoType>;
/// Describes an object of any kind.
///
/// The Object type serves as the base type for most of the other kinds of objects defined in the
/// Activity Vocabulary, including other Core types such as Activity, IntransitiveActivity,
/// Collection and OrderedCollection.
#[derive(Clone, Debug, serde::Deserialize, serde::Serialize)]
#[serde(rename_all = "camelCase")]
pub struct Object<Kind> {
/// Identifies a resource attached or related to an object that potentially requires special
/// handling.
///
/// The intent is to provide a model that is at least semantically similar to attachments in
/// email.
///
/// - Range: Object | Link
/// - Functional: false
#[serde(skip_serializing_if = "Option::is_none")]
attachment: Option<OneOrMany<AnyBase>>,
/// Identifies one or more entities to which this object is attributed.
///
/// The attributed entities might not be Actors. For instance, an object might be attributed to
/// the completion of another activity.
///
/// - Range: Object | Link
/// - Functional: false
#[serde(skip_serializing_if = "Option::is_none")]
attributed_to: Option<OneOrMany<AnyBase>>,
/// Identifies one or more entities that represent the total population of entities for which
/// the object can considered to be relevant.
///
/// - Range: Object | Link
/// - Functional: false
#[serde(skip_serializing_if = "Option::is_none")]
audience: Option<OneOrMany<AnyBase>>,
/// The content or textual representation of the Object encoded as a JSON string.
///
/// By default, the value of content is HTML. The mediaType property can be used in the object
/// to indicate a different content type.
///
/// The content MAY be expressed using multiple language-tagged values.
///
/// - Range: xsd:string | rdf:langString
/// - Functional: false
#[serde(skip_serializing_if = "Option::is_none")]
content: Option<OneOrMany<AnyString>>,
/// A natural language summarization of the object encoded as HTML.
///
/// Multiple language tagged summaries MAY be provided.
///
/// - Range: xsd:string | rdf:langString
/// - Functional: false
#[serde(skip_serializing_if = "Option::is_none")]
summary: Option<OneOrMany<AnyString>>,
/// Identifies one or more links to representations of the object.
///
/// - Range: xsd:anyUri | Link
/// - Functional: false
#[serde(skip_serializing_if = "Option::is_none")]
url: Option<OneOrMany<AnyBase>>,
/// Identifies the entity (e.g. an application) that generated the object.
///
/// - Range: Object | Link
/// - Functional: false
#[serde(skip_serializing_if = "Option::is_none")]
generator: Option<OneOrMany<AnyBase>>,
/// Indicates an entity that describes an icon for this object.
///
/// The image should have an aspect ratio of one (horizontal) to one (vertical) and should be
/// suitable for presentation at a small size.
///
/// - Range: Image | Link
/// - Functional: false
#[serde(skip_serializing_if = "Option::is_none")]
icon: Option<OneOrMany<AnyBase>>,
/// Indicates an entity that describes an image for this object.
///
/// Unlike the icon property, there are no aspect ratio or display size limitations assumed.
///
/// - Range: Image | Link
/// - Functional: false
#[serde(skip_serializing_if = "Option::is_none")]
image: Option<OneOrMany<AnyBase>>,
/// Indicates one or more physical or logical locations associated with the object.
///
/// - Range: Object | Link
/// - Functional: false
#[serde(skip_serializing_if = "Option::is_none")]
location: Option<OneOrMany<AnyBase>>,
/// One or more "tags" that have been associated with an objects. A tag can be any kind of Object.
///
/// The key difference between attachment and tag is that the former implies association by
/// inclusion, while the latter implies associated by reference.
///
/// - Range: Object | Link
/// - Functional: false
#[serde(skip_serializing_if = "Option::is_none")]
tag: Option<OneOrMany<AnyBase>>,
/// The date and time describing the actual or expected starting time of the object.
///
/// When used with an Activity object, for instance, the start_time property specifies the
/// moment the activity began or is scheduled to begin.
///
/// - Range: xsd:DateTime
/// - Functional: true
#[serde(skip_serializing_if = "Option::is_none")]
start_time: Option<XsdDateTime>,
/// The date and time describing the actual or expected ending time of the object.
///
/// When used with an Activity object, for instance, the endTime property specifies the moment
/// the activity concluded or is expected to conclude.
///
/// - Range: xsd:dateTime
/// - Functional: true
#[serde(skip_serializing_if = "Option::is_none")]
end_time: Option<XsdDateTime>,
/// When the object describes a time-bound resource, such as an audio or video, a meeting, etc,
/// the duration property indicates the object's approximate duration.
///
/// The value MUST be expressed as an xsd:duration as defined by
/// [xmlschema11-2](https://www.w3.org/TR/xmlschema11-2/), section 3.3.6 (e.g. a period of 5
/// seconds is represented as "PT5S").
///
/// - Range: xsd:duration
/// - Functional: true
#[serde(skip_serializing_if = "Option::is_none")]
duration: Option<XsdDuration>,
/// The date and time at which the object was published.
///
/// - Range: xsd:dateTime
/// - Functional: true
#[serde(skip_serializing_if = "Option::is_none")]
published: Option<XsdDateTime>,
/// The date and time at which the object was updated,
///
/// - Range: xsd:dateTime
/// - Functional: true
#[serde(skip_serializing_if = "Option::is_none")]
updated: Option<XsdDateTime>,
/// Indicates one or more entities for which this object is considered a response.
///
/// - Range: Object | Link
/// - Functional: false
#[serde(skip_serializing_if = "Option::is_none")]
in_reply_to: Option<OneOrMany<AnyBase>>,
/// Identifies a Collection containing objects considered to be responses to this object.
///
/// - Range: Object | Link
/// - Functional: false
#[serde(skip_serializing_if = "Option::is_none")]
replies: Option<OneOrMany<AnyBase>>,
/// Identifies an entity considered to be part of the public primary audience of an Object.
///
/// - Range: Object | Link
/// - Functional: false
#[serde(skip_serializing_if = "Option::is_none")]
to: Option<OneOrMany<AnyBase>>,
/// Identifies an Object that is part of the private primary audience of this Object.
///
/// Range: Object | Link
/// Functional: false
#[serde(skip_serializing_if = "Option::is_none")]
bto: Option<OneOrMany<AnyBase>>,
/// Identifies an Object that is part of the public secondary audience of this Object.
///
/// - Range: Object | Link
/// - Functional: false
#[serde(skip_serializing_if = "Option::is_none")]
cc: Option<OneOrMany<AnyBase>>,
/// Identifies one or more Objects that are part of the private secondary audience of this Object.
///
/// - Range: Object | Link
/// - Functional: false
#[serde(skip_serializing_if = "Option::is_none")]
bcc: Option<OneOrMany<AnyBase>>,
/// Base fields and unparsed json ends up here
#[serde(flatten)]
inner: Base<Kind>,
}
/// Define activitypub properties for the Object type as described by the Activity Pub vocabulary.
#[derive(Clone, Debug, serde::Deserialize, serde::Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ApObject<Inner> {
/// This is a list of all Announce activities with this object as the object property, added as
/// a side effect.
///
/// The shares collection MUST be either an OrderedCollection or a Collection and MAY be
/// filtered on privileges of an authenticated user or as appropriate when no authentication is
/// given.
///
/// - Range: anyUri
/// - Functional: true
#[serde(skip_serializing_if = "Option::is_none")]
shares: Option<IriString>,
/// This is a list of all Like activities with this object as the object property, added as a
/// side effect.
///
/// The likes collection MUST be either an OrderedCollection or a Collection and MAY be
/// filtered on privileges of an authenticated user or as appropriate when no authentication is
/// given.
///
/// - Range: anyUri
/// - Functional: true
#[serde(skip_serializing_if = "Option::is_none")]
likes: Option<IriString>,
/// The source property is intended to convey some sort of source from which the content markup
/// was derived, as a form of provenance, or to support future editing by clients.
///
/// In general, clients do the conversion from source to content, not the other way around.
///
/// The value of source is itself an object which uses its own content and mediaType fields to
/// supply source information.
///
/// - Range: Object
/// - Functional: true
#[serde(skip_serializing_if = "Option::is_none")]
source: Option<AnyBase>,
/// Servers MAY support uploading document types to be referenced in activites, such as images,
/// video or other binary data, but the precise mechanism is out of scope for this version of
/// ActivityPub.
///
/// The Social Web Community Group is refining the protocol in the
/// [ActivityPub Media Upload report](https://www.w3.org/wiki/SocialCG/ActivityPub/MediaUpload).
///
/// - Range: anyUri
/// - Functional: false
#[serde(skip_serializing_if = "Option::is_none")]
upload_media: Option<OneOrMany<IriString>>,
/// The ActivityStreams object being extended
#[serde(flatten)]
inner: Inner,
}
/// Represents a logical or physical location.
///
/// The Place object is used to represent both physical and logical locations. While numerous
/// existing vocabularies exist for describing locations in a variety of ways, inconsistencies and
/// incompatibilities between those vocabularies make it difficult to achieve appropriate
/// interoperability between implementations. The Place object is included within the Activity
/// vocabulary to provide a minimal, interoperable starting point for describing locations
/// consistently across Activity Streams 2.0 implementations.
///
/// The Place object is intentionally flexible. It can, for instance, be used to identify a
/// location simply by name, or by longitude and latitude.
///
/// The Place object can also describe an area around a given point using the radius property, the
/// altitude of the location, and a degree of accuracy.
///
/// While publishers are not required to use these specific properties and MAY make use of other
/// mechanisms for describing locations, consuming implementations that support the Place object
/// MUST support the use of these properties.
#[derive(Clone, Debug, serde::Deserialize, serde::Serialize)]
pub struct Place {
/// Indicates the accuracy of position coordinates on a Place objects.
///
/// Expressed in properties of percentage. e.g. "94.0"means "94.0% accurate".
///
/// - Range: xsd:float [>= 0.0f, <= 100.0f]
/// - Functional: true
#[serde(skip_serializing_if = "Option::is_none")]
accuracy: Option<f64>,
/// Indicates the altitude of a place. The measurement units is indicated using the units
/// property.
///
/// If units is not specified, the default is assumed to be "m" indicating meters.
///
/// - Range: xsd:float
/// - Functional: true
#[serde(skip_serializing_if = "Option::is_none")]
altitude: Option<f64>,
///The latitude of a place.
///
/// - Range: xsd:float
/// - Functional: true
#[serde(skip_serializing_if = "Option::is_none")]
latitude: Option<f64>,
/// The longitude of a place.
///
/// - Range: xsd:float
/// - Functional: true
#[serde(skip_serializing_if = "Option::is_none")]
longitude: Option<f64>,
/// The radius from the given latitude and longitude for a Place.
///
/// The units is expressed by the units property. If units is not specified, the default is
/// assumed to be "m" indicating meters.
///
/// - Range: xsd:float
/// - Functional: true
#[serde(skip_serializing_if = "Option::is_none")]
radius: Option<f64>,
/// Specifies the measurement units for the radius and altitude properties on a Place object.
///
/// If not specified, the default is assumed to be "m" for meters.
///
/// - Range: "cm" | "feet" | "inches" | "km" | "m" | xsd:anyUri | xsd:anyUri
/// - Functional: true
#[serde(skip_serializing_if = "Option::is_none")]
units: Option<Unit>,
/// The object being extended
#[serde(flatten)]
inner: Object<PlaceType>,
}
/// A Profile is a content object that describes another Object, typically used to describe Actor
/// Type objects.
///
/// The describes property is used to reference the object being described by the profile.
#[derive(Clone, Debug, serde::Deserialize, serde::Serialize)]
pub struct Profile {
/// On a Profile object, the describes property identifies the object described by the Profile.
///
/// - Range: Object
/// - Functional: true
#[serde(skip_serializing_if = "Option::is_none")]
describes: Option<AnyBase>,
/// The object being extended
#[serde(flatten)]
inner: Object<ProfileType>,
}
/// Describes a relationship between two individuals.
///
/// The subject and object properties are used to identify the connected individuals.
///
/// The Relationship object is used to represent relationships between individuals. It can be used,
/// for instance, to describe that one person is a friend of another, or that one person is a
/// member of a particular organization. The intent of modeling Relationship in this way is to
/// allow descriptions of activities that operate on the relationships in general, and to allow
/// representation of Collections of relationships.
///
/// For instance, many social systems have a notion of a "friends list". These are the collection
/// of individuals that are directly connected within a person's social graph. Suppose we have a
/// user, Sally, with direct relationships to users Joe and Jane. Sally follows Joe's updates while
/// Sally and Jane have a mutual relationship.
#[derive(Clone, Debug, serde::Deserialize, serde::Serialize)]
pub struct Relationship {
/// On a Relationship object, the subject property identifies one of the connected individuals.
///
/// For instance, for a Relationship object describing "John is related to Sally", subject
/// would refer to John.
///
/// - Range: Object | Link
/// - Functional: true
#[serde(skip_serializing_if = "Option::is_none")]
subject: Option<AnyBase>,
/// When used within a Relationship describes the entity to which the subject is related.
///
/// - Range: Object | Link
/// - Functional: false
#[serde(skip_serializing_if = "Option::is_none")]
object: Option<OneOrMany<AnyBase>>,
/// On a Relationship object, the relationship property identifies the kind of relationship
/// that exists between subject and object.
///
/// - Range: Object
/// - Functional: false
#[serde(skip_serializing_if = "Option::is_none")]
relationship: Option<OneOrMany<AnyBase>>,
/// The object being extended
#[serde(flatten)]
inner: Object<RelationshipType>,
}
/// A Tombstone represents a content object that has been deleted.
///
/// It can be used in Collections to signify that there used to be an object at this position, but
/// it has been deleted.
#[derive(Clone, Debug, serde::Deserialize, serde::Serialize)]
pub struct Tombstone {
/// On a Tombstone object, the formerType property identifies the type of the object that was
/// deleted.
///
/// - Range: Object
/// - Functional: false
#[serde(skip_serializing_if = "Option::is_none")]
former_type: Option<OneOrMany<AnyBase>>,
/// On a Tombstone object, the deleted property is a timestamp for when the object was deleted.
///
/// - Range: xsd:dateTime
/// - Functional: true
#[serde(skip_serializing_if = "Option::is_none")]
deleted: Option<XsdDateTime>,
/// The object being extended
#[serde(flatten)]
inner: Object<TombstoneType>,
}
impl<Kind> Object<Kind> {
/// Create a new Object
///
/// ```rust
/// use activitystreams::object::Object;
///
/// let object = Object::<String>::new();
/// ```
pub fn new() -> Self
where
Kind: Default,
{
Object {
attachment: None,
attributed_to: None,
audience: None,
content: None,
summary: None,
url: None,
generator: None,
icon: None,
image: None,
location: None,
tag: None,
start_time: None,
end_time: None,
duration: None,
published: None,
updated: None,
in_reply_to: None,
replies: None,
to: None,
bto: None,
cc: None,
bcc: None,
inner: Base::new(),
}
}
/// Create a new object with `None` for it's `kind` property
///
/// This means that no `type` field will be present in serialized JSON
///
/// ```rust
/// # fn main() -> Result<(), anyhow::Error> {
/// use activitystreams::object::Object;
///
/// let object = Object::<()>::new_none_type();
///
/// let s = serde_json::to_string(&object)?;
///
/// assert_eq!(s, "{}");
/// # Ok(())
/// # }
/// ```
pub fn new_none_type() -> Self {
Object {
attachment: None,
attributed_to: None,
audience: None,
content: None,
summary: None,
url: None,
generator: None,
icon: None,
image: None,
location: None,
tag: None,
start_time: None,
end_time: None,
duration: None,
published: None,
updated: None,
in_reply_to: None,
replies: None,
to: None,
bto: None,
cc: None,
bcc: None,
inner: Base::new_none_type(),
}
}
fn extending(mut base: Base<Kind>) -> Result<Self, serde_json::Error> {
Ok(Object {
attachment: base.remove("attachment")?,
attributed_to: base.remove("attributedTo")?,
audience: base.remove("audience")?,
content: base.remove("content")?,
summary: base.remove("summary")?,
url: base.remove("url")?,
generator: base.remove("generator")?,
icon: base.remove("icon")?,
image: base.remove("image")?,
location: base.remove("location")?,
tag: base.remove("tag")?,
start_time: base.remove("startTime")?,
end_time: base.remove("endTime")?,
duration: base.remove("duration")?,
published: base.remove("published")?,
updated: base.remove("updated")?,
in_reply_to: base.remove("inReplyTo")?,
replies: base.remove("replies")?,
to: base.remove("to")?,
bto: base.remove("bto")?,
cc: base.remove("cc")?,
bcc: base.remove("bcc")?,
inner: base,
})
}
fn retracting(self) -> Result<Base<Kind>, serde_json::Error> {
let Object {
attachment,
attributed_to,
audience,
content,
summary,
url,
generator,
icon,
image,
location,
tag,
start_time,
end_time,
duration,
published,
updated,
in_reply_to,
replies,
to,
bto,
cc,
bcc,
mut inner,
} = self;
inner
.insert("attachment", attachment)?
.insert("attributedTo", attributed_to)?
.insert("audience", audience)?
.insert("content", content)?
.insert("summary", summary)?
.insert("url", url)?
.insert("generator", generator)?
.insert("icon", icon)?
.insert("image", image)?
.insert("location", location)?
.insert("tag", tag)?
.insert("startTime", start_time)?
.insert("endTime", end_time)?
.insert("duration", duration)?
.insert("published", published)?
.insert("updated", updated)?
.insert("inReplyTo", in_reply_to)?
.insert("replies", replies)?
.insert("to", to)?
.insert("bto", bto)?
.insert("cc", cc)?
.insert("bcc", bcc)?;
Ok(inner)
}
}
impl<Inner> ApObject<Inner> {
/// Create a new ActivityPub Object
///
/// ```rust
/// use activitystreams::object::{ApObject, Place};
///
/// let object = ApObject::new(Place::new());
/// ```
pub fn new(inner: Inner) -> Self
where
Inner: markers::Object,
{
ApObject {
shares: None,
likes: None,
source: None,
upload_media: None,
inner,
}
}
#[allow(clippy::type_complexity)]
/// Deconstruct the ApObject into its parts
///
/// ```rust
/// use activitystreams::object::{ApObject, Image};
///
/// let object = ApObject::new(Image::new());
///
/// let (shares, likes, source, upload_media, image) = object.into_parts();
/// ```
pub fn into_parts(
self,
) -> (
Option<IriString>,
Option<IriString>,
Option<AnyBase>,
Option<OneOrMany<IriString>>,
Inner,
) {
(
self.shares,
self.likes,
self.source,
self.upload_media,
self.inner,
)
}
fn extending(mut inner: Inner) -> Result<Self, serde_json::Error>
where
Inner: UnparsedMut + markers::Object,
{
let shares = inner.remove("shares")?;
let likes = inner.remove("likes")?;
let source = inner.remove("source")?;
let upload_media = inner.remove("uploadMedia")?;
Ok(ApObject {
shares,
likes,
source,
upload_media,
inner,
})
}
fn retracting(self) -> Result<Inner, serde_json::Error>
where
Inner: UnparsedMut + markers::Object,
{
let ApObject {
shares,
likes,
source,
upload_media,
mut inner,
} = self;
inner
.insert("uploadMedia", upload_media)?
.insert("source", source)?
.insert("likes", likes)?
.insert("shares", shares)?;
Ok(inner)
}
/// Borrow inner
pub fn inner(&self) -> &Inner {
&self.inner
}
/// Mutably borrow Inner
pub fn inner_mut(&mut self) -> &mut Inner {
&mut self.inner
}
}
impl Place {
/// Create a new ActivityPub Object
///
/// ```rust
/// use activitystreams::object::Place;
///
/// let object = Place::new();
/// ```
pub fn new() -> Self {
Place {
accuracy: None,
altitude: None,
latitude: None,
longitude: None,
radius: None,
units: None,
inner: Object::new(),
}
}
fn extending(mut inner: Object<PlaceType>) -> Result<Self, serde_json::Error> {
let accuracy = inner.remove("accuracy")?;
let altitude = inner.remove("altitude")?;
let latitude = inner.remove("latitude")?;
let longitude = inner.remove("longitude")?;
let radius = inner.remove("radius")?;
let units = inner.remove("units")?;
Ok(Place {
accuracy,
altitude,
latitude,
longitude,
radius,
units,
inner,
})
}
fn retracting(self) -> Result<Object<PlaceType>, serde_json::Error> {
let Place {
accuracy,
altitude,
latitude,
longitude,
radius,
units,
mut inner,
} = self;
inner
.insert("units", units)?
.insert("radius", radius)?
.insert("longitude", longitude)?
.insert("latitude", latitude)?
.insert("altitude", altitude)?
.insert("accuracy", accuracy)?;
Ok(inner)
}
}
impl Profile {
/// Create a new ActivityPub Object
///
/// ```rust
/// use activitystreams::object::Profile;
///
/// let object = Profile::new();
/// ```
pub fn new() -> Self {
Profile {
describes: None,
inner: Object::new(),
}
}
fn extending(mut inner: Object<ProfileType>) -> Result<Self, serde_json::Error> {
let describes = inner.remove("describes")?;
Ok(Profile { describes, inner })
}
fn retracting(self) -> Result<Object<ProfileType>, serde_json::Error> {
let Profile {
describes,
mut inner,
} = self;
inner.insert("describes", describes)?;
Ok(inner)
}
}
impl Relationship {
/// Create a new ActivityPub Object
///
/// ```rust
/// use activitystreams::object::Relationship;
///
/// let object = Relationship::new();
/// ```
pub fn new() -> Self {
Relationship {
subject: None,
object: None,
relationship: None,
inner: Object::new(),
}
}
fn extending(mut inner: Object<RelationshipType>) -> Result<Self, serde_json::Error> {
let subject = inner.remove("subject")?;
let object = inner.remove("object")?;
let relationship = inner.remove("relationship")?;
Ok(Relationship {
subject,
object,
relationship,
inner,
})
}
fn retracting(self) -> Result<Object<RelationshipType>, serde_json::Error> {
let Relationship {
subject,
object,
relationship,
mut inner,
} = self;
inner
.insert("subject", subject)?
.insert("object", object)?
.insert("relationship", relationship)?;
Ok(inner)
}
}
impl Tombstone {
/// Create a new ActivityPub Object
///
/// ```rust
/// use activitystreams::object::Tombstone;
///
/// let object = Tombstone::new();
/// ```
pub fn new() -> Self {
Tombstone {
former_type: None,
deleted: None,
inner: Object::new(),
}
}
fn extending(mut inner: Object<TombstoneType>) -> Result<Self, serde_json::Error> {
let former_type = inner.remove("formerType")?;
let deleted = inner.remove("deleted")?;
Ok(Tombstone {
former_type,
deleted,
inner,
})
}
fn retracting(self) -> Result<Object<TombstoneType>, serde_json::Error> {
let Tombstone {
former_type,
deleted,
mut inner,
} = self;
inner
.insert("formerType", former_type)?
.insert("deleted", deleted)?;
Ok(inner)
}
}
impl<Kind> Extends for Object<Kind> {
type Kind = Kind;
type Error = serde_json::Error;
fn extends(base: Base<Self::Kind>) -> Result<Self, Self::Error> {
Self::extending(base)
}
fn retracts(self) -> Result<Base<Self::Kind>, Self::Error> {
self.retracting()
}
}
impl<Kind> TryFrom<Base<Kind>> for Object<Kind> {
type Error = serde_json::Error;
fn try_from(base: Base<Kind>) -> Result<Self, Self::Error> {
Self::extending(base)
}
}
impl<Kind> TryFrom<Object<Kind>> for Base<Kind> {
type Error = serde_json::Error;
fn try_from(object: Object<Kind>) -> Result<Self, Self::Error> {
object.retracting()
}
}
impl<Inner> Extends for ApObject<Inner>
where
Inner: Extends<Error = serde_json::Error> + UnparsedMut + markers::Object,
{
type Kind = Inner::Kind;
type Error = serde_json::Error;
fn extends(base: Base<Self::Kind>) -> Result<Self, Self::Error> {
let inner = Inner::extends(base)?;
Self::extending(inner)
}
fn retracts(self) -> Result<Base<Self::Kind>, Self::Error> {
let inner = self.retracting()?;
inner.retracts()
}
}
impl Extends for Place {
type Kind = PlaceType;
type Error = serde_json::Error;
fn extends(base: Base<PlaceType>) -> Result<Self, Self::Error> {
let inner = Object::extends(base)?;
Self::extending(inner)
}
fn retracts(self) -> Result<Base<PlaceType>, Self::Error> {
let inner = self.retracting()?;
inner.retracts()
}
}
impl TryFrom<Object<PlaceType>> for Place {
type Error = serde_json::Error;
fn try_from(object: Object<PlaceType>) -> Result<Self, Self::Error> {
Self::extending(object)
}
}
impl TryFrom<Place> for Object<PlaceType> {
type Error = serde_json::Error;
fn try_from(place: Place) -> Result<Self, Self::Error> {
place.retracting()
}
}
impl Extends for Profile {
type Kind = ProfileType;
type Error = serde_json::Error;
fn extends(base: Base<ProfileType>) -> Result<Self, Self::Error> {
let inner = Object::extends(base)?;
Self::extending(inner)
}
fn retracts(self) -> Result<Base<ProfileType>, Self::Error> {
let inner = self.retracting()?;
inner.retracts()
}
}
impl TryFrom<Object<ProfileType>> for Profile {
type Error = serde_json::Error;
fn try_from(object: Object<ProfileType>) -> Result<Self, Self::Error> {
Self::extending(object)
}
}
impl TryFrom<Profile> for Object<ProfileType> {
type Error = serde_json::Error;
fn try_from(profile: Profile) -> Result<Self, Self::Error> {
profile.retracting()
}
}
impl Extends for Relationship {
type Kind = RelationshipType;
type Error = serde_json::Error;
fn extends(base: Base<RelationshipType>) -> Result<Self, Self::Error> {
let inner = Object::extends(base)?;
Self::extending(inner)
}
fn retracts(self) -> Result<Base<RelationshipType>, Self::Error> {
let inner = self.retracting()?;
inner.retracts()
}
}
impl TryFrom<Object<RelationshipType>> for Relationship {
type Error = serde_json::Error;
fn try_from(object: Object<RelationshipType>) -> Result<Self, Self::Error> {
Self::extending(object)
}
}
impl TryFrom<Relationship> for Object<RelationshipType> {
type Error = serde_json::Error;
fn try_from(relationship: Relationship) -> Result<Self, Self::Error> {
relationship.retracting()
}
}
impl Extends for Tombstone {
type Kind = TombstoneType;
type Error = serde_json::Error;
fn extends(base: Base<TombstoneType>) -> Result<Self, Self::Error> {
let inner = Object::extends(base)?;
Self::extending(inner)
}
fn retracts(self) -> Result<Base<TombstoneType>, Self::Error> {
let inner = self.retracting()?;
inner.retracts()
}
}
impl TryFrom<Object<TombstoneType>> for Tombstone {
type Error = serde_json::Error;
fn try_from(object: Object<TombstoneType>) -> Result<Self, Self::Error> {
Self::extending(object)
}
}
impl TryFrom<Tombstone> for Object<TombstoneType> {
type Error = serde_json::Error;
fn try_from(tombstone: Tombstone) -> Result<Self, Self::Error> {
tombstone.retracting()
}
}
impl<Kind> UnparsedMut for Object<Kind> {
fn unparsed_mut(&mut self) -> &mut Unparsed {
self.inner.unparsed_mut()
}
}
impl<Inner> UnparsedMut for ApObject<Inner>
where
Inner: UnparsedMut,
{
fn unparsed_mut(&mut self) -> &mut Unparsed {
self.inner.unparsed_mut()
}
}
impl UnparsedMut for Place {
fn unparsed_mut(&mut self) -> &mut Unparsed {
self.inner.unparsed_mut()
}
}
impl UnparsedMut for Profile {
fn unparsed_mut(&mut self) -> &mut Unparsed {
self.inner.unparsed_mut()
}
}
impl UnparsedMut for Relationship {
fn unparsed_mut(&mut self) -> &mut Unparsed {
self.inner.unparsed_mut()
}
}
impl UnparsedMut for Tombstone {
fn unparsed_mut(&mut self) -> &mut Unparsed {
self.inner.unparsed_mut()
}
}
impl<Kind> markers::Base for Object<Kind> {}
impl<Kind> markers::Object for Object<Kind> {}
impl<Inner> markers::Base for ApObject<Inner> where Inner: markers::Base {}
impl<Inner> markers::Object for ApObject<Inner> where Inner: markers::Object {}
impl markers::Base for Place {}
impl markers::Object for Place {}
impl markers::Base for Profile {}
impl markers::Object for Profile {}
impl markers::Base for Relationship {}
impl markers::Object for Relationship {}
impl markers::Base for Tombstone {}
impl markers::Object for Tombstone {}
impl<T, Kind> ObjectExt for T where T: AsObject<Kind = Kind> {}
impl<T> ApObjectExt for T where T: AsApObject {}
impl<T> PlaceExt for T where T: AsPlace {}
impl<T> ProfileExt for T where T: AsProfile {}
impl<T> RelationshipExt for T where T: AsRelationship {}
impl<T> TombstoneExt for T where T: AsTombstone {}
impl<Kind> AsBase for Object<Kind> {
type Kind = Kind;
fn base_ref(&self) -> &Base<Self::Kind> {
&self.inner
}
fn base_mut(&mut self) -> &mut Base<Self::Kind> {
&mut self.inner
}
}
impl<Kind> AsObject for Object<Kind> {
type Kind = Kind;
fn object_ref(&self) -> &Object<Self::Kind> {
self
}
fn object_mut(&mut self) -> &mut Object<Self::Kind> {
self
}
}
impl<Inner> AsBase for ApObject<Inner>
where
Inner: AsBase,
{
type Kind = Inner::Kind;
fn base_ref(&self) -> &Base<Self::Kind> {
self.inner.base_ref()
}
fn base_mut(&mut self) -> &mut Base<Self::Kind> {
self.inner.base_mut()
}
}
impl<Inner> AsObject for ApObject<Inner>
where
Inner: AsObject,
{
type Kind = Inner::Kind;
fn object_ref(&self) -> &Object<Self::Kind> {
self.inner.object_ref()
}
fn object_mut(&mut self) -> &mut Object<Self::Kind> {
self.inner.object_mut()
}
}
impl<Inner> AsApObject for ApObject<Inner>
where
Inner: markers::Object,
{
type Inner = Inner;
fn ap_object_ref(&self) -> &ApObject<Self::Inner> {
self
}
fn ap_object_mut(&mut self) -> &mut ApObject<Self::Inner> {
self
}
}
impl<Inner> AsPlace for ApObject<Inner>
where
Inner: AsPlace,
{
fn place_ref(&self) -> &Place {
self.inner.place_ref()
}
fn place_mut(&mut self) -> &mut Place {
self.inner.place_mut()
}
}
impl<Inner> AsProfile for ApObject<Inner>
where
Inner: AsProfile,
{
fn profile_ref(&self) -> &Profile {
self.inner.profile_ref()
}
fn profile_mut(&mut self) -> &mut Profile {
self.inner.profile_mut()
}
}
impl<Inner> AsRelationship for ApObject<Inner>
where
Inner: AsRelationship,
{
fn relationship_ref(&self) -> &Relationship {
self.inner.relationship_ref()
}
fn relationship_mut(&mut self) -> &mut Relationship {
self.inner.relationship_mut()
}
}
impl<Inner> AsTombstone for ApObject<Inner>
where
Inner: AsTombstone,
{
fn tombstone_ref(&self) -> &Tombstone {
self.inner.tombstone_ref()
}
fn tombstone_mut(&mut self) -> &mut Tombstone {
self.inner.tombstone_mut()
}
}
impl AsBase for Place {
type Kind = PlaceType;
fn base_ref(&self) -> &Base<PlaceType> {
self.inner.base_ref()
}
fn base_mut(&mut self) -> &mut Base<PlaceType> {
self.inner.base_mut()
}
}
impl AsObject for Place {
type Kind = PlaceType;
fn object_ref(&self) -> &Object<PlaceType> {
&self.inner
}
fn object_mut(&mut self) -> &mut Object<PlaceType> {
&mut self.inner
}
}
impl AsPlace for Place {
fn place_ref(&self) -> &Place {
self
}
fn place_mut(&mut self) -> &mut Place {
self
}
}
impl AsBase for Profile {
type Kind = ProfileType;
fn base_ref(&self) -> &Base<ProfileType> {
self.inner.base_ref()
}
fn base_mut(&mut self) -> &mut Base<ProfileType> {
self.inner.base_mut()
}
}
impl AsObject for Profile {
type Kind = ProfileType;
fn object_ref(&self) -> &Object<ProfileType> {
&self.inner
}
fn object_mut(&mut self) -> &mut Object<ProfileType> {
&mut self.inner
}
}
impl AsProfile for Profile {
fn profile_ref(&self) -> &Profile {
self
}
fn profile_mut(&mut self) -> &mut Profile {
self
}
}
impl AsBase for Relationship {
type Kind = RelationshipType;
fn base_ref(&self) -> &Base<RelationshipType> {
self.inner.base_ref()
}
fn base_mut(&mut self) -> &mut Base<RelationshipType> {
self.inner.base_mut()
}
}
impl AsObject for Relationship {
type Kind = RelationshipType;
fn object_ref(&self) -> &Object<RelationshipType> {
&self.inner
}
fn object_mut(&mut self) -> &mut Object<RelationshipType> {
&mut self.inner
}
}
impl AsRelationship for Relationship {
fn relationship_ref(&self) -> &Relationship {
self
}
fn relationship_mut(&mut self) -> &mut Relationship {
self
}
}
impl AsBase for Tombstone {
type Kind = TombstoneType;
fn base_ref(&self) -> &Base<TombstoneType> {
self.inner.base_ref()
}
fn base_mut(&mut self) -> &mut Base<TombstoneType> {
self.inner.base_mut()
}
}
impl AsObject for Tombstone {
type Kind = TombstoneType;
fn object_ref(&self) -> &Object<TombstoneType> {
&self.inner
}
fn object_mut(&mut self) -> &mut Object<TombstoneType> {
&mut self.inner
}
}
impl AsTombstone for Tombstone {
fn tombstone_ref(&self) -> &Tombstone {
self
}
fn tombstone_mut(&mut self) -> &mut Tombstone {
self
}
}
impl<Kind> Default for Object<Kind>
where
Kind: Default,
{
fn default() -> Self {
Self::new()
}
}
impl Default for Place {
fn default() -> Self {
Self::new()
}
}
impl Default for Profile {
fn default() -> Self {
Self::new()
}
}
impl Default for Relationship {
fn default() -> Self {
Self::new()
}
}
impl Default for Tombstone {
fn default() -> Self {
Self::new()
}
}