triblespace-core 0.35.0

The triblespace core implementation.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92

use core::marker::PhantomData;

use anybytes::View;
use blake3::Hasher;

use crate::blob::schemas::longstring::LongString;
use crate::id::{ExclusiveId, Id, RawId};
use crate::macros::entity;
use crate::metadata::{self, Describe};
use crate::repo::BlobStore;
use crate::trible::Fragment;
use crate::trible::TribleSet;
use crate::value::schemas::genid::GenId;
use crate::value::schemas::hash::{Blake3, Handle};
use crate::value::Value;
use crate::value::ValueSchema;

/// Import-only attribute wrapper that keeps field names as metadata without
/// emitting contextual usage annotations.
#[derive(Debug, PartialEq, Eq, Hash)]
pub(crate) struct ImportAttribute<S: ValueSchema> {
    raw: RawId,
    name: Option<View<str>>,
    _schema: PhantomData<S>,
}

impl<S: ValueSchema> Clone for ImportAttribute<S> {
    fn clone(&self) -> Self {
        Self {
            raw: self.raw,
            name: self.name.clone(),
            _schema: PhantomData,
        }
    }
}

impl<S: ValueSchema> ImportAttribute<S> {
    /// Construct an import attribute from a raw id with an optional name.
    pub fn from_raw(raw: RawId, name: Option<View<str>>) -> Self {
        Self {
            raw,
            name,
            _schema: PhantomData,
        }
    }

    /// Construct an import attribute from a name handle and the original name bytes.
    pub fn from_handle(handle: Value<Handle<Blake3, LongString>>, name: View<str>) -> Self {
        let mut hasher = Hasher::new();
        hasher.update(&handle.raw);
        hasher.update(&<S as crate::metadata::ConstId>::ID.raw());

        let digest = hasher.finalize();
        let mut raw = [0u8; crate::id::ID_LEN];
        let lower_half = &digest.as_bytes()[digest.as_bytes().len() - crate::id::ID_LEN..];
        raw.copy_from_slice(lower_half);

        Self::from_raw(raw, Some(name))
    }

    /// Return the underlying raw id bytes.
    pub const fn raw(&self) -> RawId {
        self.raw
    }

    /// Convert to a runtime [`Id`](crate::id::Id) value.
    pub fn id(&self) -> Id {
        Id::new(self.raw).unwrap()
    }
}

impl<S> Describe for ImportAttribute<S>
where
    S: ValueSchema,
{
    fn describe<B>(&self, blobs: &mut B) -> Result<Fragment, B::PutError>
    where
        B: BlobStore<Blake3>,
    {
        let mut tribles = TribleSet::new();
        let id = self.id();

        if let Some(name) = &self.name {
            let handle = blobs.put(name.clone())?;
            tribles += entity! { ExclusiveId::force_ref(&id) @ metadata::name: handle };
        }

        tribles += entity! { ExclusiveId::force_ref(&id) @ metadata::value_schema: GenId::value_from(<S as crate::metadata::ConstId>::ID) };

        Ok(Fragment::rooted(id, tribles))
    }
}