use alloc::fmt;
use serde::{
Deserialize,
Serialize,
};
use crate::data::catalog::document::{
AliasEntry,
AxisEntry,
BuildEntry,
ContractEntry,
FacetEntry,
GroupEntry,
OrderedNode,
ReleaseEntry,
ResourceEntry,
TagEntry,
TemplateClassEntry,
TypeEntry,
keyed,
};
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum EntryKind {
Namespace,
Contract,
Release,
Build,
TemplateClass,
Tag,
Axis,
Facet,
Resource,
Alias,
Type,
}
impl EntryKind {
pub const ALL: [EntryKind; 11] = [
Self::Namespace,
Self::Contract,
Self::Release,
Self::Build,
Self::TemplateClass,
Self::Tag,
Self::Axis,
Self::Facet,
Self::Resource,
Self::Alias,
Self::Type,
];
pub fn is_group(self) -> bool {
matches!(self, Self::Namespace | Self::Release)
}
pub fn is_container_group(self) -> bool {
matches!(self, Self::Namespace)
}
pub fn from_name(name: &str) -> Option<Self> {
Self::ALL.into_iter().find(|k| k.as_str() == name)
}
pub fn as_str(self) -> &'static str {
match self {
Self::Namespace => "namespace",
Self::Contract => "contract",
Self::Release => "release",
Self::Build => "build",
Self::TemplateClass => "template_class",
Self::Tag => "tag",
Self::Axis => "axis",
Self::Facet => "facet",
Self::Resource => "resource",
Self::Alias => "alias",
Self::Type => "type",
}
}
}
impl Serialize for EntryKind {
fn serialize<S: serde::Serializer>(
&self,
serializer: S,
) -> Result<S::Ok, S::Error> {
serializer.serialize_str(self.as_str())
}
}
impl<'de> Deserialize<'de> for EntryKind {
fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
let name = String::deserialize(deserializer)?;
Self::from_name(&name)
.ok_or_else(|| serde::de::Error::custom(format!("`{name}` is not a kind")))
}
}
impl fmt::Display for EntryKind {
fn fmt(
&self,
f: &mut fmt::Formatter<'_>,
) -> fmt::Result {
f.write_str(self.as_str())
}
}
#[derive(Clone, Debug, PartialEq)]
pub enum CatalogEntry {
Namespace(GroupEntry),
Contract(ContractEntry),
Release(ReleaseEntry),
Build(BuildEntry),
TemplateClass(TemplateClassEntry),
Tag(TagEntry),
Axis(AxisEntry),
Facet(FacetEntry),
Resource(ResourceEntry),
Alias(AliasEntry),
Type(TypeEntry),
}
impl CatalogEntry {
pub fn to_node(&self) -> OrderedNode {
keyed::write_entry(self)
}
pub fn kind(&self) -> EntryKind {
match self {
Self::Namespace(_) => EntryKind::Namespace,
Self::Contract(_) => EntryKind::Contract,
Self::Release(_) => EntryKind::Release,
Self::Build(_) => EntryKind::Build,
Self::TemplateClass(_) => EntryKind::TemplateClass,
Self::Tag(_) => EntryKind::Tag,
Self::Axis(_) => EntryKind::Axis,
Self::Facet(_) => EntryKind::Facet,
Self::Resource(_) => EntryKind::Resource,
Self::Alias(_) => EntryKind::Alias,
Self::Type(_) => EntryKind::Type,
}
}
pub fn name(&self) -> &str {
match self {
Self::Namespace(e) => &e.name,
Self::Contract(e) => &e.name,
Self::Release(e) => &e.name,
Self::Build(e) => &e.name,
Self::TemplateClass(e) => &e.name,
Self::Tag(e) => &e.name,
Self::Axis(e) => &e.name,
Self::Facet(e) => &e.name,
Self::Resource(e) => &e.name,
Self::Alias(e) => &e.name,
Self::Type(e) => &e.name,
}
}
pub fn children(&self) -> &[CatalogEntry] {
match self {
Self::Namespace(e) => &e.children,
Self::Contract(e) => &e.children,
Self::Build(e) => &e.children,
_ => &[],
}
}
pub(crate) fn take_children(&mut self) -> Vec<CatalogEntry> {
match self {
Self::Namespace(e) => core::mem::take(&mut e.children),
Self::Contract(e) => core::mem::take(&mut e.children),
Self::Build(e) => core::mem::take(&mut e.children),
_ => Vec::new(),
}
}
pub fn merge(&self) -> MergeMode {
match self {
Self::Namespace(e) => e.merge,
Self::Contract(e) => e.merge,
Self::Release(e) => e.merge,
Self::Build(e) => e.merge,
Self::TemplateClass(e) => e.merge,
Self::Tag(e) => e.merge,
Self::Axis(e) => e.merge,
Self::Facet(e) => e.merge,
Self::Resource(e) => e.merge,
Self::Alias(e) => e.merge,
Self::Type(e) => e.merge,
}
}
pub fn as_group(&self) -> Option<&GroupEntry> {
match self {
Self::Namespace(e) => Some(e),
_ => None,
}
}
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum MergeMode {
#[default]
Deny,
Update,
Replace,
}
impl MergeMode {
pub fn is_deny(&self) -> bool {
*self == Self::Deny
}
pub fn update() -> Self {
Self::Update
}
pub fn is_update(&self) -> bool {
*self == Self::Update
}
}