astu 0.0.0

Astu library
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
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145

mod graph;
pub mod provider;
mod target;

use std::collections::BTreeSet;

use anyhow::Result;
use futures::stream::BoxStream;
use futures::StreamExt;

pub use self::graph::TargetGraph;
pub use self::target::Target;

/// Map targets to targets.
///
/// Unsupported target types should just return empty streams instead of
/// erroring.
pub trait Resolve {
    /// Resolve a target query.
    fn resolve_fallible(&self, target: Target) -> BoxStream<Result<Target>>;

    /// Like [`Resolve::resolve_fallible`], but ignores all errors.
    fn resolve(&self, target: Target) -> BoxStream<Target> {
        self.resolve_fallible(target)
            .map(futures::stream::iter)
            .flatten()
            .boxed()
    }

    /// Resolve multiple target queries at once.
    ///
    /// The default implementation simply resolves in serial. Override this if a
    /// more efficient implementation exists.
    fn bulk_resolve_fallible(&self, targets: Vec<Target>) -> BoxStream<Result<Target>>
    where
        Self: Sync,
    {
        futures::stream::iter(targets)
            .map(|t| self.resolve_fallible(t))
            .flatten()
            .boxed()
    }

    /// Like [`Resolve::bulk_resolve_fallible`], but ignores all errors.
    fn bulk_resolve(&self, targets: Vec<Target>) -> BoxStream<Target>
    where
        Self: Sync,
    {
        self.bulk_resolve_fallible(targets)
            .map(futures::stream::iter)
            .flatten()
            .boxed()
    }
}

/// An extension trait for [`Resolve`] that provides a variety of convenient
/// combinator functions.
///
/// This is especially useful for holding the `async` functions would otherwise
/// make the main trait dyn-incompatible.
pub trait ResolveExt: Resolve {
    /// Resolve targets to a new set.
    async fn resolve_set(&self, target: Target) -> BTreeSet<Target>;

    /// Resolve targets into an existing set.
    async fn resolve_into_set(&self, target: Target, set: &mut BTreeSet<Target>);

    /// Resolve targets into an existing graph.
    async fn resolve_into_graph(&self, target: Target, graph: &mut TargetGraph);

    /// Resolve targets into an existing graph, with the parent->child
    /// relationship reversed.
    ///
    /// This is useful when called by reverse resolvers.
    async fn resolve_into_graph_reverse(&self, target: Target, graph: &mut TargetGraph);

    /// Like [`ResolveExt::resolve_set`] but for bulk targets.
    async fn bulk_resolve_set(&self, targets: Vec<Target>) -> BTreeSet<Target>
    where
        Self: Sync;

    /// Like [`ResolveExt::resolve_into_set`] but for bulk targets.
    async fn bulk_resolve_into_set(&self, targets: Vec<Target>, set: &mut BTreeSet<Target>)
    where
        Self: Sync;
}

impl<R> ResolveExt for R
where
    R: Resolve,
{
    async fn resolve_set(&self, target: Target) -> BTreeSet<Target> {
        self.resolve(target).collect().await
    }

    async fn resolve_into_set(&self, target: Target, set: &mut BTreeSet<Target>) {
        let mut targets = self.resolve(target);
        while let Some(target) = targets.next().await {
            set.insert(target);
        }
    }

    async fn resolve_into_graph(&self, target: Target, graph: &mut TargetGraph) {
        let parent = target.clone().intern();
        graph.add_node(parent);

        let mut targets = self.resolve(target);
        while let Some(child) = targets.next().await {
            // Avoid having targets refer to themselves
            if child != *parent {
                graph.add_edge(parent, child.intern());
            }
        }
    }

    async fn resolve_into_graph_reverse(&self, target: Target, graph: &mut TargetGraph) {
        let child = target.clone().intern();
        graph.add_node(child);

        let mut targets = self.resolve(target);
        while let Some(parent) = targets.next().await {
            // Avoid having targets refer to themselves
            if parent != *child {
                graph.add_edge(parent.intern(), child);
            }
        }
    }

    async fn bulk_resolve_set(&self, targets: Vec<Target>) -> BTreeSet<Target>
    where
        Self: Sync,
    {
        self.bulk_resolve(targets).collect().await
    }

    async fn bulk_resolve_into_set(&self, targets: Vec<Target>, set: &mut BTreeSet<Target>)
    where
        Self: Sync,
    {
        let mut targets = self.bulk_resolve(targets);
        while let Some(target) = targets.next().await {
            set.insert(target);
        }
    }
}