10178074589

Committed 31 Jul 2024 09:34AM UTC coverage: 91.068% (+0.4%) from 90.682%

Build # 10178074589

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #973 from geo-engine/remove-XGB-update-toolchain

Remove-XGB-update-toolchain

Run Details

81 of 88 new or added lines in 29 files covered. (92.05%)

456 existing lines in 119 files now uncovered.

131088 of 143945 relevant lines covered (91.07%)

53581.03 hits per line

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

50.0

/operators/src/engine/operator_impl.rs

use geoengine_datatypes::dataset::NamedData;
use serde::{Deserialize, Serialize};

use crate::util::input::{MultiRasterOrVectorOperator, RasterOrVectorOperator};

use super::{OperatorData, RasterOperator, VectorOperator};

#[derive(Debug, Serialize, Deserialize, Clone)]
#[serde(rename_all = "camelCase")]
pub struct Operator<Params, Sources> {
    pub params: Params,
    pub sources: Sources,
}

#[derive(Debug, Serialize, Deserialize, PartialEq, Eq, Clone)]
#[serde(rename_all = "camelCase")]
pub struct SourceOperator<Params> {
    pub params: Params,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct SingleRasterSource {
    pub raster: Box<dyn RasterOperator>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct SingleVectorSource {
    pub vector: Box<dyn VectorOperator>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct SingleRasterOrVectorSource {
    pub source: RasterOrVectorOperator,
}

impl SingleRasterOrVectorSource {
    pub fn raster(self) -> Option<SingleRasterSource> {
        match self.source {
            RasterOrVectorOperator::Raster(r) => Some(SingleRasterSource { raster: r }),
            RasterOrVectorOperator::Vector(_) => None,
        }
    }

    pub fn vector(self) -> Option<SingleVectorSource> {
        match self.source {
            RasterOrVectorOperator::Raster(_) => None,
            RasterOrVectorOperator::Vector(v) => Some(SingleVectorSource { vector: v }),
        }
    }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct MultipleRasterOrSingleVectorSource {
    pub source: MultiRasterOrVectorOperator,
}

impl MultipleRasterOrSingleVectorSource {
    pub fn raster(self) -> Option<MultipleRasterSources> {
        match self.source {
            MultiRasterOrVectorOperator::Raster(r) => Some(MultipleRasterSources { rasters: r }),
            MultiRasterOrVectorOperator::Vector(_) => None,
        }
    }

    pub fn vector(self) -> Option<SingleVectorSource> {
        match self.source {
            MultiRasterOrVectorOperator::Raster(_) => None,
            MultiRasterOrVectorOperator::Vector(v) => Some(SingleVectorSource { vector: v }),
        }
    }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct MultipleRasterSources {
    pub rasters: Vec<Box<dyn RasterOperator>>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct MultipleVectorSources {
    pub vectors: Vec<Box<dyn VectorOperator>>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct SingleVectorMultipleRasterSources {
    pub vector: Box<dyn VectorOperator>,
    pub rasters: Vec<Box<dyn RasterOperator>>,
}

impl From<Box<dyn VectorOperator>> for SingleVectorSource {
    fn from(vector: Box<dyn VectorOperator>) -> Self {
        Self { vector }
    }
}

impl From<Box<dyn RasterOperator>> for SingleRasterSource {
    fn from(raster: Box<dyn RasterOperator>) -> Self {
        Self { raster }
    }
}

impl From<Vec<Box<dyn RasterOperator>>> for MultipleRasterSources {
    fn from(rasters: Vec<Box<dyn RasterOperator>>) -> Self {
        Self { rasters }
    }
}

impl From<Vec<Box<dyn VectorOperator>>> for MultipleVectorSources {
    fn from(vectors: Vec<Box<dyn VectorOperator>>) -> Self {
        Self { vectors }
    }
}

impl From<Box<dyn VectorOperator>> for SingleRasterOrVectorSource {
    fn from(vector: Box<dyn VectorOperator>) -> Self {
        Self {
            source: RasterOrVectorOperator::Vector(vector),
        }
    }
}

impl From<Box<dyn RasterOperator>> for SingleRasterOrVectorSource {
    fn from(raster: Box<dyn RasterOperator>) -> Self {
        Self {
            source: RasterOrVectorOperator::Raster(raster),
        }
    }
}

impl From<Box<dyn VectorOperator>> for MultipleRasterOrSingleVectorSource {
    fn from(vector: Box<dyn VectorOperator>) -> Self {
        Self {
            source: MultiRasterOrVectorOperator::Vector(vector),
        }
    }
}

impl From<Box<dyn RasterOperator>> for MultipleRasterOrSingleVectorSource {
    fn from(raster: Box<dyn RasterOperator>) -> Self {
        Self {
            source: MultiRasterOrVectorOperator::Raster(vec![raster]),
        }
    }
}

impl From<Vec<Box<dyn RasterOperator>>> for MultipleRasterOrSingleVectorSource {
    fn from(raster: Vec<Box<dyn RasterOperator>>) -> Self {
        Self {
            source: MultiRasterOrVectorOperator::Raster(raster),
        }
    }
}

impl<Params, Sources> OperatorData for Operator<Params, Sources>
where
    Sources: OperatorData,
{
    fn data_names_collect(&self, data_names: &mut Vec<NamedData>) {
        self.sources.data_names_collect(data_names);
    }
}

impl<Params> OperatorData for SourceOperator<Params>
where
    Params: OperatorData,
{
    fn data_names_collect(&self, data_names: &mut Vec<NamedData>) {
        self.params.data_names_collect(data_names);
    }
}

impl OperatorData for SingleRasterOrVectorSource {
    fn data_names_collect(&self, data_names: &mut Vec<NamedData>) {
        self.source.data_names_collect(data_names);
    }
}

impl OperatorData for MultipleRasterOrSingleVectorSource {
    fn data_names_collect(&self, data_names: &mut Vec<NamedData>) {
        self.source.data_names_collect(data_names);
    }
}

impl OperatorData for SingleVectorSource {
    fn data_names_collect(&self, data_names: &mut Vec<NamedData>) {
        self.vector.data_names_collect(data_names);
    }
}

impl OperatorData for SingleRasterSource {
    fn data_names_collect(&self, data_names: &mut Vec<NamedData>) {
        self.raster.data_names_collect(data_names);
    }
}

impl OperatorData for MultipleRasterSources {
    fn data_names_collect(&self, data_names: &mut Vec<NamedData>) {
        for source in &self.rasters {
            source.data_names_collect(data_names);
        }
    }
}

impl OperatorData for MultipleVectorSources {
    fn data_names_collect(&self, data_names: &mut Vec<NamedData>) {
        for source in &self.vectors {
            source.data_names_collect(data_names);
        }
    }
}

impl OperatorData for SingleVectorMultipleRasterSources {
    fn data_names_collect(&self, data_names: &mut Vec<NamedData>) {
        self.vector.data_names_collect(data_names);
        for source in &self.rasters {
            source.data_names_collect(data_names);
        }
    }
}

1	use geoengine_datatypes::dataset::NamedData;
2	use serde::{Deserialize, Serialize};
3
4	use crate::util::input::{MultiRasterOrVectorOperator, RasterOrVectorOperator};
5
6	use super::{OperatorData, RasterOperator, VectorOperator};
7
8	#[derive(Debug, Serialize, Deserialize, Clone)]	112✔
9	#[serde(rename_all = "camelCase")]
10	pub struct Operator<Params, Sources> {
11	pub params: Params,
12	pub sources: Sources,
13	}
14
15	#[derive(Debug, Serialize, Deserialize, PartialEq, Eq, Clone)]	172✔
16	#[serde(rename_all = "camelCase")]
17	pub struct SourceOperator<Params> {
18	pub params: Params,
19	}
20
21	#[derive(Debug, Clone, Serialize, Deserialize)]	8✔
22	#[serde(rename_all = "camelCase")]
23	pub struct SingleRasterSource {
24	pub raster: Box<dyn RasterOperator>,
25	}
26
27	#[derive(Debug, Clone, Serialize, Deserialize)]	10✔
28	#[serde(rename_all = "camelCase")]
29	pub struct SingleVectorSource {
30	pub vector: Box<dyn VectorOperator>,
31	}
32
33	#[derive(Debug, Clone, Serialize, Deserialize)]	22✔
34	#[serde(rename_all = "camelCase")]
35	pub struct SingleRasterOrVectorSource {
36	pub source: RasterOrVectorOperator,
37	}
38
39	impl SingleRasterOrVectorSource {
40	pub fn raster(self) -> Option<SingleRasterSource> {	4✔
41	match self.source {	4✔
42	RasterOrVectorOperator::Raster(r) => Some(SingleRasterSource { raster: r }),	4✔
43	RasterOrVectorOperator::Vector(_) => None,	×
44	}
45	}	4✔
46
47	pub fn vector(self) -> Option<SingleVectorSource> {	7✔
48	match self.source {	7✔
49	RasterOrVectorOperator::Raster(_) => None,	1✔
50	RasterOrVectorOperator::Vector(v) => Some(SingleVectorSource { vector: v }),	6✔
51	}
52	}	7✔
53	}
54
55	#[derive(Debug, Clone, Serialize, Deserialize)]	18✔
56	#[serde(rename_all = "camelCase")]
57	pub struct MultipleRasterOrSingleVectorSource {
58	pub source: MultiRasterOrVectorOperator,
59	}
60
61	impl MultipleRasterOrSingleVectorSource {
62	pub fn raster(self) -> Option<MultipleRasterSources> {	×
63	match self.source {	×
64	MultiRasterOrVectorOperator::Raster(r) => Some(MultipleRasterSources { rasters: r }),	×
65	MultiRasterOrVectorOperator::Vector(_) => None,	×
66	}
67	}	×
68
69	pub fn vector(self) -> Option<SingleVectorSource> {	×
70	match self.source {	×
71	MultiRasterOrVectorOperator::Raster(_) => None,	×
72	MultiRasterOrVectorOperator::Vector(v) => Some(SingleVectorSource { vector: v }),	×
73	}
74	}	×
75	}
76
UNCOV 77	#[derive(Debug, Clone, Serialize, Deserialize)]	×
78	#[serde(rename_all = "camelCase")]
79	pub struct MultipleRasterSources {
80	pub rasters: Vec<Box<dyn RasterOperator>>,
81	}
82
83	#[derive(Debug, Clone, Serialize, Deserialize)]	×
84	#[serde(rename_all = "camelCase")]
85	pub struct MultipleVectorSources {
86	pub vectors: Vec<Box<dyn VectorOperator>>,
87	}
88
89	#[derive(Debug, Clone, Serialize, Deserialize)]	9✔
90	#[serde(rename_all = "camelCase")]
91	pub struct SingleVectorMultipleRasterSources {
92	pub vector: Box<dyn VectorOperator>,
93	pub rasters: Vec<Box<dyn RasterOperator>>,
94	}
95
96	impl From<Box<dyn VectorOperator>> for SingleVectorSource {
97	fn from(vector: Box<dyn VectorOperator>) -> Self {	35✔
98	Self { vector }	35✔
99	}	35✔
100	}
101
102	impl From<Box<dyn RasterOperator>> for SingleRasterSource {
103	fn from(raster: Box<dyn RasterOperator>) -> Self {	1✔
104	Self { raster }	1✔
105	}	1✔
106	}
107
108	impl From<Vec<Box<dyn RasterOperator>>> for MultipleRasterSources {
109	fn from(rasters: Vec<Box<dyn RasterOperator>>) -> Self {	×
110	Self { rasters }	×
111	}	×
112	}
113
114	impl From<Vec<Box<dyn VectorOperator>>> for MultipleVectorSources {
115	fn from(vectors: Vec<Box<dyn VectorOperator>>) -> Self {	×
116	Self { vectors }	×
117	}	×
118	}
119
120	impl From<Box<dyn VectorOperator>> for SingleRasterOrVectorSource {
121	fn from(vector: Box<dyn VectorOperator>) -> Self {	11✔
122	Self {	11✔
123	source: RasterOrVectorOperator::Vector(vector),	11✔
124	}	11✔
125	}	11✔
126	}
127
128	impl From<Box<dyn RasterOperator>> for SingleRasterOrVectorSource {
129	fn from(raster: Box<dyn RasterOperator>) -> Self {	10✔
130	Self {	10✔
131	source: RasterOrVectorOperator::Raster(raster),	10✔
132	}	10✔
133	}	10✔
134	}
135
136	impl From<Box<dyn VectorOperator>> for MultipleRasterOrSingleVectorSource {
137	fn from(vector: Box<dyn VectorOperator>) -> Self {	13✔
138	Self {	13✔
139	source: MultiRasterOrVectorOperator::Vector(vector),	13✔
140	}	13✔
141	}	13✔
142	}
143
144	impl From<Box<dyn RasterOperator>> for MultipleRasterOrSingleVectorSource {
145	fn from(raster: Box<dyn RasterOperator>) -> Self {	6✔
146	Self {	6✔
147	source: MultiRasterOrVectorOperator::Raster(vec![raster]),	6✔
148	}	6✔
149	}	6✔
150	}
151
152	impl From<Vec<Box<dyn RasterOperator>>> for MultipleRasterOrSingleVectorSource {
153	fn from(raster: Vec<Box<dyn RasterOperator>>) -> Self {	16✔
154	Self {	16✔
155	source: MultiRasterOrVectorOperator::Raster(raster),	16✔
156	}	16✔
157	}	16✔
158	}
159
160	impl<Params, Sources> OperatorData for Operator<Params, Sources>
161	where
162	Sources: OperatorData,
163	{
164	fn data_names_collect(&self, data_names: &mut Vec<NamedData>) {	×
165	self.sources.data_names_collect(data_names);	×
166	}	×
167	}
168
169	impl<Params> OperatorData for SourceOperator<Params>
170	where
171	Params: OperatorData,
172	{
173	fn data_names_collect(&self, data_names: &mut Vec<NamedData>) {	2✔
174	self.params.data_names_collect(data_names);	2✔
175	}	2✔
176	}
177
178	impl OperatorData for SingleRasterOrVectorSource {
179	fn data_names_collect(&self, data_names: &mut Vec<NamedData>) {	×
180	self.source.data_names_collect(data_names);	×
181	}	×
182	}
183
184	impl OperatorData for MultipleRasterOrSingleVectorSource {
185	fn data_names_collect(&self, data_names: &mut Vec<NamedData>) {	×
186	self.source.data_names_collect(data_names);	×
187	}	×
188	}
189
190	impl OperatorData for SingleVectorSource {
191	fn data_names_collect(&self, data_names: &mut Vec<NamedData>) {	×
192	self.vector.data_names_collect(data_names);	×
193	}	×
194	}
195
196	impl OperatorData for SingleRasterSource {
197	fn data_names_collect(&self, data_names: &mut Vec<NamedData>) {	×
198	self.raster.data_names_collect(data_names);	×
199	}	×
200	}
201
202	impl OperatorData for MultipleRasterSources {
203	fn data_names_collect(&self, data_names: &mut Vec<NamedData>) {	×
204	for source in &self.rasters {	×
205	source.data_names_collect(data_names);	×
206	}	×
207	}	×
208	}
209
210	impl OperatorData for MultipleVectorSources {
211	fn data_names_collect(&self, data_names: &mut Vec<NamedData>) {	×
212	for source in &self.vectors {	×
213	source.data_names_collect(data_names);	×
214	}	×
215	}	×
216	}
217
218	impl OperatorData for SingleVectorMultipleRasterSources {
219	fn data_names_collect(&self, data_names: &mut Vec<NamedData>) {	×
220	self.vector.data_names_collect(data_names);	×
221	for source in &self.rasters {	×
222	source.data_names_collect(data_names);	×
223	}	×
224	}	×
225	}

geo-engine / geoengine / 10178074589

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