riddance 0.3.1

retiring, recyclable, reservable IDs
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

//! https://stackoverflow.com/questions/28418584/how-to-represent-shared-mutable-state/77399498#77399498

use riddance::{Id, Registry};

type PlayerId = Id<Player>;

struct Player {
    resource_ids: Vec<ResourceId>,
    points: i32,
}

type ResourceId = Id<Resource>;

struct Resource {
    owner_id: PlayerId,
}

struct GameState {
    players: Registry<Player>,
    resources: Registry<Resource>,
}

fn new_player(state: &mut GameState) -> PlayerId {
    state.players.insert(Player {
        points: 0,
        resource_ids: Vec::new(),
    })
}

fn new_resource(state: &mut GameState, owner_id: PlayerId) -> ResourceId {
    let new_id = state.resources.insert(Resource { owner_id });
    state.players[owner_id].resource_ids.push(new_id);
    state.players[owner_id].points += 30;
    new_id
}

fn main() {
    let mut state = GameState {
        players: Registry::new(),
        resources: Registry::new(),
    };
    let player_id = new_player(&mut state);
    let resource_id = new_resource(&mut state, player_id);
    assert_eq!(state.resources[resource_id].owner_id, player_id);
    assert!(state.players[player_id].resource_ids.contains(&resource_id));
}