rst_parser/transforms/
transform.rs

Help
1use std::iter::once;
2
3use document_tree::HasChildren;
4use document_tree::element_categories as c;
5use document_tree::elements as e;
6
7/// Helper trait for [`Transform::transform_children`] while [Fn traits] are not stable yet.
8///
9/// See <https://users.rust-lang.org/t/127846>.
10///
11/// [Fn traits]: https://github.com/rust-lang/rust/issues/29625
12pub trait IteratorMaker<This, C>: FnMut(This, C) -> Self::Iter {
13    type Iter: Iterator<Item = C>;
14}
15
16impl<F, This, C, Iter> IteratorMaker<This, C> for F
17where
18    F: ?Sized + FnMut(This, C) -> Iter,
19    Iter: Iterator<Item = C>,
20{
21    type Iter = Iter;
22}
23
24#[inline]
25fn box_iter<'a, I>(i: impl Iterator<Item = I> + 'a) -> Box<dyn Iterator<Item = I> + 'a> {
26    Box::new(i)
27}
28
29/// Transform a document tree.
30///
31/// Override individual methods to modify the document tree.
32/// By default, every method transforms an element’s children (if applicable) and then returns the element.
33pub trait Transform {
34    /// Transform children of an element.
35    ///
36    /// Can be used in other `transform_<element>` methods to recurse, e.g.:
37    ///
38    /// ```rust
39    /// use document_tree::elements as e;
40    /// use document_tree::element_categories as c;
41    /// use rst_parser::transforms::Transform;
42    ///
43    /// struct MyPass;
44    /// impl Transform for MyPass {
45    ///     fn transform_header(&mut self, mut e: e::Header) -> impl Iterator<Item = c::DecorationElement> {
46    ///         self.transform_children(&mut e, Self::transform_body_element);
47    ///         std::iter::once(e.into())
48    ///     }
49    /// }
50    /// ```
51    fn transform_children<C, E>(
52        &mut self,
53        e: &mut E,
54        mut meth: impl for<'a> IteratorMaker<&'a mut Self, C>,
55    ) where
56        E: HasChildren<C>,
57    {
58        let mut new = Vec::new();
59        for c in e.children_mut().drain(..) {
60            new.extend(meth(self, c));
61        }
62        e.children_mut().extend(new);
63    }
64
65    /// Transform a whole document tree.
66    #[must_use]
67    fn transform(&mut self, mut d: e::Document) -> e::Document {
68        self.transform_children(&mut d, Self::transform_structural_sub_element);
69        d
70    }
71
72    ////////////////
73    // categories //
74    ////////////////
75
76    #[must_use]
77    fn transform_structural_sub_element(
78        &mut self,
79        c: c::StructuralSubElement,
80    ) -> impl Iterator<Item = c::StructuralSubElement> {
81        use c::StructuralSubElement as S;
82        match c {
83            S::Title(e) => box_iter(self.transform_title(*e).map(Into::into)),
84            S::Subtitle(e) => box_iter(self.transform_subtitle(*e).map(S::from)),
85            S::Decoration(e) => box_iter(self.transform_decoration(*e)),
86            S::Docinfo(e) => box_iter(self.transform_docinfo(*e)),
87            S::SubStructure(e) => box_iter(self.transform_substructure(*e).map(S::from)),
88        }
89    }
90    #[must_use]
91    fn transform_substructure(
92        &mut self,
93        c: c::SubStructure,
94    ) -> impl Iterator<Item = c::SubStructure> {
95        use c::SubStructure as S;
96        match c {
97            S::Topic(e) => box_iter(self.transform_topic(*e).map(Into::into)),
98            S::Sidebar(e) => box_iter(self.transform_sidebar(*e)),
99            S::Transition(e) => box_iter(self.transform_transition(*e)),
100            S::Section(e) => box_iter(self.transform_section(*e)),
101            S::BodyElement(e) => box_iter(self.transform_body_element(*e).map(Into::into)),
102        }
103    }
104    #[must_use]
105    fn transform_body_element(
106        &mut self,
107        c: c::BodyElement,
108    ) -> impl Iterator<Item = c::BodyElement> {
109        use c::BodyElement as B;
110        match c {
111            B::Paragraph(e) => box_iter(self.transform_paragraph(*e)),
112            B::LiteralBlock(e) => box_iter(self.transform_literal_block(*e)),
113            B::DoctestBlock(e) => box_iter(self.transform_doctest_block(*e)),
114            B::MathBlock(e) => box_iter(self.transform_math_block(*e)),
115            B::Rubric(e) => box_iter(self.transform_rubric(*e)),
116            B::SubstitutionDefinition(e) => box_iter(self.transform_substitution_definition(*e)),
117            B::Comment(e) => box_iter(self.transform_comment(*e)),
118            B::Pending(e) => box_iter(self.transform_pending(*e)),
119            B::Target(e) => box_iter(self.transform_target(*e)),
120            B::Raw(e) => box_iter(self.transform_raw(*e)),
121            B::Image(e) => box_iter(self.transform_image(*e)),
122            B::Compound(e) => box_iter(self.transform_compound(*e)),
123            B::Container(e) => box_iter(self.transform_container(*e)),
124            B::BulletList(e) => box_iter(self.transform_bullet_list(*e)),
125            B::EnumeratedList(e) => box_iter(self.transform_enumerated_list(*e)),
126            B::DefinitionList(e) => box_iter(self.transform_definition_list(*e)),
127            B::FieldList(e) => box_iter(self.transform_field_list(*e)),
128            B::OptionList(e) => box_iter(self.transform_option_list(*e)),
129            B::LineBlock(e) => box_iter(self.transform_line_block(*e).map(Into::into)),
130            B::BlockQuote(e) => box_iter(self.transform_block_quote(*e)),
131            B::Admonition(e) => box_iter(self.transform_admonition(*e)),
132            B::Attention(e) => box_iter(self.transform_attention(*e)),
133            B::Hint(e) => box_iter(self.transform_hint(*e)),
134            B::Note(e) => box_iter(self.transform_note(*e)),
135            B::Caution(e) => box_iter(self.transform_caution(*e)),
136            B::Danger(e) => box_iter(self.transform_danger(*e)),
137            B::Error(e) => box_iter(self.transform_error(*e)),
138            B::Important(e) => box_iter(self.transform_important(*e)),
139            B::Tip(e) => box_iter(self.transform_tip(*e)),
140            B::Warning(e) => box_iter(self.transform_warning(*e)),
141            B::Footnote(e) => box_iter(self.transform_footnote(*e)),
142            B::Citation(e) => box_iter(self.transform_citation(*e)),
143            B::SystemMessage(e) => box_iter(self.transform_system_message(*e)),
144            B::Figure(e) => box_iter(self.transform_figure(*e)),
145            B::Table(e) => box_iter(self.transform_table(*e)),
146        }
147    }
148    #[must_use]
149    fn transform_bibliographic_element(
150        &mut self,
151        c: c::BibliographicElement,
152    ) -> impl Iterator<Item = c::BibliographicElement> {
153        use c::BibliographicElement as B;
154        match c {
155            B::Authors(e) => box_iter(self.transform_authors(*e)),
156            B::Author(e) => box_iter(self.transform_author(*e).map(Into::into)),
157            B::Organization(e) => box_iter(self.transform_organization(*e).map(Into::into)),
158            B::Address(e) => box_iter(self.transform_address(*e).map(Into::into)),
159            B::Contact(e) => box_iter(self.transform_contact(*e).map(Into::into)),
160            B::Version(e) => box_iter(self.transform_version(*e)),
161            B::Revision(e) => box_iter(self.transform_revision(*e)),
162            B::Status(e) => box_iter(self.transform_status(*e)),
163            B::Date(e) => box_iter(self.transform_date(*e)),
164            B::Copyright(e) => box_iter(self.transform_copyright(*e)),
165            B::Field(e) => box_iter(self.transform_field(*e).map(Into::into)),
166        }
167    }
168    #[must_use]
169    fn transform_text_or_inline_element(
170        &mut self,
171        c: c::TextOrInlineElement,
172    ) -> impl Iterator<Item = c::TextOrInlineElement> {
173        use c::TextOrInlineElement as T;
174        match c {
175            T::String(e) => box_iter(self.transform_string(*e).map(Into::into)),
176            T::Emphasis(e) => box_iter(self.transform_emphasis(*e)),
177            T::Strong(e) => box_iter(self.transform_strong(*e)),
178            T::Literal(e) => box_iter(self.transform_literal(*e)),
179            T::Reference(e) => box_iter(self.transform_reference(*e)),
180            T::FootnoteReference(e) => box_iter(self.transform_footnote_reference(*e)),
181            T::CitationReference(e) => box_iter(self.transform_citation_reference(*e)),
182            T::SubstitutionReference(e) => box_iter(self.transform_substitution_reference(*e)),
183            T::TitleReference(e) => box_iter(self.transform_title_reference(*e)),
184            T::Abbreviation(e) => box_iter(self.transform_abbreviation(*e)),
185            T::Acronym(e) => box_iter(self.transform_acronym(*e)),
186            T::Superscript(e) => box_iter(self.transform_superscript(*e)),
187            T::Subscript(e) => box_iter(self.transform_subscript(*e)),
188            T::Inline(e) => box_iter(self.transform_inline(*e)),
189            T::Problematic(e) => box_iter(self.transform_problematic(*e)),
190            T::Generated(e) => box_iter(self.transform_generated(*e)),
191            T::Math(e) => box_iter(self.transform_math(*e)),
192            T::TargetInline(e) => box_iter(self.transform_target_inline(*e)),
193            T::RawInline(e) => box_iter(self.transform_raw_inline(*e)),
194            T::ImageInline(e) => box_iter(self.transform_image_inline(*e)),
195        }
196    }
197    #[must_use]
198    fn transform_author_info(&mut self, c: c::AuthorInfo) -> impl Iterator<Item = c::AuthorInfo> {
199        use c::AuthorInfo as A;
200        match c {
201            A::Author(e) => box_iter(self.transform_author(*e)),
202            A::Organization(e) => box_iter(self.transform_organization(*e)),
203            A::Address(e) => box_iter(self.transform_address(*e)),
204            A::Contact(e) => box_iter(self.transform_contact(*e)),
205        }
206    }
207    #[must_use]
208    fn transform_decoration_element(
209        &mut self,
210        c: c::DecorationElement,
211    ) -> impl Iterator<Item = c::DecorationElement> {
212        use c::DecorationElement as D;
213        match c {
214            D::Header(e) => box_iter(self.transform_header(*e)),
215            D::Footer(e) => box_iter(self.transform_footer(*e)),
216        }
217    }
218    #[must_use]
219    fn transform_sub_topic(&mut self, c: c::SubTopic) -> impl Iterator<Item = c::SubTopic> {
220        use c::SubTopic as S;
221        match c {
222            S::Title(e) => box_iter(self.transform_title(*e).map(Into::into)),
223            S::BodyElement(e) => box_iter(self.transform_body_element(*e).map(Into::into)),
224        }
225    }
226    #[must_use]
227    fn transform_sub_sidebar(&mut self, c: c::SubSidebar) -> impl Iterator<Item = c::SubSidebar> {
228        use c::SubSidebar as S;
229        match c {
230            S::Topic(e) => box_iter(self.transform_topic(*e).map(Into::into)),
231            S::Title(e) => box_iter(self.transform_title(*e).map(Into::into)),
232            S::Subtitle(e) => box_iter(self.transform_subtitle(*e)),
233            S::BodyElement(e) => box_iter(self.transform_body_element(*e).map(Into::into)),
234        }
235    }
236    #[must_use]
237    fn transform_sub_dl_item(&mut self, c: c::SubDLItem) -> impl Iterator<Item = c::SubDLItem> {
238        use c::SubDLItem as S;
239        match c {
240            S::Term(e) => box_iter(self.transform_term(*e)),
241            S::Classifier(e) => box_iter(self.transform_classifier(*e)),
242            S::Definition(e) => box_iter(self.transform_definition(*e)),
243        }
244    }
245    #[must_use]
246    fn transform_sub_field(&mut self, c: c::SubField) -> impl Iterator<Item = c::SubField> {
247        use c::SubField as S;
248        match c {
249            S::FieldName(e) => box_iter(self.transform_field_name(*e)),
250            S::FieldBody(e) => box_iter(self.transform_field_body(*e)),
251        }
252    }
253    #[must_use]
254    fn transform_sub_option_list_item(
255        &mut self,
256        c: c::SubOptionListItem,
257    ) -> impl Iterator<Item = c::SubOptionListItem> {
258        use c::SubOptionListItem as S;
259        match c {
260            S::OptionGroup(e) => box_iter(self.transform_option_group(*e)),
261            S::Description(e) => box_iter(self.transform_description(*e)),
262        }
263    }
264    #[must_use]
265    fn transform_sub_option(&mut self, c: c::SubOption) -> impl Iterator<Item = c::SubOption> {
266        use c::SubOption as S;
267        match c {
268            S::OptionString(e) => box_iter(self.transform_option_string(*e)),
269            S::OptionArgument(e) => box_iter(self.transform_option_argument(*e)),
270        }
271    }
272    #[must_use]
273    fn transform_sub_line_block(
274        &mut self,
275        c: c::SubLineBlock,
276    ) -> impl Iterator<Item = c::SubLineBlock> {
277        use c::SubLineBlock as S;
278        match c {
279            S::LineBlock(e) => box_iter(self.transform_line_block(*e).map(Into::into)),
280            S::Line(e) => box_iter(self.transform_line(*e)),
281        }
282    }
283    #[must_use]
284    fn transform_sub_block_quote(
285        &mut self,
286        c: c::SubBlockQuote,
287    ) -> impl Iterator<Item = c::SubBlockQuote> {
288        use c::SubBlockQuote as S;
289        match c {
290            S::Attribution(e) => box_iter(self.transform_attribution(*e)),
291            S::BodyElement(e) => box_iter(self.transform_body_element(*e).map(Into::into)),
292        }
293    }
294    #[must_use]
295    fn transform_sub_footnote(
296        &mut self,
297        c: c::SubFootnote,
298    ) -> impl Iterator<Item = c::SubFootnote> {
299        use c::SubFootnote as S;
300        match c {
301            S::Label(e) => box_iter(self.transform_label(*e)),
302            S::BodyElement(e) => box_iter(self.transform_body_element(*e).map(Into::into)),
303        }
304    }
305    #[must_use]
306    fn transform_sub_figure(&mut self, c: c::SubFigure) -> impl Iterator<Item = c::SubFigure> {
307        use c::SubFigure as S;
308        match c {
309            S::Caption(e) => box_iter(self.transform_caption(*e)),
310            S::Legend(e) => box_iter(self.transform_legend(*e)),
311            S::BodyElement(e) => box_iter(self.transform_body_element(*e).map(Into::into)),
312        }
313    }
314    #[must_use]
315    fn transform_sub_table(&mut self, c: c::SubTable) -> impl Iterator<Item = c::SubTable> {
316        use c::SubTable as S;
317        match c {
318            S::Title(e) => box_iter(self.transform_title(*e).map(Into::into)),
319            S::TableGroup(e) => box_iter(self.transform_table_group(*e)),
320        }
321    }
322    #[must_use]
323    fn transform_sub_table_group(
324        &mut self,
325        c: c::SubTableGroup,
326    ) -> impl Iterator<Item = c::SubTableGroup> {
327        use c::SubTableGroup as S;
328        match c {
329            S::TableColspec(e) => box_iter(self.transform_table_colspec(*e)),
330            S::TableHead(e) => box_iter(self.transform_table_head(*e)),
331            S::TableBody(e) => box_iter(self.transform_table_body(*e)),
332        }
333    }
334
335    //////////////
336    // elements //
337    //////////////
338
339    //structual elements
340    #[must_use]
341    fn transform_section(&mut self, mut e: e::Section) -> impl Iterator<Item = c::SubStructure> {
342        self.transform_children(&mut e, Self::transform_structural_sub_element);
343        once(e.into())
344    }
345    #[must_use]
346    // TODO: introduce and return category for topic|bodyelement
347    fn transform_topic(&mut self, mut e: e::Topic) -> impl Iterator<Item = e::Topic> {
348        self.transform_children(&mut e, Self::transform_sub_topic);
349        once(e)
350    }
351    #[must_use]
352    fn transform_sidebar(&mut self, mut e: e::Sidebar) -> impl Iterator<Item = c::SubStructure> {
353        self.transform_children(&mut e, Self::transform_sub_sidebar);
354        once(e.into())
355    }
356
357    //structural subelements
358    #[must_use]
359    fn transform_title(&mut self, mut e: e::Title) -> impl Iterator<Item = e::Title> {
360        self.transform_children(&mut e, Self::transform_text_or_inline_element);
361        once(e)
362    }
363    #[must_use]
364    fn transform_subtitle(&mut self, mut e: e::Subtitle) -> impl Iterator<Item = c::SubSidebar> {
365        self.transform_children(&mut e, Self::transform_text_or_inline_element);
366        once(e.into())
367    }
368    #[must_use]
369    fn transform_decoration(
370        &mut self,
371        mut e: e::Decoration,
372    ) -> impl Iterator<Item = c::StructuralSubElement> {
373        self.transform_children(&mut e, Self::transform_decoration_element);
374        once(e.into())
375    }
376    #[must_use]
377    fn transform_docinfo(
378        &mut self,
379        mut e: e::Docinfo,
380    ) -> impl Iterator<Item = c::StructuralSubElement> {
381        self.transform_children(&mut e, Self::transform_bibliographic_element);
382        once(e.into())
383    }
384    #[must_use]
385    fn transform_transition(&mut self, e: e::Transition) -> impl Iterator<Item = c::SubStructure> {
386        once(e.into())
387    }
388
389    //bibliographic elements
390    #[must_use]
391    fn transform_authors(
392        &mut self,
393        mut e: e::Authors,
394    ) -> impl Iterator<Item = c::BibliographicElement> {
395        self.transform_children(&mut e, Self::transform_author_info);
396        once(e.into())
397    }
398    #[must_use]
399    fn transform_author(&mut self, mut e: e::Author) -> impl Iterator<Item = c::AuthorInfo> {
400        self.transform_children(&mut e, Self::transform_text_or_inline_element);
401        once(e.into())
402    }
403    #[must_use]
404    fn transform_organization(
405        &mut self,
406        mut e: e::Organization,
407    ) -> impl Iterator<Item = c::AuthorInfo> {
408        self.transform_children(&mut e, Self::transform_text_or_inline_element);
409        once(e.into())
410    }
411    #[must_use]
412    fn transform_address(&mut self, mut e: e::Address) -> impl Iterator<Item = c::AuthorInfo> {
413        self.transform_children(&mut e, Self::transform_text_or_inline_element);
414        once(e.into())
415    }
416    #[must_use]
417    fn transform_contact(&mut self, mut e: e::Contact) -> impl Iterator<Item = c::AuthorInfo> {
418        self.transform_children(&mut e, Self::transform_text_or_inline_element);
419        once(e.into())
420    }
421    #[must_use]
422    fn transform_version(
423        &mut self,
424        mut e: e::Version,
425    ) -> impl Iterator<Item = c::BibliographicElement> {
426        self.transform_children(&mut e, Self::transform_text_or_inline_element);
427        once(e.into())
428    }
429    #[must_use]
430    fn transform_revision(
431        &mut self,
432        mut e: e::Revision,
433    ) -> impl Iterator<Item = c::BibliographicElement> {
434        self.transform_children(&mut e, Self::transform_text_or_inline_element);
435        once(e.into())
436    }
437    #[must_use]
438    fn transform_status(
439        &mut self,
440        mut e: e::Status,
441    ) -> impl Iterator<Item = c::BibliographicElement> {
442        self.transform_children(&mut e, Self::transform_text_or_inline_element);
443        once(e.into())
444    }
445    #[must_use]
446    fn transform_date(&mut self, mut e: e::Date) -> impl Iterator<Item = c::BibliographicElement> {
447        self.transform_children(&mut e, Self::transform_text_or_inline_element);
448        once(e.into())
449    }
450    #[must_use]
451    fn transform_copyright(
452        &mut self,
453        mut e: e::Copyright,
454    ) -> impl Iterator<Item = c::BibliographicElement> {
455        self.transform_children(&mut e, Self::transform_text_or_inline_element);
456        once(e.into())
457    }
458    #[must_use]
459    fn transform_field(&mut self, mut e: e::Field) -> impl Iterator<Item = e::Field> {
460        self.transform_children(&mut e, Self::transform_sub_field);
461        once(e)
462    }
463
464    //decoration elements
465    #[must_use]
466    fn transform_header(&mut self, mut e: e::Header) -> impl Iterator<Item = c::DecorationElement> {
467        self.transform_children(&mut e, Self::transform_body_element);
468        once(e.into())
469    }
470    #[must_use]
471    fn transform_footer(&mut self, mut e: e::Footer) -> impl Iterator<Item = c::DecorationElement> {
472        self.transform_children(&mut e, Self::transform_body_element);
473        once(e.into())
474    }
475
476    //simple body elements
477    #[must_use]
478    fn transform_paragraph(&mut self, mut e: e::Paragraph) -> impl Iterator<Item = c::BodyElement> {
479        self.transform_children(&mut e, Self::transform_text_or_inline_element);
480        once(e.into())
481    }
482    #[must_use]
483    fn transform_literal_block(
484        &mut self,
485        mut e: e::LiteralBlock,
486    ) -> impl Iterator<Item = c::BodyElement> {
487        self.transform_children(&mut e, Self::transform_text_or_inline_element);
488        once(e.into())
489    }
490    #[must_use]
491    fn transform_doctest_block(
492        &mut self,
493        mut e: e::DoctestBlock,
494    ) -> impl Iterator<Item = c::BodyElement> {
495        self.transform_children(&mut e, Self::transform_text_or_inline_element);
496        once(e.into())
497    }
498    #[must_use]
499    fn transform_math_block(
500        &mut self,
501        mut e: e::MathBlock,
502    ) -> impl Iterator<Item = c::BodyElement> {
503        self.transform_children(&mut e, Self::transform_string);
504        once(e.into())
505    }
506    #[must_use]
507    fn transform_rubric(&mut self, mut e: e::Rubric) -> impl Iterator<Item = c::BodyElement> {
508        self.transform_children(&mut e, Self::transform_text_or_inline_element);
509        once(e.into())
510    }
511    #[must_use]
512    fn transform_substitution_definition(
513        &mut self,
514        mut e: e::SubstitutionDefinition,
515    ) -> impl Iterator<Item = c::BodyElement> {
516        self.transform_children(&mut e, Self::transform_text_or_inline_element);
517        once(e.into())
518    }
519    #[must_use]
520    fn transform_comment(&mut self, mut e: e::Comment) -> impl Iterator<Item = c::BodyElement> {
521        self.transform_children(&mut e, Self::transform_text_or_inline_element);
522        once(e.into())
523    }
524    #[must_use]
525    fn transform_pending(&mut self, e: e::Pending) -> impl Iterator<Item = c::BodyElement> {
526        once(e.into())
527    }
528    #[must_use]
529    fn transform_target(&mut self, e: e::Target) -> impl Iterator<Item = c::BodyElement> {
530        once(e.into())
531    }
532    #[must_use]
533    fn transform_raw(&mut self, mut e: e::Raw) -> impl Iterator<Item = c::BodyElement> {
534        self.transform_children(&mut e, Self::transform_string);
535        once(e.into())
536    }
537    #[must_use]
538    fn transform_image(&mut self, e: e::Image) -> impl Iterator<Item = c::BodyElement> {
539        once(e.into())
540    }
541
542    //compound body elements
543    #[must_use]
544    fn transform_compound(&mut self, mut e: e::Compound) -> impl Iterator<Item = c::BodyElement> {
545        self.transform_children(&mut e, Self::transform_body_element);
546        once(e.into())
547    }
548    #[must_use]
549    fn transform_container(&mut self, mut e: e::Container) -> impl Iterator<Item = c::BodyElement> {
550        self.transform_children(&mut e, Self::transform_body_element);
551        once(e.into())
552    }
553    #[must_use]
554    fn transform_bullet_list(
555        &mut self,
556        mut e: e::BulletList,
557    ) -> impl Iterator<Item = c::BodyElement> {
558        self.transform_children(&mut e, Self::transform_list_item);
559        once(e.into())
560    }
561    #[must_use]
562    fn transform_enumerated_list(
563        &mut self,
564        mut e: e::EnumeratedList,
565    ) -> impl Iterator<Item = c::BodyElement> {
566        self.transform_children(&mut e, Self::transform_list_item);
567        once(e.into())
568    }
569    #[must_use]
570    fn transform_definition_list(
571        &mut self,
572        mut e: e::DefinitionList,
573    ) -> impl Iterator<Item = c::BodyElement> {
574        self.transform_children(&mut e, Self::transform_definition_list_item);
575        once(e.into())
576    }
577    #[must_use]
578    fn transform_field_list(
579        &mut self,
580        mut e: e::FieldList,
581    ) -> impl Iterator<Item = c::BodyElement> {
582        self.transform_children(&mut e, Self::transform_field);
583        once(e.into())
584    }
585    #[must_use]
586    fn transform_option_list(
587        &mut self,
588        mut e: e::OptionList,
589    ) -> impl Iterator<Item = c::BodyElement> {
590        self.transform_children(&mut e, Self::transform_option_list_item);
591        once(e.into())
592    }
593    #[must_use]
594    fn transform_line_block(&mut self, mut e: e::LineBlock) -> impl Iterator<Item = e::LineBlock> {
595        self.transform_children(&mut e, Self::transform_sub_line_block);
596        once(e)
597    }
598    #[must_use]
599    fn transform_block_quote(
600        &mut self,
601        mut e: e::BlockQuote,
602    ) -> impl Iterator<Item = c::BodyElement> {
603        self.transform_children(&mut e, Self::transform_sub_block_quote);
604        once(e.into())
605    }
606    #[must_use]
607    fn transform_admonition(
608        &mut self,
609        mut e: e::Admonition,
610    ) -> impl Iterator<Item = c::BodyElement> {
611        self.transform_children(&mut e, Self::transform_sub_topic);
612        once(e.into())
613    }
614    #[must_use]
615    fn transform_attention(&mut self, mut e: e::Attention) -> impl Iterator<Item = c::BodyElement> {
616        self.transform_children(&mut e, Self::transform_body_element);
617        once(e.into())
618    }
619    #[must_use]
620    fn transform_hint(&mut self, mut e: e::Hint) -> impl Iterator<Item = c::BodyElement> {
621        self.transform_children(&mut e, Self::transform_body_element);
622        once(e.into())
623    }
624    #[must_use]
625    fn transform_note(&mut self, mut e: e::Note) -> impl Iterator<Item = c::BodyElement> {
626        self.transform_children(&mut e, Self::transform_body_element);
627        once(e.into())
628    }
629    #[must_use]
630    fn transform_caution(&mut self, mut e: e::Caution) -> impl Iterator<Item = c::BodyElement> {
631        self.transform_children(&mut e, Self::transform_body_element);
632        once(e.into())
633    }
634    #[must_use]
635    fn transform_danger(&mut self, mut e: e::Danger) -> impl Iterator<Item = c::BodyElement> {
636        self.transform_children(&mut e, Self::transform_body_element);
637        once(e.into())
638    }
639    #[must_use]
640    fn transform_error(&mut self, mut e: e::Error) -> impl Iterator<Item = c::BodyElement> {
641        self.transform_children(&mut e, Self::transform_body_element);
642        once(e.into())
643    }
644    #[must_use]
645    fn transform_important(&mut self, mut e: e::Important) -> impl Iterator<Item = c::BodyElement> {
646        self.transform_children(&mut e, Self::transform_body_element);
647        once(e.into())
648    }
649    #[must_use]
650    fn transform_tip(&mut self, mut e: e::Tip) -> impl Iterator<Item = c::BodyElement> {
651        self.transform_children(&mut e, Self::transform_body_element);
652        once(e.into())
653    }
654    #[must_use]
655    fn transform_warning(&mut self, mut e: e::Warning) -> impl Iterator<Item = c::BodyElement> {
656        self.transform_children(&mut e, Self::transform_body_element);
657        once(e.into())
658    }
659    #[must_use]
660    fn transform_footnote(&mut self, mut e: e::Footnote) -> impl Iterator<Item = c::BodyElement> {
661        self.transform_children(&mut e, Self::transform_sub_footnote);
662        once(e.into())
663    }
664    #[must_use]
665    fn transform_citation(&mut self, mut e: e::Citation) -> impl Iterator<Item = c::BodyElement> {
666        self.transform_children(&mut e, Self::transform_sub_footnote);
667        once(e.into())
668    }
669    #[must_use]
670    fn transform_system_message(
671        &mut self,
672        mut e: e::SystemMessage,
673    ) -> impl Iterator<Item = c::BodyElement> {
674        self.transform_children(&mut e, Self::transform_body_element);
675        once(e.into())
676    }
677    #[must_use]
678    fn transform_figure(&mut self, mut e: e::Figure) -> impl Iterator<Item = c::BodyElement> {
679        self.transform_children(&mut e, Self::transform_sub_figure);
680        once(e.into())
681    }
682    #[must_use]
683    fn transform_table(&mut self, mut e: e::Table) -> impl Iterator<Item = c::BodyElement> {
684        self.transform_children(&mut e, Self::transform_sub_table);
685        once(e.into())
686    }
687
688    //table elements
689    #[must_use]
690    fn transform_table_group(&mut self, mut e: e::TableGroup) -> impl Iterator<Item = c::SubTable> {
691        self.transform_children(&mut e, Self::transform_sub_table_group);
692        once(e.into())
693    }
694    #[must_use]
695    fn transform_table_head(
696        &mut self,
697        mut e: e::TableHead,
698    ) -> impl Iterator<Item = c::SubTableGroup> {
699        self.transform_children(&mut e, Self::transform_table_row);
700        once(e.into())
701    }
702    #[must_use]
703    fn transform_table_body(
704        &mut self,
705        mut e: e::TableBody,
706    ) -> impl Iterator<Item = c::SubTableGroup> {
707        self.transform_children(&mut e, Self::transform_table_row);
708        once(e.into())
709    }
710    #[must_use]
711    fn transform_table_row(&mut self, mut e: e::TableRow) -> impl Iterator<Item = e::TableRow> {
712        self.transform_children(&mut e, Self::transform_table_entry);
713        once(e)
714    }
715    #[must_use]
716    fn transform_table_entry(
717        &mut self,
718        mut e: e::TableEntry,
719    ) -> impl Iterator<Item = e::TableEntry> {
720        self.transform_children(&mut e, Self::transform_body_element);
721        once(e)
722    }
723    #[must_use]
724    fn transform_table_colspec(
725        &mut self,
726        e: e::TableColspec,
727    ) -> impl Iterator<Item = c::SubTableGroup> {
728        once(e.into())
729    }
730
731    //body sub elements
732    #[must_use]
733    fn transform_list_item(&mut self, mut e: e::ListItem) -> impl Iterator<Item = e::ListItem> {
734        self.transform_children(&mut e, Self::transform_body_element);
735        once(e)
736    }
737    #[must_use]
738    fn transform_definition_list_item(
739        &mut self,
740        mut e: e::DefinitionListItem,
741    ) -> impl Iterator<Item = e::DefinitionListItem> {
742        self.transform_children(&mut e, Self::transform_sub_dl_item);
743        once(e)
744    }
745    #[must_use]
746    fn transform_term(&mut self, mut e: e::Term) -> impl Iterator<Item = c::SubDLItem> {
747        self.transform_children(&mut e, Self::transform_text_or_inline_element);
748        once(e.into())
749    }
750    #[must_use]
751    fn transform_classifier(&mut self, mut e: e::Classifier) -> impl Iterator<Item = c::SubDLItem> {
752        self.transform_children(&mut e, Self::transform_text_or_inline_element);
753        once(e.into())
754    }
755    #[must_use]
756    fn transform_definition(&mut self, mut e: e::Definition) -> impl Iterator<Item = c::SubDLItem> {
757        self.transform_children(&mut e, Self::transform_body_element);
758        once(e.into())
759    }
760    #[must_use]
761    fn transform_field_name(&mut self, mut e: e::FieldName) -> impl Iterator<Item = c::SubField> {
762        self.transform_children(&mut e, Self::transform_text_or_inline_element);
763        once(e.into())
764    }
765    #[must_use]
766    fn transform_field_body(&mut self, mut e: e::FieldBody) -> impl Iterator<Item = c::SubField> {
767        self.transform_children(&mut e, Self::transform_body_element);
768        once(e.into())
769    }
770    #[must_use]
771    fn transform_option_list_item(
772        &mut self,
773        mut e: e::OptionListItem,
774    ) -> impl Iterator<Item = e::OptionListItem> {
775        self.transform_children(&mut e, Self::transform_sub_option_list_item);
776        once(e)
777    }
778    #[must_use]
779    fn transform_option_group(
780        &mut self,
781        mut e: e::OptionGroup,
782    ) -> impl Iterator<Item = c::SubOptionListItem> {
783        self.transform_children(&mut e, Self::transform_option);
784        once(e.into())
785    }
786    #[must_use]
787    fn transform_description(
788        &mut self,
789        mut e: e::Description,
790    ) -> impl Iterator<Item = c::SubOptionListItem> {
791        self.transform_children(&mut e, Self::transform_body_element);
792        once(e.into())
793    }
794    #[must_use]
795    fn transform_option(&mut self, mut e: e::Option_) -> impl Iterator<Item = e::Option_> {
796        self.transform_children(&mut e, Self::transform_sub_option);
797        once(e)
798    }
799    #[must_use]
800    fn transform_option_string(
801        &mut self,
802        mut e: e::OptionString,
803    ) -> impl Iterator<Item = c::SubOption> {
804        self.transform_children(&mut e, Self::transform_string);
805        once(e.into())
806    }
807    #[must_use]
808    fn transform_option_argument(
809        &mut self,
810        mut e: e::OptionArgument,
811    ) -> impl Iterator<Item = c::SubOption> {
812        self.transform_children(&mut e, Self::transform_string);
813        once(e.into())
814    }
815    #[must_use]
816    fn transform_line(&mut self, mut e: e::Line) -> impl Iterator<Item = c::SubLineBlock> {
817        self.transform_children(&mut e, Self::transform_text_or_inline_element);
818        once(e.into())
819    }
820    #[must_use]
821    fn transform_attribution(
822        &mut self,
823        mut e: e::Attribution,
824    ) -> impl Iterator<Item = c::SubBlockQuote> {
825        self.transform_children(&mut e, Self::transform_text_or_inline_element);
826        once(e.into())
827    }
828    #[must_use]
829    fn transform_label(&mut self, mut e: e::Label) -> impl Iterator<Item = c::SubFootnote> {
830        self.transform_children(&mut e, Self::transform_text_or_inline_element);
831        once(e.into())
832    }
833    #[must_use]
834    fn transform_caption(&mut self, mut e: e::Caption) -> impl Iterator<Item = c::SubFigure> {
835        self.transform_children(&mut e, Self::transform_text_or_inline_element);
836        once(e.into())
837    }
838    #[must_use]
839    fn transform_legend(&mut self, mut e: e::Legend) -> impl Iterator<Item = c::SubFigure> {
840        self.transform_children(&mut e, Self::transform_body_element);
841        once(e.into())
842    }
843
844    //inline elements
845    #[must_use]
846    fn transform_string(&mut self, e: String) -> impl Iterator<Item = String> {
847        once(e)
848    }
849    #[must_use]
850    fn transform_emphasis(
851        &mut self,
852        mut e: e::Emphasis,
853    ) -> impl Iterator<Item = c::TextOrInlineElement> {
854        self.transform_children(&mut e, Self::transform_text_or_inline_element);
855        once(e.into())
856    }
857    #[must_use]
858    fn transform_literal(
859        &mut self,
860        mut e: e::Literal,
861    ) -> impl Iterator<Item = c::TextOrInlineElement> {
862        self.transform_children(&mut e, Self::transform_string);
863        once(e.into())
864    }
865    #[must_use]
866    fn transform_reference(
867        &mut self,
868        mut e: e::Reference,
869    ) -> impl Iterator<Item = c::TextOrInlineElement> {
870        self.transform_children(&mut e, Self::transform_text_or_inline_element);
871        once(e.into())
872    }
873    #[must_use]
874    fn transform_strong(
875        &mut self,
876        mut e: e::Strong,
877    ) -> impl Iterator<Item = c::TextOrInlineElement> {
878        self.transform_children(&mut e, Self::transform_text_or_inline_element);
879        once(e.into())
880    }
881    #[must_use]
882    fn transform_footnote_reference(
883        &mut self,
884        mut e: e::FootnoteReference,
885    ) -> impl Iterator<Item = c::TextOrInlineElement> {
886        self.transform_children(&mut e, Self::transform_text_or_inline_element);
887        once(e.into())
888    }
889    #[must_use]
890    fn transform_citation_reference(
891        &mut self,
892        mut e: e::CitationReference,
893    ) -> impl Iterator<Item = c::TextOrInlineElement> {
894        self.transform_children(&mut e, Self::transform_text_or_inline_element);
895        once(e.into())
896    }
897    #[must_use]
898    fn transform_substitution_reference(
899        &mut self,
900        mut e: e::SubstitutionReference,
901    ) -> impl Iterator<Item = c::TextOrInlineElement> {
902        self.transform_children(&mut e, Self::transform_text_or_inline_element);
903        once(e.into())
904    }
905    #[must_use]
906    fn transform_title_reference(
907        &mut self,
908        mut e: e::TitleReference,
909    ) -> impl Iterator<Item = c::TextOrInlineElement> {
910        self.transform_children(&mut e, Self::transform_text_or_inline_element);
911        once(e.into())
912    }
913    #[must_use]
914    fn transform_abbreviation(
915        &mut self,
916        mut e: e::Abbreviation,
917    ) -> impl Iterator<Item = c::TextOrInlineElement> {
918        self.transform_children(&mut e, Self::transform_text_or_inline_element);
919        once(e.into())
920    }
921    #[must_use]
922    fn transform_acronym(
923        &mut self,
924        mut e: e::Acronym,
925    ) -> impl Iterator<Item = c::TextOrInlineElement> {
926        self.transform_children(&mut e, Self::transform_text_or_inline_element);
927        once(e.into())
928    }
929    #[must_use]
930    fn transform_superscript(
931        &mut self,
932        mut e: e::Superscript,
933    ) -> impl Iterator<Item = c::TextOrInlineElement> {
934        self.transform_children(&mut e, Self::transform_text_or_inline_element);
935        once(e.into())
936    }
937    #[must_use]
938    fn transform_subscript(
939        &mut self,
940        mut e: e::Subscript,
941    ) -> impl Iterator<Item = c::TextOrInlineElement> {
942        self.transform_children(&mut e, Self::transform_text_or_inline_element);
943        once(e.into())
944    }
945    #[must_use]
946    fn transform_inline(
947        &mut self,
948        mut e: e::Inline,
949    ) -> impl Iterator<Item = c::TextOrInlineElement> {
950        self.transform_children(&mut e, Self::transform_text_or_inline_element);
951        once(e.into())
952    }
953    #[must_use]
954    fn transform_problematic(
955        &mut self,
956        mut e: e::Problematic,
957    ) -> impl Iterator<Item = c::TextOrInlineElement> {
958        self.transform_children(&mut e, Self::transform_text_or_inline_element);
959        once(e.into())
960    }
961    #[must_use]
962    fn transform_generated(
963        &mut self,
964        mut e: e::Generated,
965    ) -> impl Iterator<Item = c::TextOrInlineElement> {
966        self.transform_children(&mut e, Self::transform_text_or_inline_element);
967        once(e.into())
968    }
969    #[must_use]
970    fn transform_math(&mut self, mut e: e::Math) -> impl Iterator<Item = c::TextOrInlineElement> {
971        self.transform_children(&mut e, Self::transform_string);
972        once(e.into())
973    }
974    #[must_use]
975    fn transform_target_inline(
976        &mut self,
977        mut e: e::TargetInline,
978    ) -> impl Iterator<Item = c::TextOrInlineElement> {
979        self.transform_children(&mut e, Self::transform_string);
980        once(e.into())
981    }
982    #[must_use]
983    fn transform_raw_inline(
984        &mut self,
985        mut e: e::RawInline,
986    ) -> impl Iterator<Item = c::TextOrInlineElement> {
987        self.transform_children(&mut e, Self::transform_string);
988        once(e.into())
989    }
990    #[must_use]
991    fn transform_image_inline(
992        &mut self,
993        e: e::ImageInline,
994    ) -> impl Iterator<Item = c::TextOrInlineElement> {
995        once(e.into())
996    }
997}
rst_parser/transforms/transform.rs

rst_parser/transforms/
transform.rs
