use rkyv::{Archive, Deserialize, Serialize};
#[derive(
Debug,
Clone,
Copy,
PartialEq,
Eq,
Hash,
PartialOrd,
Ord,
Archive,
Serialize,
Deserialize,
serde::Serialize,
serde::Deserialize,
)]
#[rkyv(compare(PartialEq, PartialOrd), derive(PartialEq, Eq, PartialOrd, Ord))]
pub enum EdgeFamily {
Semantic,
Traversal,
Containment,
Arrangement,
Imported,
Provenance,
}
#[derive(
Debug,
Clone,
Copy,
PartialEq,
Eq,
Hash,
PartialOrd,
Ord,
Archive,
Serialize,
Deserialize,
serde::Serialize,
serde::Deserialize,
)]
#[rkyv(compare(PartialEq, PartialOrd), derive(PartialEq, Eq, PartialOrd, Ord))]
#[derive(strum::EnumIter, strum::FromRepr)]
pub enum SemanticSubKind {
Hyperlink,
UserGrouped,
AgentDerived,
Cites,
Quotes,
Summarizes,
Elaborates,
ExampleOf,
Supports,
Contradicts,
Questions,
SameEntityAs,
DuplicateOf,
CanonicalMirrorOf,
DependsOn,
Blocks,
NextStep,
}
#[derive(
Debug,
Clone,
Copy,
PartialEq,
Eq,
Hash,
PartialOrd,
Ord,
Archive,
Serialize,
Deserialize,
serde::Serialize,
serde::Deserialize,
)]
#[rkyv(compare(PartialEq, PartialOrd), derive(PartialEq, Eq, PartialOrd, Ord))]
#[derive(strum::EnumIter, strum::FromRepr)]
pub enum ArrangementSubKind {
FrameMember,
TileGroup,
SplitPair,
}
#[derive(
Debug,
Clone,
Copy,
PartialEq,
Eq,
Hash,
PartialOrd,
Ord,
Archive,
Serialize,
Deserialize,
serde::Serialize,
serde::Deserialize,
)]
#[rkyv(compare(PartialEq, PartialOrd), derive(PartialEq, Eq, PartialOrd, Ord))]
#[derive(strum::EnumIter, strum::FromRepr)]
pub enum ContainmentSubKind {
UrlPath,
Domain,
FileSystem,
UserFolder,
ClipSource,
NotebookSection,
CollectionMember,
}
impl ContainmentSubKind {
pub fn as_tag(self) -> &'static str {
match self {
Self::UrlPath => "url-path",
Self::Domain => "domain",
Self::FileSystem => "filesystem",
Self::UserFolder => "user-folder",
Self::ClipSource => "clip-source",
Self::NotebookSection => "notebook-section",
Self::CollectionMember => "collection-member",
}
}
}
#[derive(
Debug,
Clone,
Copy,
PartialEq,
Eq,
Hash,
PartialOrd,
Ord,
Archive,
Serialize,
Deserialize,
serde::Serialize,
serde::Deserialize,
)]
#[rkyv(compare(PartialEq, PartialOrd), derive(PartialEq, Eq, PartialOrd, Ord))]
#[derive(strum::EnumIter, strum::FromRepr)]
pub enum ImportedSubKind {
BookmarkFolder,
HistoryImport,
SessionImport,
RssMembership,
FileSystemImport,
ArchiveMembership,
SharedCollection,
}
#[derive(
Debug,
Clone,
Copy,
PartialEq,
Eq,
Hash,
PartialOrd,
Ord,
Archive,
Serialize,
Deserialize,
serde::Serialize,
serde::Deserialize,
)]
#[rkyv(compare(PartialEq, PartialOrd), derive(PartialEq, Eq, PartialOrd, Ord))]
#[derive(strum::EnumIter, strum::FromRepr)]
pub enum ProvenanceSubKind {
ClippedFrom,
ExcerptedFrom,
SummarizedFrom,
TranslatedFrom,
RewrittenFrom,
GeneratedFrom,
ExtractedFrom,
ImportedFromSource,
CopiedFrom,
MergedFrom,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Archive, Serialize, Deserialize)]
pub enum RelationDurability {
Durable,
Session,
}
impl RelationDurability {
pub fn as_tag(self) -> &'static str {
match self {
Self::Durable => "durable",
Self::Session => "session",
}
}
}
impl ArrangementSubKind {
pub fn as_tag(self) -> &'static str {
match self {
Self::FrameMember => "frame-member",
Self::TileGroup => "tile-group",
Self::SplitPair => "split-pair",
}
}
pub fn durability(self) -> RelationDurability {
match self {
Self::FrameMember => RelationDurability::Durable,
Self::TileGroup | Self::SplitPair => RelationDurability::Session,
}
}
pub fn provenance(self) -> &'static str {
match self {
Self::FrameMember => "workbench.frame_snapshot",
Self::TileGroup => "workbench.tile_grouping",
Self::SplitPair => "workbench.split_pairing",
}
}
}
#[derive(
Debug, Clone, PartialEq, Archive, Serialize, Deserialize, serde::Serialize, serde::Deserialize,
)]
#[serde(deny_unknown_fields)]
pub enum EdgeAssertion {
Semantic {
sub_kind: SemanticSubKind,
label: Option<String>,
},
Containment {
sub_kind: ContainmentSubKind,
},
Arrangement {
sub_kind: ArrangementSubKind,
},
Imported {
sub_kind: ImportedSubKind,
},
Provenance {
sub_kind: ProvenanceSubKind,
},
}
#[derive(
Debug,
Clone,
Copy,
PartialEq,
Eq,
Hash,
Archive,
Serialize,
Deserialize,
serde::Serialize,
serde::Deserialize,
)]
pub enum RelationSelector {
Family(EdgeFamily),
Semantic(SemanticSubKind),
Containment(ContainmentSubKind),
Arrangement(ArrangementSubKind),
Imported(ImportedSubKind),
Provenance(ProvenanceSubKind),
}
#[derive(
Debug,
Clone,
Copy,
PartialEq,
Eq,
Archive,
Serialize,
Deserialize,
serde::Serialize,
serde::Deserialize,
)]
pub enum NavigationTrigger {
Unknown,
LinkClick,
Back,
Forward,
AddressBarEntry,
PanePromotion,
Programmatic,
Redirect,
ReopenSession,
JumpAnchor,
InPageSearchJump,
ImportedHistory,
}
impl NavigationTrigger {
#[allow(dead_code)]
pub(crate) fn contributes_to_forward_count(self) -> bool {
!matches!(self, Self::Back)
}
}
#[derive(
Debug,
Clone,
Copy,
PartialEq,
Eq,
Hash,
Archive,
Serialize,
Deserialize,
serde::Serialize,
serde::Deserialize,
)]
pub enum RelationKind {
Semantic(SemanticSubKind),
OpenPredicate,
Traversal,
Containment(ContainmentSubKind),
Arrangement(ArrangementSubKind),
Imported(ImportedSubKind),
Provenance(ProvenanceSubKind),
}
const OPEN_PREDICATE_TAG_SUB: u32 = 0x00ff_ffff;
impl RelationKind {
pub fn predicate_iri(self) -> Option<&'static str> {
use super::edge_data::predicate_iri as semantic_predicate_iri;
match self {
RelationKind::Semantic(sub_kind) => Some(semantic_predicate_iri(sub_kind)),
RelationKind::OpenPredicate | RelationKind::Traversal => None,
RelationKind::Containment(sub_kind) => Some(match sub_kind {
ContainmentSubKind::UrlPath => "https://mere.computer/ns/rel#containment.url-path",
ContainmentSubKind::Domain => "https://mere.computer/ns/rel#containment.domain",
ContainmentSubKind::FileSystem => {
"https://mere.computer/ns/rel#containment.filesystem"
},
ContainmentSubKind::UserFolder => {
"https://mere.computer/ns/rel#containment.user-folder"
},
ContainmentSubKind::ClipSource => {
"https://mere.computer/ns/rel#containment.clip-source"
},
ContainmentSubKind::NotebookSection => {
"https://mere.computer/ns/rel#containment.notebook-section"
},
ContainmentSubKind::CollectionMember => {
"https://mere.computer/ns/rel#containment.collection-member"
},
}),
RelationKind::Arrangement(sub_kind) => Some(match sub_kind {
ArrangementSubKind::FrameMember => {
"https://mere.computer/ns/rel#arrangement.frame-member"
},
ArrangementSubKind::TileGroup => {
"https://mere.computer/ns/rel#arrangement.tile-group"
},
ArrangementSubKind::SplitPair => {
"https://mere.computer/ns/rel#arrangement.split-pair"
},
}),
RelationKind::Imported(sub_kind) => Some(match sub_kind {
ImportedSubKind::BookmarkFolder => {
"https://mere.computer/ns/rel#imported.bookmark-folder"
},
ImportedSubKind::HistoryImport => {
"https://mere.computer/ns/rel#imported.history-import"
},
ImportedSubKind::SessionImport => {
"https://mere.computer/ns/rel#imported.session-import"
},
ImportedSubKind::RssMembership => {
"https://mere.computer/ns/rel#imported.rss-membership"
},
ImportedSubKind::FileSystemImport => {
"https://mere.computer/ns/rel#imported.filesystem-import"
},
ImportedSubKind::ArchiveMembership => {
"https://mere.computer/ns/rel#imported.archive-membership"
},
ImportedSubKind::SharedCollection => {
"https://mere.computer/ns/rel#imported.shared-collection"
},
}),
RelationKind::Provenance(sub_kind) => Some(match sub_kind {
ProvenanceSubKind::ClippedFrom => {
"https://mere.computer/ns/rel#provenance.clipped-from"
},
ProvenanceSubKind::ExcerptedFrom => {
"https://mere.computer/ns/rel#provenance.excerpted-from"
},
ProvenanceSubKind::SummarizedFrom => {
"https://mere.computer/ns/rel#provenance.summarized-from"
},
ProvenanceSubKind::TranslatedFrom => {
"https://mere.computer/ns/rel#provenance.translated-from"
},
ProvenanceSubKind::RewrittenFrom => {
"https://mere.computer/ns/rel#provenance.rewritten-from"
},
ProvenanceSubKind::GeneratedFrom => {
"https://mere.computer/ns/rel#provenance.generated-from"
},
ProvenanceSubKind::ExtractedFrom => {
"https://mere.computer/ns/rel#provenance.extracted-from"
},
ProvenanceSubKind::ImportedFromSource => {
"https://mere.computer/ns/rel#provenance.imported-from-source"
},
ProvenanceSubKind::CopiedFrom => {
"https://mere.computer/ns/rel#provenance.copied-from"
},
ProvenanceSubKind::MergedFrom => {
"https://mere.computer/ns/rel#provenance.merged-from"
},
}),
}
}
pub fn from_predicate_iri(iri: &str) -> Option<Self> {
use super::edge_data::sub_kind_from_iri as semantic_sub_kind_from_iri;
if let Some(sub_kind) = semantic_sub_kind_from_iri(iri) {
return Some(RelationKind::Semantic(sub_kind));
}
[
ContainmentSubKind::UrlPath,
ContainmentSubKind::Domain,
ContainmentSubKind::FileSystem,
ContainmentSubKind::UserFolder,
ContainmentSubKind::ClipSource,
ContainmentSubKind::NotebookSection,
ContainmentSubKind::CollectionMember,
]
.into_iter()
.map(RelationKind::Containment)
.chain(
[
ArrangementSubKind::FrameMember,
ArrangementSubKind::TileGroup,
ArrangementSubKind::SplitPair,
]
.into_iter()
.map(RelationKind::Arrangement),
)
.chain(
[
ImportedSubKind::BookmarkFolder,
ImportedSubKind::HistoryImport,
ImportedSubKind::SessionImport,
ImportedSubKind::RssMembership,
ImportedSubKind::FileSystemImport,
ImportedSubKind::ArchiveMembership,
ImportedSubKind::SharedCollection,
]
.into_iter()
.map(RelationKind::Imported),
)
.chain(
[
ProvenanceSubKind::ClippedFrom,
ProvenanceSubKind::ExcerptedFrom,
ProvenanceSubKind::SummarizedFrom,
ProvenanceSubKind::TranslatedFrom,
ProvenanceSubKind::RewrittenFrom,
ProvenanceSubKind::GeneratedFrom,
ProvenanceSubKind::ExtractedFrom,
ProvenanceSubKind::ImportedFromSource,
ProvenanceSubKind::CopiedFrom,
ProvenanceSubKind::MergedFrom,
]
.into_iter()
.map(RelationKind::Provenance),
)
.find(|kind| kind.predicate_iri() == Some(iri))
}
pub fn family(self) -> EdgeFamily {
match self {
RelationKind::Semantic(_) | RelationKind::OpenPredicate => EdgeFamily::Semantic,
RelationKind::Traversal => EdgeFamily::Traversal,
RelationKind::Containment(_) => EdgeFamily::Containment,
RelationKind::Arrangement(_) => EdgeFamily::Arrangement,
RelationKind::Imported(_) => EdgeFamily::Imported,
RelationKind::Provenance(_) => EdgeFamily::Provenance,
}
}
pub fn tag(self) -> u32 {
let (family, sub) = match self {
RelationKind::Semantic(sk) => (0u32, sk as u32),
RelationKind::OpenPredicate => (0, OPEN_PREDICATE_TAG_SUB),
RelationKind::Traversal => (1, 0),
RelationKind::Containment(sk) => (2, sk as u32),
RelationKind::Arrangement(sk) => (3, sk as u32),
RelationKind::Imported(sk) => (4, sk as u32),
RelationKind::Provenance(sk) => (5, sk as u32),
};
(family << 24) | (sub & 0x00ff_ffff)
}
pub fn from_tag(tag: u32) -> Option<Self> {
let family = tag >> 24;
let sub = tag & 0x00ff_ffff;
match family {
0 if sub == OPEN_PREDICATE_TAG_SUB => Some(RelationKind::OpenPredicate),
0 => SemanticSubKind::from_repr(sub as usize).map(RelationKind::Semantic),
1 => (sub == 0).then_some(RelationKind::Traversal),
2 => ContainmentSubKind::from_repr(sub as usize).map(RelationKind::Containment),
3 => ArrangementSubKind::from_repr(sub as usize).map(RelationKind::Arrangement),
4 => ImportedSubKind::from_repr(sub as usize).map(RelationKind::Imported),
5 => ProvenanceSubKind::from_repr(sub as usize).map(RelationKind::Provenance),
_ => None,
}
}
}