mc-core 0.1.1

MinecraftRS - Minimal core implementation of Minecraft backend.
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

use std::sync::RwLock;
use std::collections::{HashMap, HashSet};

use once_cell::sync::OnceCell;

use crate::block::{Block, BlockKey};


/// A map structure that maps blocks (defined statically) to a value.
#[repr(transparent)]
pub struct BlockMap<T>(pub HashMap<BlockKey, T>);

impl<T> BlockMap<T> {

    pub fn new() -> Self {
        Self(HashMap::new())
    }

    pub fn insert(&mut self, block: &'static Block, value: T) -> Option<T> {
        self.0.insert(block.get_key(), value)
    }

    pub fn remove(&mut self, block: &'static Block) -> Option<T> {
        self.0.remove(&block.get_key())
    }

    pub fn get(&self, block: &'static Block) -> Option<&T> {
        self.0.get(&block.get_key())
    }

}

/// A set structure that store blocks.
#[repr(transparent)]
pub struct BlockSet(pub HashSet<BlockKey>);

impl BlockSet {

    pub fn new() -> Self {
        Self(HashSet::new())
    }

    pub fn insert(&mut self, block: &'static Block) -> bool {
        self.0.insert(block.get_key())
    }

    pub fn extend<I: IntoIterator<Item = &'static Block>>(&mut self, iter: I) {
        self.0.extend(iter.into_iter().map(|b| b.get_key()));
    }

    pub fn remove(&mut self, block: &'static Block) -> bool {
        self.0.remove(&block.get_key())
    }

    pub fn contains(&self, block: &'static Block) -> bool {
        self.0.contains(&block.get_key())
    }

}



pub struct BlockStaticMap<T> {
    inner: OnceCell<RwLock<BlockMap<T>>>
}

impl<T> BlockStaticMap<T> {

    pub const fn new() -> Self {
        Self { inner: OnceCell::new() }
    }

    pub fn inner(&self) -> &RwLock<BlockMap<T>> {
        self.inner.get_or_init(|| RwLock::new(BlockMap::new()))
    }

    pub fn insert(&self, block: &'static Block, value: T) -> Option<T> {
        self.inner().write().unwrap().insert(block, value)
    }

    pub fn insert_with(&self, func: impl FnOnce(&mut BlockMap<T>)) {
        let mut map_guard = self.inner().write().unwrap();
        (func)(&mut *map_guard);
    }

    pub fn remove(&self, block: &'static Block) -> Option<T> {
        self.inner().write().unwrap().remove(block)
    }

    pub fn get(&self, block: &'static Block) -> Option<T>
    where
        T: Copy
    {
        self.inner().read().unwrap().get(block).copied()
    }

}


pub struct BlockStaticSet {
    inner: OnceCell<RwLock<BlockSet>>
}

impl BlockStaticSet {

    pub const fn new() -> Self {
        Self { inner: OnceCell::new() }
    }

    pub fn inner(&self) -> &RwLock<BlockSet> {
        self.inner.get_or_init(|| RwLock::new(BlockSet::new()))
    }

    pub fn insert(&self, block: &'static Block) -> bool {
        self.inner().write().unwrap().insert(block)
    }

    pub fn insert_with(&self, func: impl FnOnce(&mut BlockSet)) {
        let mut set_guard = self.inner().write().unwrap();
        (func)(&mut *set_guard);
    }

    pub fn extend<I: IntoIterator<Item = &'static Block>>(&self, iter: I) {
        self.inner().write().unwrap().extend(iter);
    }

    pub fn remove(&self, block: &'static Block) -> bool {
        self.inner().write().unwrap().remove(block)
    }

    pub fn contains(&self, block: &'static Block) -> bool {
        self.inner().read().unwrap().contains(block)
    }

}