3929938005

Build Type

push

github

Committed by GitHub

Commit Message

Merge #713

Run Details

84930 of 96741 relevant lines covered (87.79%)

79640.1 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

89.13

/operators/src/util/input/raster_or_vector.rs

use crate::engine::{OperatorData, RasterOperator, TypedOperator, VectorOperator};
use geoengine_datatypes::dataset::DataId;
use serde::{Deserialize, Serialize};

/// It is either a `RasterOperator` or a `VectorOperator`
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum RasterOrVectorOperator {
    Raster(Box<dyn RasterOperator>),
    Vector(Box<dyn VectorOperator>),
}

impl RasterOrVectorOperator {
    pub fn is_raster(&self) -> bool {
        match self {
            RasterOrVectorOperator::Raster(_) => true,
            RasterOrVectorOperator::Vector(_) => false,
        }
    }

    pub fn is_vector(&self) -> bool {
        match self {
            RasterOrVectorOperator::Raster(_) => false,
            RasterOrVectorOperator::Vector(_) => true,
        }
    }
}

impl From<RasterOrVectorOperator> for TypedOperator {
    fn from(operator: RasterOrVectorOperator) -> Self {
        match operator {
            RasterOrVectorOperator::Raster(operator) => Self::Raster(operator),
            RasterOrVectorOperator::Vector(operator) => Self::Vector(operator),
        }
    }
}

impl From<Box<dyn RasterOperator>> for RasterOrVectorOperator {
    fn from(operator: Box<dyn RasterOperator>) -> Self {
        Self::Raster(operator)
    }
}

impl From<Box<dyn VectorOperator>> for RasterOrVectorOperator {
    fn from(operator: Box<dyn VectorOperator>) -> Self {
        Self::Vector(operator)
    }
}

impl OperatorData for RasterOrVectorOperator {
    fn data_ids_collect(&self, data_ids: &mut Vec<DataId>) {
        match self {
            RasterOrVectorOperator::Raster(r) => r.data_ids_collect(data_ids),
            RasterOrVectorOperator::Vector(v) => v.data_ids_collect(data_ids),
        }
    }
}

#[cfg(test)]
mod tests {
    use crate::source::{GdalSource, GdalSourceParameters};
    use geoengine_datatypes::dataset::DatasetId;
    use std::str::FromStr;

    use super::*;

    #[test]
    fn it_serializes() {
        let operator = RasterOrVectorOperator::Raster(
            GdalSource {
                params: GdalSourceParameters {
                    data: DatasetId::from_str("fc734022-61e0-49da-b327-257ba9d602a7")
                        .unwrap()
                        .into(),
                },
            }
            .boxed(),
        );

        assert_eq!(
            serde_json::to_value(&operator).unwrap(),
            serde_json::json!({
                "type": "GdalSource",
                "params": {
                    "data": {
                        "type": "internal",
                        "datasetId": "fc734022-61e0-49da-b327-257ba9d602a7"
                    }
                }
            })
        );
    }

    #[test]
    fn it_deserializes_raster_ops() {
        let workflow = serde_json::json!({
            "type": "GdalSource",
            "params": {
                "data": {
                    "type": "internal",
                    "datasetId":  "fc734022-61e0-49da-b327-257ba9d602a7"
                }
            }
        })
        .to_string();

        let raster_or_vector_operator: RasterOrVectorOperator =
            serde_json::from_str(&workflow).unwrap();

        assert!(raster_or_vector_operator.is_raster());
        assert!(!raster_or_vector_operator.is_vector());
    }

    #[test]
    fn it_deserializes_vector_ops() {
        let workflow = serde_json::json!({
            "type": "OgrSource",
            "params": {
                "data": {
                    "type": "internal",
                    "datasetId":  "fc734022-61e0-49da-b327-257ba9d602a7"
                },
                "attribute_projection": null,
            }
        })
        .to_string();

        let raster_or_vector_operator: RasterOrVectorOperator =
            serde_json::from_str(&workflow).unwrap();

        assert!(raster_or_vector_operator.is_vector());
        assert!(!raster_or_vector_operator.is_raster());
    }
}

1	use crate::engine::{OperatorData, RasterOperator, TypedOperator, VectorOperator};
2	use geoengine_datatypes::dataset::DataId;
3	use serde::{Deserialize, Serialize};
4
5	/// It is either a `RasterOperator` or a `VectorOperator`
6	#[derive(Debug, Clone, Serialize, Deserialize)]	16✔
7	#[serde(untagged)]
8	pub enum RasterOrVectorOperator {
9	Raster(Box<dyn RasterOperator>),
10	Vector(Box<dyn VectorOperator>),
11	}
12
13	impl RasterOrVectorOperator {
14	pub fn is_raster(&self) -> bool {	2✔
15	match self {	2✔
16	RasterOrVectorOperator::Raster(_) => true,	1✔
17	RasterOrVectorOperator::Vector(_) => false,	1✔
18	}
19	}	2✔
20
21	pub fn is_vector(&self) -> bool {	2✔
22	match self {	2✔
23	RasterOrVectorOperator::Raster(_) => false,	1✔
24	RasterOrVectorOperator::Vector(_) => true,	1✔
25	}
26	}	2✔
27	}
28
29	impl From<RasterOrVectorOperator> for TypedOperator {
30	fn from(operator: RasterOrVectorOperator) -> Self {	×
31	match operator {	×
32	RasterOrVectorOperator::Raster(operator) => Self::Raster(operator),	×
33	RasterOrVectorOperator::Vector(operator) => Self::Vector(operator),	×
34	}
35	}	×
36	}
37
38	impl From<Box<dyn RasterOperator>> for RasterOrVectorOperator {
39	fn from(operator: Box<dyn RasterOperator>) -> Self {	4✔
40	Self::Raster(operator)	4✔
41	}	4✔
42	}
43
44	impl From<Box<dyn VectorOperator>> for RasterOrVectorOperator {
45	fn from(operator: Box<dyn VectorOperator>) -> Self {	6✔
46	Self::Vector(operator)	6✔
47	}	6✔
48	}
49
50	impl OperatorData for RasterOrVectorOperator {
51	fn data_ids_collect(&self, data_ids: &mut Vec<DataId>) {	×
52	match self {	×
53	RasterOrVectorOperator::Raster(r) => r.data_ids_collect(data_ids),	×
54	RasterOrVectorOperator::Vector(v) => v.data_ids_collect(data_ids),	×
55	}
56	}	×
57	}
58
59	#[cfg(test)]
60	mod tests {
61	use crate::source::{GdalSource, GdalSourceParameters};
62	use geoengine_datatypes::dataset::DatasetId;
63	use std::str::FromStr;
64
65	use super::*;
66
67	#[test]	1✔
68	fn it_serializes() {	1✔
69	let operator = RasterOrVectorOperator::Raster(	1✔
70	GdalSource {	1✔
71	params: GdalSourceParameters {	1✔
72	data: DatasetId::from_str("fc734022-61e0-49da-b327-257ba9d602a7")	1✔
73	.unwrap()	1✔
74	.into(),	1✔
75	},	1✔
76	}	1✔
77	.boxed(),	1✔
78	);	1✔
79		1✔
80	assert_eq!(	1✔
81	serde_json::to_value(&operator).unwrap(),	1✔
82	serde_json::json!({	1✔
83	"type": "GdalSource",	1✔
84	"params": {	1✔
85	"data": {	1✔
86	"type": "internal",	1✔
87	"datasetId": "fc734022-61e0-49da-b327-257ba9d602a7"	1✔
88	}	1✔
89	}	1✔
90	})	1✔
91	);	1✔
92	}	1✔
93
94	#[test]	1✔
95	fn it_deserializes_raster_ops() {	1✔
96	let workflow = serde_json::json!({	1✔
97	"type": "GdalSource",	1✔
98	"params": {	1✔
99	"data": {	1✔
100	"type": "internal",	1✔
101	"datasetId": "fc734022-61e0-49da-b327-257ba9d602a7"	1✔
102	}	1✔
103	}	1✔
104	})	1✔
105	.to_string();	1✔
106		1✔
107	let raster_or_vector_operator: RasterOrVectorOperator =	1✔
108	serde_json::from_str(&workflow).unwrap();	1✔
109		1✔
110	assert!(raster_or_vector_operator.is_raster());	1✔
111	assert!(!raster_or_vector_operator.is_vector());	1✔
112	}	1✔
113
114	#[test]	1✔
115	fn it_deserializes_vector_ops() {	1✔
116	let workflow = serde_json::json!({	1✔
117	"type": "OgrSource",	1✔
118	"params": {	1✔
119	"data": {	1✔
120	"type": "internal",	1✔
121	"datasetId": "fc734022-61e0-49da-b327-257ba9d602a7"	1✔
122	},	1✔
123	"attribute_projection": null,	1✔
124	}	1✔
125	})	1✔
126	.to_string();	1✔
127		1✔
128	let raster_or_vector_operator: RasterOrVectorOperator =	1✔
129	serde_json::from_str(&workflow).unwrap();	1✔
130		1✔
131	assert!(raster_or_vector_operator.is_vector());	1✔
132	assert!(!raster_or_vector_operator.is_raster());	1✔
133	}	1✔
134	}

geo-engine / geoengine / 3929938005

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous