Struct activitystreams_ext::Ext1

pub struct Ext1<Inner, A> {
    pub ext_one: A,
    pub inner: Inner,
}

Extend a type with a single value

Fields

ext_one: A

inner: Inner

The type being extended

Implementations

impl<Inner, A> Ext1<Inner, A>

pub fn new(inner: Inner, ext_one: A) -> Self

pub fn into_parts(self) -> (Inner, A)

pub fn extend<B>(self, ext_two: B) -> Ext2<Inner, A, B>

Trait Implementations

impl<Inner, A> Activity for Ext1<Inner, A> where
    Inner: Activity, 

impl<Inner, A> Actor for Ext1<Inner, A> where
    Inner: Actor, 

impl<Inner, A> ActorAndObjectRef for Ext1<Inner, A> where
    Inner: ActorAndObjectRef, 

fn actor_field_ref(&self) -> &OneOrMany<AnyBase>

Immutable borrow of actor field

fn actor_field_mut(&mut self) -> &mut OneOrMany<AnyBase>

Immutable borrow of object field

fn object_field_ref(&self) -> &OneOrMany<AnyBase>

Mutable borrow of actor field

fn object_field_mut(&mut self) -> &mut OneOrMany<AnyBase>

Mutable borrow of object field

impl<Inner, A, Kind> AsActivity<Kind> for Ext1<Inner, A> where
    Inner: AsActivity<Kind>, 

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

Immutable borrow of Activity<Kind>

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

Mutable borrow of Activity<Kind>

impl<Inner, A, ApInner> AsApActor<ApInner> for Ext1<Inner, A> where
    Inner: AsApActor<ApInner>, 

fn ap_actor_ref(&self) -> &ApActor<ApInner>

Immutable borrow of ApActor<Inner>

fn ap_actor_mut(&mut self) -> &mut ApActor<ApInner>

Mutable borrow of ApActor<Inner>

impl<Inner, A, ApInner> AsApObject<ApInner> for Ext1<Inner, A> where
    Inner: AsApObject<ApInner>, 

fn ap_object_ref(&self) -> &ApObject<ApInner>

Immutable borrow of ApObject<Inner>

fn ap_object_mut(&mut self) -> &mut ApObject<ApInner>

Mutable borrow of ApObject<Inner>

impl<Inner, A, Kind> AsBase<Kind> for Ext1<Inner, A> where
    Inner: AsBase<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<Inner, A, Kind> AsCollection<Kind> for Ext1<Inner, A> where
    Inner: AsCollection<Kind>, 

fn collection_ref(&self) -> &Collection<Kind>

fn collection_mut(&mut self) -> &mut Collection<Kind>

impl<Inner, A, Kind> AsCollectionPage<Kind> for Ext1<Inner, A> where
    Inner: AsCollectionPage<Kind>, 

fn collection_page_ref(&self) -> &CollectionPage<Kind>

fn collection_page_mut(&mut self) -> &mut CollectionPage<Kind>

impl<Inner, A, Kind> AsObject<Kind> for Ext1<Inner, A> where
    Inner: AsObject<Kind>, 

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

Immutable borrow of Object<Kind>

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

Mutable borrow of Object<Kind>

impl<Inner, A> AsQuestion for Ext1<Inner, A> where
    Inner: AsQuestion, 

fn question_ref(&self) -> &Question

Immutable borrow of Question

fn question_mut(&mut self) -> &mut Question

Mutable borrow of Question

impl<Inner, A> Base for Ext1<Inner, A> where
    Inner: Base, 

impl<Inner: Clone, A: Clone> Clone for Ext1<Inner, A>

fn clone(&self) -> Ext1<Inner, A>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Inner, A> Collection for Ext1<Inner, A> where
    Inner: Collection, 

impl<Inner, A> CollectionPage for Ext1<Inner, A> where
    Inner: CollectionPage, 

impl<Inner: Debug, A: Debug> Debug for Ext1<Inner, A>

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

Formats the value using the given formatter.

impl<'de, Inner, A> Deserialize<'de> for Ext1<Inner, A> where
    Inner: Deserialize<'de>,
    A: 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, A, Kind, Error> Extends<Kind> for Ext1<Inner, A> where
    Inner: Extends<Kind, Error = Error> + UnparsedMut,
    A: UnparsedExtension<Inner, Error = Error>,
    Error: From<Error> + Error, 

type Error = Error

The erro produced must be a StdError

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

Produce an object from the Base

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

Produce a base from the object

impl<Inner, A> IntransitiveActivity for Ext1<Inner, A> where
    Inner: IntransitiveActivity, 

impl<Inner, A> Object for Ext1<Inner, A> where
    Inner: Object, 

impl<Inner, A> OptOriginRef for Ext1<Inner, A> where
    Inner: OptOriginRef, 

fn origin_field_ref(&self) -> &Option<OneOrMany<AnyBase>>

Immutable borrow of origin field

fn origin_field_mut(&mut self) -> &mut Option<OneOrMany<AnyBase>>

Mutable borrow of origin field

impl<Inner, A> OptTargetRef for Ext1<Inner, A> where
    Inner: OptTargetRef, 

fn target_field_ref(&self) -> &Option<OneOrMany<AnyBase>>

Immutable borrow of target field

fn target_field_mut(&mut self) -> &mut Option<OneOrMany<AnyBase>>

Mutable borrow of target field

impl<Inner, A> OriginRef for Ext1<Inner, A> where
    Inner: OriginRef, 

fn origin_field_ref(&self) -> &OneOrMany<AnyBase>

Immutable borrow of origin field

fn origin_field_mut(&mut self) -> &mut OneOrMany<AnyBase>

Mutable borrow of origin field

impl<Inner, A> Serialize for Ext1<Inner, A> where
    Inner: Serialize,
    A: 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, A> TargetRef for Ext1<Inner, A> where
    Inner: TargetRef, 

fn target_field_ref(&self) -> &OneOrMany<AnyBase>

Immutable borrow of target field

fn target_field_mut(&mut self) -> &mut OneOrMany<AnyBase>

Mutable borrow of target field