time/format_description/
owned_format_item.rs

Help
1//! A format item with owned data.
2
3use alloc::boxed::Box;
4use alloc::string::String;
5use alloc::vec::Vec;
6use core::fmt;
7
8use crate::error;
9use crate::format_description::{BorrowedFormatItem, Component};
10
11/// A complete description of how to format and parse a type.
12#[non_exhaustive]
13#[derive(Clone, PartialEq, Eq)]
14pub enum OwnedFormatItem {
15    /// Bytes that are formatted as-is.
16    ///
17    /// **Note**: These bytes **should** be UTF-8, but are not required to be. The value is passed
18    /// through `String::from_utf8_lossy` when necessary.
19    Literal(Box<[u8]>),
20    /// A minimal representation of a single non-literal item.
21    Component(Component),
22    /// A series of literals or components that collectively form a partial or complete
23    /// description.
24    Compound(Box<[Self]>),
25    /// A `FormatItem` that may or may not be present when parsing. If parsing fails, there
26    /// will be no effect on the resulting `struct`.
27    ///
28    /// This variant has no effect on formatting, as the value is guaranteed to be present.
29    Optional(Box<Self>),
30    /// A series of `FormatItem`s where, when parsing, the first successful parse is used. When
31    /// formatting, the first element of the [`Vec`] is used. An empty [`Vec`] is a no-op when
32    /// formatting or parsing.
33    First(Box<[Self]>),
34}
35
36impl fmt::Debug for OwnedFormatItem {
37    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
38        match self {
39            Self::Literal(literal) => f.write_str(&String::from_utf8_lossy(literal)),
40            Self::Component(component) => component.fmt(f),
41            Self::Compound(compound) => compound.fmt(f),
42            Self::Optional(item) => f.debug_tuple("Optional").field(item).finish(),
43            Self::First(items) => f.debug_tuple("First").field(items).finish(),
44        }
45    }
46}
47
48impl From<BorrowedFormatItem<'_>> for OwnedFormatItem {
49    fn from(item: BorrowedFormatItem<'_>) -> Self {
50        (&item).into()
51    }
52}
53
54impl From<&BorrowedFormatItem<'_>> for OwnedFormatItem {
55    fn from(item: &BorrowedFormatItem<'_>) -> Self {
56        match item {
57            BorrowedFormatItem::Literal(literal) => {
58                Self::Literal(literal.to_vec().into_boxed_slice())
59            }
60            BorrowedFormatItem::Component(component) => Self::Component(*component),
61            BorrowedFormatItem::Compound(compound) => Self::Compound(
62                compound
63                    .iter()
64                    .cloned()
65                    .map(Into::into)
66                    .collect::<Vec<_>>()
67                    .into_boxed_slice(),
68            ),
69            BorrowedFormatItem::Optional(item) => Self::Optional(Box::new((*item).into())),
70            BorrowedFormatItem::First(items) => Self::First(
71                items
72                    .iter()
73                    .cloned()
74                    .map(Into::into)
75                    .collect::<Vec<_>>()
76                    .into_boxed_slice(),
77            ),
78        }
79    }
80}
81
82impl From<Vec<BorrowedFormatItem<'_>>> for OwnedFormatItem {
83    fn from(items: Vec<BorrowedFormatItem<'_>>) -> Self {
84        items.as_slice().into()
85    }
86}
87
88impl<'a, T: AsRef<[BorrowedFormatItem<'a>]> + ?Sized> From<&T> for OwnedFormatItem {
89    fn from(items: &T) -> Self {
90        Self::Compound(
91            items
92                .as_ref()
93                .iter()
94                .cloned()
95                .map(Into::into)
96                .collect::<Vec<_>>()
97                .into_boxed_slice(),
98        )
99    }
100}
101
102impl From<Component> for OwnedFormatItem {
103    fn from(component: Component) -> Self {
104        Self::Component(component)
105    }
106}
107
108impl TryFrom<OwnedFormatItem> for Component {
109    type Error = error::DifferentVariant;
110
111    fn try_from(value: OwnedFormatItem) -> Result<Self, Self::Error> {
112        match value {
113            OwnedFormatItem::Component(component) => Ok(component),
114            _ => Err(error::DifferentVariant),
115        }
116    }
117}
118
119impl From<Vec<Self>> for OwnedFormatItem {
120    fn from(items: Vec<Self>) -> Self {
121        Self::Compound(items.into_boxed_slice())
122    }
123}
124
125impl TryFrom<OwnedFormatItem> for Vec<OwnedFormatItem> {
126    type Error = error::DifferentVariant;
127
128    fn try_from(value: OwnedFormatItem) -> Result<Self, Self::Error> {
129        match value {
130            OwnedFormatItem::Compound(items) => Ok(items.into_vec()),
131            _ => Err(error::DifferentVariant),
132        }
133    }
134}
135
136impl PartialEq<Component> for OwnedFormatItem {
137    fn eq(&self, rhs: &Component) -> bool {
138        matches!(self, Self::Component(component) if component == rhs)
139    }
140}
141
142impl PartialEq<OwnedFormatItem> for Component {
143    fn eq(&self, rhs: &OwnedFormatItem) -> bool {
144        rhs == self
145    }
146}
147
148impl PartialEq<&[Self]> for OwnedFormatItem {
149    fn eq(&self, rhs: &&[Self]) -> bool {
150        matches!(self, Self::Compound(compound) if &&**compound == rhs)
151    }
152}
153
154impl PartialEq<OwnedFormatItem> for &[OwnedFormatItem] {
155    fn eq(&self, rhs: &OwnedFormatItem) -> bool {
156        rhs == self
157    }
158}
time/format_description/owned_format_item.rs

time/format_description/
owned_format_item.rs
