tiled 0.15.0

A rust crate for loading maps created by the Tiled editor
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

use std::io::BufReader;
use std::{fs::File, io::Read, path::Path};

/// A trait defining types that can load data from a [`ResourcePath`](crate::ResourcePath).
///
/// This trait should be implemented if you wish to load data from a virtual filesystem.
///
/// ## Example
/// ```
/// use std::io::Cursor;
///
/// /// Basic example reader impl that just keeps a few resources in memory
/// struct MemoryReader;
///
/// impl tiled::ResourceReader for MemoryReader {
///     type Resource = Cursor<&'static [u8]>;
///     type Error = std::io::Error;
///
///     fn read_from(&mut self, path: &std::path::Path) -> std::result::Result<Self::Resource, Self::Error> {
///         if path == std::path::Path::new("my_map.tmx") {
///             Ok(Cursor::new(include_bytes!("../assets/tiled_xml.tmx")))
///         } else {
///             Err(std::io::Error::new(std::io::ErrorKind::NotFound, "file not found"))
///         }
///     }
/// }
/// ```
pub trait ResourceReader {
    /// The type of the resource that the reader provides. For example, for
    /// [`FilesystemResourceReader`], this is defined as [`File`].
    type Resource: Read;
    /// The type that is returned if [`read_from()`](Self::read_from()) fails. For example, for
    /// [`FilesystemResourceReader`], this is defined as [`std::io::Error`].
    type Error: std::error::Error + Send + Sync + 'static;

    /// Try to return a reader object from a path into the resources filesystem.
    fn read_from(&mut self, path: &Path) -> std::result::Result<Self::Resource, Self::Error>;
}

/// A [`ResourceReader`] that reads from [`File`] handles.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct FilesystemResourceReader;

impl FilesystemResourceReader {
    /// Creates a new [`FilesystemResourceReader`].
    pub fn new() -> Self {
        Self
    }
}

impl ResourceReader for FilesystemResourceReader {
    type Resource = BufReader<File>;
    type Error = std::io::Error;

    fn read_from(&mut self, path: &Path) -> std::result::Result<Self::Resource, Self::Error> {
        let file = File::open(path)?;
        Ok(BufReader::new(file))
    }
}

impl<T, R, E> ResourceReader for T
where
    T: for<'a> Fn(&'a Path) -> Result<R, E>,
    R: Read,
    E: std::error::Error + Send + Sync + 'static,
{
    type Resource = R;

    type Error = E;

    fn read_from(&mut self, path: &Path) -> std::result::Result<Self::Resource, Self::Error> {
        self(path)
    }
}