egml-core 0.0.2-alpha.5

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

use crate::model::base::AbstractGmlKind;
use crate::model::geometry::Envelope;
use crate::model::geometry::primitives::AbstractSurfacePatchKind;

#[derive(Debug, Clone, PartialEq)]
pub enum AbstractObjectKind {
    AbstractGmlKind(AbstractGmlKind),
    AbstractSurfacePatchKind(AbstractSurfacePatchKind),
    Envelope(Envelope),
}

#[macro_export]
macro_rules! impl_from_for_abstract_object_kind {
    ($variant:ident, $type:ty) => {
        impl From<$type> for $crate::model::AbstractObjectKind {
            #[allow(unreachable_code)]
            fn from(x: $type) -> Self {
                $crate::model::AbstractObjectKind::$variant(x.into())
            }
        }
    };
    ($variant:ident) => {
        $crate::impl_from_for_abstract_object_kind!($variant, $variant);
    };
}

#[macro_export]
macro_rules! impl_try_from_for_abstract_object_kind {
    ($variant:ident, $type:ty) => {
        impl TryFrom<$crate::model::AbstractObjectKind> for $type {
            type Error = ();
            #[allow(unreachable_code)]
            fn try_from(x: $crate::model::AbstractObjectKind) -> Result<Self, ()> {
                match x {
                    $crate::model::AbstractObjectKind::$variant(k) => k.try_into().map_err(|_| ()),
                    #[allow(unreachable_patterns)]
                    _ => Err(()),
                }
            }
        }
    };
    ($variant:ident) => {
        $crate::impl_try_from_for_abstract_object_kind!($variant, $variant);
    };
}

impl_from_for_abstract_object_kind!(AbstractGmlKind);
impl_from_for_abstract_object_kind!(AbstractSurfacePatchKind);

impl From<Envelope> for AbstractObjectKind {
    fn from(x: Envelope) -> Self {
        AbstractObjectKind::Envelope(x)
    }
}

impl_try_from_for_abstract_object_kind!(AbstractGmlKind);
impl_try_from_for_abstract_object_kind!(AbstractSurfacePatchKind);

impl TryFrom<AbstractObjectKind> for Envelope {
    type Error = ();
    fn try_from(x: AbstractObjectKind) -> Result<Self, ()> {
        match x {
            AbstractObjectKind::Envelope(e) => Ok(e),
            _ => Err(()),
        }
    }
}