//! Types and traits for dealing with Collection attributes //! //! ```rust //! # fn main() -> Result<(), anyhow::Error> { //! use activitystreams::{ //! collection::OrderedCollection, //! context, //! prelude::*, //! uri, //! }; //! //! let mut collection = OrderedCollection::new(); //! //! collection //! .set_items(uri!("https://example.com/notes/1234")) //! .set_total_items(1u64) //! .set_current(uri!("https://example.com/notes/1234")) //! .set_first(uri!("https://example.com/notes/1234")) //! .set_last(uri!("https://example.com/notes/1234")) //! .set_id(uri!("https://example.com/collections/1234")) //! .set_context(context()); //! # Ok(()) //! # } //! ``` use crate::{ base::{AnyBase, AsBase, Base, Extends}, markers, object::{ApObject, AsObject, Object}, primitives::OneOrMany, unparsed::{Unparsed, UnparsedMut, UnparsedMutExt}, }; use std::convert::TryFrom; pub mod kind { //! Kinds of collections defined by the spec //! //! These types exist only to be statically-typed versions of the associated string. e.g. //! `CollectionType` -> `"Collection"` use crate::kind; kind!(CollectionType, Collection); kind!(OrderedCollectionType, OrderedCollection); kind!(CollectionPageType, CollectionPage); kind!(OrderedCollectionPageType, OrderedCollectionPage); } use self::kind::*; /// Implementation trait for deriving Collection methods for a type /// /// Any type implementing AsCollection will automatically gain methods provided by CollectionExt pub trait AsCollection: markers::Collection { fn collection_ref(&self) -> &Collection; fn collection_mut(&mut self) -> &mut Collection; } /// Implementation trait for deriving Collection methods for a type /// /// Any type implementing AsCollectionPage will automatically gain methods provided by CollectionPageExt pub trait AsCollectionPage: markers::CollectionPage { fn collection_page_ref(&self) -> &CollectionPage; fn collection_page_mut(&mut self) -> &mut CollectionPage; } /// Implementation trait for deriving Collection methods for a type /// /// Any type implementing AsOrderedCollectionPage will automatically gain methods provided by /// OrderedCollectionPageExt pub trait AsOrderedCollectionPage: markers::CollectionPage { fn ordered_collection_page_ref(&self) -> &OrderedCollectionPage; fn ordered_collection_page_mut(&mut self) -> &mut OrderedCollectionPage; } /// Helper methods for interacting with Collection types /// /// This trait represents methods valid for any ActivityStreams Collection /// /// Documentation for the fields related to these methods can be found on the /// `Collection` struct pub trait CollectionExt: AsCollection { /// Fetch the items for the current activity /// /// ```rust /// # use activitystreams::{collection::UnorderedCollection}; /// # let mut collection = UnorderedCollection::new(); /// # /// use activitystreams::prelude::*; /// /// let items_ref = collection.items(); /// println!("{:?}", items_ref); /// ``` fn items<'a>(&'a self) -> Option<&'a OneOrMany> where Kind: 'a, { self.collection_ref().items.as_ref() } /// Set the items for the current activity /// /// This overwrites the contents of items /// /// ```rust /// # fn main() -> Result<(), anyhow::Error> { /// use activitystreams::prelude::*; /// # use activitystreams::{collection::UnorderedCollection, uri}; /// # let mut collection = UnorderedCollection::new(); /// /// collection.set_items(uri!("https://example.com")); /// # Ok(()) /// # } /// ``` fn set_items(&mut self, item: T) -> &mut Self where T: Into, { self.collection_mut().items = Some(item.into().into()); self } /// Set many itemss for the current activity /// /// This overwrites the contents of items /// /// ```rust /// # fn main() -> Result<(), anyhow::Error> { /// use activitystreams::prelude::*; /// # use activitystreams::{collection::UnorderedCollection, uri}; /// # let mut collection = UnorderedCollection::new(); /// /// collection.set_many_items(vec![ /// uri!("https://example.com/one"), /// uri!("https://example.com/two"), /// ]); /// # Ok(()) /// # } /// ``` fn set_many_items(&mut self, items: I) -> &mut Self where I: IntoIterator, T: Into, { let v: Vec<_> = items.into_iter().map(Into::into).collect(); self.collection_mut().items = Some(v.into()); self } /// Add a items to the current activity /// /// This does not overwrite the contents of items, only appends an item /// /// ```rust /// # fn main() -> Result<(), anyhow::Error> { /// use activitystreams::prelude::*; /// # use activitystreams::{collection::UnorderedCollection, uri}; /// # let mut collection = UnorderedCollection::new(); /// /// collection /// .add_items(uri!("https://example.com/one")) /// .add_items(uri!("https://example.com/two")); /// # Ok(()) /// # } /// ``` fn add_items(&mut self, item: T) -> &mut Self where T: Into, { match self.collection_mut().items { Some(ref mut items) => { items.add(item.into()); } None => self.collection_mut().items = Some(item.into().into()), } self } /// Take the items of the current object, leaving nothing /// /// ```rust /// # use activitystreams::{collection::UnorderedCollection}; /// # let mut collection = UnorderedCollection::new(); /// use activitystreams::prelude::*; /// /// if let Some(items) = collection.take_items() { /// println!("{:?}", items); /// } /// ``` fn take_items(&mut self) -> Option> { self.collection_mut().items.take() } /// Delete the items from the current object /// /// ```rust /// # use activitystreams::{context, collection::UnorderedCollection}; /// # let mut collection = UnorderedCollection::new(); /// # collection.set_items(context()); /// use activitystreams::prelude::*; /// /// assert!(collection.items().is_some()); /// collection.delete_items(); /// assert!(collection.items().is_none()); /// ``` fn delete_items(&mut self) -> &mut Self { self.collection_mut().items = None; self } /// Fetch the total_items of the current object /// /// ```rust /// # use activitystreams::{collection::UnorderedCollection}; /// # let mut collection = UnorderedCollection::new(); /// use activitystreams::prelude::*; /// /// if let Some(total_items) = collection.total_items() { /// println!("{:?}", total_items); /// } /// ``` fn total_items<'a>(&'a self) -> Option where Kind: 'a, { self.collection_ref().total_items } /// Set the total_items for the current object /// /// This overwrites the contents of total_items /// /// ```rust /// # use activitystreams::{collection::UnorderedCollection}; /// # let mut collection = UnorderedCollection::new(); /// use activitystreams::prelude::*; /// /// collection.set_total_items(5u64); /// ``` fn set_total_items(&mut self, total_items: T) -> &mut Self where T: Into, { self.collection_mut().total_items = Some(total_items.into()); self } /// Take the total_items of the current object, leaving nothing /// /// ```rust /// # use activitystreams::{collection::UnorderedCollection}; /// # let mut collection = UnorderedCollection::new(); /// use activitystreams::prelude::*; /// /// if let Some(total_items) = collection.take_total_items() { /// println!("{:?}", total_items); /// } /// ``` fn take_total_items(&mut self) -> Option { self.collection_mut().total_items.take() } /// Delete the total_items from the current object /// /// ```rust /// # use activitystreams::{collection::UnorderedCollection}; /// # let mut collection = UnorderedCollection::new(); /// # collection.set_total_items(5u64); /// use activitystreams::prelude::*; /// /// assert!(collection.total_items().is_some()); /// collection.delete_total_items(); /// assert!(collection.total_items().is_none()); /// ``` fn delete_total_items(&mut self) -> &mut Self { self.collection_mut().total_items = None; self } /// Fetch the current field for the current object /// /// ```rust /// # use activitystreams::{collection::UnorderedCollection}; /// # let mut collection = UnorderedCollection::new(); /// # /// use activitystreams::prelude::*; /// /// if let Some(current) = collection.current() { /// println!("{:?}", current); /// } /// ``` fn current<'a>(&'a self) -> Option<&'a AnyBase> where Kind: 'a, { self.collection_ref().current.as_ref() } /// Set the current field for the current object /// /// This overwrites the contents of current /// /// ```rust /// # fn main() -> Result<(), anyhow::Error> { /// # use activitystreams::{collection::UnorderedCollection, uri}; /// # let mut collection = UnorderedCollection::new(); /// # /// use activitystreams::prelude::*; /// /// collection.set_current(uri!("https://example.com")); /// # Ok(()) /// # } /// ``` fn set_current(&mut self, current: T) -> &mut Self where T: Into, { self.collection_mut().current = Some(current.into()); self } /// Take the current field from the current object, leaving nothing /// /// ```rust /// # use activitystreams::{collection::UnorderedCollection}; /// # let mut collection = UnorderedCollection::new(); /// # /// use activitystreams::prelude::*; /// /// if let Some(current) = collection.take_current() { /// println!("{:?}", current); /// } /// ``` fn take_current(&mut self) -> Option { self.collection_mut().current.take() } /// Delete the current field from the current object /// /// ```rust /// # use activitystreams::{context, collection::UnorderedCollection}; /// # let mut collection = UnorderedCollection::new(); /// # collection.set_current(context()); /// # /// use activitystreams::prelude::*; /// /// assert!(collection.current().is_some()); /// collection.delete_current(); /// assert!(collection.current().is_none()); /// ``` fn delete_current(&mut self) -> &mut Self { self.collection_mut().current = None; self } /// Fetch the first field for the current object /// /// ```rust /// # use activitystreams::{collection::UnorderedCollection}; /// # let mut collection = UnorderedCollection::new(); /// # /// use activitystreams::prelude::*; /// /// if let Some(first) = collection.first() { /// println!("{:?}", first); /// } /// ``` fn first<'a>(&'a self) -> Option<&'a AnyBase> where Kind: 'a, { self.collection_ref().first.as_ref() } /// Set the first field for the current object /// /// This overwrites the contents of first /// /// ```rust /// # fn main() -> Result<(), anyhow::Error> { /// # use activitystreams::{collection::UnorderedCollection}; /// # let mut collection = UnorderedCollection::new(); /// # /// use activitystreams::{prelude::*, uri}; /// /// collection.set_first(uri!("https://example.com")); /// # Ok(()) /// # } /// ``` fn set_first(&mut self, first: T) -> &mut Self where T: Into, { self.collection_mut().first = Some(first.into()); self } /// Take the first field from the current object, leaving nothing /// /// ```rust /// # use activitystreams::{collection::UnorderedCollection}; /// # let mut collection = UnorderedCollection::new(); /// # /// use activitystreams::prelude::*; /// /// if let Some(first) = collection.take_first() { /// println!("{:?}", first); /// } /// ``` fn take_first(&mut self) -> Option { self.collection_mut().first.take() } /// Delete the first field from the current object /// /// ```rust /// # use activitystreams::{context, collection::UnorderedCollection}; /// # let mut collection = UnorderedCollection::new(); /// # collection.set_first(context()); /// # /// use activitystreams::prelude::*; /// /// assert!(collection.first().is_some()); /// collection.delete_first(); /// assert!(collection.first().is_none()); /// ``` fn delete_first(&mut self) -> &mut Self { self.collection_mut().first = None; self } /// Fetch the last field for the current object /// /// ```rust /// # use activitystreams::{collection::UnorderedCollection}; /// # let mut collection = UnorderedCollection::new(); /// # /// use activitystreams::prelude::*; /// /// if let Some(last) = collection.last() { /// println!("{:?}", last); /// } /// ``` fn last<'a>(&'a self) -> Option<&'a AnyBase> where Kind: 'a, { self.collection_ref().last.as_ref() } /// Set the last field for the current object /// /// This overwrites the contents of last /// /// ```rust /// # fn main() -> Result<(), anyhow::Error> { /// # use activitystreams::{collection::UnorderedCollection}; /// # let mut collection = UnorderedCollection::new(); /// # /// use activitystreams::{prelude::*, uri}; /// /// collection.set_last(uri!("https://example.com")); /// # Ok(()) /// # } /// ``` fn set_last(&mut self, last: T) -> &mut Self where T: Into, { self.collection_mut().last = Some(last.into()); self } /// Take the last field from the current object, leaving nothing /// /// ```rust /// # use activitystreams::{collection::UnorderedCollection}; /// # let mut collection = UnorderedCollection::new(); /// # /// use activitystreams::prelude::*; /// /// if let Some(last) = collection.take_last() { /// println!("{:?}", last); /// } /// ``` fn take_last(&mut self) -> Option { self.collection_mut().last.take() } /// Delete the last field from the current object /// /// ```rust /// # use activitystreams::{context, collection::UnorderedCollection}; /// # let mut collection = UnorderedCollection::new(); /// # collection.set_last(context()); /// # /// use activitystreams::prelude::*; /// /// assert!(collection.last().is_some()); /// collection.delete_last(); /// assert!(collection.last().is_none()); /// ``` fn delete_last(&mut self) -> &mut Self { self.collection_mut().last = None; self } } /// Helper methods for interacting with CollectionPage types /// /// This trait represents methods valid for any ActivityStreams CollectionPage /// /// Documentation for the fields related to these methods can be found on the /// `CollectionPage` struct pub trait CollectionPageExt: AsCollectionPage { /// Fetch the part_of field for the current object /// /// ```rust /// # use activitystreams::{collection::UnorderedCollectionPage}; /// # let mut collection = UnorderedCollectionPage::new(); /// # /// use activitystreams::prelude::*; /// /// if let Some(part_of) = collection.part_of() { /// println!("{:?}", part_of); /// } /// ``` fn part_of<'a>(&'a self) -> Option<&'a AnyBase> where Kind: 'a, { self.collection_page_ref().part_of.as_ref() } /// Set the part_of field for the current object /// /// This overwrites the contents of part_of /// /// ```rust /// # fn main() -> Result<(), anyhow::Error> { /// # use activitystreams::{collection::UnorderedCollectionPage}; /// # let mut collection = UnorderedCollectionPage::new(); /// # /// use activitystreams::{prelude::*, uri}; /// /// collection.set_part_of(uri!("https://example.com")); /// # Ok(()) /// # } /// ``` fn set_part_of(&mut self, part_of: T) -> &mut Self where T: Into, { self.collection_page_mut().part_of = Some(part_of.into()); self } /// Take the part_of field from the current object, leaving nothing /// /// ```rust /// # use activitystreams::{collection::UnorderedCollectionPage}; /// # let mut collection = UnorderedCollectionPage::new(); /// # /// use activitystreams::prelude::*; /// /// if let Some(part_of) = collection.take_part_of() { /// println!("{:?}", part_of); /// } /// ``` fn take_part_of(&mut self) -> Option { self.collection_page_mut().part_of.take() } /// Delete the part_of field from the current object /// /// ```rust /// # use activitystreams::{context, collection::UnorderedCollectionPage}; /// # let mut collection = UnorderedCollectionPage::new(); /// # collection.set_part_of(context()); /// # /// use activitystreams::prelude::*; /// /// assert!(collection.part_of().is_some()); /// collection.delete_part_of(); /// assert!(collection.part_of().is_none()); /// ``` fn delete_part_of(&mut self) -> &mut Self { self.collection_page_mut().part_of = None; self } /// Fetch the next field for the current object /// /// ```rust /// # use activitystreams::{collection::UnorderedCollectionPage}; /// # let mut collection = UnorderedCollectionPage::new(); /// # /// use activitystreams::prelude::*; /// /// if let Some(next) = collection.next() { /// println!("{:?}", next); /// } /// ``` fn next<'a>(&'a self) -> Option<&'a AnyBase> where Kind: 'a, { self.collection_page_ref().next.as_ref() } /// Set the next field for the current object /// /// This overwrites the contents of next /// /// ```rust /// # fn main() -> Result<(), anyhow::Error> { /// # use activitystreams::{collection::UnorderedCollectionPage}; /// # let mut collection = UnorderedCollectionPage::new(); /// # /// use activitystreams::{prelude::*, uri}; /// /// collection.set_next(uri!("https://example.com")); /// # Ok(()) /// # } /// ``` fn set_next(&mut self, next: T) -> &mut Self where T: Into, { self.collection_page_mut().next = Some(next.into()); self } /// Take the next field from the current object, leaving nothing /// /// ```rust /// # use activitystreams::{collection::UnorderedCollectionPage}; /// # let mut collection = UnorderedCollectionPage::new(); /// # /// use activitystreams::prelude::*; /// /// if let Some(next) = collection.take_next() { /// println!("{:?}", next); /// } /// ``` fn take_next(&mut self) -> Option { self.collection_page_mut().next.take() } /// Delete the next field from the current object /// /// ```rust /// # use activitystreams::{context, collection::UnorderedCollectionPage}; /// # let mut collection = UnorderedCollectionPage::new(); /// # collection.set_next(context()); /// # /// use activitystreams::prelude::*; /// /// assert!(collection.next().is_some()); /// collection.delete_next(); /// assert!(collection.next().is_none()); /// ``` fn delete_next(&mut self) -> &mut Self { self.collection_page_mut().next = None; self } /// Fetch the prev field for the current object /// /// ```rust /// # use activitystreams::{collection::UnorderedCollectionPage}; /// # let mut collection = UnorderedCollectionPage::new(); /// # /// use activitystreams::prelude::*; /// /// if let Some(prev) = collection.prev() { /// println!("{:?}", prev); /// } /// ``` fn prev<'a>(&'a self) -> Option<&'a AnyBase> where Kind: 'a, { self.collection_page_ref().prev.as_ref() } /// Set the prev field for the current object /// /// This overwrites the contents of prev /// /// ```rust /// # fn main() -> Result<(), anyhow::Error> { /// # use activitystreams::{collection::UnorderedCollectionPage}; /// # let mut collection = UnorderedCollectionPage::new(); /// # /// use activitystreams::{prelude::*, uri}; /// /// collection.set_prev(uri!("https://example.com")); /// # Ok(()) /// # } /// ``` fn set_prev(&mut self, prev: T) -> &mut Self where T: Into, { self.collection_page_mut().prev = Some(prev.into()); self } /// Take the prev field from the current object, leaving nothing /// /// ```rust /// # use activitystreams::{collection::UnorderedCollectionPage}; /// # let mut collection = UnorderedCollectionPage::new(); /// # /// use activitystreams::prelude::*; /// /// if let Some(prev) = collection.take_prev() { /// println!("{:?}", prev); /// } /// ``` fn take_prev(&mut self) -> Option { self.collection_page_mut().prev.take() } /// Delete the prev field from the current object /// /// ```rust /// # use activitystreams::{context, collection::UnorderedCollectionPage}; /// # let mut collection = UnorderedCollectionPage::new(); /// # collection.set_prev(context()); /// # /// use activitystreams::prelude::*; /// /// assert!(collection.prev().is_some()); /// collection.delete_prev(); /// assert!(collection.prev().is_none()); /// ``` fn delete_prev(&mut self) -> &mut Self { self.collection_page_mut().prev = None; self } } pub trait OrderedCollectionPageExt: AsOrderedCollectionPage { /// Fetch the start_index of the current object /// /// ```rust /// # use activitystreams::{collection::OrderedCollectionPage}; /// # let mut collection = OrderedCollectionPage::new(); /// use activitystreams::prelude::*; /// /// if let Some(start_index) = collection.start_index() { /// println!("{:?}", start_index); /// } /// ``` fn start_index(&self) -> Option { self.ordered_collection_page_ref().start_index } /// Set the start_index for the current object /// /// This overwrites the contents of start_index /// /// ```rust /// # use activitystreams::{collection::OrderedCollectionPage}; /// # let mut collection = OrderedCollectionPage::new(); /// use activitystreams::prelude::*; /// /// collection.set_start_index(5u64); /// ``` fn set_start_index(&mut self, start_index: T) -> &mut Self where T: Into, { self.ordered_collection_page_mut().start_index = Some(start_index.into()); self } /// Take the start_index of the current object, leaving nothing /// /// ```rust /// # use activitystreams::{collection::OrderedCollectionPage}; /// # let mut collection = OrderedCollectionPage::new(); /// use activitystreams::prelude::*; /// /// if let Some(start_index) = collection.start_index() { /// println!("{:?}", start_index); /// } /// ``` fn take_start_index(&mut self) -> Option { self.ordered_collection_page_mut().start_index.take() } /// Delete the start_index from the current object /// /// ```rust /// # use activitystreams::{collection::OrderedCollectionPage}; /// # let mut collection = OrderedCollectionPage::new(); /// # collection.set_start_index(5u64); /// use activitystreams::prelude::*; /// /// assert!(collection.start_index().is_some()); /// collection.delete_start_index(); /// assert!(collection.start_index().is_none()); /// ``` fn delete_start_index(&mut self) -> &mut Self { self.ordered_collection_page_mut().start_index = None; self } } /// A subtype of Collection in which members of the logical collection are assumed to always be /// strictly ordered. /// /// This is just an alias for `Collection` because there's no fields /// inherent to UnorderedCollection that aren't already present on a Collection. pub type OrderedCollection = Collection; /// The default Collection type. /// /// This is just an alias for `Collection` because there's no fields /// inherent to UnorderedCollection that aren't already present on a Collection. pub type UnorderedCollection = Collection; /// Used to represent distinct subsets of items from a Collection. /// /// This is just an alias for `CollectionPage` because there's no fields /// inherent to UnorderedCollection that aren't already present on a CollectionPage. pub type UnorderedCollectionPage = CollectionPage; /// A Collection is a subtype of Object that represents ordered or unordered sets of Object or Link /// instances. /// /// The items within a Collection can be ordered or unordered. The OrderedCollection type MAY be /// used to identify a Collection whose items are always ordered. In the JSON serialization, the /// unordered items of a Collection are represented using the items property while ordered items /// are represented using the orderedItems property. #[derive(Debug, Clone, serde::Deserialize, serde::Serialize)] #[serde(rename_all = "camelCase")] pub struct Collection { /// Identifies the items contained in a collection. The items might be ordered or unordered. /// /// - Range: Object | Link | Ordered List of [ Object | Link ] /// - Functional: false items: Option>, /// A non-negative integer specifying the total number of objects contained by the logical view /// of the collection. /// /// This number might not reflect the actual number of items serialized within the Collection /// object instance. /// /// - Range: xsd:nonNegativeInteger /// - Functional: true #[serde(skip_serializing_if = "Option::is_none")] total_items: Option, /// In a paged Collection, indicates the page that contains the most recently updated member /// items. /// /// - Range: CollectionPage | Link /// - Functional: true #[serde(skip_serializing_if = "Option::is_none")] current: Option, /// In a paged Collection, indicates the furthest preceeding page of items in the collection. /// /// - Range: CollectionPage | Link /// - Functional: true #[serde(skip_serializing_if = "Option::is_none")] first: Option, /// In a paged Collection, indicates the furthest proceeding page of the collection. /// /// - Range: CollectionPage | Link /// - Functional: true #[serde(skip_serializing_if = "Option::is_none")] last: Option, /// Base fields and unparsed json ends up here #[serde(flatten)] inner: Object, } /// Used to represent distinct subsets of items from a Collection. /// /// A Collection can contain a large number of items. Often, it becomes impractical for an /// implementation to serialize every item contained by a Collection using the items (or /// ordered_items) property alone. In such cases, the items within a Collection can be divided into /// distinct subsets or "pages". A page is identified using the CollectionPage type. #[derive(Debug, Clone, serde::Deserialize, serde::Serialize)] #[serde(rename_all = "camelCase")] pub struct CollectionPage { /// Identifies the Collection to which a CollectionPage objects items belong. /// /// - Range: Collection | Link /// - Functional: true #[serde(skip_serializing_if = "Option::is_none")] part_of: Option, /// In a paged Collection, indicates the next page of items. /// /// - Range: CollectionPage | Link /// - Functional: true #[serde(skip_serializing_if = "Option::is_none")] next: Option, /// In a paged Collection, identifies the previous page of items. /// /// - Range: CollectionPage | Link /// - Functional: true #[serde(skip_serializing_if = "Option::is_none")] prev: Option, /// Base fields and unparsed json ends up here #[serde(flatten)] inner: Collection, } /// Used to represent ordered subsets of items from an OrderedCollection. #[derive(Debug, Clone, serde::Deserialize, serde::Serialize)] #[serde(rename_all = "camelCase")] pub struct OrderedCollectionPage { /// A non-negative integer value identifying the relative position within the logical view of a strictly ordered collection. /// /// - Range: xsd:nonNegativeInteger /// - Functional: true #[serde(skip_serializing_if = "Option::is_none")] start_index: Option, /// Base fields and unparsed json ends up here #[serde(flatten)] inner: CollectionPage, } impl Collection { /// Create a new Collection /// /// ```rust /// use activitystreams::collection::Collection; /// /// let collection = Collection::::new(); /// ``` pub fn new() -> Self where Kind: Default, { Collection { items: None, total_items: None, current: None, first: None, last: None, inner: Object::new(), } } fn extending(mut inner: Object) -> Result { let items = inner.remove("items")?; let total_items = inner.remove("totalItems")?; let current = inner.remove("current")?; let first = inner.remove("first")?; let last = inner.remove("last")?; Ok(Collection { items, total_items, current, first, last, inner, }) } fn retracting(self) -> Result, serde_json::Error> { let Collection { items, total_items, current, first, last, mut inner, } = self; inner .insert("last", last)? .insert("first", first)? .insert("current", current)? .insert("totalItems", total_items)? .insert("items", items)?; Ok(inner) } } impl CollectionPage { /// Create a new CollectionPage /// /// ```rust /// use activitystreams::collection::CollectionPage; /// /// let collection = CollectionPage::::new(); /// ``` pub fn new() -> Self where Kind: Default, { CollectionPage { part_of: None, next: None, prev: None, inner: Collection::new(), } } fn extending(object: Object) -> Result { let mut inner = Collection::extending(object)?; let part_of = inner.remove("partOf")?; let next = inner.remove("next")?; let prev = inner.remove("prev")?; Ok(CollectionPage { part_of, next, prev, inner, }) } fn retracting(self) -> Result, serde_json::Error> { let CollectionPage { part_of, next, prev, mut inner, } = self; inner .insert("prev", prev)? .insert("next", next)? .insert("partOf", part_of)?; inner.retracting() } } impl OrderedCollectionPage { /// Create a new CollectionPage /// /// ```rust /// use activitystreams::collection::OrderedCollectionPage; /// /// let collection = OrderedCollectionPage::new(); /// ``` pub fn new() -> Self { OrderedCollectionPage { start_index: None, inner: CollectionPage::new(), } } fn extending(object: Object) -> Result { let mut inner = CollectionPage::extending(object)?; let start_index = inner.remove("startIndex")?; Ok(OrderedCollectionPage { start_index, inner }) } fn retracting(self) -> Result, serde_json::Error> { let OrderedCollectionPage { start_index, mut inner, } = self; inner.insert("startIndex", start_index)?; inner.retracting() } } impl markers::Base for Collection {} impl markers::Object for Collection {} impl markers::Collection for Collection {} impl markers::Base for CollectionPage {} impl markers::Object for CollectionPage {} impl markers::Collection for CollectionPage {} impl markers::CollectionPage for CollectionPage {} impl markers::Base for OrderedCollectionPage {} impl markers::Object for OrderedCollectionPage {} impl markers::Collection for OrderedCollectionPage {} impl markers::CollectionPage for OrderedCollectionPage {} impl markers::Collection for ApObject where Inner: markers::Collection {} impl markers::CollectionPage for ApObject where Inner: markers::CollectionPage {} impl Extends for Collection { type Error = serde_json::Error; fn extends(base: Base) -> Result { let inner = Object::extends(base)?; Self::extending(inner) } fn retracts(self) -> Result, Self::Error> { let inner = self.retracting()?; inner.retracts() } } impl TryFrom> for Object { type Error = serde_json::Error; fn try_from(collection: Collection) -> Result { collection.retracting() } } impl TryFrom> for Collection { type Error = serde_json::Error; fn try_from(object: Object) -> Result { Self::extending(object) } } impl Extends for CollectionPage { type Error = serde_json::Error; fn extends(base: Base) -> Result { let inner = Object::extends(base)?; Self::extending(inner) } fn retracts(self) -> Result, Self::Error> { let inner = self.retracting()?; inner.retracts() } } impl TryFrom> for CollectionPage { type Error = serde_json::Error; fn try_from(object: Object) -> Result { Self::extending(object) } } impl TryFrom> for Object { type Error = serde_json::Error; fn try_from(collection_page: CollectionPage) -> Result { collection_page.retracting() } } impl Extends for OrderedCollectionPage { type Error = serde_json::Error; fn extends(base: Base) -> Result { let inner = Object::extends(base)?; Self::extending(inner) } fn retracts(self) -> Result, Self::Error> { let inner = self.retracting()?; inner.retracts() } } impl TryFrom> for OrderedCollectionPage { type Error = serde_json::Error; fn try_from(object: Object) -> Result { Self::extending(object) } } impl TryFrom for Object { type Error = serde_json::Error; fn try_from(collection_page: OrderedCollectionPage) -> Result { collection_page.retracting() } } impl UnparsedMut for Collection { fn unparsed_mut(&mut self) -> &mut Unparsed { self.inner.unparsed_mut() } } impl UnparsedMut for CollectionPage { fn unparsed_mut(&mut self) -> &mut Unparsed { self.inner.unparsed_mut() } } impl UnparsedMut for OrderedCollectionPage { fn unparsed_mut(&mut self) -> &mut Unparsed { self.inner.unparsed_mut() } } impl AsBase for Collection { fn base_ref(&self) -> &Base { self.inner.base_ref() } fn base_mut(&mut self) -> &mut Base { self.inner.base_mut() } } impl AsObject for Collection { fn object_ref(&self) -> &Object { &self.inner } fn object_mut(&mut self) -> &mut Object { &mut self.inner } } impl AsCollection for Collection { fn collection_ref(&self) -> &Collection { self } fn collection_mut(&mut self) -> &mut Collection { self } } impl AsBase for CollectionPage { fn base_ref(&self) -> &Base { self.inner.base_ref() } fn base_mut(&mut self) -> &mut Base { self.inner.base_mut() } } impl AsObject for CollectionPage { fn object_ref(&self) -> &Object { self.inner.object_ref() } fn object_mut(&mut self) -> &mut Object { self.inner.object_mut() } } impl AsCollection for CollectionPage { fn collection_ref(&self) -> &Collection { &self.inner } fn collection_mut(&mut self) -> &mut Collection { &mut self.inner } } impl AsCollectionPage for CollectionPage { fn collection_page_ref(&self) -> &CollectionPage { self } fn collection_page_mut(&mut self) -> &mut CollectionPage { self } } impl AsBase for OrderedCollectionPage { fn base_ref(&self) -> &Base { self.inner.base_ref() } fn base_mut(&mut self) -> &mut Base { self.inner.base_mut() } } impl AsObject for OrderedCollectionPage { fn object_ref(&self) -> &Object { self.inner.object_ref() } fn object_mut(&mut self) -> &mut Object { self.inner.object_mut() } } impl AsCollection for OrderedCollectionPage { fn collection_ref(&self) -> &Collection { self.inner.collection_ref() } fn collection_mut(&mut self) -> &mut Collection { self.inner.collection_mut() } } impl AsCollectionPage for OrderedCollectionPage { fn collection_page_ref(&self) -> &CollectionPage { &self.inner } fn collection_page_mut(&mut self) -> &mut CollectionPage { &mut self.inner } } impl AsOrderedCollectionPage for OrderedCollectionPage { fn ordered_collection_page_ref(&self) -> &OrderedCollectionPage { self } fn ordered_collection_page_mut(&mut self) -> &mut OrderedCollectionPage { self } } impl AsCollection for ApObject where Inner: AsCollection, { fn collection_ref(&self) -> &Collection { self.inner().collection_ref() } fn collection_mut(&mut self) -> &mut Collection { self.inner_mut().collection_mut() } } impl AsCollectionPage for ApObject where Inner: AsCollectionPage, { fn collection_page_ref(&self) -> &CollectionPage { self.inner().collection_page_ref() } fn collection_page_mut(&mut self) -> &mut CollectionPage { self.inner_mut().collection_page_mut() } } impl AsOrderedCollectionPage for ApObject where Inner: AsOrderedCollectionPage, { fn ordered_collection_page_ref(&self) -> &OrderedCollectionPage { self.inner().ordered_collection_page_ref() } fn ordered_collection_page_mut(&mut self) -> &mut OrderedCollectionPage { self.inner_mut().ordered_collection_page_mut() } } impl CollectionExt for T where T: AsCollection {} impl CollectionPageExt for T where T: AsCollectionPage {} impl OrderedCollectionPageExt for T where T: AsOrderedCollectionPage {}