cosmic-space 0.3.14

the Space portion of starlane as opposed to hyperspace
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

use crate::artifact::ArtRef;
use crate::config::mechtron::MechtronConfig;
use crate::{Bin, BindConfig, SpaceErr, Stub};
use dashmap::DashMap;
use std::sync::Arc;
use crate::point::Point;

#[derive(Clone)]
pub struct ArtifactApi {
    binds: Arc<DashMap<Point, Arc<BindConfig>>>,
    mechtrons: Arc<DashMap<Point, Arc<MechtronConfig>>>,
    raw: Arc<DashMap<Point, Arc<Vec<u8>>>>,
    fetcher: Arc<dyn ArtifactFetcher>,
}

impl ArtifactApi {
    pub fn new(fetcher: Arc<dyn ArtifactFetcher>) -> Self {
        Self {
            binds: Arc::new(DashMap::new()),
            mechtrons: Arc::new(DashMap::new()),
            raw: Arc::new(DashMap::new()),
            fetcher,
        }
    }

    pub fn mechtron(&self, point: &Point) -> Result<ArtRef<MechtronConfig>, SpaceErr> {
        {
            if self.mechtrons.contains_key(point) {
                let mechtron = self.mechtrons.get(point).unwrap().clone();
                return Ok(ArtRef::new(mechtron, point.clone()));
            }
        }

        let mechtron: Arc<MechtronConfig> = Arc::new(self.fetch(point)?);
        self.mechtrons.insert(point.clone(), mechtron.clone());
        return Ok(ArtRef::new(mechtron, point.clone()));
    }

    pub fn bind(&self, point: &Point) -> Result<ArtRef<BindConfig>, SpaceErr> {
        {
            if self.binds.contains_key(point) {
                let bind = self.binds.get(point).unwrap().clone();
                return Ok(ArtRef::new(bind, point.clone()));
            }
        }

        let bind: Arc<BindConfig> = Arc::new(self.fetch(point)?);
        {
            self.binds.insert(point.clone(), bind.clone());
        }
        return Ok(ArtRef::new(bind, point.clone()));
    }

    pub fn raw(&self, point: &Point) -> Result<ArtRef<Vec<u8>>, SpaceErr> {
        if self.binds.contains_key(point) {
            let bin = self.raw.get(point).unwrap().clone();
            return Ok(ArtRef::new(bin, point.clone()));
        }

        let bin = self.fetcher.fetch(point)?;

        self.raw.insert(point.clone(), bin.clone());

        return Ok(ArtRef::new(bin, point.clone()));
    }

    fn fetch<A>(&self, point: &Point) -> Result<A, SpaceErr>
    where
        A: TryFrom<Bin, Error = SpaceErr>,
    {
        if !point.has_bundle() {
            return Err("point is not from a bundle".into());
        }
        let bin = self.fetcher.fetch(point)?;
        Ok(A::try_from(bin)?)
    }
}
#[async_trait]
pub trait ArtifactFetcher: Send + Sync {
    fn stub(&self, point: &Point) -> Result<Stub, SpaceErr>;
    fn fetch(&self, point: &Point) -> Result<Bin, SpaceErr>;
}