[−][src]Struct activitystreams_ext::Ext4

pub struct Ext4<Inner, A, B, C, D> {
    pub ext_one: A,
    pub ext_two: B,
    pub ext_three: C,
    pub ext_four: D,
    pub inner: Inner,
}

Extend a type with four values

Fields

ext_one: Aext_two: Bext_three: Cext_four: Dinner: Inner

The type being extended

Implementations

`impl<Inner, A, B, C, D> Ext4<Inner, A, B, C, D>`[src]

`pub fn new( inner: Inner, ext_one: A, ext_two: B, ext_three: C, ext_four: D ) -> Self`[src]

`pub fn into_parts(self) -> (Inner, A, B, C, D)`[src]

Trait Implementations

`impl<Inner, A, B, C, D> Activity for Ext4<Inner, A, B, C, D> where Inner: Activity,` [src]

`impl<Inner, A, B, C, D> Actor for Ext4<Inner, A, B, C, D> where Inner: Actor,` [src]

`impl<Inner, A, B, C, D> ActorAndObjectRef for Ext4<Inner, A, B, C, D> where Inner: ActorAndObjectRef,` [src]

`fn actor_field_ref(&self) -> &OneOrMany<AnyBase>`[src]

`fn actor_field_mut(&mut self) -> &mut OneOrMany<AnyBase>`[src]

`fn object_field_ref(&self) -> &OneOrMany<AnyBase>`[src]

`fn object_field_mut(&mut self) -> &mut OneOrMany<AnyBase>`[src]

`impl<Inner, A, B, C, D, Kind> AsActivity<Kind> for Ext4<Inner, A, B, C, D> where Inner: AsActivity<Kind>,` [src]

`fn activity_ref(&self) -> &Activity<Kind>`[src]

`fn activity_mut(&mut self) -> &mut Activity<Kind>`[src]

`impl<Inner, A, B, C, D, ApInner> AsApActor<ApInner> for Ext4<Inner, A, B, C, D> where Inner: AsApActor<ApInner>,` [src]

`fn ap_actor_ref(&self) -> &ApActor<ApInner>`[src]

`fn ap_actor_mut(&mut self) -> &mut ApActor<ApInner>`[src]

`impl<Inner, A, B, C, D, ApInner> AsApObject<ApInner> for Ext4<Inner, A, B, C, D> where Inner: AsApObject<ApInner>,` [src]

`fn ap_object_ref(&self) -> &ApObject<ApInner>`[src]

`fn ap_object_mut(&mut self) -> &mut ApObject<ApInner>`[src]

`impl<Inner, A, B, C, D, Kind> AsBase<Kind> for Ext4<Inner, A, B, C, D> where Inner: AsBase<Kind>,` [src]

`fn base_ref(&self) -> &Base<Kind>`[src]

`fn base_mut(&mut self) -> &mut Base<Kind>`[src]

`impl<Inner, A, B, C, D, Kind> AsCollection<Kind> for Ext4<Inner, A, B, C, D> where Inner: AsCollection<Kind>,` [src]

`fn collection_ref(&self) -> &Collection<Kind>`[src]

`fn collection_mut(&mut self) -> &mut Collection<Kind>`[src]

`impl<Inner, A, B, C, D, Kind> AsCollectionPage<Kind> for Ext4<Inner, A, B, C, D> where Inner: AsCollectionPage<Kind>,` [src]

`fn collection_page_ref(&self) -> &CollectionPage<Kind>`[src]

`fn collection_page_mut(&mut self) -> &mut CollectionPage<Kind>`[src]

`impl<Inner, A, B, C, D, Kind> AsObject<Kind> for Ext4<Inner, A, B, C, D> where Inner: AsObject<Kind>,` [src]

`fn object_ref(&self) -> &Object<Kind>`[src]

`fn object_mut(&mut self) -> &mut Object<Kind>`[src]

`impl<Inner, A, B, C, D> AsQuestion for Ext4<Inner, A, B, C, D> where Inner: AsQuestion,` [src]

`fn question_ref(&self) -> &Question`[src]

`fn question_mut(&mut self) -> &mut Question`[src]

`impl<Inner, A, B, C, D> Base for Ext4<Inner, A, B, C, D> where Inner: Base,` [src]

`impl<Inner: Clone, A: Clone, B: Clone, C: Clone, D: Clone> Clone for Ext4<Inner, A, B, C, D>`[src]

`fn clone(&self) -> Ext4<Inner, A, B, C, D>`[src]

`fn clone_from(&mut self, source: &Self)`1.0.0[src]

`impl<Inner, A, B, C, D> Collection for Ext4<Inner, A, B, C, D> where Inner: Collection,` [src]

`impl<Inner, A, B, C, D> CollectionPage for Ext4<Inner, A, B, C, D> where Inner: CollectionPage,` [src]

`impl<Inner: Debug, A: Debug, B: Debug, C: Debug, D: Debug> Debug for Ext4<Inner, A, B, C, D>`[src]

`fn fmt(&self, f: &mut Formatter) -> Result`[src]

`impl<'de, Inner, A, B, C, D> Deserialize<'de> for Ext4<Inner, A, B, C, D> where Inner: Deserialize<'de>, A: Deserialize<'de>, B: Deserialize<'de>, C: Deserialize<'de>, D: Deserialize<'de>,` [src]

`fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where __D: Deserializer<'de>,` [src]

`impl<Inner, A, B, C, D, Kind, Error> Extends<Kind> for Ext4<Inner, A, B, C, D> where Inner: Extends<Kind, Error = Error> + UnparsedMut, A: UnparsedExtension<Inner, Error = Error>, B: UnparsedExtension<Inner, Error = Error>, C: UnparsedExtension<Inner, Error = Error>, D: UnparsedExtension<Inner, Error = Error>, Error: From<Error> + Error,` [src]

`type Error = Error`

The erro produced must be a StdError

`fn extends(base: Base<Kind>) -> Result<Self, Self::Error>`[src]

`fn retracts(self) -> Result<Base<Kind>, Self::Error>`[src]

`impl<Inner, A, B, C, D> IntransitiveActivity for Ext4<Inner, A, B, C, D> where Inner: IntransitiveActivity,` [src]

`impl<Inner, A, B, C, D> Object for Ext4<Inner, A, B, C, D> where Inner: Object,` [src]

`impl<Inner, A, B, C, D> OptOriginRef for Ext4<Inner, A, B, C, D> where Inner: OptOriginRef,` [src]

`fn origin_field_ref(&self) -> &Option<OneOrMany<AnyBase>>`[src]

`fn origin_field_mut(&mut self) -> &mut Option<OneOrMany<AnyBase>>`[src]

`impl<Inner, A, B, C, D> OptTargetRef for Ext4<Inner, A, B, C, D> where Inner: OptTargetRef,` [src]

`fn target_field_ref(&self) -> &Option<OneOrMany<AnyBase>>`[src]

`fn target_field_mut(&mut self) -> &mut Option<OneOrMany<AnyBase>>`[src]

`impl<Inner, A, B, C, D> OriginRef for Ext4<Inner, A, B, C, D> where Inner: OriginRef,` [src]

`fn origin_field_ref(&self) -> &OneOrMany<AnyBase>`[src]

`fn origin_field_mut(&mut self) -> &mut OneOrMany<AnyBase>`[src]

`impl<Inner, A, B, C, D> Serialize for Ext4<Inner, A, B, C, D> where Inner: Serialize, A: Serialize, B: Serialize, C: Serialize, D: Serialize,` [src]

`fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,` [src]

`impl<Inner, A, B, C, D> TargetRef for Ext4<Inner, A, B, C, D> where Inner: TargetRef,` [src]

`fn target_field_ref(&self) -> &OneOrMany<AnyBase>`[src]

`fn target_field_mut(&mut self) -> &mut OneOrMany<AnyBase>`[src]

Auto Trait Implementations

`impl<Inner, A, B, C, D> RefUnwindSafe for Ext4<Inner, A, B, C, D> where A: RefUnwindSafe, B: RefUnwindSafe, C: RefUnwindSafe, D: RefUnwindSafe, Inner: RefUnwindSafe,`

`impl<Inner, A, B, C, D> Send for Ext4<Inner, A, B, C, D> where A: Send, B: Send, C: Send, D: Send, Inner: Send,`

`impl<Inner, A, B, C, D> Sync for Ext4<Inner, A, B, C, D> where A: Sync, B: Sync, C: Sync, D: Sync, Inner: Sync,`

`impl<Inner, A, B, C, D> Unpin for Ext4<Inner, A, B, C, D> where A: Unpin, B: Unpin, C: Unpin, D: Unpin, Inner: Unpin,`

`impl<Inner, A, B, C, D> UnwindSafe for Ext4<Inner, A, B, C, D> where A: UnwindSafe, B: UnwindSafe, C: UnwindSafe, D: UnwindSafe, Inner: UnwindSafe,`

Blanket Implementations

`impl<T, Kind> ActivityExt<Kind> for T where T: AsActivity<Kind>,` [src]

`fn result<'a>(&'a self) -> Option<&'a OneOrMany<AnyBase>> where Kind: 'a,` [src]

`fn set_result<T>(&mut self, result: T) -> &mut Self where T: Into<AnyBase>,` [src]

`fn set_many_results<I, T>(&mut self, items: I) -> &mut Self where I: IntoIterator<Item = T>, T: Into<AnyBase>,` [src]

`fn add_result<T>(&mut self, result: T) -> &mut Self where T: Into<AnyBase>,` [src]

`fn take_result(&mut self) -> Option<OneOrMany<AnyBase>>`[src]

`fn delete_result(&mut self) -> &mut Self`[src]

`fn instrument<'a>(&'a self) -> Option<&'a OneOrMany<AnyBase>> where Kind: 'a,` [src]

`fn set_instrument<T>(&mut self, instrument: T) -> &mut Self where T: Into<AnyBase>,` [src]

`fn set_many_instruments<I, T>(&mut self, items: I) -> &mut Self where I: IntoIterator<Item = T>, T: Into<AnyBase>,` [src]

`fn add_instrument<T>(&mut self, instrument: T) -> &mut Self where T: Into<AnyBase>,` [src]

`fn take_instrument(&mut self) -> Option<OneOrMany<AnyBase>>`[src]

`fn delete_instrument(&mut self) -> &mut Self`[src]

`impl<T> ActorAndObjectRefExt for T where T: ActorAndObjectRef,` [src]

`fn actor<'a, Kind>(&'a self) -> Result<&'a OneOrMany<AnyBase>, DomainError> where Kind: 'a, Self: BaseExt<Kind>,` [src]

`fn actor_unchecked(&self) -> &OneOrMany<AnyBase>`[src]

`fn actor_is(&self, id: &Url) -> bool`[src]

`fn set_actor<T>(&mut self, actor: T) -> &mut Self where T: Into<AnyBase>,` [src]

`fn set_many_actors<I, T>(&mut self, items: I) -> &mut Self where I: IntoIterator<Item = T>, T: Into<AnyBase>,` [src]

`fn add_actor<T>(&mut self, actor: T) -> &mut Self where T: Into<AnyBase>,` [src]

`fn object(&self) -> &OneOrMany<AnyBase>`[src]

`fn object_is(&self, id: &Url) -> bool`[src]

`fn set_object<T>(&mut self, object: T) -> &mut Self where T: Into<AnyBase>,` [src]

`fn set_many_objects<I, T>(&mut self, items: I) -> &mut Self where I: IntoIterator<Item = T>, T: Into<AnyBase>,` [src]

`fn add_object<T>(&mut self, object: T) -> &mut Self where T: Into<AnyBase>,` [src]

`impl<T> Any for T where T: 'static + ?Sized,` [src]

`fn type_id(&self) -> TypeId`[src]

`impl<T, Inner> ApActorExt<Inner> for T where T: AsApActor<Inner>,` [src]

`fn inbox<'a, Kind>(&'a self) -> Result<&'a Url, DomainError> where Inner: 'a, Kind: 'a, Self: BaseExt<Kind> + 'a,` [src]

`fn inbox_unchecked<'a>(&'a self) -> &'a Url where Inner: 'a,` [src]

`fn inbox_mut<'a>(&'a mut self) -> &'a mut Url where Inner: 'a,` [src]

`fn set_inbox(&mut self, inbox: Url) -> &mut Self`[src]

`fn outbox<'a, Kind>(&'a self) -> Result<Option<&'a Url>, DomainError> where Inner: 'a, Kind: 'a, Self: BaseExt<Kind>,` [src]

`fn outbox_unchecked<'a>(&'a self) -> Option<&'a Url> where Inner: 'a,` [src]

`fn outbox_mut<'a>(&'a mut self) -> Option<&'a mut Url> where Inner: 'a,` [src]

`fn set_outbox(&mut self, outbox: Url) -> &mut Self`[src]

`fn take_outbox(&mut self) -> Option<Url>`[src]

`fn delete_outbox(&mut self) -> &mut Self`[src]

`fn following<'a, Kind>(&'a self) -> Result<Option<&'a Url>, DomainError> where Inner: 'a, Kind: 'a, Self: BaseExt<Kind>,` [src]

`fn following_unchecked<'a>(&'a self) -> Option<&'a Url> where Inner: 'a,` [src]

`fn following_mut<'a>(&'a mut self) -> Option<&'a mut Url> where Inner: 'a,` [src]

`fn set_following(&mut self, following: Url) -> &mut Self`[src]

`fn take_following(&mut self) -> Option<Url>`[src]

`fn delete_following(&mut self) -> &mut Self`[src]

`fn followers<'a, Kind>(&'a self) -> Result<Option<&'a Url>, DomainError> where Inner: 'a, Kind: 'a, Self: BaseExt<Kind>,` [src]

`fn followers_unchecked<'a>(&'a self) -> Option<&'a Url> where Inner: 'a,` [src]

`fn followers_mut<'a>(&'a mut self) -> Option<&'a mut Url> where Inner: 'a,` [src]

`fn set_followers(&mut self, followers: Url) -> &mut Self`[src]

`fn take_followers(&mut self) -> Option<Url>`[src]

`fn delete_followers(&mut self) -> &mut Self`[src]

`fn liked<'a, Kind>(&'a self) -> Result<Option<&'a Url>, DomainError> where Inner: 'a, Kind: 'a, Self: BaseExt<Kind>,` [src]

`fn liked_unchecked<'a>(&'a self) -> Option<&'a Url> where Inner: 'a,` [src]

`fn liked_mut<'a>(&'a mut self) -> Option<&'a mut Url> where Inner: 'a,` [src]

`fn set_liked(&mut self, liked: Url) -> &mut Self`[src]

`fn take_liked(&mut self) -> Option<Url>`[src]

`fn delete_liked(&mut self) -> &mut Self`[src]

`fn streams<'a, Kind>( &'a self ) -> Result<Option<OneOrMany<&'a Url>>, DomainError> where Inner: 'a, Kind: 'a, Self: BaseExt<Kind>,` [src]

`fn streams_unchecked<'a>(&'a self) -> Option<OneOrMany<&'a Url>> where Inner: 'a,` [src]

`fn streams_mut<'a>(&'a mut self) -> Option<OneOrMany<&'a mut Url>> where Inner: 'a,` [src]

`fn set_streams(&mut self, streams: Url) -> &mut Self`[src]

`fn set_many_streams<I, U>(&mut self, items: I) -> &mut Self where I: IntoIterator<Item = U>, U: Into<Url>,` [src]

`fn add_streams(&mut self, stream: Url) -> &mut Self`[src]

`fn take_streams(&mut self) -> Option<OneOrMany<Url>>`[src]

`fn delete_streams(&mut self) -> &mut Self`[src]

`fn preferred_username<'a>(&'a self) -> Option<&'a str> where Inner: 'a,` [src]

`fn set_preferred_username<T>(&mut self, string: T) -> &mut Self where T: Into<String>,` [src]

`fn take_preferred_username(&mut self) -> Option<String>`[src]

`fn delete_preferred_username(&mut self) -> &mut Self`[src]

`fn endpoints<'a, Kind>( &'a self ) -> Result<Option<Endpoints<&'a Url>>, DomainError> where Inner: 'a, Kind: 'a, Self: BaseExt<Kind>,` [src]

`fn endpoints_unchecked<'a>(&'a self) -> Option<Endpoints<&'a Url>> where Inner: 'a,` [src]

`fn endpoints_mut<'a>(&'a mut self) -> Option<Endpoints<&'a mut Url>> where Inner: 'a,` [src]

`fn set_endpoints(&mut self, endpoints: Endpoints<Url>) -> &mut Self`[src]

`fn take_endpoints(&mut self) -> Option<Endpoints<Url>>`[src]

`fn delete_endpoints(&mut self) -> &mut Self`[src]

`impl<T, Inner> ApObjectExt<Inner> for T where T: AsApObject<Inner>,` [src]

`fn shares<'a>(&'a self) -> Option<&'a Url> where Inner: 'a,` [src]

`fn set_shares(&mut self, shares: Url) -> &mut Self`[src]

`fn take_shares(&mut self) -> Option<Url>`[src]

`fn delete_shares(&mut self) -> &mut Self`[src]

`fn likes<'a>(&'a self) -> Option<&'a Url> where Inner: 'a,` [src]

`fn set_likes(&mut self, likes: Url) -> &mut Self`[src]

`fn take_likes(&mut self) -> Option<Url>`[src]

`fn delete_likes(&mut self) -> &mut Self`[src]

`fn source<'a>(&'a self) -> Option<&'a AnyBase> where Inner: 'a,` [src]

`fn set_source<T>(&mut self, source: T) -> &mut Self where T: Into<AnyBase>,` [src]

`fn take_source(&mut self) -> Option<AnyBase>`[src]

`fn delete_source(&mut self) -> &mut Self`[src]

`fn upload_media<'a>(&'a self) -> Option<OneOrMany<&'a Url>> where Inner: 'a,` [src]

`fn set_upload_media(&mut self, upload_media: Url) -> &mut Self`[src]

`fn set_many_upload_medias<I, U>(&mut self, items: I) -> &mut Self where I: IntoIterator<Item = U>, U: Into<Url>,` [src]

`fn add_upload_media(&mut self, upload_media: Url) -> &mut Self`[src]

`fn take_upload_media(&mut self) -> Option<OneOrMany<Url>>`[src]

`fn delete_upload_media(&mut self) -> &mut Self`[src]

`impl<T, Kind> BaseExt<Kind> for T where T: AsBase<Kind>,` [src]

`fn context<'a>(&'a self) -> Option<&'a OneOrMany<AnyBase>> where Kind: 'a,` [src]

`fn set_context<T>(&mut self, context: T) -> &mut Self where T: Into<AnyBase>,` [src]

`fn set_many_contexts<I, T>(&mut self, items: I) -> &mut Self where I: IntoIterator<Item = T>, T: Into<AnyBase>,` [src]

`fn add_context<T>(&mut self, context: T) -> &mut Self where T: Into<AnyBase>,` [src]

`fn take_context(&mut self) -> Option<OneOrMany<AnyBase>>`[src]

`fn delete_context(&mut self) -> &mut Self`[src]

`fn id<'a>(&'a self, domain: &str) -> Result<Option<&'a Url>, DomainError> where Kind: 'a,` [src]

`fn id_unchecked<'a>(&'a self) -> Option<&'a Url> where Kind: 'a,` [src]

`fn id_mut<'a>(&'a mut self) -> Option<&'a mut Url> where Kind: 'a,` [src]

`fn is_id(&self, id: &Url) -> bool`[src]

`fn set_id(&mut self, id: Url) -> &mut Self`[src]

`fn take_id(&mut self) -> Option<Url>`[src]

`fn delete_id(&mut self) -> &mut Self`[src]

`fn kind<'a>(&'a self) -> Option<&'a Kind> where Kind: 'a,` [src]

`fn is_kind(&self, kind: &Kind) -> bool where Kind: PartialEq<Kind>,` [src]

`fn set_kind(&mut self, kind: Kind) -> &mut Self`[src]

`fn take_kind(&mut self) -> Option<Kind>`[src]

`fn delete_kind(&mut self) -> &mut Self`[src]

`fn name<'a>(&'a self) -> Option<OneOrMany<&'a AnyString>> where Kind: 'a,` [src]

`fn set_name<T>(&mut self, name: T) -> &mut Self where T: Into<AnyString>,` [src]

`fn set_many_names<I, T>(&mut self, items: I) -> &mut Self where I: IntoIterator<Item = T>, T: Into<AnyString>,` [src]

`fn add_name<T>(&mut self, name: T) -> &mut Self where T: Into<AnyString>,` [src]

`fn take_name(&mut self) -> Option<OneOrMany<AnyString>>`[src]

`fn delete_name(&mut self) -> &mut Self`[src]

`fn media_type<'a>(&'a self) -> Option<&'a Mime> where Kind: 'a,` [src]

`fn set_media_type(&mut self, media_type: Mime) -> &mut Self`[src]

`fn take_media_type(&mut self) -> Option<Mime>`[src]

`fn delete_media_type(&mut self) -> &mut Self`[src]

`fn preview<'a>(&'a self) -> Option<OneOrMany<&'a AnyBase>> where Kind: 'a,` [src]

`fn set_preview<T>(&mut self, preview: T) -> &mut Self where T: Into<AnyBase>,` [src]

`fn set_many_previews<I, T>(&mut self, items: I) -> &mut Self where I: IntoIterator<Item = T>, T: Into<AnyBase>,` [src]

`fn add_preview<T>(&mut self, preview: T) -> &mut Self where T: Into<AnyBase>,` [src]

`fn take_preview(&mut self) -> Option<OneOrMany<AnyBase>>`[src]

`fn delete_preview(&mut self) -> &mut Self`[src]

`impl<T> Borrow<T> for T where T: ?Sized,` [src]

`fn borrow(&self) -> &T`[src]

`impl<T> BorrowMut<T> for T where T: ?Sized,` [src]

`fn borrow_mut(&mut self) -> &mut T`[src]

`impl<T, Kind> CollectionExt<Kind> for T where T: AsCollection<Kind>,` [src]

`fn items<'a>(&'a self) -> Option<&'a OneOrMany<AnyBase>> where Kind: 'a,` [src]

`fn set_items<T>(&mut self, item: T) -> &mut Self where T: Into<AnyBase>,` [src]

`fn set_many_items<I, T>(&mut self, items: I) -> &mut Self where I: IntoIterator<Item = T>, T: Into<AnyBase>,` [src]

`fn add_items<T>(&mut self, item: T) -> &mut Self where T: Into<AnyBase>,` [src]

`fn take_items(&mut self) -> Option<OneOrMany<AnyBase>>`[src]

`fn delete_items(&mut self) -> &mut Self`[src]

`fn total_items<'a>(&'a self) -> Option<u64> where Kind: 'a,` [src]

`fn set_total_items<T>(&mut self, total_items: T) -> &mut Self where T: Into<u64>,` [src]

`fn take_total_items(&mut self) -> Option<u64>`[src]

`fn delete_total_items(&mut self) -> &mut Self`[src]

`fn current<'a>(&'a self) -> Option<&'a AnyBase> where Kind: 'a,` [src]

`fn set_current<T>(&mut self, current: T) -> &mut Self where T: Into<AnyBase>,` [src]

`fn take_current(&mut self) -> Option<AnyBase>`[src]

`fn delete_current(&mut self) -> &mut Self`[src]

`fn first<'a>(&'a self) -> Option<&'a AnyBase> where Kind: 'a,` [src]

`fn set_first<T>(&mut self, first: T) -> &mut Self where T: Into<AnyBase>,` [src]

`fn take_first(&mut self) -> Option<AnyBase>`[src]

`fn delete_first(&mut self) -> &mut Self`[src]

`fn last<'a>(&'a self) -> Option<&'a AnyBase> where Kind: 'a,` [src]

`fn set_last<T>(&mut self, last: T) -> &mut Self where T: Into<AnyBase>,` [src]

`fn take_last(&mut self) -> Option<AnyBase>`[src]

`fn delete_last(&mut self) -> &mut Self`[src]

`impl<T, Kind> CollectionPageExt<Kind> for T where T: AsCollectionPage<Kind>,` [src]

`fn part_of<'a>(&'a self) -> Option<&'a AnyBase> where Kind: 'a,` [src]

`fn set_part_of<T>(&mut self, part_of: T) -> &mut Self where T: Into<AnyBase>,` [src]

`fn take_part_of(&mut self) -> Option<AnyBase>`[src]

`fn delete_part_of(&mut self) -> &mut Self`[src]

`fn next<'a>(&'a self) -> Option<&'a AnyBase> where Kind: 'a,` [src]

`fn set_next<T>(&mut self, next: T) -> &mut Self where T: Into<AnyBase>,` [src]

`fn take_next(&mut self) -> Option<AnyBase>`[src]

`fn delete_next(&mut self) -> &mut Self`[src]

`fn prev<'a>(&'a self) -> Option<&'a AnyBase> where Kind: 'a,` [src]

`fn set_prev<T>(&mut self, prev: T) -> &mut Self where T: Into<AnyBase>,` [src]

`fn take_prev(&mut self) -> Option<AnyBase>`[src]

`fn delete_prev(&mut self) -> &mut Self`[src]

`impl<T> DeserializeOwned for T where T: for<'de> Deserialize<'de>,` [src]

`impl<T, Kind> ExtendsExt<Kind> for T where T: Extends<Kind>, <T as Extends<Kind>>::Error: From<Error>,` [src]

`fn into_any_base(self) -> Result<AnyBase, Self::Error> where Kind: Serialize, Self::Error: From<Error>,` [src]

`fn from_any_base(any_base: AnyBase) -> Result<Option<Self>, Self::Error> where Kind: DeserializeOwned, Self::Error: From<Error>,` [src]

`impl<T> From<T> for T`[src]

`fn from(t: T) -> T`[src]

`impl<T, U> Into for T where U: From<T>,` [src]

`fn into(self) -> U`[src]

`impl<T, Kind> ObjectExt<Kind> for T where T: AsObject<Kind>,` [src]

`fn attachment<'a>(&'a self) -> Option<&'a OneOrMany<AnyBase>> where Kind: 'a,` [src]

`fn set_attachment<T>(&mut self, attachment: T) -> &mut Self where T: Into<AnyBase>,` [src]

`fn set_many_attachments<I, T>(&mut self, items: I) -> &mut Self where I: IntoIterator<Item = T>, T: Into<AnyBase>,` [src]

`fn add_attachment<T>(&mut self, attachment: T) -> &mut Self where T: Into<AnyBase>,` [src]

`fn take_attachment(&mut self) -> Option<OneOrMany<AnyBase>>`[src]

`fn delete_attachment(&mut self) -> &mut Self`[src]

`fn attributed_to<'a>(&'a self) -> Option<&'a OneOrMany<AnyBase>> where Kind: 'a,` [src]

`fn set_attributed_to<T>(&mut self, attributed_to: T) -> &mut Self where T: Into<AnyBase>,` [src]

`fn set_many_attributed_tos<I, T>(&mut self, items: I) -> &mut Self where I: IntoIterator<Item = T>, T: Into<AnyBase>,` [src]

`fn add_attributed_to<T>(&mut self, attributed_to: T) -> &mut Self where T: Into<AnyBase>,` [src]

`fn take_attributed_to(&mut self) -> Option<OneOrMany<AnyBase>>`[src]

`fn delete_attributed_to(&mut self) -> &mut Self`[src]

`fn audience<'a>(&'a self) -> Option<&'a OneOrMany<AnyBase>> where Kind: 'a,` [src]

`fn set_audience<T>(&mut self, audience: T) -> &mut Self where T: Into<AnyBase>,` [src]

`fn set_many_audiences<I, T>(&mut self, items: I) -> &mut Self where I: IntoIterator<Item = T>, T: Into<AnyBase>,` [src]

`fn add_audience<T>(&mut self, audience: T) -> &mut Self where T: Into<AnyBase>,` [src]

`fn take_audience(&mut self) -> Option<OneOrMany<AnyBase>>`[src]

`fn delete_audience(&mut self) -> &mut Self`[src]

`fn content<'a>(&'a self) -> Option<&'a OneOrMany<AnyString>> where Kind: 'a,` [src]

`fn set_content<T>(&mut self, content: T) -> &mut Self where T: Into<AnyString>,` [src]

`fn set_many_contents<I, T>(&mut self, items: I) -> &mut Self where I: IntoIterator<Item = T>, T: Into<AnyString>,` [src]

`fn add_content<T>(&mut self, content: T) -> &mut Self where T: Into<AnyString>,` [src]

`fn take_content(&mut self) -> Option<OneOrMany<AnyString>>`[src]

`fn delete_content(&mut self) -> &mut Self`[src]

`fn summary<'a>(&'a self) -> Option<&'a OneOrMany<AnyString>> where Kind: 'a,` [src]

`fn set_summary<T>(&mut self, summary: T) -> &mut Self where T: Into<AnyString>,` [src]

`fn set_many_summaries<I, T>(&mut self, items: I) -> &mut Self where I: IntoIterator<Item = T>, T: Into<AnyString>,` [src]

`fn add_summary<T>(&mut self, summary: T) -> &mut Self where T: Into<AnyString>,` [src]

`fn take_summary(&mut self) -> Option<OneOrMany<AnyString>>`[src]

`fn delete_summary(&mut self) -> &mut Self`[src]

`fn url<'a>(&'a self) -> Option<&'a OneOrMany<AnyBase>> where Kind: 'a,` [src]

`fn set_url<T>(&mut self, url: T) -> &mut Self where T: Into<AnyBase>,` [src]

`fn set_many_urls<I, T>(&mut self, items: I) -> &mut Self where I: IntoIterator<Item = T>, T: Into<AnyBase>,` [src]

`fn add_url<T>(&mut self, url: T) -> &mut Self where T: Into<AnyBase>,` [src]

`fn take_url(&mut self) -> Option<OneOrMany<AnyBase>>`[src]

`fn delete_url(&mut self) -> &mut Self`[src]

`fn generator<'a>(&'a self) -> Option<&'a OneOrMany<AnyBase>> where Kind: 'a,` [src]

`fn set_generator<T>(&mut self, generator: T) -> &mut Self where T: Into<AnyBase>,` [src]

`fn set_many_generators<I, T>(&mut self, items: I) -> &mut Self where I: IntoIterator<Item = T>, T: Into<AnyBase>,` [src]

`fn add_generator<T>(&mut self, generator: T) -> &mut Self where T: Into<AnyBase>,` [src]

`fn take_generator(&mut self) -> Option<OneOrMany<AnyBase>>`[src]

`fn delete_generator(&mut self) -> &mut Self`[src]

`fn icon<'a>(&'a self) -> Option<&'a OneOrMany<AnyBase>> where Kind: 'a,` [src]

`fn set_icon<T>(&mut self, icon: T) -> &mut Self where T: Into<AnyBase>,` [src]

`fn set_many_icons<I, T>(&mut self, items: I) -> &mut Self where I: IntoIterator<Item = T>, T: Into<AnyBase>,` [src]

`fn add_icon<T>(&mut self, icon: T) -> &mut Self where T: Into<AnyBase>,` [src]

`fn take_icon(&mut self) -> Option<OneOrMany<AnyBase>>`[src]

`fn delete_icon(&mut self) -> &mut Self`[src]

`fn image<'a>(&'a self) -> Option<&'a OneOrMany<AnyBase>> where Kind: 'a,` [src]

`fn set_image<T>(&mut self, image: T) -> &mut Self where T: Into<AnyBase>,` [src]

`fn set_many_images<I, T>(&mut self, items: I) -> &mut Self where I: IntoIterator<Item = T>, T: Into<AnyBase>,` [src]

`fn add_image<T>(&mut self, image: T) -> &mut Self where T: Into<AnyBase>,` [src]

`fn take_image(&mut self) -> Option<OneOrMany<AnyBase>>`[src]

`fn delete_image(&mut self) -> &mut Self`[src]

`fn location<'a>(&'a self) -> Option<&'a OneOrMany<AnyBase>> where Kind: 'a,` [src]

`fn set_location<T>(&mut self, location: T) -> &mut Self where T: Into<AnyBase>,` [src]

`fn set_many_locations<I, T>(&mut self, items: I) -> &mut Self where I: IntoIterator<Item = T>, T: Into<AnyBase>,` [src]

`fn add_location<T>(&mut self, location: T) -> &mut Self where T: Into<AnyBase>,` [src]

`fn take_location(&mut self) -> Option<OneOrMany<AnyBase>>`[src]

`fn delete_location(&mut self) -> &mut Self`[src]

`fn tag<'a>(&'a self) -> Option<&'a OneOrMany<AnyBase>> where Kind: 'a,` [src]

`fn set_tag<T>(&mut self, tag: T) -> &mut Self where T: Into<AnyBase>,` [src]

`fn set_many_tags<I, T>(&mut self, items: I) -> &mut Self where I: IntoIterator<Item = T>, T: Into<AnyBase>,` [src]

`fn add_tag<T>(&mut self, tag: T) -> &mut Self where T: Into<AnyBase>,` [src]

`fn take_tag(&mut self) -> Option<OneOrMany<AnyBase>>`[src]

`fn delete_tag(&mut self) -> &mut Self`[src]

`fn start_time<'a>(&'a self) -> Option<DateTime<FixedOffset>> where Kind: 'a,` [src]

`fn set_start_time(&mut self, start_time: DateTime<FixedOffset>) -> &mut Self`[src]

`fn take_start_time(&mut self) -> Option<DateTime<FixedOffset>>`[src]

`fn delete_start_time(&mut self) -> &mut Self`[src]

`fn end_time<'a>(&'a self) -> Option<DateTime<FixedOffset>> where Kind: 'a,` [src]

`fn set_end_time(&mut self, end_time: DateTime<FixedOffset>) -> &mut Self`[src]

`fn take_end_time(&mut self) -> Option<DateTime<FixedOffset>>`[src]

`fn delete_end_time(&mut self) -> &mut Self`[src]

`fn duration<'a>(&'a self) -> Option<Duration> where Kind: 'a,` [src]

`fn set_duration(&mut self, duration: Duration) -> &mut Self`[src]

`fn take_duration(&mut self) -> Option<Duration>`[src]

`fn delete_duration(&mut self) -> &mut Self`[src]

`fn published<'a>(&'a self) -> Option<DateTime<FixedOffset>> where Kind: 'a,` [src]

`fn set_published(&mut self, published: DateTime<FixedOffset>) -> &mut Self`[src]

`fn take_published(&mut self) -> Option<DateTime<FixedOffset>>`[src]

`fn delete_published(&mut self) -> &mut Self`[src]

`fn updated<'a>(&'a self) -> Option<DateTime<FixedOffset>> where Kind: 'a,` [src]

`fn set_updated(&mut self, updated: DateTime<FixedOffset>) -> &mut Self`[src]

`fn take_updated(&mut self) -> Option<DateTime<FixedOffset>>`[src]

`fn delete_updated(&mut self) -> &mut Self`[src]

`fn in_reply_to<'a>(&'a self) -> Option<&'a OneOrMany<AnyBase>> where Kind: 'a,` [src]

`fn set_in_reply_to<T>(&mut self, in_reply_to: T) -> &mut Self where T: Into<AnyBase>,` [src]

`fn set_many_in_reply_tos<I, T>(&mut self, items: I) -> &mut Self where I: IntoIterator<Item = T>, T: Into<AnyBase>,` [src]

`fn add_in_reply_to<T>(&mut self, in_reply_to: T) -> &mut Self where T: Into<AnyBase>,` [src]

`fn take_in_reply_to(&mut self) -> Option<OneOrMany<AnyBase>>`[src]

`fn delete_in_reply_to(&mut self) -> &mut Self`[src]

`fn replies<'a>(&'a self) -> Option<&'a OneOrMany<AnyBase>> where Kind: 'a,` [src]

`fn set_replies<T>(&mut self, replies: T) -> &mut Self where T: Into<AnyBase>,` [src]

`fn set_many_replies<I, T>(&mut self, items: I) -> &mut Self where I: IntoIterator<Item = T>, T: Into<AnyBase>,` [src]

`fn add_replies<T>(&mut self, replies: T) -> &mut Self where T: Into<AnyBase>,` [src]

`fn take_replies(&mut self) -> Option<OneOrMany<AnyBase>>`[src]

`fn delete_replies(&mut self) -> &mut Self`[src]

`fn to<'a>(&'a self) -> Option<&'a OneOrMany<AnyBase>> where Kind: 'a,` [src]

`fn set_to<T>(&mut self, to: T) -> &mut Self where T: Into<AnyBase>,` [src]

`fn set_many_tos<I, T>(&mut self, items: I) -> &mut Self where I: IntoIterator<Item = T>, T: Into<AnyBase>,` [src]

`fn add_to<T>(&mut self, to: T) -> &mut Self where T: Into<AnyBase>,` [src]

`fn take_to(&mut self) -> Option<OneOrMany<AnyBase>>`[src]

`fn delete_to(&mut self) -> &mut Self`[src]

`fn bto<'a>(&'a self) -> Option<&'a OneOrMany<AnyBase>> where Kind: 'a,` [src]

`fn set_bto<T>(&mut self, bto: T) -> &mut Self where T: Into<AnyBase>,` [src]

`fn set_many_btos<I, T>(&mut self, items: I) -> &mut Self where I: IntoIterator<Item = T>, T: Into<AnyBase>,` [src]

`fn add_bto<T>(&mut self, bto: T) -> &mut Self where T: Into<AnyBase>,` [src]

`fn take_bto(&mut self) -> Option<OneOrMany<AnyBase>>`[src]

`fn delete_bto(&mut self) -> &mut Self`[src]

`fn cc<'a>(&'a self) -> Option<&'a OneOrMany<AnyBase>> where Kind: 'a,` [src]

`fn set_cc<T>(&mut self, cc: T) -> &mut Self where T: Into<AnyBase>,` [src]

`fn set_many_ccs<I, T>(&mut self, items: I) -> &mut Self where I: IntoIterator<Item = T>, T: Into<AnyBase>,` [src]

`fn add_cc<T>(&mut self, cc: T) -> &mut Self where T: Into<AnyBase>,` [src]

`fn take_cc(&mut self) -> Option<OneOrMany<AnyBase>>`[src]

`fn delete_cc(&mut self) -> &mut Self`[src]

`fn bcc<'a>(&'a self) -> Option<&'a OneOrMany<AnyBase>> where Kind: 'a,` [src]

`fn set_bcc<T>(&mut self, bcc: T) -> &mut Self where T: Into<AnyBase>,` [src]

`fn set_many_bcc<I, T>(&mut self, items: I) -> &mut Self where I: IntoIterator<Item = T>, T: Into<AnyBase>,` [src]

`fn add_bcc<T>(&mut self, bcc: T) -> &mut Self where T: Into<AnyBase>,` [src]

`fn take_bcc(&mut self) -> Option<OneOrMany<AnyBase>>`[src]

`fn delete_bcc(&mut self) -> &mut Self`[src]

`impl<T> OptOriginRefExt for T where T: OptOriginRef,` [src]

`fn origin(&self) -> Option<&OneOrMany<AnyBase>>`[src]

`fn set_origin<T>(&mut self, origin: T) -> &mut Self where T: Into<AnyBase>,` [src]

`fn set_many_origins<I, T>(&mut self, items: I) -> &mut Self where I: IntoIterator<Item = T>, T: Into<AnyBase>,` [src]

`fn add_origin<T>(&mut self, origin: T) -> &mut Self where T: Into<AnyBase>,` [src]

`fn take_origin(&mut self) -> Option<OneOrMany<AnyBase>>`[src]

`fn delete_origin(&mut self) -> &mut Self`[src]

`impl<T> OptTargetRefExt for T where T: OptTargetRef,` [src]

`fn target(&self) -> Option<&OneOrMany<AnyBase>>`[src]

`fn set_target<T>(&mut self, target: T) -> &mut Self where T: Into<AnyBase>,` [src]

`fn set_many_targets<I, T>(&mut self, items: I) -> &mut Self where I: IntoIterator<Item = T>, T: Into<AnyBase>,` [src]

`fn add_target<T>(&mut self, target: T) -> &mut Self where T: Into<AnyBase>,` [src]

`fn take_target(&mut self) -> Option<OneOrMany<AnyBase>>`[src]

`fn delete_target(&mut self) -> &mut Self`[src]

`impl<T> OriginRefExt for T where T: OriginRef,` [src]

`fn origin(&self) -> &OneOrMany<AnyBase>`[src]

`fn set_origin<T>(&mut self, origin: T) -> &mut Self where T: Into<AnyBase>,` [src]

`fn set_many_origins<I, T>(&mut self, items: I) -> &mut Self where I: IntoIterator<Item = T>, T: Into<AnyBase>,` [src]

`fn add_origin<T>(&mut self, origin: T) -> &mut Self where T: Into<AnyBase>,` [src]

`impl<T> QuestionExt for T where T: AsQuestion,` [src]

`fn one_of(&self) -> Option<&OneOrMany<AnyBase>>`[src]

`fn set_one_of<T>(&mut self, one_of: T) -> &mut Self where T: Into<AnyBase>,` [src]

`fn set_many_one_ofs<I, T>(&mut self, items: I) -> &mut Self where I: IntoIterator<Item = T>, T: Into<AnyBase>,` [src]

`fn add_one_of<T>(&mut self, one_of: T) -> &mut Self where T: Into<AnyBase>,` [src]

`fn take_one_of(&mut self) -> Option<OneOrMany<AnyBase>>`[src]

`fn delete_one_of(&mut self) -> &mut Self`[src]

`fn any_of(&self) -> Option<&OneOrMany<AnyBase>>`[src]

`fn set_any_of<T>(&mut self, any_of: T) -> &mut Self where T: Into<AnyBase>,` [src]

`fn set_many_any_ofs<I, T>(&mut self, items: I) -> &mut Self where I: IntoIterator<Item = T>, T: Into<AnyBase>,` [src]

`fn add_any_of<T>(&mut self, any_of: T) -> &mut Self where T: Into<AnyBase>,` [src]

`fn take_any_of(&mut self) -> Option<OneOrMany<AnyBase>>`[src]

`fn delete_any_of(&mut self) -> &mut Self`[src]

`impl<T> TargetRefExt for T where T: TargetRef,` [src]

`fn target(&self) -> &OneOrMany<AnyBase>`[src]

`fn set_target<T>(&mut self, target: T) -> &mut Self where T: Into<AnyBase>,` [src]

`fn set_many_targets<I, T>(&mut self, items: I) -> &mut Self where I: IntoIterator<Item = T>, T: Into<AnyBase>,` [src]

`fn add_target<T>(&mut self, target: T) -> &mut Self where T: Into<AnyBase>,` [src]

`impl<T> ToOwned for T where T: Clone,` [src]

`type Owned = T`

The resulting type after obtaining ownership.

`fn to_owned(&self) -> T`[src]

`fn clone_into(&self, target: &mut T)`[src]

`impl<T, U> TryFrom for T where U: Into<T>,` [src]

`type Error = Infallible`

The type returned in the event of a conversion error.

`fn try_from(value: U) -> Result<T, <T as TryFrom>::Error>`[src]

`impl<T, U> TryInto for T where U: TryFrom<T>,` [src]

`type Error = >::Error`

The type returned in the event of a conversion error.

`fn try_into(self) -> Result<U, >::Error>`[src]

[−][src]Struct activitystreams_ext::Ext4

Fields

Implementations

impl<Inner, A, B, C, D> Ext4<Inner, A, B, C, D>[src]

pub fn new( inner: Inner, ext_one: A, ext_two: B, ext_three: C, ext_four: D) -> Self[src]

pub fn into_parts(self) -> (Inner, A, B, C, D)[src]

Trait Implementations

impl<Inner, A, B, C, D> Activity for Ext4<Inner, A, B, C, D> where Inner: Activity, [src]

impl<Inner, A, B, C, D> Actor for Ext4<Inner, A, B, C, D> where Inner: Actor, [src]

impl<Inner, A, B, C, D> ActorAndObjectRef for Ext4<Inner, A, B, C, D> where Inner: ActorAndObjectRef, [src]

fn actor_field_ref(&self) -> &OneOrMany<AnyBase>[src]

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

fn object_field_ref(&self) -> &OneOrMany<AnyBase>[src]

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

impl<Inner, A, B, C, D, Kind> AsActivity<Kind> for Ext4<Inner, A, B, C, D> where Inner: AsActivity<Kind>, [src]

fn activity_ref(&self) -> &Activity<Kind>[src]

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

impl<Inner, A, B, C, D, ApInner> AsApActor<ApInner> for Ext4<Inner, A, B, C, D> where Inner: AsApActor<ApInner>, [src]

fn ap_actor_ref(&self) -> &ApActor<ApInner>[src]

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

impl<Inner, A, B, C, D, ApInner> AsApObject<ApInner> for Ext4<Inner, A, B, C, D> where Inner: AsApObject<ApInner>, [src]

fn ap_object_ref(&self) -> &ApObject<ApInner>[src]

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

impl<Inner, A, B, C, D, Kind> AsBase<Kind> for Ext4<Inner, A, B, C, D> where Inner: AsBase<Kind>, [src]

fn base_ref(&self) -> &Base<Kind>[src]

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

impl<Inner, A, B, C, D, Kind> AsCollection<Kind> for Ext4<Inner, A, B, C, D> where Inner: AsCollection<Kind>, [src]

fn collection_ref(&self) -> &Collection<Kind>[src]

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

impl<Inner, A, B, C, D, Kind> AsCollectionPage<Kind> for Ext4<Inner, A, B, C, D> where Inner: AsCollectionPage<Kind>, [src]

fn collection_page_ref(&self) -> &CollectionPage<Kind>[src]

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

impl<Inner, A, B, C, D, Kind> AsObject<Kind> for Ext4<Inner, A, B, C, D> where Inner: AsObject<Kind>, [src]

fn object_ref(&self) -> &Object<Kind>[src]

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

impl<Inner, A, B, C, D> AsQuestion for Ext4<Inner, A, B, C, D> where Inner: AsQuestion, [src]

fn question_ref(&self) -> &Question[src]

fn question_mut(&mut self) -> &mut Question[src]

impl<Inner, A, B, C, D> Base for Ext4<Inner, A, B, C, D> where Inner: Base, [src]

impl<Inner: Clone, A: Clone, B: Clone, C: Clone, D: Clone> Clone for Ext4<Inner, A, B, C, D>[src]

fn clone(&self) -> Ext4<Inner, A, B, C, D>[src]

fn clone_from(&mut self, source: &Self)1.0.0[src]

impl<Inner, A, B, C, D> Collection for Ext4<Inner, A, B, C, D> where Inner: Collection, [src]

impl<Inner, A, B, C, D> CollectionPage for Ext4<Inner, A, B, C, D> where Inner: CollectionPage, [src]

impl<Inner: Debug, A: Debug, B: Debug, C: Debug, D: Debug> Debug for Ext4<Inner, A, B, C, D>[src]

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

impl<'de, Inner, A, B, C, D> Deserialize<'de> for Ext4<Inner, A, B, C, D> where Inner: Deserialize<'de>, A: Deserialize<'de>, B: Deserialize<'de>, C: Deserialize<'de>, D: Deserialize<'de>, [src]

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

type Error = Error

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

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

impl<Inner, A, B, C, D> IntransitiveActivity for Ext4<Inner, A, B, C, D> where Inner: IntransitiveActivity, [src]

impl<Inner, A, B, C, D> Object for Ext4<Inner, A, B, C, D> where Inner: Object, [src]

impl<Inner, A, B, C, D> OptOriginRef for Ext4<Inner, A, B, C, D> where Inner: OptOriginRef, [src]

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

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

impl<Inner, A, B, C, D> OptTargetRef for Ext4<Inner, A, B, C, D> where Inner: OptTargetRef, [src]

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

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

impl<Inner, A, B, C, D> OriginRef for Ext4<Inner, A, B, C, D> where Inner: OriginRef, [src]

fn origin_field_ref(&self) -> &OneOrMany<AnyBase>[src]

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

impl<Inner, A, B, C, D> Serialize for Ext4<Inner, A, B, C, D> where Inner: Serialize, A: Serialize, B: Serialize, C: Serialize, D: Serialize, [src]

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

impl<Inner, A, B, C, D> TargetRef for Ext4<Inner, A, B, C, D> where Inner: TargetRef, [src]

fn target_field_ref(&self) -> &OneOrMany<AnyBase>[src]

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