recluse 0.1.1

A web crawler framework for Rust
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

use std::{pin::Pin, task::{Context, Poll}};

/// Generic select implementation that works with any two futures.
/// 
/// Usage:
/// 
/// ```rust
/// let either_fut = Select::new(fut1, fut2).await;
/// 
/// match either_fut {
///     Either::Left(value) => { /**/ },
///     Either::Right(value) => { /**/ },
/// }
/// ```
pub struct Select<F1, F2> {
    future1: Pin<Box<F1>>,
    future2: Pin<Box<F2>>,
}

impl<F1, F2> Select<F1, F2>
where
    F1: Future,
    F2: Future,
{
    pub fn new(future1: F1, future2: F2) -> Self {
        Self {
            future1: Box::pin(future1),
            future2: Box::pin(future2),
        }
    }
}

#[derive(Debug)]
pub enum Either<A, B> {
    Left(A),
    Right(B),
}

impl<F1, F2> Future for Select<F1, F2>
where
    F1: Future,
    F2: Future,
{
    type Output = Either<F1::Output, F2::Output>;

    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
        // Try polling the first future
        if let Poll::Ready(output) = self.future1.as_mut().poll(cx) {
            return Poll::Ready(Either::Left(output));
        }

        // Try polling the second future
        if let Poll::Ready(output) = self.future2.as_mut().poll(cx) {
            return Poll::Ready(Either::Right(output));
        }

        // Neither future is ready
        Poll::Pending
    }
}