egml-core 0.0.2-alpha.6

Core primitives and operations for processing GML data.
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

use crate::model::base::{HasOwnershipAttributes, HasOwnershipAttributesMut, OwnershipAttributes};

/// A GML property holding an ordered sequence of inline objects of type `T`.
///
/// Corresponds to array property types such as `gml:PointArrayPropertyType` and
/// `gml:GeometryArrayPropertyType`, which derive from `gml:ArrayAssociationType`
/// and declare only `gml:OwnershipAttributeGroup`: members are always inline and
/// can't be referenced via `xlink:href`
/// ([OGC 07-036 ยง7.2.3.4](https://docs.ogc.org/is/07-036/07-036.pdf)).
#[derive(Debug, Clone, PartialEq)]
pub struct ArrayProperty<T> {
    objects: Vec<T>,
    ownership: OwnershipAttributes,
}

impl<T> ArrayProperty<T> {
    pub fn new(objects: Vec<T>, ownership: OwnershipAttributes) -> Self {
        Self { objects, ownership }
    }

    pub fn from_objects(objects: Vec<T>) -> Self {
        Self::new(objects, OwnershipAttributes::default())
    }

    pub fn objects(&self) -> &[T] {
        &self.objects
    }

    pub fn objects_mut(&mut self) -> &mut Vec<T> {
        &mut self.objects
    }

    pub fn set_objects(&mut self, objects: Vec<T>) {
        self.objects = objects;
    }

    pub fn push_object(&mut self, object: T) {
        self.objects.push(object);
    }

    pub fn extend_objects(&mut self, objects: impl IntoIterator<Item = T>) {
        self.objects.extend(objects);
    }
}

impl<T> Default for ArrayProperty<T> {
    fn default() -> Self {
        Self::from_objects(Vec::new())
    }
}

impl<T> HasOwnershipAttributes for ArrayProperty<T> {
    fn ownership(&self) -> &OwnershipAttributes {
        &self.ownership
    }
}

impl<T> HasOwnershipAttributesMut for ArrayProperty<T> {
    fn ownership_mut(&mut self) -> &mut OwnershipAttributes {
        &mut self.ownership
    }
}

#[cfg(test)]
mod tests {
    use super::ArrayProperty;
    use crate::model::base::{HasOwnershipAttributes, HasOwnershipAttributesMut};

    #[test]
    fn from_objects_does_not_own() {
        let property = ArrayProperty::from_objects(vec![1, 2]);
        assert_eq!(property.objects(), [1, 2]);
        assert!(!property.owns());
    }

    #[test]
    fn objects_can_be_modified() {
        let mut property = ArrayProperty::default();
        property.push_object(1);
        property.extend_objects([2, 3]);
        property.objects_mut().retain(|x| *x != 2);
        assert_eq!(property.objects(), [1, 3]);
        property.set_objects(vec![4]);
        assert_eq!(property.objects(), [4]);
    }

    #[test]
    fn set_owns() {
        let mut property: ArrayProperty<i32> = ArrayProperty::default();
        property.set_owns(true);
        assert!(property.owns());
    }
}