Struct Ext2

pub struct Ext2<Inner, A, B> {
    pub ext_one: A,
    pub ext_two: B,
    pub inner: Inner,
}

Extend a type with two values

Fields

ext_one: A

ext_two: B

inner: Inner

The type being extended

Implementations

impl<Inner, A, B> Ext2<Inner, A, B>

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

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

pub fn extend<C>(self, ext_three: C) -> Ext3<Inner, A, B, C>

Trait Implementations

impl<Inner, A, B> AsActivity for Ext2<Inner, A, B>

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, A, B> AsActivityActor for Ext2<Inner, A, B>

where Inner: AsActivityActor,

type Inner = <Inner as AsActivityActor>::Inner

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

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

impl<Inner, A, B> AsActivityObject for Ext2<Inner, A, B>

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, A, B> AsApActor for Ext2<Inner, A, B>

where Inner: AsApActor,

type Inner = <Inner as AsApActor>::Inner

fn ap_actor_ref(&self) -> &ApActor<Self::Inner>

Immutable borrow of ApActor<Inner>

fn ap_actor_mut(&mut self) -> &mut ApActor<Self::Inner>

Mutable borrow of ApActor<Inner>

impl<Inner, A, B> AsApObject for Ext2<Inner, A, B>

where Inner: AsApObject,

type Inner = <Inner as AsApObject>::Inner

fn ap_object_ref(&self) -> &ApObject<Self::Inner>

Immutable borrow of ApObject<Inner>

fn ap_object_mut(&mut self) -> &mut ApObject<Self::Inner>

Mutable borrow of ApObject<Inner>

impl<Inner, A, B> AsBase for Ext2<Inner, A, B>

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, A, B> AsCollection for Ext2<Inner, A, B>

where Inner: AsCollection,

type Kind = <Inner as AsCollection>::Kind

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

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

impl<Inner, A, B> AsCollectionPage for Ext2<Inner, A, B>

where Inner: AsCollectionPage,

type Kind = <Inner as AsCollectionPage>::Kind

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

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

impl<Inner, A, B> AsObject for Ext2<Inner, A, B>

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, A, B> AsOptOrigin for Ext2<Inner, A, B>

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, A, B> AsOptTarget for Ext2<Inner, A, B>

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, A, B> AsOrigin for Ext2<Inner, A, B>

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, A, B> AsQuestion for Ext2<Inner, A, B>

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, B> AsTarget for Ext2<Inner, A, B>

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, A: Clone, B: Clone> Clone for Ext2<Inner, A, B>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<Inner: Debug, A: Debug, B: Debug> Debug for Ext2<Inner, A, B>

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

Formats the value using the given formatter.

impl<'de, Inner, A, B> Deserialize<'de> for Ext2<Inner, A, B>

where Inner: Deserialize<'de>, A: Deserialize<'de>, B: 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, B, Error> Extends for Ext2<Inner, A, B>

where Inner: Extends<Error = Error> + UnparsedMut, A: UnparsedExtension<Inner, Error = Error>, B: UnparsedExtension<Inner, Error = Error>, Error: From<Error> + Error,

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, A, B> Serialize for Ext2<Inner, A, B>

where Inner: Serialize, A: Serialize, B: 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, B> Activity for Ext2<Inner, A, B>

where Inner: Activity,

impl<Inner, A, B> Actor for Ext2<Inner, A, B>

where Inner: Actor,

impl<Inner, A, B> Base for Ext2<Inner, A, B>

where Inner: Base,

impl<Inner, A, B> Collection for Ext2<Inner, A, B>

where Inner: Collection,

impl<Inner, A, B> CollectionPage for Ext2<Inner, A, B>

where Inner: CollectionPage,

impl<Inner, A, B> IntransitiveActivity for Ext2<Inner, A, B>

where Inner: IntransitiveActivity,

impl<Inner, A, B> Object for Ext2<Inner, A, B>

where Inner: Object,