icydb 0.76.9

IcyDB — A type-safe, embedded ORM and schema system for the Internet Computer
Documentation 
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
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108

use crate::{
    traits::{EntityKind, EntityValue},
    types::Id,
};
use icydb_core::db::WriteBatchResponse as CoreWriteBatchResponse;

///
/// WriteResponse
///
/// Facade over a single write result with explicit accessors.
/// Returned IDs are public identifiers used for correlation, reporting, and lookup.
///

#[derive(Debug)]
pub struct WriteResponse<E: EntityKind> {
    entity: E,
}

impl<E: EntityKind> WriteResponse<E> {
    /// Construct a facade write response from a stored entity.
    #[must_use]
    pub const fn new(entity: E) -> Self {
        Self { entity }
    }

    /// Return the stored entity.
    #[must_use]
    pub fn entity(self) -> E {
        self.entity
    }

    /// Return the stored entity's primary identity
    #[must_use]
    pub fn id(&self) -> Id<E>
    where
        E: EntityValue,
    {
        self.entity.id()
    }
}

///
/// WriteBatchResponse
///
/// Facade over batch write results with explicit entity and identity accessors.
///

#[derive(Debug)]
pub struct WriteBatchResponse<E: EntityKind> {
    entities: Vec<E>,
}

impl<E: EntityKind> WriteBatchResponse<E> {
    /// Construct a facade batch response from stored entities.
    #[must_use]
    pub const fn new(entities: Vec<E>) -> Self {
        Self { entities }
    }

    /// Construct a facade batch response from the core response.
    #[must_use]
    pub fn from_core(inner: CoreWriteBatchResponse<E>) -> Self {
        Self {
            entities: inner.into_iter().collect(),
        }
    }

    /// Return the number of entries.
    #[must_use]
    pub const fn len(&self) -> usize {
        self.entities.len()
    }

    /// Returns `true` if the batch is empty.
    #[must_use]
    pub const fn is_empty(&self) -> bool {
        self.entities.is_empty()
    }

    /// Return all stored entities.
    #[must_use]
    pub fn entities(self) -> Vec<E> {
        self.entities
    }

    /// Borrow an iterator over primary keys for correlation, reporting, and lookup.
    pub fn ids(&self) -> impl Iterator<Item = Id<E>> + '_
    where
        E: EntityValue,
    {
        self.entities.iter().map(EntityValue::id)
    }
}

impl<E: EntityKind> WriteBatchResponse<E> {
    pub fn iter(&self) -> std::slice::Iter<'_, E> {
        self.entities.iter()
    }
}

impl<'a, E: EntityKind> IntoIterator for &'a WriteBatchResponse<E> {
    type Item = &'a E;
    type IntoIter = std::slice::Iter<'a, E>;

    fn into_iter(self) -> Self::IntoIter {
        self.iter()
    }
}