uqa-core 0.4.0

Document sets, finite-support relations, posting storage, and value types for UQA
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
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124

//
// Unified Query Algebra
//
// Copyright (c) 2023-2026 Cognica, Inc.
//

//! Sets reuse exact owned map nodes without a second tree implementation.

use std::borrow::Borrow;

use super::{BudgetedMapIter, OwnedMap, OwnedMapIntoIter};

/// An ordinary ordered set with exact node layouts and the same enclosing-owner admission contract as `OwnedMap`.
#[derive(Debug, PartialEq, Eq)]
pub struct OwnedSet<K>(OwnedMap<K, ()>);

impl<K: Ord + Clone> Clone for OwnedSet<K> {
    fn clone(&self) -> Self {
        Self(self.0.clone())
    }
}

impl<K> Default for OwnedSet<K> {
    fn default() -> Self {
        Self(OwnedMap::new())
    }
}

impl<K> OwnedSet<K> {
    pub fn new() -> Self {
        Self::default()
    }

    pub const fn entry_bytes() -> usize {
        OwnedMap::<K, ()>::entry_bytes()
    }

    pub fn allocated_bytes(&self) -> usize {
        self.0.allocated_bytes()
    }

    pub fn len(&self) -> usize {
        self.0.len()
    }

    pub fn is_empty(&self) -> bool {
        self.0.is_empty()
    }

    pub fn iter(&self) -> OwnedSetIter<'_, K> {
        OwnedSetIter(self.0.iter())
    }
}

impl<K: Ord> OwnedSet<K> {
    pub fn insert(&mut self, key: K) -> bool {
        self.0.insert(key, ()).is_none()
    }

    pub fn contains<Q: Ord + ?Sized>(&self, key: &Q) -> bool
    where
        K: Borrow<Q>,
    {
        self.0.contains_key(key)
    }
}

impl<K: Ord> FromIterator<K> for OwnedSet<K> {
    fn from_iter<T: IntoIterator<Item = K>>(iter: T) -> Self {
        Self(iter.into_iter().map(|key| (key, ())).collect())
    }
}

pub struct OwnedSetIter<'a, K>(BudgetedMapIter<'a, K, ()>);

impl<'a, K> Iterator for OwnedSetIter<'a, K> {
    type Item = &'a K;

    fn next(&mut self) -> Option<Self::Item> {
        self.0.next().map(|(key, ())| key)
    }

    fn size_hint(&self) -> (usize, Option<usize>) {
        self.0.size_hint()
    }
}

impl<K> ExactSizeIterator for OwnedSetIter<'_, K> {}
impl<K> std::iter::FusedIterator for OwnedSetIter<'_, K> {}

impl<'a, K> IntoIterator for &'a OwnedSet<K> {
    type Item = &'a K;
    type IntoIter = OwnedSetIter<'a, K>;

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

pub struct OwnedSetIntoIter<K>(OwnedMapIntoIter<K, ()>);

impl<K> Iterator for OwnedSetIntoIter<K> {
    type Item = K;

    fn next(&mut self) -> Option<Self::Item> {
        self.0.next().map(|(key, ())| key)
    }

    fn size_hint(&self) -> (usize, Option<usize>) {
        self.0.size_hint()
    }
}

impl<K> ExactSizeIterator for OwnedSetIntoIter<K> {}
impl<K> std::iter::FusedIterator for OwnedSetIntoIter<K> {}

impl<K> IntoIterator for OwnedSet<K> {
    type Item = K;
    type IntoIter = OwnedSetIntoIter<K>;

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