use std::fmt;
use rustc_hash::FxHashMap;
use crate::ast::{Definition, Document, FragmentDefinition};
const INLINE_FRAGMENTS: usize = 8;
#[derive(Clone)]
pub(crate) struct FragmentIndex<'a> {
entries: Vec<(&'a str, usize)>,
index: Option<FxHashMap<&'a str, usize>>,
}
impl<'a> FragmentIndex<'a> {
#[must_use]
pub(crate) fn new(document: &Document<'a>) -> Self {
let mut entries: Vec<(&'a str, usize)> = Vec::new();
for (position, definition) in document.definitions.iter().enumerate() {
let Definition::Fragment(fragment) = definition else {
continue;
};
if entries.iter().any(|(name, _)| *name == fragment.name) {
continue;
}
entries.push((fragment.name, position));
}
let index = (entries.len() > INLINE_FRAGMENTS).then(|| {
entries
.iter()
.enumerate()
.map(|(position, (name, _))| (*name, position))
.collect()
});
Self { entries, index }
}
#[inline]
fn position(&self, name: &str) -> Option<usize> {
match &self.index {
Some(index) => index.get(name).map(|position| self.entries[*position].1),
None => self
.entries
.iter()
.find(|(known, _)| *known == name)
.map(|(_, position)| *position),
}
}
fn len(&self) -> usize {
self.entries.len()
}
}
#[derive(Clone)]
pub struct Fragments<'a> {
inner: FragmentsInner<'a>,
}
#[derive(Clone)]
enum FragmentsInner<'a> {
Small {
entries: [Option<(&'a str, &'a FragmentDefinition<'a>)>; INLINE_FRAGMENTS],
len: u8,
},
Large {
entries: Vec<(&'a str, &'a FragmentDefinition<'a>)>,
index: FxHashMap<&'a str, usize>,
},
Prepared {
document: &'a Document<'a>,
index: &'a FragmentIndex<'a>,
},
}
impl<'a> Fragments<'a> {
#[must_use]
pub fn empty() -> Self {
Self {
inner: FragmentsInner::Small {
entries: [None; INLINE_FRAGMENTS],
len: 0,
},
}
}
#[must_use]
pub fn new(document: &'a Document<'a>) -> Self {
let mut entries = [None; INLINE_FRAGMENTS];
let mut len = 0usize;
let mut fragments = document.fragments();
for fragment in fragments.by_ref() {
if len == INLINE_FRAGMENTS {
let mut order: Vec<(&'a str, &'a FragmentDefinition<'a>)> =
entries.iter().flatten().copied().collect();
let mut index = FxHashMap::with_capacity_and_hasher(
document.fragments().count(),
Default::default(),
);
for (position, (name, _)) in order.iter().enumerate() {
index.entry(*name).or_insert(position);
}
if let std::collections::hash_map::Entry::Vacant(entry) = index.entry(fragment.name)
{
entry.insert(order.len());
order.push((fragment.name, fragment));
}
for fragment in fragments {
if let std::collections::hash_map::Entry::Vacant(entry) =
index.entry(fragment.name)
{
entry.insert(order.len());
order.push((fragment.name, fragment));
}
}
return Self {
inner: FragmentsInner::Large {
entries: order,
index,
},
};
}
entries[len] = Some((fragment.name, fragment));
len += 1;
}
Self {
inner: FragmentsInner::Small {
entries,
len: len as u8,
},
}
}
#[must_use]
pub(crate) fn prepared(document: &'a Document<'a>, index: &'a FragmentIndex<'a>) -> Self {
Self {
inner: FragmentsInner::Prepared { document, index },
}
}
#[must_use]
pub fn get(&self, name: &str) -> Option<&'a FragmentDefinition<'a>> {
match &self.inner {
FragmentsInner::Small { entries, len } => entries[..usize::from(*len)]
.iter()
.flatten()
.find(|(known, _)| *known == name)
.map(|(_, fragment)| *fragment),
FragmentsInner::Large { entries, index } => {
index.get(name).map(|position| entries[*position].1)
}
FragmentsInner::Prepared { document, index } => {
let position = index.position(name)?;
match document.definitions.get(position) {
Some(Definition::Fragment(fragment)) => Some(fragment),
_ => None,
}
}
}
}
#[must_use]
pub fn contains(&self, name: &str) -> bool {
self.get(name).is_some()
}
#[must_use]
pub fn len(&self) -> usize {
match &self.inner {
FragmentsInner::Small { len, .. } => usize::from(*len),
FragmentsInner::Large { entries, .. } => entries.len(),
FragmentsInner::Prepared { index, .. } => index.len(),
}
}
#[must_use]
pub fn is_empty(&self) -> bool {
self.len() == 0
}
pub fn iter(&self) -> FragmentsIter<'_, 'a> {
match &self.inner {
FragmentsInner::Small { entries, len } => {
FragmentsIter::Small(entries[..usize::from(*len)].iter())
}
FragmentsInner::Large { entries, .. } => FragmentsIter::Large(entries.iter()),
FragmentsInner::Prepared { document, index } => {
FragmentsIter::Prepared(index.entries.iter(), document)
}
}
}
}
impl<'a> From<&'a Document<'a>> for Fragments<'a> {
fn from(document: &'a Document<'a>) -> Self {
Self::new(document)
}
}
impl<'b, 'a> IntoIterator for &'b Fragments<'a> {
type Item = &'a FragmentDefinition<'a>;
type IntoIter = FragmentsIter<'b, 'a>;
fn into_iter(self) -> Self::IntoIter {
self.iter()
}
}
impl fmt::Debug for Fragments<'_> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_map()
.entries(self.iter().map(|fragment| (fragment.name, fragment)))
.finish()
}
}
pub enum FragmentsIter<'b, 'a> {
Small(std::slice::Iter<'b, Option<(&'a str, &'a FragmentDefinition<'a>)>>),
Large(std::slice::Iter<'b, (&'a str, &'a FragmentDefinition<'a>)>),
Prepared(std::slice::Iter<'a, (&'a str, usize)>, &'a Document<'a>),
}
impl<'a> Iterator for FragmentsIter<'_, 'a> {
type Item = &'a FragmentDefinition<'a>;
fn next(&mut self) -> Option<Self::Item> {
match self {
Self::Small(iter) => iter.find_map(|entry| entry.map(|(_, fragment)| fragment)),
Self::Large(iter) => iter.next().map(|(_, fragment)| *fragment),
Self::Prepared(entries, document) => loop {
let (_, position) = entries.next()?;
if let Some(Definition::Fragment(fragment)) = document.definitions.get(*position) {
return Some(fragment);
}
},
}
}
fn size_hint(&self) -> (usize, Option<usize>) {
match self {
Self::Small(iter) => (0, iter.size_hint().1),
Self::Large(iter) => iter.size_hint(),
Self::Prepared(entries, _) => (0, entries.size_hint().1),
}
}
}
impl fmt::Debug for FragmentsIter<'_, '_> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("FragmentsIter").finish_non_exhaustive()
}
}