shex_ast 0.0.3

Rust implementation of ShEx
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

use iri_s::{IriS, IriSError};
use prefixmap::{PrefixMap, PrefixMapError};
use thiserror::Error;

#[derive(Debug, Error)]
pub enum DerefError {

    #[error(transparent)]
    IriSError(#[from] IriSError),

    #[error(transparent)]
    PrefixMapError(#[from] PrefixMapError),
    
    #[error("No prefix map to dereference prefixed name {prefix}{local}")]
    NoPrefixMapPrefixedName { prefix: String, local: String }
}

pub trait Deref {
    fn deref(&self, 
        base: &Option<IriS>, 
        prefixmap: &Option<PrefixMap>
    ) -> Result<Self, DerefError> where Self: Sized; 

    fn deref_opt<T>(
        maybe: &Option<T>, 
        base: &Option<IriS>, 
        prefixmap: &Option<PrefixMap>) -> Result<Option<T>, DerefError> where T: Deref {
       let result = match maybe {
        None => None,
        Some(t) => {
           let new_t = t.deref(base, prefixmap)?;
           Some(new_t)
        }
       };
        Ok(result)
    }

    fn deref_box<T>(
        bt: &Box<T>, 
        base: &Option<IriS>, 
        prefixmap: &Option<PrefixMap>) -> Result<Box<T>, DerefError> where T: Deref {
        let t = bt.as_ref().deref(base, prefixmap)?;
        Ok(Box::new(t))
    }

    fn deref_opt_box<T>(
        maybe: &Option<Box<T>>, 
        base: &Option<IriS>, 
        prefixmap: &Option<PrefixMap>) -> Result<Option<Box<T>>, DerefError> where T: Deref {
       let result = match maybe {
        None => None,
        Some(t) => {
           let new_t = t.deref(base, prefixmap)?;
           Some(Box::new(new_t))
        }
       };
       Ok(result)
    }

    fn deref_vec<T>(ts: &Vec<T>,         
        base: &Option<IriS>, 
        prefixmap: &Option<PrefixMap>) -> Result<Vec<T>, DerefError> where T: Deref {
            let mut new_ts = Vec::new();
            for t in ts {
              new_ts.push(t.deref(base, prefixmap)?);
            }
            Ok(new_ts)     
    }


    fn deref_opt_vec<T>(
        maybe_ts: &Option<Vec<T>>, 
        base: &Option<IriS>, 
        prefixmap: &Option<PrefixMap>) -> Result<Option<Vec<T>>, DerefError> where T: Deref {
       let result = match maybe_ts {
        None => None,
        Some(ts) => {
           let mut new_ts = Vec::new();
           for t in ts {
            new_ts.push(t.deref(base, prefixmap)?);
           }
           Some(new_ts)
        }
       };
        Ok(result)
    }

}