diff options
| -rw-r--r-- | src/dav/calencoder.rs | 569 | ||||
| -rw-r--r-- | src/dav/caltypes.rs | 5 |
2 files changed, 278 insertions, 296 deletions
diff --git a/src/dav/calencoder.rs b/src/dav/calencoder.rs index 80b8656..01cecc3 100644 --- a/src/dav/calencoder.rs +++ b/src/dav/calencoder.rs @@ -1,141 +1,94 @@ -/* -use super::encoder::{QuickWritable, Context}; -use super::caltypes::*; -use super::types::Extension; - use quick_xml::Error as QError; use quick_xml::events::{Event, BytesEnd, BytesStart, BytesText}; -use quick_xml::writer::{ElementWriter, Writer}; use quick_xml::name::PrefixDeclaration; use tokio::io::AsyncWrite; -const ICAL_DATETIME_FMT: &str = "%Y%m%dT%H%M%SZ"; - -// =============== Calendar Trait =========================== -pub trait CalContext: Context { - fn create_cal_element(&self, name: &str) -> BytesStart; -} - -// =============== CalDAV Extension Setup =================== -impl Context for CalExtension { - fn child(&self) -> Self { - Self { root: false } - } - fn create_dav_element(&self, name: &str) -> BytesStart { - self.create_ns_element("D", name) - } - - async fn hook_error(&self, err: &Violation, xml: &mut Writer<impl AsyncWrite+Unpin>) -> Result<(), QError> { - err.write(xml, self.child()).await - } - - async fn hook_property(&self, prop: &Self::Property, xml: &mut Writer<impl AsyncWrite+Unpin>) -> Result<(), QError> { - prop.write(xml, self.child()).await - } - - async fn hook_resourcetype(&self, restype: &Self::ResourceType, xml: &mut Writer<impl AsyncWrite+Unpin>) -> Result<(), QError> { - restype.write(xml, self.child()).await - } - - async fn hook_propertyrequest(&self, propreq: &Self::PropertyRequest, xml: &mut Writer<impl AsyncWrite+Unpin>) -> Result<(), QError> { - propreq.write(xml, self.child()).await - } -} - -impl CalContext for CalExtension { - fn create_cal_element(&self, name: &str) -> BytesStart { - self.create_ns_element("C", name) - } -} +use super::caltypes::*; +use super::xml::{QWrite, IWrite, Writer}; +use super::types::Extension; -impl CalExtension { - fn create_ns_element(&self, ns: &str, name: &str) -> BytesStart { - let mut start = BytesStart::new(format!("{}:{}", ns, name)); - if self.root { - start.push_attribute(("xmlns:D", "DAV:")); - start.push_attribute(("xmlns:C", "urn:ietf:params:xml:ns:caldav")); - } - start - } -} +const ICAL_DATETIME_FMT: &str = "%Y%m%dT%H%M%SZ"; // ==================== Calendar Types Serialization ========================= // -------------------- MKCALENDAR METHOD ------------------------------------ -impl<C: CalContext> QuickWritable<C> for MkCalendar<C> { - async fn write(&self, xml: &mut Writer<impl AsyncWrite+Unpin>, ctx: C) -> Result<(), QError> { - let start = ctx.create_cal_element("mkcalendar"); +impl<E: Extension> QWrite for MkCalendar<E> { + async fn qwrite(&self, xml: &mut Writer<impl IWrite>) -> Result<(), QError> { + let start = xml.create_cal_element("mkcalendar"); let end = start.to_end(); - xml.write_event_async(Event::Start(start.clone())).await?; - self.0.write(xml, ctx.child()).await?; - xml.write_event_async(Event::End(end)).await + xml.q.write_event_async(Event::Start(start.clone())).await?; + self.0.qwrite(xml).await?; + xml.q.write_event_async(Event::End(end)).await } } -impl<C: CalContext> QuickWritable<C> for MkCalendarResponse<C> { - async fn write(&self, xml: &mut Writer<impl AsyncWrite+Unpin>, ctx: C) -> Result<(), QError> { - let start = ctx.create_cal_element("mkcalendar-response"); +impl<E: Extension> QWrite for MkCalendarResponse<E> { + async fn qwrite(&self, xml: &mut Writer<impl IWrite>) -> Result<(), QError> { + let start = xml.create_cal_element("mkcalendar-response"); let end = start.to_end(); - xml.write_event_async(Event::Start(start.clone())).await?; + xml.q.write_event_async(Event::Start(start.clone())).await?; for propstat in self.0.iter() { - propstat.write(xml, ctx.child()).await?; + propstat.qwrite(xml).await?; } - xml.write_event_async(Event::End(end)).await + xml.q.write_event_async(Event::End(end)).await } } // ----------------------- REPORT METHOD ------------------------------------- -impl<C: CalContext> QuickWritable<C> for CalendarQuery<C> { - async fn write(&self, xml: &mut Writer<impl AsyncWrite+Unpin>, ctx: C) -> Result<(), QError> { - let start = ctx.create_cal_element("calendar-query"); +impl<E: Extension> QWrite for CalendarQuery<E> { + async fn qwrite(&self, xml: &mut Writer<impl IWrite>) -> Result<(), QError> { + let start = xml.create_cal_element("calendar-query"); let end = start.to_end(); - xml.write_event_async(Event::Start(start.clone())).await?; + xml.q.write_event_async(Event::Start(start.clone())).await?; if let Some(selector) = &self.selector { - selector.write(xml, ctx.child()).await?; + selector.qwrite(xml).await?; } - self.filter.write(xml, ctx.child()).await?; + self.filter.qwrite(xml).await?; if let Some(tz) = &self.timezone { - tz.write(xml, ctx.child()).await?; + tz.qwrite(xml).await?; } - xml.write_event_async(Event::End(end)).await + xml.q.write_event_async(Event::End(end)).await } } -impl<C: CalContext> QuickWritable<C> for CalendarMultiget<C> { - async fn write(&self, xml: &mut Writer<impl AsyncWrite+Unpin>, ctx: C) -> Result<(), QError> { - let start = ctx.create_cal_element("calendar-multiget"); +impl<E: Extension> QWrite for CalendarMultiget<E> { + async fn qwrite(&self, xml: &mut Writer<impl IWrite>) -> Result<(), QError> { + let start = xml.create_cal_element("calendar-multiget"); let end = start.to_end(); - xml.write_event_async(Event::Start(start.clone())).await?; + xml.q.write_event_async(Event::Start(start.clone())).await?; if let Some(selector) = &self.selector { - selector.write(xml, ctx.child()).await?; + selector.qwrite(xml).await?; } for href in self.href.iter() { - href.write(xml, ctx.child()).await?; + href.qwrite(xml).await?; } - xml.write_event_async(Event::End(end)).await + xml.q.write_event_async(Event::End(end)).await } } -impl<C: CalContext> QuickWritable<C> for FreeBusyQuery { - async fn write(&self, xml: &mut Writer<impl AsyncWrite+Unpin>, ctx: C) -> Result<(), QError> { - let start = ctx.create_cal_element("free-busy-query"); +impl QWrite for FreeBusyQuery { + async fn qwrite(&self, xml: &mut Writer<impl IWrite>) -> Result<(), QError> { + let start = xml.create_cal_element("free-busy-query"); let end = start.to_end(); - xml.write_event_async(Event::Start(start.clone())).await?; - self.0.write(xml, ctx.child()).await?; - xml.write_event_async(Event::End(end)).await + xml.q.write_event_async(Event::Start(start.clone())).await?; + self.0.qwrite(xml).await?; + xml.q.write_event_async(Event::End(end)).await } } // -------------------------- DAV::prop -------------------------------------- -impl<C: CalContext> QuickWritable<C> for PropertyRequest { - async fn write(&self, xml: &mut Writer<impl AsyncWrite+Unpin>, ctx: C) -> Result<(), QError> { - let mut atom = async |c| xml.write_event_async(Event::Empty(ctx.create_cal_element(c))).await; +impl QWrite for PropertyRequest { + async fn qwrite(&self, xml: &mut Writer<impl IWrite>) -> Result<(), QError> { + let mut atom = async |c| { + let empty_tag = xml.create_cal_element(c); + xml.q.write_event_async(Event::Empty(empty_tag)).await + }; match self { Self::CalendarDescription => atom("calendar-description").await, @@ -148,128 +101,137 @@ impl<C: CalContext> QuickWritable<C> for PropertyRequest { Self::MaxInstances => atom("max-instances").await, Self::MaxAttendeesPerInstance => atom("max-attendees-per-instance").await, Self::SupportedCollationSet => atom("supported-collation-set").await, - Self::CalendarData(req) => req.write(xml, ctx).await, + Self::CalendarData(req) => req.qwrite(xml).await, } } } -impl<C: CalContext> QuickWritable<C> for Property { - async fn write(&self, xml: &mut Writer<impl AsyncWrite+Unpin>, ctx: C) -> Result<(), QError> { +impl QWrite for Property { + async fn qwrite(&self, xml: &mut Writer<impl IWrite>) -> Result<(), QError> { match self { Self::CalendarDescription { lang, text } => { - let mut start = ctx.create_cal_element("calendar-description"); + let mut start = xml.create_cal_element("calendar-description"); if let Some(the_lang) = lang { start.push_attribute(("xml:lang", the_lang.as_str())); } let end = start.to_end(); - xml.write_event_async(Event::Start(start.clone())).await?; - xml.write_event_async(Event::Text(BytesText::new(text))).await?; - xml.write_event_async(Event::End(end)).await + xml.q.write_event_async(Event::Start(start.clone())).await?; + xml.q.write_event_async(Event::Text(BytesText::new(text))).await?; + xml.q.write_event_async(Event::End(end)).await }, Self::CalendarTimezone(payload) => { - let start = ctx.create_cal_element("calendar-timezone"); + let start = xml.create_cal_element("calendar-timezone"); let end = start.to_end(); - xml.write_event_async(Event::Start(start.clone())).await?; - xml.write_event_async(Event::Text(BytesText::new(payload))).await?; - xml.write_event_async(Event::End(end)).await + xml.q.write_event_async(Event::Start(start.clone())).await?; + xml.q.write_event_async(Event::Text(BytesText::new(payload))).await?; + xml.q.write_event_async(Event::End(end)).await }, Self::SupportedCalendarComponentSet(many_comp) => { - let start = ctx.create_cal_element("supported-calendar-component-set"); + let start = xml.create_cal_element("supported-calendar-component-set"); let end = start.to_end(); - xml.write_event_async(Event::Start(start.clone())).await?; + xml.q.write_event_async(Event::Start(start.clone())).await?; for comp in many_comp.iter() { - comp.write(xml, ctx.child()).await?; + comp.qwrite(xml).await?; } - xml.write_event_async(Event::End(end)).await + xml.q.write_event_async(Event::End(end)).await }, Self::SupportedCalendarData(many_mime) => { - let start = ctx.create_cal_element("supported-calendar-data"); + let start = xml.create_cal_element("supported-calendar-data"); let end = start.to_end(); - xml.write_event_async(Event::Start(start.clone())).await?; + xml.q.write_event_async(Event::Start(start.clone())).await?; for mime in many_mime.iter() { - mime.write(xml, ctx.child()).await?; + mime.qwrite(xml).await?; } - xml.write_event_async(Event::End(end)).await + xml.q.write_event_async(Event::End(end)).await }, Self::MaxResourceSize(bytes) => { - let start = ctx.create_cal_element("max-resource-size"); + let start = xml.create_cal_element("max-resource-size"); let end = start.to_end(); - xml.write_event_async(Event::Start(start.clone())).await?; - xml.write_event_async(Event::Text(BytesText::new(bytes.to_string().as_str()))).await?; - xml.write_event_async(Event::End(end)).await + xml.q.write_event_async(Event::Start(start.clone())).await?; + xml.q.write_event_async(Event::Text(BytesText::new(bytes.to_string().as_str()))).await?; + xml.q.write_event_async(Event::End(end)).await }, Self::MinDateTime(dt) => { - let start = ctx.create_cal_element("min-date-time"); + let start = xml.create_cal_element("min-date-time"); let end = start.to_end(); let dtstr = format!("{}", dt.format(ICAL_DATETIME_FMT)); - xml.write_event_async(Event::Start(start.clone())).await?; - xml.write_event_async(Event::Text(BytesText::new(dtstr.as_str()))).await?; - xml.write_event_async(Event::End(end)).await + xml.q.write_event_async(Event::Start(start.clone())).await?; + xml.q.write_event_async(Event::Text(BytesText::new(dtstr.as_str()))).await?; + xml.q.write_event_async(Event::End(end)).await }, Self::MaxDateTime(dt) => { - let start = ctx.create_cal_element("max-date-time"); + let start = xml.create_cal_element("max-date-time"); let end = start.to_end(); let dtstr = format!("{}", dt.format(ICAL_DATETIME_FMT)); - xml.write_event_async(Event::Start(start.clone())).await?; - xml.write_event_async(Event::Text(BytesText::new(dtstr.as_str()))).await?; - xml.write_event_async(Event::End(end)).await + xml.q.write_event_async(Event::Start(start.clone())).await?; + xml.q.write_event_async(Event::Text(BytesText::new(dtstr.as_str()))).await?; + xml.q.write_event_async(Event::End(end)).await }, Self::MaxInstances(count) => { - let start = ctx.create_cal_element("max-instances"); + let start = xml.create_cal_element("max-instances"); let end = start.to_end(); - xml.write_event_async(Event::Start(start.clone())).await?; - xml.write_event_async(Event::Text(BytesText::new(count.to_string().as_str()))).await?; - xml.write_event_async(Event::End(end)).await + xml.q.write_event_async(Event::Start(start.clone())).await?; + xml.q.write_event_async(Event::Text(BytesText::new(count.to_string().as_str()))).await?; + xml.q.write_event_async(Event::End(end)).await }, Self::MaxAttendeesPerInstance(count) => { - let start = ctx.create_cal_element("max-attendees-per-instance"); + let start = xml.create_cal_element("max-attendees-per-instance"); let end = start.to_end(); - xml.write_event_async(Event::Start(start.clone())).await?; - xml.write_event_async(Event::Text(BytesText::new(count.to_string().as_str()))).await?; - xml.write_event_async(Event::End(end)).await + xml.q.write_event_async(Event::Start(start.clone())).await?; + xml.q.write_event_async(Event::Text(BytesText::new(count.to_string().as_str()))).await?; + xml.q.write_event_async(Event::End(end)).await }, Self::SupportedCollationSet(many_collations) => { - let start = ctx.create_cal_element("supported-collation-set"); + let start = xml.create_cal_element("supported-collation-set"); let end = start.to_end(); - xml.write_event_async(Event::Start(start.clone())).await?; + xml.q.write_event_async(Event::Start(start.clone())).await?; for collation in many_collations.iter() { - collation.write(xml, ctx.child()).await?; + collation.qwrite(xml).await?; } - xml.write_event_async(Event::End(end)).await + xml.q.write_event_async(Event::End(end)).await }, - Self::CalendarData(inner) => inner.write(xml, ctx).await, + Self::CalendarData(inner) => inner.qwrite(xml).await, } } } // ---------------------- DAV::resourcetype ---------------------------------- -impl<C: CalContext> QuickWritable<C> for ResourceType { - async fn write(&self, xml: &mut Writer<impl AsyncWrite+Unpin>, ctx: C) -> Result<(), QError> { +impl QWrite for ResourceType { + async fn qwrite(&self, xml: &mut Writer<impl IWrite>) -> Result<(), QError> { match self { - Self::Calendar => xml.write_event_async(Event::Empty(ctx.create_dav_element("calendar"))).await, + Self::Calendar => { + let empty_tag = xml.create_dav_element("calendar"); + xml.q.write_event_async(Event::Empty(empty_tag)).await + }, } } } // --------------------------- DAV::error ------------------------------------ -impl<C: CalContext> QuickWritable<C> for Violation { - async fn write(&self, xml: &mut Writer<impl AsyncWrite+Unpin>, ctx: C) -> Result<(), QError> { - let mut atom = async |c| xml.write_event_async(Event::Empty(ctx.create_cal_element(c))).await; +impl QWrite for Violation { + async fn qwrite(&self, xml: &mut Writer<impl IWrite>) -> Result<(), QError> { + let mut atom = async |c| { + let empty_tag = xml.create_cal_element(c); + xml.q.write_event_async(Event::Empty(empty_tag)).await + }; match self { //@FIXME // DAV elements, should not be here but in RFC3744 on ACLs // (we do not use atom as this error is in the DAV namespace, not the caldav one) - Self::NeedPrivileges => xml.write_event_async(Event::Empty(ctx.create_dav_element("need-privileges"))).await, + Self::NeedPrivileges => { + let empty_tag = xml.create_dav_element("need-privileges"); + xml.q.write_event_async(Event::Empty(empty_tag)).await + }, // Regular CalDAV errors Self::ResourceMustBeNull => atom("resource-must-be-null").await, @@ -280,12 +242,12 @@ impl<C: CalContext> QuickWritable<C> for Violation { Self::ValidCalendarObjectResource => atom("valid-calendar-object-resource").await, Self::SupportedCalendarComponent => atom("supported-calendar-component").await, Self::NoUidConflict(href) => { - let start = ctx.create_cal_element("no-uid-conflict"); + let start = xml.create_cal_element("no-uid-conflict"); let end = start.to_end(); - xml.write_event_async(Event::Start(start.clone())).await?; - href.write(xml, ctx.child()).await?; - xml.write_event_async(Event::End(end)).await + xml.q.write_event_async(Event::Start(start.clone())).await?; + href.qwrite(xml).await?; + xml.q.write_event_async(Event::End(end)).await }, Self::MaxResourceSize => atom("max-resource-size").await, Self::MinDateTime => atom("min-date-time").await, @@ -294,20 +256,20 @@ impl<C: CalContext> QuickWritable<C> for Violation { Self::MaxAttendeesPerInstance => atom("max-attendees-per-instance").await, Self::ValidFilter => atom("valid-filter").await, Self::SupportedFilter { comp, prop, param } => { - let start = ctx.create_cal_element("supported-filter"); + let start = xml.create_cal_element("supported-filter"); let end = start.to_end(); - xml.write_event_async(Event::Start(start.clone())).await?; + xml.q.write_event_async(Event::Start(start.clone())).await?; for comp_item in comp.iter() { - comp_item.write(xml, ctx.child()).await?; + comp_item.qwrite(xml).await?; } for prop_item in prop.iter() { - prop_item.write(xml, ctx.child()).await?; + prop_item.qwrite(xml).await?; } for param_item in param.iter() { - param_item.write(xml, ctx.child()).await?; + param_item.qwrite(xml).await?; } - xml.write_event_async(Event::End(end)).await + xml.q.write_event_async(Event::End(end)).await }, Self::NumberOfMatchesWithinLimits => atom("number-of-matches-within-limits").await, } @@ -316,112 +278,115 @@ impl<C: CalContext> QuickWritable<C> for Violation { // ---------------------------- Inner XML ------------------------------------ -impl<C: CalContext> QuickWritable<C> for SupportedCollation { - async fn write(&self, xml: &mut Writer<impl AsyncWrite+Unpin>, ctx: C) -> Result<(), QError> { - let start = ctx.create_cal_element("supported-collation"); +impl QWrite for SupportedCollation { + async fn qwrite(&self, xml: &mut Writer<impl IWrite>) -> Result<(), QError> { + let start = xml.create_cal_element("supported-collation"); let end = start.to_end(); - xml.write_event_async(Event::Start(start.clone())).await?; - self.0.write(xml, ctx.child()).await?; - xml.write_event_async(Event::End(end)).await + xml.q.write_event_async(Event::Start(start.clone())).await?; + self.0.qwrite(xml).await?; + xml.q.write_event_async(Event::End(end)).await } } -impl<C: CalContext> QuickWritable<C> for Collation { - async fn write(&self, xml: &mut Writer<impl AsyncWrite+Unpin>, ctx: C) -> Result<(), QError> { +impl QWrite for Collation { + async fn qwrite(&self, xml: &mut Writer<impl IWrite>) -> Result<(), QError> { let col = match self { Self::AsciiCaseMap => "i;ascii-casemap", Self::Octet => "i;octet", Self::Unknown(v) => v.as_str(), }; - xml.write_event_async(Event::Text(BytesText::new(col))).await + xml.q.write_event_async(Event::Text(BytesText::new(col))).await } } -impl<C: CalContext> QuickWritable<C> for CalendarDataPayload { - async fn write(&self, xml: &mut Writer<impl AsyncWrite+Unpin>, ctx: C) -> Result<(), QError> { - let mut start = ctx.create_cal_element("calendar-data"); +impl QWrite for CalendarDataPayload { + async fn qwrite(&self, xml: &mut Writer<impl IWrite>) -> Result<(), QError> { + let mut start = xml.create_cal_element("calendar-data"); if let Some(mime) = &self.mime { start.push_attribute(("content-type", mime.content_type.as_str())); start.push_attribute(("version", mime.version.as_str())); } let end = start.to_end(); - xml.write_event_async(Event::Start(start.clone())).await?; - xml.write_event_async(Event::Text(BytesText::new(self.payload.as_str()))).await?; - xml.write_event_async(Event::End(end)).await + xml.q.write_event_async(Event::Start(start.clone())).await?; + xml.q.write_event_async(Event::Text(BytesText::new(self.payload.as_str()))).await?; + xml.q.write_event_async(Event::End(end)).await } } -impl<C: CalContext> QuickWritable<C> for CalendarDataRequest { - async fn write(&self, xml: &mut Writer<impl AsyncWrite+Unpin>, ctx: C) -> Result<(), QError> { - let mut start = ctx.create_cal_element("calendar-data"); +impl QWrite for CalendarDataRequest { + async fn qwrite(&self, xml: &mut Writer<impl IWrite>) -> Result<(), QError> { + let mut start = xml.create_cal_element("calendar-data"); if let Some(mime) = &self.mime { start.push_attribute(("content-type", mime.content_type.as_str())); start.push_attribute(("version", mime.version.as_str())); } let end = start.to_end(); - xml.write_event_async(Event::Start(start.clone())).await?; + xml.q.write_event_async(Event::Start(start.clone())).await?; if let Some(comp) = &self.comp { - comp.write(xml, ctx.child()).await?; + comp.qwrite(xml).await?; } if let Some(recurrence) = &self.recurrence { - recurrence.write(xml, ctx.child()).await?; + recurrence.qwrite(xml).await?; } if let Some(freebusy) = &self.limit_freebusy_set { - freebusy.write(xml, ctx.child()).await?; + freebusy.qwrite(xml).await?; } - xml.write_event_async(Event::End(end)).await + xml.q.write_event_async(Event::End(end)).await } } -impl<C: CalContext> QuickWritable<C> for CalendarDataEmpty { - async fn write(&self, xml: &mut Writer<impl AsyncWrite+Unpin>, ctx: C) -> Result<(), QError> { - let mut empty = ctx.create_cal_element("calendar-data"); +impl QWrite for CalendarDataEmpty { + async fn qwrite(&self, xml: &mut Writer<impl IWrite>) -> Result<(), QError> { + let mut empty = xml.create_cal_element("calendar-data"); if let Some(mime) = &self.0 { empty.push_attribute(("content-type", mime.content_type.as_str())); empty.push_attribute(("version", mime.version.as_str())); } - xml.write_event_async(Event::Empty(empty)).await + xml.q.write_event_async(Event::Empty(empty)).await } } -impl<C: CalContext> QuickWritable<C> for Comp { - async fn write(&self, xml: &mut Writer<impl AsyncWrite+Unpin>, ctx: C) -> Result<(), QError> { - let mut start = ctx.create_cal_element("comp"); +impl QWrite for Comp { + async fn qwrite(&self, xml: &mut Writer<impl IWrite>) -> Result<(), QError> { + let mut start = xml.create_cal_element("comp"); start.push_attribute(("name", self.name.as_str())); match &self.additional_rules { - None => xml.write_event_async(Event::Empty(start)).await, + None => xml.q.write_event_async(Event::Empty(start)).await, Some(rules) => { let end = start.to_end(); - xml.write_event_async(Event::Start(start.clone())).await?; - rules.prop_kind.write(xml, ctx.child()).await?; - rules.comp_kind.write(xml, ctx.child()).await?; - xml.write_event_async(Event::End(end)).await + xml.q.write_event_async(Event::Start(start.clone())).await?; + rules.prop_kind.qwrite(xml).await?; + rules.comp_kind.qwrite(xml).await?; + xml.q.write_event_async(Event::End(end)).await }, } } } -impl<C: CalContext> QuickWritable<C> for CompSupport { - async fn write(&self, xml: &mut Writer<impl AsyncWrite+Unpin>, ctx: C) -> Result<(), QError> { - let mut empty = ctx.create_cal_element("comp"); +impl QWrite for CompSupport { + async fn qwrite(&self, xml: &mut Writer<impl IWrite>) -> Result<(), QError> { + let mut empty = xml.create_cal_element("comp"); empty.push_attribute(("name", self.0.as_str())); - xml.write_event_async(Event::Empty(empty)).await + xml.q.write_event_async(Event::Empty(empty)).await } } -impl<C: CalContext> QuickWritable<C> for CompKind { - async fn write(&self, xml: &mut Writer<impl AsyncWrite+Unpin>, ctx: C) -> Result<(), QError> { +impl QWrite for CompKind { + async fn qwrite(&self, xml: &mut Writer<impl IWrite>) -> Result<(), QError> { match self { - Self::AllComp => xml.write_event_async(Event::Empty(ctx.create_cal_element("allcomp"))).await, + Self::AllComp => { + let empty_tag = xml.create_cal_element("allcomp"); + xml.q.write_event_async(Event::Empty(empty_tag)).await + }, Self::Comp(many_comp) => { for comp in many_comp.iter() { // Required: recursion in an async fn requires boxing // rustc --explain E0733 - Box::pin(comp.write(xml, ctx.child())).await?; + Box::pin(comp.qwrite(xml)).await?; } Ok(()) } @@ -429,13 +394,16 @@ impl<C: CalContext> QuickWritable<C> for CompKind { } } -impl<C: CalContext> QuickWritable<C> for PropKind { - async fn write(&self, xml: &mut Writer<impl AsyncWrite+Unpin>, ctx: C) -> Result<(), QError> { +impl QWrite for PropKind { + async fn qwrite(&self, xml: &mut Writer<impl IWrite>) -> Result<(), QError> { match self { - Self::AllProp => xml.write_event_async(Event::Empty(ctx.create_cal_element("allprop"))).await, + Self::AllProp => { + let empty_tag = xml.create_cal_element("allprop"); + xml.q.write_event_async(Event::Empty(empty_tag)).await + }, Self::Prop(many_prop) => { for prop in many_prop.iter() { - prop.write(xml, ctx.child()).await?; + prop.qwrite(xml).await?; } Ok(()) } @@ -443,163 +411,175 @@ impl<C: CalContext> QuickWritable<C> for PropKind { } } -impl<C: CalContext> QuickWritable<C> for CalProp { - async fn write(&self, xml: &mut Writer<impl AsyncWrite+Unpin>, ctx: C) -> Result<(), QError> { - let mut empty = ctx.create_cal_element("prop"); +impl QWrite for CalProp { + async fn qwrite(&self, xml: &mut Writer<impl IWrite>) -> Result<(), QError> { + let mut empty = xml.create_cal_element("prop"); empty.push_attribute(("name", self.name.0.as_str())); match self.novalue { None => (), Some(true) => empty.push_attribute(("novalue", "yes")), Some(false) => empty.push_attribute(("novalue", "no")), } - xml.write_event_async(Event::Empty(empty)).await + xml.q.write_event_async(Event::Empty(empty)).await } } -impl<C: CalContext> QuickWritable<C> for RecurrenceModifier { - async fn write(&self, xml: &mut Writer<impl AsyncWrite+Unpin>, ctx: C) -> Result<(), QError> { +impl QWrite for RecurrenceModifier { + async fn qwrite(&self, xml: &mut Writer<impl IWrite>) -> Result<(), QError> { match self { - Self::Expand(exp) => exp.write(xml, ctx).await, - Self::LimitRecurrenceSet(lrs) => lrs.write(xml, ctx).await, + Self::Expand(exp) => exp.qwrite(xml).await, + Self::LimitRecurrenceSet(lrs) => lrs.qwrite(xml).await, } } } -impl<C: CalContext> QuickWritable<C> for Expand { - async fn write(&self, xml: &mut Writer<impl AsyncWrite+Unpin>, ctx: C) -> Result<(), QError> { - let mut empty = ctx.create_cal_element("expand"); +impl QWrite for Expand { + async fn qwrite(&self, xml: &mut Writer<impl IWrite>) -> Result<(), QError> { + let mut empty = xml.create_cal_element("expand"); empty.push_attribute(("start", format!("{}", self.0.format(ICAL_DATETIME_FMT)).as_str())); empty.push_attribute(("end", format!("{}", self.1.format(ICAL_DATETIME_FMT)).as_str())); - xml.write_event_async(Event::Empty(empty)).await + xml.q.write_event_async(Event::Empty(empty)).await } } -impl<C: CalContext> QuickWritable<C> for LimitRecurrenceSet { - async fn write(&self, xml: &mut Writer<impl AsyncWrite+Unpin>, ctx: C) -> Result<(), QError> { - let mut empty = ctx.create_cal_element("limit-recurrence-set"); +impl QWrite for LimitRecurrenceSet { + async fn qwrite(&self, xml: &mut Writer<impl IWrite>) -> Result<(), QError> { + let mut empty = xml.create_cal_element("limit-recurrence-set"); empty.push_attribute(("start", format!("{}", self.0.format(ICAL_DATETIME_FMT)).as_str())); empty.push_attribute(("end", format!("{}", self.1.format(ICAL_DATETIME_FMT)).as_str())); - xml.write_event_async(Event::Empty(empty)).await + xml.q.write_event_async(Event::Empty(empty)).await } } -impl<C: CalContext> QuickWritable<C> for LimitFreebusySet { - async fn write(&self, xml: &mut Writer<impl AsyncWrite+Unpin>, ctx: C) -> Result<(), QError> { - let mut empty = ctx.create_cal_element("limit-freebusy-set"); +impl QWrite for LimitFreebusySet { + async fn qwrite(&self, xml: &mut Writer<impl IWrite>) -> Result<(), QError> { + let mut empty = xml.create_cal_element("limit-freebusy-set"); empty.push_attribute(("start", format!("{}", self.0.format(ICAL_DATETIME_FMT)).as_str())); empty.push_attribute(("end", format!("{}", self.1.format(ICAL_DATETIME_FMT)).as_str())); - xml.write_event_async(Event::Empty(empty)).await + xml.q.write_event_async(Event::Empty(empty)).await } } -impl<C: CalContext> QuickWritable<C> for CalendarSelector<C> { - async fn write(&self, xml: &mut Writer<impl AsyncWrite+Unpin>, ctx: C) -> Result<(), QError> { +impl<E: Extension> QWrite for CalendarSelector<E> { + async fn qwrite(&self, xml: &mut Writer<impl IWrite>) -> Result<(), QError> { match self { - Self::AllProp => xml.write_event_async(Event::Empty(ctx.create_dav_element("allprop"))).await, - Self::PropName => xml.write_event_async(Event::Empty(ctx.create_dav_element("propname"))).await, - Self::Prop(prop) => prop.write(xml, ctx).await, + Self::AllProp => { + let empty_tag = xml.create_dav_element("allprop"); + xml.q.write_event_async(Event::Empty(empty_tag)).await + }, + Self::PropName => { + let empty_tag = xml.create_dav_element("propname"); + xml.q.write_event_async(Event::Empty(empty_tag)).await + }, + Self::Prop(prop) => prop.qwrite(xml).await, } } } -impl<C: CalContext> QuickWritable<C> for CompFilter { - async fn write(&self, xml: &mut Writer<impl AsyncWrite+Unpin>, ctx: C) -> Result<(), QError> { - let mut start = ctx.create_cal_element("comp-filter"); +impl QWrite for CompFilter { + async fn qwrite(&self, xml: &mut Writer<impl IWrite>) -> Result<(), QError> { + let mut start = xml.create_cal_element("comp-filter"); start.push_attribute(("name", self.name.as_str())); match &self.additional_rules { - None => xml.write_event_async(Event::Empty(start)).await, + None => xml.q.write_event_async(Event::Empty(start)).await, Some(rules) => { let end = start.to_end(); - xml.write_event_async(Event::Start(start.clone())).await?; - rules.write(xml, ctx.child()).await?; - xml.write_event_async(Event::End(end)).await + xml.q.write_event_async(Event::Start(start.clone())).await?; + rules.qwrite(xml).await?; + xml.q.write_event_async(Event::End(end)).await } } } } -impl<C: CalContext> QuickWritable<C> for CompFilterRules { - async fn write(&self, xml: &mut Writer<impl AsyncWrite+Unpin>, ctx: C) -> Result<(), QError> { +impl QWrite for CompFilterRules { + async fn qwrite(&self, xml: &mut Writer<impl IWrite>) -> Result<(), QError> { match self { - Self::IsNotDefined => xml.write_event_async(Event::Empty(ctx.create_dav_element("is-not-defined"))).await, - Self::Matches(cfm) => cfm.write(xml, ctx).await, + Self::IsNotDefined => { + let empty_tag = xml.create_dav_element("is-not-defined"); + xml.q.write_event_async(Event::Empty(empty_tag)).await + }, + Self::Matches(cfm) => cfm.qwrite(xml).await, } } } -impl<C: CalContext> QuickWritable<C> for CompFilterMatch { - async fn write(&self, xml: &mut Writer<impl AsyncWrite+Unpin>, ctx: C) -> Result<(), QError> { +impl QWrite for CompFilterMatch { + async fn qwrite(&self, xml: &mut Writer<impl IWrite>) -> Result<(), QError> { if let Some(time_range) = &self.time_range { - time_range.write(xml, ctx.child()).await?; + time_range.qwrite(xml).await?; } for prop_item in self.prop_filter.iter() { - prop_item.write(xml, ctx.child()).await?; + prop_item.qwrite(xml).await?; } for comp_item in self.comp_filter.iter() { // Required: recursion in an async fn requires boxing // rustc --explain E0733 - Box::pin(comp_item.write(xml, ctx.child())).await?; + Box::pin(comp_item.qwrite(xml)).await?; } Ok(()) } } -impl<C: CalContext> QuickWritable<C> for PropFilter { - async fn write(&self, xml: &mut Writer<impl AsyncWrite+Unpin>, ctx: C) -> Result<(), QError> { - let mut start = ctx.create_cal_element("prop-filter"); +impl QWrite for PropFilter { + async fn qwrite(&self, xml: &mut Writer<impl IWrite>) -> Result<(), QError> { + let mut start = xml.create_cal_element("prop-filter"); start.push_attribute(("name", self.name.as_str())); match &self.additional_rules { - None => xml.write_event_async(Event::Empty(start)).await, + None => xml.q.write_event_async(Event::Empty(start.clone())).await, Some(rules) => { let end = start.to_end(); - xml.write_event_async(Event::Start(start.clone())).await?; - rules.write(xml, ctx.child()).await?; - xml.write_event_async(Event::End(end)).await + xml.q.write_event_async(Event::Start(start.clone())).await?; + rules.qwrite(xml).await?; + xml.q.write_event_async(Event::End(end)).await } } } } -impl<C: CalContext> QuickWritable<C> for PropFilterRules { - async fn write(&self, xml: &mut Writer<impl AsyncWrite+Unpin>, ctx: C) -> Result<(), QError> { +impl QWrite for PropFilterRules { + async fn qwrite(&self, xml: &mut Writer<impl IWrite>) -> Result<(), QError> { match self { - Self::IsNotDefined => xml.write_event_async(Event::Empty(ctx.create_dav_element("is-not-defined"))).await, - Self::Match(prop_match) => prop_match.write(xml, ctx).await, + Self::IsNotDefined => { + let empty_tag = xml.create_dav_element("is-not-defined"); + xml.q.write_event_async(Event::Empty(empty_tag)).await + }, + Self::Match(prop_match) => prop_match.qwrite(xml).await, } } } -impl<C: CalContext> QuickWritable<C> for PropFilterMatch { - async fn write(&self, xml: &mut Writer<impl AsyncWrite+Unpin>, ctx: C) -> Result<(), QError> { +impl QWrite for PropFilterMatch { + async fn qwrite(&self, xml: &mut Writer<impl IWrite>) -> Result<(), QError> { if let Some(time_range) = &self.time_range { - time_range.write(xml, ctx.child()).await?; + time_range.qwrite(xml).await?; } if let Some(time_or_text) = &self.time_or_text { - time_or_text.write(xml, ctx.child()).await?; + time_or_text.qwrite(xml).await?; } for param_item in self.param_filter.iter() { - param_item.write(xml, ctx.child()).await?; + param_item.qwrite(xml).await?; } Ok(()) } } -impl<C: CalContext> QuickWritable<C> for TimeOrText { - async fn write(&self, xml: &mut Writer<impl AsyncWrite+Unpin>, ctx: C) -> Result<(), QError> { +impl QWrite for TimeOrText { + async fn qwrite(&self, xml: &mut Writer<impl IWrite>) -> Result<(), QError> { match self { - Self::Time(time) => time.write(xml, ctx).await, - Self::Text(txt) => txt.write(xml, ctx).await, + Self::Time(time) => time.qwrite(xml).await, + Self::Text(txt) => txt.qwrite(xml).await, } } } -impl<C: CalContext> QuickWritable<C> for TextMatch { - async fn write(&self, xml: &mut Writer<impl AsyncWrite+Unpin>, ctx: C) -> Result<(), QError> { - let mut start = ctx.create_cal_element("text-match"); +impl QWrite for TextMatch { + async fn qwrite(&self, xml: &mut Writer<impl IWrite>) -> Result<(), QError> { + let mut start = xml.create_cal_element("text-match"); if let Some(collation) = &self.collation { start.push_attribute(("collation", collation.as_str())); } @@ -610,63 +590,66 @@ impl<C: CalContext> QuickWritable<C> for TextMatch { } let end = start.to_end(); - xml.write_event_async(Event::Start(start.clone())).await?; - xml.write_event_async(Event::Text(BytesText::new(self.text.as_str()))).await?; - xml.write_event_async(Event::End(end)).await + xml.q.write_event_async(Event::Start(start.clone())).await?; + xml.q.write_event_async(Event::Text(BytesText::new(self.text.as_str()))).await?; + xml.q.write_event_async(Event::End(end)).await } } -impl<C: CalContext> QuickWritable<C> for ParamFilter { - async fn write(&self, xml: &mut Writer<impl AsyncWrite+Unpin>, ctx: C) -> Result<(), QError> { - let mut start = ctx.create_cal_element("param-filter"); +impl QWrite for ParamFilter { + async fn qwrite(&self, xml: &mut Writer<impl IWrite>) -> Result<(), QError> { + let mut start = xml.create_cal_element("param-filter"); start.push_attribute(("name", self.name.as_str())); match &self.additional_rules { - None => xml.write_event_async(Event::Empty(start)).await, + None => xml.q.write_event_async(Event::Empty(start)).await, Some(rules) => { let end = start.to_end(); - xml.write_event_async(Event::Start(start.clone())).await?; - rules.write(xml, ctx.child()).await?; - xml.write_event_async(Event::End(end)).await + xml.q.write_event_async(Event::Start(start.clone())).await?; + rules.qwrite(xml).await?; + xml.q.write_event_async(Event::End(end)).await } } } } -impl<C: CalContext> QuickWritable<C> for ParamFilterMatch { - async fn write(&self, xml: &mut Writer<impl AsyncWrite+Unpin>, ctx: C) -> Result<(), QError> { +impl QWrite for ParamFilterMatch { + async fn qwrite(&self, xml: &mut Writer<impl IWrite>) -> Result<(), QError> { match self { - Self::IsNotDefined => xml.write_event_async(Event::Empty(ctx.create_dav_element("is-not-defined"))).await, - Self::Match(tm) => tm.write(xml, ctx).await, + Self::IsNotDefined => { + let empty_tag = xml.create_dav_element("is-not-defined"); + xml.q.write_event_async(Event::Empty(empty_tag)).await + }, + Self::Match(tm) => tm.qwrite(xml).await, } } } -impl<C: CalContext> QuickWritable<C> for TimeZone { - async fn write(&self, xml: &mut Writer<impl AsyncWrite+Unpin>, ctx: C) -> Result<(), QError> { - let mut start = ctx.create_cal_element("timezone"); +impl QWrite for TimeZone { + async fn qwrite(&self, xml: &mut Writer<impl IWrite>) -> Result<(), QError> { + let mut start = xml.create_cal_element("timezone"); let end = start.to_end(); - xml.write_event_async(Event::Start(start.clone())).await?; - xml.write_event_async(Event::Text(BytesText::new(self.0.as_str()))).await?; - xml.write_event_async(Event::End(end)).await + xml.q.write_event_async(Event::Start(start.clone())).await?; + xml.q.write_event_async(Event::Text(BytesText::new(self.0.as_str()))).await?; + xml.q.write_event_async(Event::End(end)).await } } -impl<C: CalContext> QuickWritable<C> for Filter { - async fn write(&self, xml: &mut Writer<impl AsyncWrite+Unpin>, ctx: C) -> Result<(), QError> { - let mut start = ctx.create_cal_element("filter"); +impl QWrite for Filter { + async fn qwrite(&self, xml: &mut Writer<impl IWrite>) -> Result<(), QError> { + let mut start = xml.create_cal_element("filter"); let end = start.to_end(); - xml.write_event_async(Event::Start(start.clone())).await?; - self.0.write(xml, ctx.child()).await?; - xml.write_event_async(Event::End(end)).await + xml.q.write_event_async(Event::Start(start.clone())).await?; + self.0.qwrite(xml).await?; + xml.q.write_event_async(Event::End(end)).await } } -impl<C: CalContext> QuickWritable<C> for TimeRange { - async fn write(&self, xml: &mut Writer<impl AsyncWrite+Unpin>, ctx: C) -> Result<(), QError> { - let mut empty = ctx.create_cal_element("time-range"); +impl QWrite for TimeRange { + async fn qwrite(&self, xml: &mut Writer<impl IWrite>) -> Result<(), QError> { + let mut empty = xml.create_cal_element("time-range"); match self { Self::OnlyStart(start) => empty.push_attribute(("start", format!("{}", start.format(ICAL_DATETIME_FMT)).as_str())), Self::OnlyEnd(end) => empty.push_attribute(("end", format!("{}", end.format(ICAL_DATETIME_FMT)).as_str())), @@ -675,11 +658,11 @@ impl<C: CalContext> QuickWritable<C> for TimeRange { empty.push_attribute(("end", format!("{}", end.format(ICAL_DATETIME_FMT)).as_str())); } } - xml.write_event_async(Event::Empty(empty)).await + xml.q.write_event_async(Event::Empty(empty)).await } } - +/* #[cfg(test)] mod tests { use super::*; diff --git a/src/dav/caltypes.rs b/src/dav/caltypes.rs index c8177e9..585afe2 100644 --- a/src/dav/caltypes.rs +++ b/src/dav/caltypes.rs @@ -1,6 +1,5 @@ #![allow(dead_code)] -/* use chrono::{DateTime,Utc}; use super::types as dav; @@ -647,7 +646,7 @@ pub enum Violation { /// making use of the same UID property value in the DAV:href element; /// /// <!ELEMENT no-uid-conflict (DAV:href)> - NoUidConflict(Dav::Href), + NoUidConflict(dav::Href), /// (CALDAV:max-resource-size): The resource submitted in the PUT /// request, or targeted by a COPY or MOVE request, MUST have an octet @@ -1394,4 +1393,4 @@ impl Collation { Self::Unknown(c) => c.as_str(), } } -}*/ +} |