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,
}
#[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,
)]
pub enum EdgeAssertion {
Semantic {
sub_kind: SemanticSubKind,
label: Option<String>,
decay_progress: Option<f32>,
},
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),
Traversal,
Containment(ContainmentSubKind),
Arrangement(ArrangementSubKind),
Imported(ImportedSubKind),
Provenance(ProvenanceSubKind),
}
impl RelationKind {
pub fn family(self) -> EdgeFamily {
match self {
RelationKind::Semantic(_) => 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::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 => 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,
}
}
}