Struct activitystreams::base::Base

pub struct Base<Kind> { /* fields omitted */ }

A representation of the common fields between Links and Objects in ActivityStreams

Although the spec does not define a type more abstract that Object or Link, it does define fields present in both, so for the sake of "Everything derives from something," I've implemented a type.

Implementations

impl Base<Value>

pub fn solidify<Kind>(self) -> Result<Base<Kind>, Error> where
    Kind: DeserializeOwned, 

Convert this Base<serde_json::Value> into a Base<Kind>

This is required before extending Base into the other types found in this crate

impl<Kind> Base<Kind>

pub fn new() -> Self where
    Kind: Default, 

Create a new Base

use activitystreams::base::Base;

let base = Base::<String>::new();

pub fn extend<T>(self) -> Result<T, T::Error> where
    T: Extends<Kind>, 

Extend the Base into any other ActivityStreams type provided in this crate

let video = base.extend::<Video>()?;

pub fn retract<T>(t: T) -> Result<Self, T::Error> where
    T: Extends<Kind>, 

Retract any other ActivityStreams type into a Base<Kind>

let base = Base::retract(video)?;

pub fn into_generic(self) -> Result<Base<Value>, Error> where
    Kind: Serialize, 

Convert this Base into a Base<serde_json::Value>

This is required before putting a Base into an AnyBase type

pub fn map_kind<NewKind>(self, f: impl Fn(Kind) -> NewKind) -> Base<NewKind>

An inffalible conversion from Base<T> to Base<U> where there is a known path from T to U

use activitystreams::{base::Base, prelude::*};

let mut base = Base::<String>::new();
base.set_kind("Hey".to_owned());

let new_base = base.map_kind(|kind| match kind.as_str() {
    "Create" => 1,
    "Update" => 5,
    _ => 0,
});

assert!(*new_base.kind().unwrap() == 0);

pub fn try_map_kind<NewKind, E>(
    self,
    f: impl Fn(Kind) -> Result<NewKind, E>
) -> Result<Base<NewKind>, E>

A fallible conversion from Base<T> to Base<U>

use activitystreams::{base::Base, prelude::*};

let mut base = Base::<String>::new();
base.set_kind("Hey".to_owned());

let new_base = base.try_map_kind(|kind| match kind.as_str() {
    "Create" => Ok(1),
    "Update" => Ok(5),
    _ => Err(anyhow::Error::msg("invalid kind")),
});

assert!(new_base.is_err());

Trait Implementations

impl<Kind> AsBase<Kind> for Base<Kind>

fn base_ref(&self) -> &Base<Kind>

Immutable borrow of Base<Kind>

fn base_mut(&mut self) -> &mut Base<Kind>

Mutable borrow of Base

impl<Kind> Base for Base<Kind>

impl<Kind: Clone> Clone for Base<Kind>

fn clone(&self) -> Base<Kind>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Kind: Debug> Debug for Base<Kind>

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

Formats the value using the given formatter.

impl<'de, Kind> Deserialize<'de> for Base<Kind> where
    Kind: Deserialize<'de>, 

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

Deserialize this value from the given Serde deserializer.

impl From<Base<Value>> for AnyBase

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

Performs the conversion.

impl From<Base<Value>> for OneOrMany<AnyBase>

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

Performs the conversion.

impl<Kind> Serialize for Base<Kind> where
    Kind: Serialize, 

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

Serialize this value into the given Serde serializer.

impl<Kind> TryFrom<Base<Kind>> for Link<Kind> where
    Kind: DeserializeOwned, 

type Error = Error

The type returned in the event of a conversion error.

fn try_from(base: Base<Kind>) -> Result<Self, Self::Error>

Performs the conversion.

impl<Kind> TryFrom<Base<Kind>> for Object<Kind>

type Error = Error

The type returned in the event of a conversion error.

fn try_from(base: Base<Kind>) -> Result<Self, Self::Error>

Performs the conversion.

impl<Kind> TryFrom<Link<Kind>> for Base<Kind> where
    Kind: Serialize, 

type Error = Error

The type returned in the event of a conversion error.

fn try_from(link: Link<Kind>) -> Result<Self, Self::Error>

Performs the conversion.

impl<Kind> TryFrom<Object<Kind>> for Base<Kind>

type Error = Error

The type returned in the event of a conversion error.

fn try_from(object: Object<Kind>) -> Result<Self, Self::Error>

Performs the conversion.

impl<Kind> UnparsedMut for Base<Kind>

fn unparsed_mut(&mut self) -> &mut Unparsed

Get a mutable reference to Unparsed