simple-triplestore 0.1.1

A simple graph database for storing triples with support for custom node and edge properties.
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

mod key_bounds;

use crate::{traits::IdType, traits::Property};

/// The three components of an edge (subject, predicate, object)
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct Triple<Id: IdType> {
    pub sub: Id,
    pub pred: Id,
    pub obj: Id,
}

impl<Id: IdType> PartialOrd for Triple<Id> {
    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
        match self.sub.partial_cmp(&other.sub) {
            None => None,
            Some(std::cmp::Ordering::Less) => Some(std::cmp::Ordering::Less),
            Some(std::cmp::Ordering::Greater) => Some(std::cmp::Ordering::Greater),
            Some(std::cmp::Ordering::Equal) => match self.pred.partial_cmp(&other.pred) {
                None => None,
                Some(std::cmp::Ordering::Less) => Some(std::cmp::Ordering::Less),
                Some(std::cmp::Ordering::Greater) => Some(std::cmp::Ordering::Greater),
                Some(std::cmp::Ordering::Equal) => match self.obj.partial_cmp(&other.obj) {
                    None => None,
                    Some(std::cmp::Ordering::Less) => Some(std::cmp::Ordering::Less),
                    Some(std::cmp::Ordering::Greater) => Some(std::cmp::Ordering::Greater),
                    Some(std::cmp::Ordering::Equal) => Some(std::cmp::Ordering::Equal),
                },
            },
        }
    }
}

/// A triple along with the associated NodeProps and EdgeProps.
#[derive(Debug, Clone, PartialEq)]
pub struct PropsTriple<Id: IdType, NodeProps: Property, EdgeProps: Property> {
    pub sub: (Id, NodeProps),
    pub pred: (Id, EdgeProps),
    pub obj: (Id, NodeProps),
}

impl<Id: IdType, NodeProps: Property, EdgeProps: Property>
    From<PropsTriple<Id, NodeProps, EdgeProps>> for Triple<Id>
{
    fn from(
        PropsTriple {
            sub: (sub, _),
            pred: (pred, _),
            obj: (obj, _),
        }: PropsTriple<Id, NodeProps, EdgeProps>,
    ) -> Self {
        Self { sub, pred, obj }
    }
}