Skip to content

Reduce serde and iterator forwarding boilerplate #65

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
jskoiz wants to merge 1 commit into
base: main
Choose a base branch
from
Open

Reduce serde and iterator forwarding boilerplate #65

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
222 changes: 63 additions & 159 deletions src/ast.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -1782,63 +1782,77 @@ where
}
}

/// Iterator over borrowed mapping key/value pairs.
pub struct Iter<'a> {
iter: std::slice::Iter<'a, (Value, Value)>,
}
/// Generates the `Iterator`/`DoubleEndedIterator`/`ExactSizeIterator` trio for a
/// mapping view that projects the inner `(Value, Value)` pair iterator. The first
/// arm handles borrowed views (with a lifetime), the second owning views.
macro_rules! mapping_projection_iter {
($name:ident<$lt:lifetime>, $item:ty, |$pair:pat_param| $proj:expr) => {
impl<$lt> Iterator for $name<$lt> {
type Item = $item;

fn next(&mut self) -> Option<Self::Item> {
self.iter.next().map(|$pair| $proj)
}

impl<'a> Iterator for Iter<'a> {
type Item = (&'a Value, &'a Value);
fn size_hint(&self) -> (usize, Option<usize>) {
self.iter.size_hint()
}
}

fn next(&mut self) -> Option<Self::Item> {
self.iter.next().map(|(key, value)| (key, value))
}
impl DoubleEndedIterator for $name<'_> {
fn next_back(&mut self) -> Option<Self::Item> {
self.iter.next_back().map(|$pair| $proj)
}
}

fn size_hint(&self) -> (usize, Option<usize>) {
self.iter.size_hint()
}
}
impl ExactSizeIterator for $name<'_> {
fn len(&self) -> usize {
self.iter.len()
}
}
};
($name:ident, $item:ty, |$pair:pat_param| $proj:expr) => {
impl Iterator for $name {
type Item = $item;

impl DoubleEndedIterator for Iter<'_> {
fn next_back(&mut self) -> Option<Self::Item> {
self.iter.next_back().map(|(key, value)| (key, value))
}
fn next(&mut self) -> Option<Self::Item> {
self.iter.next().map(|$pair| $proj)
}

fn size_hint(&self) -> (usize, Option<usize>) {
self.iter.size_hint()
}
}

impl DoubleEndedIterator for $name {
fn next_back(&mut self) -> Option<Self::Item> {
self.iter.next_back().map(|$pair| $proj)
}
}

impl ExactSizeIterator for $name {
fn len(&self) -> usize {
self.iter.len()
}
}
};
}

impl ExactSizeIterator for Iter<'_> {
fn len(&self) -> usize {
self.iter.len()
}
/// Iterator over borrowed mapping key/value pairs.
pub struct Iter<'a> {
iter: std::slice::Iter<'a, (Value, Value)>,
}

mapping_projection_iter!(Iter<'a>, (&'a Value, &'a Value), |(key, value)| (key, value));

/// Iterator over borrowed mapping keys and mutable values.
pub struct IterMut<'a> {
iter: std::slice::IterMut<'a, (Value, Value)>,
}

impl<'a> Iterator for IterMut<'a> {
type Item = (&'a Value, &'a mut Value);

fn next(&mut self) -> Option<Self::Item> {
self.iter.next().map(|(key, value)| (&*key, value))
}

fn size_hint(&self) -> (usize, Option<usize>) {
self.iter.size_hint()
}
}

impl DoubleEndedIterator for IterMut<'_> {
fn next_back(&mut self) -> Option<Self::Item> {
self.iter.next_back().map(|(key, value)| (&*key, value))
}
}

impl ExactSizeIterator for IterMut<'_> {
fn len(&self) -> usize {
self.iter.len()
}
}
mapping_projection_iter!(IterMut<'a>, (&'a Value, &'a mut Value), |(key, value)| (
&*key, value
));

/// Owning iterator over mapping key/value pairs.
pub struct IntoIter {
Expand Down Expand Up @@ -1874,145 +1888,35 @@ pub struct Keys<'a> {
iter: std::slice::Iter<'a, (Value, Value)>,
}

impl<'a> Iterator for Keys<'a> {
type Item = &'a Value;

fn next(&mut self) -> Option<Self::Item> {
self.iter.next().map(|(key, _)| key)
}

fn size_hint(&self) -> (usize, Option<usize>) {
self.iter.size_hint()
}
}

impl DoubleEndedIterator for Keys<'_> {
fn next_back(&mut self) -> Option<Self::Item> {
self.iter.next_back().map(|(key, _)| key)
}
}

impl ExactSizeIterator for Keys<'_> {
fn len(&self) -> usize {
self.iter.len()
}
}
mapping_projection_iter!(Keys<'a>, &'a Value, |(key, _)| key);

/// Owning iterator over mapping keys.
pub struct IntoKeys {
iter: std::vec::IntoIter<(Value, Value)>,
}

impl Iterator for IntoKeys {
type Item = Value;

fn next(&mut self) -> Option<Self::Item> {
self.iter.next().map(|(key, _)| key)
}

fn size_hint(&self) -> (usize, Option<usize>) {
self.iter.size_hint()
}
}

impl DoubleEndedIterator for IntoKeys {
fn next_back(&mut self) -> Option<Self::Item> {
self.iter.next_back().map(|(key, _)| key)
}
}

impl ExactSizeIterator for IntoKeys {
fn len(&self) -> usize {
self.iter.len()
}
}
mapping_projection_iter!(IntoKeys, Value, |(key, _)| key);

/// Iterator over borrowed mapping values.
pub struct Values<'a> {
iter: std::slice::Iter<'a, (Value, Value)>,
}

impl<'a> Iterator for Values<'a> {
type Item = &'a Value;

fn next(&mut self) -> Option<Self::Item> {
self.iter.next().map(|(_, value)| value)
}

fn size_hint(&self) -> (usize, Option<usize>) {
self.iter.size_hint()
}
}

impl DoubleEndedIterator for Values<'_> {
fn next_back(&mut self) -> Option<Self::Item> {
self.iter.next_back().map(|(_, value)| value)
}
}

impl ExactSizeIterator for Values<'_> {
fn len(&self) -> usize {
self.iter.len()
}
}
mapping_projection_iter!(Values<'a>, &'a Value, |(_, value)| value);

/// Iterator over mutable mapping values.
pub struct ValuesMut<'a> {
iter: std::slice::IterMut<'a, (Value, Value)>,
}

impl<'a> Iterator for ValuesMut<'a> {
type Item = &'a mut Value;

fn next(&mut self) -> Option<Self::Item> {
self.iter.next().map(|(_, value)| value)
}

fn size_hint(&self) -> (usize, Option<usize>) {
self.iter.size_hint()
}
}

impl DoubleEndedIterator for ValuesMut<'_> {
fn next_back(&mut self) -> Option<Self::Item> {
self.iter.next_back().map(|(_, value)| value)
}
}

impl ExactSizeIterator for ValuesMut<'_> {
fn len(&self) -> usize {
self.iter.len()
}
}
mapping_projection_iter!(ValuesMut<'a>, &'a mut Value, |(_, value)| value);

/// Owning iterator over mapping values.
pub struct IntoValues {
iter: std::vec::IntoIter<(Value, Value)>,
}

impl Iterator for IntoValues {
type Item = Value;

fn next(&mut self) -> Option<Self::Item> {
self.iter.next().map(|(_, value)| value)
}

fn size_hint(&self) -> (usize, Option<usize>) {
self.iter.size_hint()
}
}

impl DoubleEndedIterator for IntoValues {
fn next_back(&mut self) -> Option<Self::Item> {
self.iter.next_back().map(|(_, value)| value)
}
}

impl ExactSizeIterator for IntoValues {
fn len(&self) -> usize {
self.iter.len()
}
}
mapping_projection_iter!(IntoValues, Value, |(_, value)| value);

/// Entry view into a [`Mapping`].
pub enum Entry<'a> {
Expand Down
18 changes: 0 additions & 18 deletions src/event_de/source.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -631,24 +631,6 @@ impl<'de> EventSource<'de> {
}
}

fn scalar_key_at(&self, pos: usize) -> Result<Option<(Node, usize)>> {
self.scalar_key_at_in(&self.events, pos)
}

fn scalar_key_at_in(&self, events: &[Event], pos: usize) -> Result<Option<(Node, usize)>> {
let Some(Event::Scalar {
value,
style,
meta,
span,
}) = events.get(pos)
else {
return Ok(None);
};
self.scalar_from_event(value.clone(), *style, meta, *span)
.map(|node| Some((node, pos + 1)))
}

fn scalar_key_node_from_event(
&self,
value: String,
Expand Down
Loading
Loading