Source code
Revision control
Copy as Markdown
Other Tools
use serde_spanned::Spanned;
use crate::alloc_prelude::*;
use crate::de::DeValue;
/// Type representing a TOML array, payload of the `DeValue::Array` variant
#[derive(Clone)]
pub struct DeArray<'i> {
items: Vec<Spanned<DeValue<'i>>>,
array_of_tables: bool,
}
impl<'i> DeArray<'i> {
/// Constructs a new, empty `DeArray`.
///
/// This will not allocate until elements are pushed onto it.
pub const fn new() -> Self {
Self {
items: Vec::new(),
array_of_tables: false,
}
}
/// Appends an element to the back of a collection.
///
/// # Panics
///
/// Panics if the new capacity exceeds `isize::MAX` _bytes_.
pub fn push(&mut self, value: Spanned<DeValue<'i>>) {
self.items.push(value);
}
}
impl DeArray<'_> {
pub(crate) fn is_array_of_tables(&self) -> bool {
self.array_of_tables
}
pub(crate) fn set_array_of_tables(&mut self, yes: bool) {
self.array_of_tables = yes;
}
}
impl<'i> core::ops::Deref for DeArray<'i> {
type Target = [Spanned<DeValue<'i>>];
#[inline]
fn deref(&self) -> &[Spanned<DeValue<'i>>] {
self.items.as_slice()
}
}
impl<'i> core::ops::DerefMut for DeArray<'i> {
#[inline]
fn deref_mut(&mut self) -> &mut [Spanned<DeValue<'i>>] {
self.items.as_mut_slice()
}
}
impl<'i> AsRef<[Spanned<DeValue<'i>>]> for DeArray<'i> {
fn as_ref(&self) -> &[Spanned<DeValue<'i>>] {
&self.items
}
}
impl<'i> AsMut<[Spanned<DeValue<'i>>]> for DeArray<'i> {
fn as_mut(&mut self) -> &mut [Spanned<DeValue<'i>>] {
&mut self.items
}
}
impl<'i> core::borrow::Borrow<[Spanned<DeValue<'i>>]> for DeArray<'i> {
fn borrow(&self) -> &[Spanned<DeValue<'i>>] {
&self.items[..]
}
}
impl<'i> core::borrow::BorrowMut<[Spanned<DeValue<'i>>]> for DeArray<'i> {
fn borrow_mut(&mut self) -> &mut [Spanned<DeValue<'i>>] {
&mut self.items[..]
}
}
impl<'i, I: core::slice::SliceIndex<[Spanned<DeValue<'i>>]>> core::ops::Index<I> for DeArray<'i> {
type Output = I::Output;
#[inline]
fn index(&self, index: I) -> &Self::Output {
self.items.index(index)
}
}
impl<'a, 'i> IntoIterator for &'a DeArray<'i> {
type Item = &'a Spanned<DeValue<'i>>;
type IntoIter = core::slice::Iter<'a, Spanned<DeValue<'i>>>;
fn into_iter(self) -> Self::IntoIter {
self.iter()
}
}
impl<'i> IntoIterator for DeArray<'i> {
type Item = Spanned<DeValue<'i>>;
type IntoIter = alloc::vec::IntoIter<Spanned<DeValue<'i>>>;
#[inline]
fn into_iter(self) -> Self::IntoIter {
self.items.into_iter()
}
}
impl<'i> FromIterator<Spanned<DeValue<'i>>> for DeArray<'i> {
#[inline]
#[track_caller]
fn from_iter<I: IntoIterator<Item = Spanned<DeValue<'i>>>>(iter: I) -> Self {
Self {
items: iter.into_iter().collect(),
array_of_tables: false,
}
}
}
impl Default for DeArray<'static> {
#[inline]
fn default() -> Self {
Self {
items: Default::default(),
array_of_tables: false,
}
}
}
impl core::fmt::Debug for DeArray<'_> {
#[inline]
fn fmt(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
self.items.fmt(formatter)
}
}