Struct activitystreams::activity::ActivityActor

pub struct ActivityActor<Inner> { /* private fields */ }

Activity with an actor property

Implementations

impl<Kind> ActivityActor<ActivityObject<Activity<Kind>>>

pub fn new<T, U>(actor: T, object: U) -> Selfwhere
    T: Into<OneOrMany<AnyBase>>,
    U: Into<OneOrMany<AnyBase>>,
    Kind: Default,

Create a new ActorAndObject Activity

use activitystreams::activity::ActorAndObject;

let activity = ActorAndObject::<String>::new(vec![], vec![]);

pub fn new_none_type<T, U>(actor: T, object: U) -> Selfwhere
    T: Into<OneOrMany<AnyBase>>,
    U: Into<OneOrMany<AnyBase>>,

Create a new ActorAndObject with None for it’s kind property

This means that no type field will be present in serialized JSON

use activitystreams::activity::ActorAndObject;

let activity = ActorAndObject::<()>::new_none_type(vec![], vec![]);

let s = serde_json::to_string(&activity)?;

assert_eq!(s, r#"{"actor":[],"object":[]}"#);

pub fn into_parts(
    self
) -> (OneOrMany<AnyBase>, OneOrMany<AnyBase>, Activity<Kind>)

Deconstruct the ActorAndObject into its parts

use activitystreams::activity::ActorAndObject;

let activity = ActorAndObject::<String>::new(vec![], vec![]);

let (actor, object, activity) = activity.into_parts();

Trait Implementations

impl<Inner> AsActivity for ActivityActor<Inner>where
    Inner: AsActivity,

type Kind = <Inner as AsActivity>::Kind

fn activity_ref(&self) -> &Activity<Self::Kind>

Immutable borrow of Activity<Kind>

fn activity_mut(&mut self) -> &mut Activity<Self::Kind>

Mutable borrow of Activity<Kind>

impl<Inner> AsActivityActor for ActivityActor<Inner>where
    Inner: Activity,

type Inner = Inner

fn activity_actor_ref(&self) -> &ActivityActor<Self::Inner>

fn activity_actor_mut(&mut self) -> &mut ActivityActor<Self::Inner>

impl<Inner> AsActivityObject for ActivityActor<Inner>where
    Inner: AsActivityObject,

type Inner = <Inner as AsActivityObject>::Inner

fn activity_object_ref(&self) -> &ActivityObject<Self::Inner>

fn activity_object_mut(&mut self) -> &mut ActivityObject<Self::Inner>

impl<Inner> AsBase for ActivityActor<Inner>where
    Inner: AsBase,

type Kind = <Inner as AsBase>::Kind

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

Immutable borrow of Base<Kind>

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

Mutable borrow of Base

impl<Inner> AsObject for ActivityActor<Inner>where
    Inner: AsObject,

type Kind = <Inner as AsObject>::Kind

fn object_ref(&self) -> &Object<Self::Kind>

Immutable borrow of Object<Kind>

fn object_mut(&mut self) -> &mut Object<Self::Kind>

Mutable borrow of Object<Kind>

impl<Inner> AsOptOrigin for ActivityActor<Inner>where
    Inner: AsOptOrigin,

type Inner = <Inner as AsOptOrigin>::Inner

fn opt_origin_ref(&self) -> &OptOrigin<Self::Inner>

fn opt_origin_mut(&mut self) -> &mut OptOrigin<Self::Inner>

impl<Inner> AsOptTarget for ActivityActor<Inner>where
    Inner: AsOptTarget,

type Inner = <Inner as AsOptTarget>::Inner

fn opt_target_ref(&self) -> &OptTarget<Self::Inner>

fn opt_target_mut(&mut self) -> &mut OptTarget<Self::Inner>

impl<Inner> AsOrigin for ActivityActor<Inner>where
    Inner: AsOrigin,

type Inner = <Inner as AsOrigin>::Inner

fn origin_ref(&self) -> &Origin<Self::Inner>

fn origin_mut(&mut self) -> &mut Origin<Self::Inner>

impl<Inner> AsTarget for ActivityActor<Inner>where
    Inner: AsTarget,

type Inner = <Inner as AsTarget>::Inner

fn target_ref(&self) -> &Target<Self::Inner>

fn target_mut(&mut self) -> &mut Target<Self::Inner>

impl<Inner: Clone> Clone for ActivityActor<Inner>

fn clone(&self) -> ActivityActor<Inner>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Inner: Debug> Debug for ActivityActor<Inner>

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

Formats the value using the given formatter.

impl<'de, Inner> Deserialize<'de> for ActivityActor<Inner>where
    Inner: Deserialize<'de>,

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

Deserialize this value from the given Serde deserializer.

impl<Inner> Extends for ActivityActor<Inner>where
    Inner: Extends<Error = Error> + UnparsedMut,

type Kind = <Inner as Extends>::Kind

type Error = Error

The erro produced must be a StdError

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

Produce an object from the Base

fn retracts(self) -> Result<Base<Self::Kind>, Self::Error>

Produce a base from the object

impl<Inner> Serialize for ActivityActor<Inner>where
    Inner: Serialize,

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

Serialize this value into the given Serde serializer.

impl<Inner, Kind> TryFrom<ActivityActor<Inner>> for Object<Kind>where
    Object<Kind>: TryFrom<Inner, Error = Error>,
    Inner: UnparsedMut,

type Error = Error

The type returned in the event of a conversion error.

fn try_from(activity: ActivityActor<Inner>) -> Result<Self, Self::Error>

Performs the conversion.

impl<Inner, Kind> TryFrom<Object<Kind>> for ActivityActor<Inner>where
    Inner: TryFrom<Object<Kind>, Error = Error> + UnparsedMut,

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<Inner> UnparsedMut for ActivityActor<Inner>where
    Inner: UnparsedMut,

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

Get a mutable reference to Unparsed

impl<Inner> Activity for ActivityActor<Inner>where
    Inner: Activity,

impl<Inner> Base for ActivityActor<Inner>where
    Inner: Base,

impl<Inner> IntransitiveActivity for ActivityActor<Inner>where
    Inner: IntransitiveActivity,

impl<Inner> Object for ActivityActor<Inner>where
    Inner: Object,