srdf/
neighs.rs

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
use std::{collections::HashSet, vec::IntoIter};

use crate::SRDF;

pub enum Neigh<S>
where
    S: SRDF,
{
    Direct { p: S::IRI, o: S::Term },
    Inverse { s: S::Subject, p: S::IRI },
}

impl<S> Neigh<S>
where
    S: SRDF,
{
    pub fn direct(pred: S::IRI, object: S::Term) -> Neigh<S> {
        Neigh::Direct { p: pred, o: object }
    }

    pub fn inverse(pred: S::IRI, subject: S::Subject) -> Neigh<S> {
        Neigh::Inverse {
            p: pred,
            s: subject,
        }
    }
}

// TODO...the following code is just a draft...
// I would like to generate the neighs as an iterator...
pub struct NeighsIterator<S>
where
    S: SRDF,
{
    _term: S::Term,
    _neigh_iter: IntoIter<Neigh<S>>,
}

impl<S> NeighsIterator<S>
where
    S: SRDF,
{
    pub fn new(term: S::Term, rdf: S) -> Result<NeighsIterator<S>, S::Err> {
        match S::term_as_subject(&term) {
            None => {
                todo!()
            }
            Some(subject) => {
                let preds: HashSet<S::IRI> = rdf.predicates_for_subject(&subject)?;
                let _qs = preds.into_iter();
                /*let vv = qs.flat_map(|p| {
                    let objs = rdf.get_objects_for_subject_predicate(&subject, &p)?;
                    objs.into_iter().map(|o| Neigh::Direct { p, o })
                });*/
                todo!(); // Ok(vv)
            }
        }
        // NeighsIterator { term, objectsIter }
    }
}

impl<S> FromIterator<Neigh<S>> for NeighsIterator<S>
where
    S: SRDF,
{
    fn from_iter<T>(_t: T) -> Self
    where
        T: IntoIterator,
    {
        todo!()
    }
}

impl<S> Iterator for NeighsIterator<S>
where
    S: SRDF,
{
    type Item = Neigh<S>;

    fn next(&mut self) -> Option<Self::Item> {
        todo!()
    }
}