cvar 0.2.0

Configuration variables.
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

/*!

This example demonstrates how properties can be created and destroyed at runtime.
!*/

#[derive(Debug, Default)]
struct RuntimeProps {
	// Store the list of runtime properties somewhere
	props: Vec<Box<cvar::IProperty>>,
}
impl RuntimeProps {
	// Action to create new properties
	fn create(&mut self, args: &[&str], console: &mut cvar::IConsole) {
		if args.len() != 3 {
			let _ = writeln!(console, "Invalid arguments! expecting <type> <name> <value>");
			return;
		}
		match args[0] {
			"string" => {
				let prop = cvar::OwnedProp(args[1].into(), String::from(args[2]), String::from(args[2]));
				self.props.push(Box::new(prop));
			},
			"int" => {
				let value: i32 = args[2].parse().unwrap();
				let prop = cvar::OwnedProp(args[1].into(), value, value);
				self.props.push(Box::new(prop));
			},
			"float" => {
				let value: f32 = args[2].parse().unwrap();
				let prop = cvar::OwnedProp(args[1].into(), value, value);
				self.props.push(Box::new(prop));
			},
			_ => {
				let _ = writeln!(console, "Invalid type! supports string, int or float");
			},
		}
	}
	// Action to remove properties
	fn destroy(&mut self, args: &[&str], console: &mut cvar::IConsole) {
		if args.len() != 1 {
			let _ = writeln!(console, "Invalid arguments! expecting the name of the property to remove");
			return;
		}
		self.props.retain(|prop| prop.name() != args[0]);
	}
}
impl cvar::IVisit for RuntimeProps {
	fn visit_mut(&mut self, f: &mut FnMut(&mut cvar::INode)) {
		f(&mut cvar::Action("create!", "", |args, console| self.create(args, console)));
		f(&mut cvar::Action("destroy!", "", |args, console| self.destroy(args, console)));
		for prop in &mut self.props {
			f(prop.as_inode_mut());
		}
	}
}

fn main() {
	let mut runtime_props = RuntimeProps::default();

	// Create some runtime props
	let mut output = String::new();
	cvar::console::invoke(&mut runtime_props, "create!", &["float", "f", "3.141592"], &mut output);
	cvar::console::invoke(&mut runtime_props, "create!", &["string", "s", "Hello World!"], &mut output);
	cvar::console::invoke(&mut runtime_props, "create!", &["int", "i", "42"], &mut output);

	// Inspect the underlying props
	assert_eq!(runtime_props.props.len(), 3);
	assert_eq!(runtime_props.props[0].get(), "3.141592");
	assert_eq!(runtime_props.props[1].get(), "Hello World!");
	assert_eq!(runtime_props.props[2].get(), "42");

	println!("Hit enter to list all the cvars and their values.");
	println!("Assign value to cvar with `<name> <value>`.");
	println!("Create new cvars with `create! <type> <name> <value>`.");
	println!("Destroy the cvars with `destroy! <name>.");

	loop {
		// Read input from stdin
		let mut line = String::new();
		if read_line(&mut line) {
			break;
		}

		// Crude command line parsing
		let args: Vec<&str> = line.split_whitespace().collect();

		// Print the tree of props if empty
		if args.is_empty() {
			cvar::console::walk(&mut runtime_props, |path, node| {
				match node.as_node_mut() {
					cvar::NodeMut::Prop(prop) => {
						println!("{} `{}`", path, prop.get());
					},
					cvar::NodeMut::List(_list) => (),
					cvar::NodeMut::Action(_act) => {
						println!("{}", path);
					},
				}
			});
			continue;
		}

		// Find the node the user wants to interact with
		let path = args[0];
		let args = &args[1..];
		if !cvar::console::find(&mut runtime_props, path, |node| {
			match node.as_node_mut() {
				cvar::NodeMut::Prop(prop) => {
					// If we passed any arguments, try to set the value
					if args.len() > 0 {
						if let Err(err) = prop.set(args[0]) {
							println!("Cannot parse `{}`: {}.", args[0], err);
						}
					}
					// In any case print the value the prop currently has
					println!("{} `{}`", path, prop.get());
				},
				cvar::NodeMut::Action(act) => {
					// Redirect output to stdout
					let mut console = cvar::IoConsole::stdout();
					act.invoke(args, &mut console);
				},
				cvar::NodeMut::List(_) => {},
			}
		}) {
			println!("Cannot find `{}`", path);
		}
	}
}

// Reads a line from stdin and return true if there was a break
pub fn read_line(line: &mut String) -> bool {
	use std::io;
	print!(">>> ");
	let _ = io::Write::flush(&mut io::stdout());
	return io::stdin().read_line(line).is_err() || line.is_empty();
}