libpobsd 0.4.0

Library to interact with the PlayOnBSD database
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

//! Provides a queryable representation of the PlayOnBSD database.
use crate::models::Game;

use paste::paste;
#[cfg(feature = "serde")]
use serde::{Deserialize, Serialize};
use std::collections::HashMap;

macro_rules! load_game {
    (items: $($item:ident),+; arrays: $($array:ident),+) => {
        paste! {
            /// Load game into the database
            pub fn load_game(&mut self, game: Game) {
                let uid = game.uid;
                self.add_game(game);
                let game = self.games.get(&uid).unwrap().clone();
                $(
                    if let Some(item) = &game.$item {
                        self.[<add_game_to_ $item s>](&item, game.uid);
                    }
                )*
                $(
                    if let Some(items) = &game.$array {
                        for item in items {
                            self.[<add_game_to_ $array>](&item, game.uid);
                        }
                    }
                )*
            }
        }
    };
}

macro_rules! add_game_to {
    ($field:ident) => {
        paste! {
            fn [<add_game_to_ $field>](&mut self, item: &str, game_id: u32) {
                match self.[<$field>].get_mut(item) {
                    Some(item) => item.push(game_id),
                    None => {
                        let _ = self.[<$field>].insert(item.into(), vec![game_id]);
                    }
                }
            }
        }
    };
}

/// Queryable representation of the PlayOnBSD database
#[derive(Default, Clone)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
pub struct GameDataBase {
    /// HashMap using the game uid as key and the corresponding game as value
    pub(crate) games: HashMap<u32, Game>,
    /// HashMap using the engine name as key and vector of game uid corresponding to said engine as value
    pub(crate) engines: HashMap<String, Vec<u32>>,
    /// HashMap using the runtime name as key and vector of game uid corresponding to said engine as value
    pub(crate) runtimes: HashMap<String, Vec<u32>>,
    /// HashMap using the genre name as key and vector of game uid corresponding to said engine as value
    pub(crate) genres: HashMap<String, Vec<u32>>,
    /// HashMap using the tag name as key and vector of game uid corresponding to said engine as value
    pub(crate) tags: HashMap<String, Vec<u32>>,
    /// HashMap using the year as key and vector of game uid corresponding to said engine as value
    pub(crate) years: HashMap<String, Vec<u32>>,
    /// HashMap using the dev name as key and vector of game uid corresponding to said engine as value
    pub(crate) devs: HashMap<String, Vec<u32>>,
    /// HashMap using the pub name as key and vector of game uid corresponding to said engine as value
    pub(crate) publis: HashMap<String, Vec<u32>>,
}

impl GameDataBase {
    /// Create a database from a vector of games
    pub fn new(games: Vec<Game>) -> Self {
        let mut db = GameDataBase::default();
        for game in games {
            db.load_game(game);
        }
        db
    }
    load_game!(
        items: engine, runtime, year;
        arrays: devs, publis, genres, tags
    );

    fn add_game(&mut self, game: Game) {
        self.games.insert(game.uid, game);
    }

    add_game_to!(tags);
    add_game_to!(engines);
    add_game_to!(runtimes);
    add_game_to!(genres);
    add_game_to!(years);
    add_game_to!(devs);
    add_game_to!(publis);
}