daab 0.4.0

DAG aware artifact builder
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


use daab::rc::Cache;
use daab::rc::Resolver;
use daab::rc::Blueprint as Bp;
use daab::rc::Builder as Builder;
use daab::Never;
use daab::prelude::*;

use std::rc::Rc;

#[derive(Debug)]
struct FooArtifact;

#[derive(Debug)]
struct BazArtifact;

#[derive(Debug)]
struct BarArtifact {
	foo_artifact: Rc<FooArtifact>,
	baz_artifact: Rc<BazArtifact>
}

#[derive(Debug)]
struct FooBuilder;

impl Builder for FooBuilder {
	type Artifact = FooArtifact;
	type DynState = ();
	type Err = ();

	fn build(&self, _resolver: &mut Resolver) -> Result<Rc<Self::Artifact>, ()> {
		println!("Building FooArtifact...");
		Ok(Rc::new(FooArtifact))
	}
	fn init_dyn_state(&self) -> Self::DynState {
		// empty
	}
}

#[derive(Debug)]
struct BazBuilder;

impl Builder for BazBuilder {
	type Artifact = BazArtifact;
	type DynState = ();
	type Err = Never;

	fn build(&self, _resolver: &mut Resolver) -> Result<Rc<Self::Artifact>, Never> {
		println!("Building BazArtifact...");
		Ok(BazArtifact.into())
	}
	fn init_dyn_state(&self) -> Self::DynState {
		// empty
	}
}

#[derive(Debug)]
struct BarBuilder {
	foo_builder: Bp<FooBuilder>,
	baz_builder: Bp<BazBuilder>
}

impl Builder for BarBuilder {
	type Artifact = BarArtifact;
	type DynState = ();
	type Err = ();

	fn build(&self, resolver: &mut Resolver) -> Result<Rc<Self::Artifact>, ()> {
		let foo_artifact = resolver.resolve(&self.foo_builder)?;
		let baz_artifact = resolver.resolve(&self.baz_builder).unpack();
		println!("Building BarArtifact...");
		Ok(BarArtifact {
			foo_artifact,
			baz_artifact
		}.into())
	}
	fn init_dyn_state(&self) -> Self::DynState {
		// empty
	}
}

fn main() {
	let mut cache = Cache::new();

	let foo_builder = Bp::new(FooBuilder);
	let baz_builder = Bp::new(BazBuilder);
	let bar_builder = Bp::new(BarBuilder {
		foo_builder: foo_builder.clone(),
		baz_builder
	});

	println!("Taking FooBuilder dyn_state...");
	let dyn_st = cache.get_dyn_state(&foo_builder);
	dbg!(dyn_st);
	println!("Setting FooBuilder dyn_state...");
	*cache.dyn_state_mut(&foo_builder) = ();
	println!("Taking FooBuilder dyn_state...");
	let dyn_st = cache.get_dyn_state(&foo_builder);
	dbg!(dyn_st);
	println!("Taking FooBuilder dyn_state...");
	let dyn_st = cache.get_dyn_state(&foo_builder);
	dbg!(dyn_st);

	println!("Requesting BarArtifact...");
	cache.get_ref(&bar_builder).unwrap();
	println!("Requesting BarArtifact...");
	cache.get_ref(&bar_builder).unwrap();
	println!("Invalidating BarArtifact...");
	cache.invalidate(&bar_builder);
	println!("Requesting BarArtifact...");
	cache.get_ref(&bar_builder).unwrap();
	println!("Requesting BarArtifact...");
	cache.get_ref(&bar_builder).unwrap();
}