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
use uri::Uri;
use specs::xml_specs::XmlDataTypes;

/// Contains specifications for validating turtle syntax.
pub struct TurtleSpecs {}

impl TurtleSpecs {
    /// Checks if the provided literal is a plain literal that corresponds to the provided data type.
    ///
    /// # Examples
    ///
    /// ```
    /// use rdf::specs::turtle_specs::TurtleSpecs;
    /// use rdf::specs::xml_specs::XmlDataTypes;
    ///
    /// assert!(TurtleSpecs::is_plain_literal(&"3.0".to_string(), &Some(XmlDataTypes::Decimal.to_uri())));
    /// assert!(TurtleSpecs::is_plain_literal(&"true".to_string(), &Some(XmlDataTypes::Boolean.to_uri())));
    /// assert!(TurtleSpecs::is_plain_literal(&"3e10".to_string(), &Some(XmlDataTypes::Decimal.to_uri())));
    /// assert_eq!(TurtleSpecs::is_plain_literal(&"a".to_string(), &Some(XmlDataTypes::Decimal.to_uri())), false);
    /// ```
    pub fn is_plain_literal(literal: &str, data_type: &Option<Uri>) -> bool {
        if TurtleSpecs::is_double_literal(literal)
            && *data_type == Some(XmlDataTypes::Decimal.to_uri())
        {
            return true;
        }

        if TurtleSpecs::is_boolean_literal(literal)
            && *data_type == Some(XmlDataTypes::Boolean.to_uri())
        {
            return true;
        }

        if TurtleSpecs::is_integer_literal(literal)
            && (*data_type == Some(XmlDataTypes::Integer.to_uri())
                || *data_type == Some(XmlDataTypes::UnsignedLong.to_uri())
                || *data_type == Some(XmlDataTypes::Long.to_uri()))
        {
            return true;
        }

        false
    }

    /// Checks if the provided literal is decimal.
    ///
    /// # Examples
    ///
    /// ```
    /// use rdf::specs::turtle_specs::TurtleSpecs;
    ///
    /// assert!(TurtleSpecs::is_double_literal(&"3.0".to_string()));
    /// assert!(TurtleSpecs::is_double_literal(&"3e10".to_string()));
    /// assert_eq!(TurtleSpecs::is_double_literal(&"a".to_string()), false);
    /// ```
    pub fn is_double_literal(literal: &str) -> bool {
        match literal.parse::<f64>() {
            Ok(_) => true,
            Err(_) => false,
        }
    }

    /// Checks if the provided literal is an integer.
    ///
    /// # Examples
    ///
    /// ```
    /// use rdf::specs::turtle_specs::TurtleSpecs;
    ///
    /// assert!(TurtleSpecs::is_integer_literal(&"3".to_string()));
    /// assert_eq!(TurtleSpecs::is_integer_literal(&"3.0".to_string()), false);
    /// ```
    pub fn is_integer_literal(literal: &str) -> bool {
        match literal.parse::<i64>() {
            Ok(_) => true,
            Err(_) => false,
        }
    }

    /// Checks if the provided literal is a boolean.
    ///
    /// # Examples
    ///
    /// ```
    /// use rdf::specs::turtle_specs::TurtleSpecs;
    ///
    /// assert!(TurtleSpecs::is_boolean_literal(&"true".to_string()));
    /// assert!(TurtleSpecs::is_boolean_literal(&"false".to_string()));
    /// assert_eq!(TurtleSpecs::is_boolean_literal(&"1".to_string()), false);
    /// ```
    pub fn is_boolean_literal(literal: &str) -> bool {
        match literal.parse::<bool>() {
            Ok(_) => true,
            Err(_) => false,
        }
    }
}