score 0.2.0

Discrete event simulation library
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

// Copyright (C) 2017 Jesse Jones
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 3, or (at your option)
// any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software Foundation,
// Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

//! `IntValue` and `FloatValue` and `StringValue` are simple wrappers around an
//! [`Effector`]. They don't do very much but they assist in creating type safe
//! [`Component`] structs. See the [`set_value`] macro for an example.
use effector::*;

pub struct IntValue
{
}

pub struct FloatValue
{
}

pub struct StringValue
{
}

impl IntValue
{
	/// This is normally called via the set_value! macro.
	pub fn set_value(&self, effector: &mut Effector, name: &str, value: i64)
	{
		effector.set_int(name, value);
	}
}

impl FloatValue
{
	/// This is normally called via the set_value! macro.
	pub fn set_value(&self, effector: &mut Effector, name: &str, value: f64)
	{
		effector.set_float(name, value);
	}
}

impl StringValue
{
	/// This is normally called via the set_value! macro.
	pub fn set_value(&self, effector: &mut Effector, name: &str, value: &str)
	{
		effector.set_string(name, value);
	}
}

/// Type safe way to update the simulation [`Store`].
///
/// # Examples
///
/// ```
/// use score::*;
///
/// struct InterfaceComponent
/// {
/// 	tx_packets: IntValue,
/// }
///
/// fn reset(iface: InterfaceComponent, mut effector: Effector)
/// {
/// 	// The effector is actually the object that is updated.
/// 	// When the component finishes processing the current event
/// 	// the simulation will apply all the effects from effectors.
/// 	set_value!(effector, iface.tx_packets = 0);
/// }
/// ```
#[macro_export]
macro_rules! set_value
{
	($effector:ident, $target:ident . $field:ident = $value:expr) => ({
		$target.$field.set_value(&mut $effector, stringify!($field), $value);
	});
}