ltk_meta 0.6.0

Metadata formats and utilities for League Toolkit
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84

use crate::{
    property::values::{self},
    traits::PropertyValueDyn,
    PropertyValueEnum,
};

pub struct ItemsDyn<'a, M>(ItemsDynInner<'a, M>);
impl<'a, M> Iterator for ItemsDyn<'a, M> {
    type Item = &'a dyn PropertyValueDyn<Meta = M>;

    fn next(&mut self) -> Option<Self::Item> {
        self.0.next()
    }
}
impl<'a, M> From<ItemsDynInner<'a, M>> for ItemsDyn<'a, M> {
    fn from(value: ItemsDynInner<'a, M>) -> Self {
        Self(value)
    }
}

pub struct IntoItems<M>(IntoItemsInner<M>);
impl<M> Iterator for IntoItems<M> {
    type Item = PropertyValueEnum<M>;

    fn next(&mut self) -> Option<Self::Item> {
        self.0.next()
    }
}
impl<M> From<IntoItemsInner<M>> for IntoItems<M> {
    fn from(value: IntoItemsInner<M>) -> Self {
        Self(value)
    }
}

macro_rules! define_dyn_iter {
    ( [$( $variant:ident, )*] ) => {
        pub(super) enum ItemsDynInner<'a, M> {
            $($variant(std::slice::Iter<'a, values::$variant<M>>),)*
        }

        impl<'a, M> Iterator for ItemsDynInner<'a, M> {
            type Item = &'a dyn PropertyValueDyn<Meta = M>;

            fn next(&mut self) -> Option<Self::Item> {
                match self {
                    $(Self::$variant(it) => it.next().map(|x| x as _),)*
                }
            }
        }

        $(
            impl<'a, M> From<std::slice::Iter<'a, values::$variant<M>>> for ItemsDynInner<'a, M> {
                fn from(other: std::slice::Iter<'a, values::$variant<M>>) -> Self {
                    Self::$variant(other)
                }
            }
        )*


        pub(super) enum IntoItemsInner<M> {
            $($variant(std::vec::IntoIter<values::$variant<M>>),)*
        }
        impl<M> Iterator for IntoItemsInner<M> {
            type Item = PropertyValueEnum<M>;

            fn next(&mut self) -> Option<Self::Item> {
                match self {
                    $(Self::$variant(it) => it.next().map(|x| x.into()),)*
                }
            }
        }

        $(
            impl<M> From<std::vec::IntoIter<values::$variant<M>>> for IntoItemsInner<M> {
                fn from(other: std::vec::IntoIter<values::$variant<M>>) -> Self {
                    Self::$variant(other)
                }
            }
        )*

    };
}

container_variants!(define_dyn_iter);