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

38.79

/operators/src/engine/initialized_sources.rs

use async_trait::async_trait;

use crate::{
    error::Error,
    util::{
        input::{MultiRasterOrVectorOperator, RasterOrVectorOperator},
        Result,
    },
};

use super::{
    ExecutionContext, InitializedRasterOperator, InitializedVectorOperator,
    MultipleRasterOrSingleVectorSource, MultipleRasterSources, MultipleVectorSources,
    SingleRasterOrVectorSource, SingleRasterSource, SingleVectorMultipleRasterSources,
    SingleVectorSource, WorkflowOperatorPath,
};

#[async_trait]
pub trait InitializedSources<Initialized, E = Error> {
    /// Initialize the source operator(s) with a path
    async fn initialize_sources(
        self,
        path: WorkflowOperatorPath,
        context: &dyn ExecutionContext,
    ) -> Result<Initialized, E>;
}

pub struct InitializedSingleRasterSource<R: InitializedRasterOperator> {
    pub raster: R,
    pub path: WorkflowOperatorPath,
}

pub struct InitializedSingleVectorSource<V: InitializedVectorOperator> {
    pub vector: V,
    pub path: WorkflowOperatorPath,
}

pub struct InitializedMultipleRasterSources<R: InitializedRasterOperator> {
    pub path: WorkflowOperatorPath,
    pub rasters: Vec<R>,
}

pub struct InitializedMultipleVectorSources<V: InitializedVectorOperator> {
    pub path: WorkflowOperatorPath,
    pub vectors: Vec<V>,
}

pub struct InitializedSingleVectorMultipleRasterSources<
    V: InitializedVectorOperator,
    R: InitializedRasterOperator,
> {
    pub path: WorkflowOperatorPath,
    pub vector: V,
    pub rasters: Vec<R>,
}

pub enum InitializedSingleRasterOrVectorOperator<
    R: InitializedRasterOperator,
    V: InitializedVectorOperator,
> {
    Raster(R),
    Vector(V),
}

impl<R: InitializedRasterOperator, V: InitializedVectorOperator>
    InitializedSingleRasterOrVectorOperator<R, V>
{
    pub fn is_raster(&self) -> bool {
        match self {
            InitializedSingleRasterOrVectorOperator::Raster(_) => true,
            InitializedSingleRasterOrVectorOperator::Vector(_) => false,
        }
    }

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

pub struct InitializedSingleRasterOrVectorSource<
    R: InitializedRasterOperator,
    V: InitializedVectorOperator,
> {
    pub path: WorkflowOperatorPath,
    pub source: InitializedSingleRasterOrVectorOperator<R, V>,
}

pub enum InitializedMultiRasterOrVectorOperator<
    R: InitializedRasterOperator,
    V: InitializedVectorOperator,
> {
    Raster(Vec<R>),
    Vector(V),
}

impl<R: InitializedRasterOperator, V: InitializedVectorOperator>
    InitializedMultiRasterOrVectorOperator<R, V>
{
    pub fn is_raster(&self) -> bool {
        match self {
            InitializedMultiRasterOrVectorOperator::Raster(_) => true,
            InitializedMultiRasterOrVectorOperator::Vector(_) => false,
        }
    }

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

pub struct InitializedMultiRasterOrVectorSource<
    R: InitializedRasterOperator,
    V: InitializedVectorOperator,
> {
    pub path: WorkflowOperatorPath,
    pub source: InitializedMultiRasterOrVectorOperator<R, V>,
}

#[async_trait]
impl InitializedSources<InitializedSingleRasterSource<Box<dyn InitializedRasterOperator>>>
    for SingleRasterSource
{
    async fn initialize_sources(
        self,
        path: WorkflowOperatorPath,
        context: &dyn ExecutionContext,
    ) -> Result<InitializedSingleRasterSource<Box<dyn InitializedRasterOperator>>> {
        let op_path = path.clone_and_append(0);

        let op_initialized = self.raster.initialize(op_path, context).await?;
        Ok(InitializedSingleRasterSource {
            raster: op_initialized,
            path,
        })
    }
}

#[async_trait]
impl InitializedSources<InitializedSingleVectorSource<Box<dyn InitializedVectorOperator>>>
    for SingleVectorSource
{
    async fn initialize_sources(
        self,
        path: WorkflowOperatorPath,
        context: &dyn ExecutionContext,
    ) -> Result<InitializedSingleVectorSource<Box<dyn InitializedVectorOperator>>> {
        let op_path = path.clone_and_append(0);

        let op_initialized = self.vector.initialize(op_path, context).await?;
        Ok(InitializedSingleVectorSource {
            vector: op_initialized,
            path,
        })
    }
}

#[async_trait]
impl InitializedSources<InitializedMultipleRasterSources<Box<dyn InitializedRasterOperator>>>
    for MultipleRasterSources
{
    async fn initialize_sources(
        self,
        path: WorkflowOperatorPath,
        context: &dyn ExecutionContext,
    ) -> Result<InitializedMultipleRasterSources<Box<dyn InitializedRasterOperator>>> {
        let rasters = futures::future::try_join_all(
            self.rasters
                .into_iter()
                .enumerate()
                .map(|(i, op)| op.initialize(path.clone_and_append(i as u8), context)),
        )
        .await?;

        Ok(InitializedMultipleRasterSources { path, rasters })
    }
}

#[async_trait]
impl InitializedSources<InitializedMultipleVectorSources<Box<dyn InitializedVectorOperator>>>
    for MultipleVectorSources
{
    async fn initialize_sources(
        self,
        path: WorkflowOperatorPath,
        context: &dyn ExecutionContext,
    ) -> Result<InitializedMultipleVectorSources<Box<dyn InitializedVectorOperator>>> {
        let vectors = futures::future::try_join_all(
            self.vectors
                .into_iter()
                .enumerate()
                .map(|(i, op)| op.initialize(path.clone_and_append(i as u8), context)),
        )
        .await?;

        Ok(InitializedMultipleVectorSources { path, vectors })
    }
}

#[async_trait]
impl
    InitializedSources<
        InitializedSingleVectorMultipleRasterSources<
            Box<dyn InitializedVectorOperator>,
            Box<dyn InitializedRasterOperator>,
        >,
    > for SingleVectorMultipleRasterSources
{
    async fn initialize_sources(
        self,
        path: WorkflowOperatorPath,
        context: &dyn ExecutionContext,
    ) -> Result<
        InitializedSingleVectorMultipleRasterSources<
            Box<dyn InitializedVectorOperator>,
            Box<dyn InitializedRasterOperator>,
        >,
    > {
        let op_path = path.clone_and_append(0);
        let vector = self.vector.initialize(op_path, context).await?;

        let rasters = futures::future::try_join_all(
            self.rasters
                .into_iter()
                .enumerate()
                .map(|(i, op)| op.initialize(path.clone_and_append(i as u8 + 1), context)),
        )
        .await?;

        Ok(InitializedSingleVectorMultipleRasterSources {
            path,
            vector,
            rasters,
        })
    }
}

#[async_trait]
impl
    InitializedSources<
        InitializedSingleRasterOrVectorSource<
            Box<dyn InitializedRasterOperator>,
            Box<dyn InitializedVectorOperator>,
        >,
    > for SingleRasterOrVectorSource
{
    async fn initialize_sources(
        self,
        path: WorkflowOperatorPath,
        context: &dyn ExecutionContext,
    ) -> Result<
        InitializedSingleRasterOrVectorSource<
            Box<dyn InitializedRasterOperator>,
            Box<dyn InitializedVectorOperator>,
        >,
    > {
        let op_path = path.clone_and_append(0);

        let source = match self.source {
            RasterOrVectorOperator::Raster(raster) => {
                let raster = raster.initialize(op_path, context).await?;
                InitializedSingleRasterOrVectorOperator::Raster(raster)
            }
            RasterOrVectorOperator::Vector(vector) => {
                let vector = vector.initialize(op_path, context).await?;
                InitializedSingleRasterOrVectorOperator::Vector(vector)
            }
        };

        Ok(InitializedSingleRasterOrVectorSource { path, source })
    }
}

#[async_trait]
impl
    InitializedSources<
        InitializedMultiRasterOrVectorSource<
            Box<dyn InitializedRasterOperator>,
            Box<dyn InitializedVectorOperator>,
        >,
    > for MultipleRasterOrSingleVectorSource
{
    async fn initialize_sources(
        self,
        path: WorkflowOperatorPath,
        context: &dyn ExecutionContext,
    ) -> Result<
        InitializedMultiRasterOrVectorSource<
            Box<dyn InitializedRasterOperator>,
            Box<dyn InitializedVectorOperator>,
        >,
    > {
        let source = match self.source {
            MultiRasterOrVectorOperator::Vector(vector) => {
                let op_path = path.clone_and_append(0);

                let op_initialized = vector.initialize(op_path, context).await?;
                InitializedMultiRasterOrVectorOperator::Vector(op_initialized)
            }
            MultiRasterOrVectorOperator::Raster(r) => {
                let rasters = futures::future::try_join_all(
                    r.into_iter()
                        .enumerate()
                        .map(|(i, op)| op.initialize(path.clone_and_append(i as u8 + 1), context)),
                )
                .await?;

                InitializedMultiRasterOrVectorOperator::Raster(rasters)
            }
        };

        Ok(InitializedMultiRasterOrVectorSource { path, source })
    }
}

1	use async_trait::async_trait;
2
3	use crate::{
4	error::Error,
5	util::{
6	input::{MultiRasterOrVectorOperator, RasterOrVectorOperator},
7	Result,
8	},
9	};
10
11	use super::{
12	ExecutionContext, InitializedRasterOperator, InitializedVectorOperator,
13	MultipleRasterOrSingleVectorSource, MultipleRasterSources, MultipleVectorSources,
14	SingleRasterOrVectorSource, SingleRasterSource, SingleVectorMultipleRasterSources,
15	SingleVectorSource, WorkflowOperatorPath,
16	};
17
18	#[async_trait]
19	pub trait InitializedSources<Initialized, E = Error> {
20	/// Initialize the source operator(s) with a path
21	async fn initialize_sources(
22	self,
23	path: WorkflowOperatorPath,
24	context: &dyn ExecutionContext,
25	) -> Result<Initialized, E>;
26	}
27
28	pub struct InitializedSingleRasterSource<R: InitializedRasterOperator> {
29	pub raster: R,
30	pub path: WorkflowOperatorPath,
31	}
32
33	pub struct InitializedSingleVectorSource<V: InitializedVectorOperator> {
34	pub vector: V,
35	pub path: WorkflowOperatorPath,
36	}
37
38	pub struct InitializedMultipleRasterSources<R: InitializedRasterOperator> {
39	pub path: WorkflowOperatorPath,
40	pub rasters: Vec<R>,
41	}
42
43	pub struct InitializedMultipleVectorSources<V: InitializedVectorOperator> {
44	pub path: WorkflowOperatorPath,
45	pub vectors: Vec<V>,
46	}
47
48	pub struct InitializedSingleVectorMultipleRasterSources<
49	V: InitializedVectorOperator,
50	R: InitializedRasterOperator,
51	> {
52	pub path: WorkflowOperatorPath,
53	pub vector: V,
54	pub rasters: Vec<R>,
55	}
56
57	pub enum InitializedSingleRasterOrVectorOperator<
58	R: InitializedRasterOperator,
59	V: InitializedVectorOperator,
60	> {
61	Raster(R),
62	Vector(V),
63	}
64
65	impl<R: InitializedRasterOperator, V: InitializedVectorOperator>
66	InitializedSingleRasterOrVectorOperator<R, V>
67	{
68	pub fn is_raster(&self) -> bool {	×
69	match self {	×
70	InitializedSingleRasterOrVectorOperator::Raster(_) => true,	×
71	InitializedSingleRasterOrVectorOperator::Vector(_) => false,	×
72	}
73	}	×
74
75	pub fn is_vector(&self) -> bool {	×
76	match self {	×
77	InitializedSingleRasterOrVectorOperator::Raster(_) => false,	×
78	InitializedSingleRasterOrVectorOperator::Vector(_) => true,	×
79	}
80	}	×
81	}
82
83	pub struct InitializedSingleRasterOrVectorSource<
84	R: InitializedRasterOperator,
85	V: InitializedVectorOperator,
86	> {
87	pub path: WorkflowOperatorPath,
88	pub source: InitializedSingleRasterOrVectorOperator<R, V>,
89	}
90
91	pub enum InitializedMultiRasterOrVectorOperator<
92	R: InitializedRasterOperator,
93	V: InitializedVectorOperator,
94	> {
95	Raster(Vec<R>),
96	Vector(V),
97	}
98
99	impl<R: InitializedRasterOperator, V: InitializedVectorOperator>
100	InitializedMultiRasterOrVectorOperator<R, V>
101	{
102	pub fn is_raster(&self) -> bool {	×
103	match self {	×
104	InitializedMultiRasterOrVectorOperator::Raster(_) => true,	×
105	InitializedMultiRasterOrVectorOperator::Vector(_) => false,	×
106	}
107	}	×
108
109	pub fn is_vector(&self) -> bool {	×
110	match self {	×
111	InitializedMultiRasterOrVectorOperator::Raster(_) => false,	×
112	InitializedMultiRasterOrVectorOperator::Vector(_) => true,	×
113	}
114	}	×
115	}
116
117	pub struct InitializedMultiRasterOrVectorSource<
118	R: InitializedRasterOperator,
119	V: InitializedVectorOperator,
120	> {
121	pub path: WorkflowOperatorPath,
122	pub source: InitializedMultiRasterOrVectorOperator<R, V>,
123	}
124
125	#[async_trait]
126	impl InitializedSources<InitializedSingleRasterSource<Box<dyn InitializedRasterOperator>>>
127	for SingleRasterSource
128	{
129	async fn initialize_sources(
130	self,
131	path: WorkflowOperatorPath,
132	context: &dyn ExecutionContext,
133	) -> Result<InitializedSingleRasterSource<Box<dyn InitializedRasterOperator>>> {	88✔
134	let op_path = path.clone_and_append(0);	88✔
135		88✔
136	let op_initialized = self.raster.initialize(op_path, context).await?;	411✔
137	Ok(InitializedSingleRasterSource {	88✔
138	raster: op_initialized,	88✔
139	path,	88✔
140	})	88✔
141	}	88✔
142	}
143
144	#[async_trait]
145	impl InitializedSources<InitializedSingleVectorSource<Box<dyn InitializedVectorOperator>>>
146	for SingleVectorSource
147	{
148	async fn initialize_sources(
149	self,
150	path: WorkflowOperatorPath,
151	context: &dyn ExecutionContext,
152	) -> Result<InitializedSingleVectorSource<Box<dyn InitializedVectorOperator>>> {	49✔
153	let op_path = path.clone_and_append(0);	49✔
154		49✔
155	let op_initialized = self.vector.initialize(op_path, context).await?;	49✔
156	Ok(InitializedSingleVectorSource {	49✔
157	vector: op_initialized,	49✔
158	path,	49✔
159	})	49✔
160	}	49✔
161	}
162
163	#[async_trait]
164	impl InitializedSources<InitializedMultipleRasterSources<Box<dyn InitializedRasterOperator>>>
165	for MultipleRasterSources
166	{
167	async fn initialize_sources(
168	self,
169	path: WorkflowOperatorPath,
170	context: &dyn ExecutionContext,
171	) -> Result<InitializedMultipleRasterSources<Box<dyn InitializedRasterOperator>>> {	19✔
172	let rasters = futures::future::try_join_all(	19✔
173	self.rasters	19✔
174	.into_iter()	19✔
175	.enumerate()	19✔
176	.map(\|(i, op)\| op.initialize(path.clone_and_append(i as u8), context)),	45✔
177	)	19✔
178	.await?;	137✔
179		19✔
180	Ok(InitializedMultipleRasterSources { path, rasters })	19✔
181	}	19✔
182	}
183
184	#[async_trait]
185	impl InitializedSources<InitializedMultipleVectorSources<Box<dyn InitializedVectorOperator>>>
186	for MultipleVectorSources
187	{
188	async fn initialize_sources(
189	self,
190	path: WorkflowOperatorPath,
191	context: &dyn ExecutionContext,
192	) -> Result<InitializedMultipleVectorSources<Box<dyn InitializedVectorOperator>>> {	×
193	let vectors = futures::future::try_join_all(	×
194	self.vectors	×
195	.into_iter()	×
196	.enumerate()	×
197	.map(\|(i, op)\| op.initialize(path.clone_and_append(i as u8), context)),	×
198	)	×
199	.await?;	×
UNCOV 200		×
201	Ok(InitializedMultipleVectorSources { path, vectors })	×
202	}	×
203	}
204
205	#[async_trait]
206	impl
207	InitializedSources<
208	InitializedSingleVectorMultipleRasterSources<
209	Box<dyn InitializedVectorOperator>,
210	Box<dyn InitializedRasterOperator>,
211	>,
212	> for SingleVectorMultipleRasterSources
213	{
214	async fn initialize_sources(
215	self,
216	path: WorkflowOperatorPath,
217	context: &dyn ExecutionContext,
218	) -> Result<
219	InitializedSingleVectorMultipleRasterSources<
220	Box<dyn InitializedVectorOperator>,
221	Box<dyn InitializedRasterOperator>,
222	>,
223	> {	×
224	let op_path = path.clone_and_append(0);	×
225	let vector = self.vector.initialize(op_path, context).await?;	×
UNCOV 226		×
227	let rasters = futures::future::try_join_all(	×
228	self.rasters	×
229	.into_iter()	×
230	.enumerate()	×
231	.map(\|(i, op)\| op.initialize(path.clone_and_append(i as u8 + 1), context)),	×
232	)	×
233	.await?;	×
UNCOV 234		×
235	Ok(InitializedSingleVectorMultipleRasterSources {	×
236	path,	×
237	vector,	×
238	rasters,	×
239	})	×
240	}	×
241	}
242
243	#[async_trait]
244	impl
245	InitializedSources<
246	InitializedSingleRasterOrVectorSource<
247	Box<dyn InitializedRasterOperator>,
248	Box<dyn InitializedVectorOperator>,
249	>,
250	> for SingleRasterOrVectorSource
251	{
252	async fn initialize_sources(
253	self,
254	path: WorkflowOperatorPath,
255	context: &dyn ExecutionContext,
256	) -> Result<
257	InitializedSingleRasterOrVectorSource<
258	Box<dyn InitializedRasterOperator>,
259	Box<dyn InitializedVectorOperator>,
260	>,
261	> {	9✔
262	let op_path = path.clone_and_append(0);	9✔
263		9✔
264	let source = match self.source {	9✔
265	RasterOrVectorOperator::Raster(raster) => {	9✔
266	let raster = raster.initialize(op_path, context).await?;	9✔
267	InitializedSingleRasterOrVectorOperator::Raster(raster)	9✔
268	}	9✔
269	RasterOrVectorOperator::Vector(vector) => {	9✔
270	let vector = vector.initialize(op_path, context).await?;	9✔
271	InitializedSingleRasterOrVectorOperator::Vector(vector)	9✔
272	}	9✔
273	};	9✔
274		9✔
275	Ok(InitializedSingleRasterOrVectorSource { path, source })	9✔
276	}	9✔
277	}
278
279	#[async_trait]
280	impl
281	InitializedSources<
282	InitializedMultiRasterOrVectorSource<
283	Box<dyn InitializedRasterOperator>,
284	Box<dyn InitializedVectorOperator>,
285	>,
286	> for MultipleRasterOrSingleVectorSource
287	{
288	async fn initialize_sources(
289	self,
290	path: WorkflowOperatorPath,
291	context: &dyn ExecutionContext,
292	) -> Result<
293	InitializedMultiRasterOrVectorSource<
294	Box<dyn InitializedRasterOperator>,
295	Box<dyn InitializedVectorOperator>,
296	>,
297	> {	×
298	let source = match self.source {	×
299	MultiRasterOrVectorOperator::Vector(vector) => {	×
300	let op_path = path.clone_and_append(0);	×
UNCOV 301		×
302	let op_initialized = vector.initialize(op_path, context).await?;	×
303	InitializedMultiRasterOrVectorOperator::Vector(op_initialized)	×
UNCOV 304	}	×
305	MultiRasterOrVectorOperator::Raster(r) => {	×
306	let rasters = futures::future::try_join_all(	×
307	r.into_iter()	×
308	.enumerate()	×
309	.map(\|(i, op)\| op.initialize(path.clone_and_append(i as u8 + 1), context)),	×
310	)	×
311	.await?;	×
UNCOV 312		×
313	InitializedMultiRasterOrVectorOperator::Raster(rasters)	×
UNCOV 314	}	×
UNCOV 315	};	×
UNCOV 316		×
317	Ok(InitializedMultiRasterOrVectorSource { path, source })	×
318	}	×
319	}

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