gtether 0.2.3

Highly concurrent multiplayer focused game engine, with an emphasis on realtime streamable asset management.
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

use crate::resource::id::ResourceId;
use crate::resource::source::{ResourceSource, SealedResourceDataResult, SealedResourceDataSource, SourceIndex};
use crate::resource::ResourceLoadError;

pub(in crate::resource) struct Sources {
    inner: Vec<Box<dyn ResourceSource>>,
}

impl Sources {
    #[inline]
    pub fn new(sources: impl IntoIterator<Item=Box<dyn ResourceSource>>) -> Self {
        Self {
            inner: sources.into_iter().collect(),
        }
    }

    pub fn watch_n(&self, id: &ResourceId, source_idx: &SourceIndex) {
        for (idx, source) in self.inner.iter().enumerate() {
            if idx <= source_idx.idx() {
                source.watcher().watch(id.clone(), source_idx.sub_idx().cloned());
            } else {
                source.watcher().unwatch(id);
            }
        }
    }

    pub fn find_hash(&self, id: &ResourceId) -> Option<SealedResourceDataSource> {
        for (idx, source) in self.inner.iter().enumerate() {
            match source.hash(id) {
                Some(hash) => return Some(hash.seal(idx)),
                None => {},
            }
        }
        None
    }

    pub async fn find_data(&self, id: &ResourceId) -> Option<SealedResourceDataResult> {
        for (idx, source) in self.inner.iter().enumerate() {
            match source.load(id).await {
                Ok(data) => return Some(Ok(data.seal(idx))),
                Err(ResourceLoadError::NotFound(_)) => {},
                Err(e) => return Some(Err(e)),
            }
        }
        None
    }
}