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

// 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.
use component::*;
use effector::*;
use event::*;
use sim_state::*;
use std::sync::mpsc;

/// This is moved into each thread of an active `Component`.
pub struct ThreadData
{
	/// The ID of the `Component` bound to the thread instance.
	pub id: ComponentID,

	/// Threads receive from this in order to process `Event`s sent to them.
	/// Normally called via the process_events! macro.
	pub rx: mpsc::Receiver<(Event, SimState)>,
	
	/// Threads use this to send their side effects back to the simulation using
	/// an [`Effector`]. Normally called via the process_events! macro.
	pub tx: mpsc::Sender<Effector>,
	
	/// In order to have deterministic simuluations randomness has to be carefully
	/// controlled. Each component thread is given its own random number generator
	/// seed which should be the only source of randomness used by the thread.
	///
	/// # Examples
	///
	/// ```
	/// #[macro_use]
	/// extern crate score;
	/// extern crate rand;
	///
	/// use rand::{Rng, SeedableRng, StdRng};
	/// use score::*;
	/// use std::thread;
	///
	/// fn component_thread(data: ThreadData)
	/// {
	/// 	let mut rng = StdRng::from_seed(&[data.seed]);
	/// 	thread::spawn(move || {
	/// 		process_events!(data, event, state, effector,
	/// 			"init 0" => {
	/// 				if rng.gen::<bool>() {
	/// 					log_info!(effector, "heads");
	/// 				} else {
	/// 					log_info!(effector, "tails");
	/// 				}
	/// 			}
	/// 		);
	/// 	});
	/// }
	/// # fn main() {
	/// # }
	/// ```
	pub seed: usize,	// TODO: document stuff to be careful of, eg HashMap iteration
}

impl ThreadData
{
	pub(crate) fn new(id: ComponentID, rx: mpsc::Receiver<(Event, SimState)>, tx: mpsc::Sender<Effector>, seed: usize) -> ThreadData
	{
		ThreadData{id, rx, tx, seed: seed}
	}
}