sfml 0.25.1

Rust binding for sfml
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

#![doc = include_str!("../README.md")]
#![warn(
    missing_docs,
    trivial_numeric_casts,
    missing_copy_implementations,
    missing_debug_implementations,
    unused_results,
    trivial_casts,
    unsafe_op_in_unsafe_fn,
    unsafe_attr_outside_unsafe,
    clippy::must_use_candidate,
    clippy::doc_markdown,
    clippy::cast_possible_truncation,
    clippy::mut_mut,
    clippy::cast_possible_wrap,
    clippy::cast_sign_loss,
    clippy::unwrap_used,
    clippy::unreadable_literal,
    clippy::ptr_as_ptr,
    clippy::cast_lossless,
    clippy::missing_panics_doc
)]

extern crate link_cplusplus;

#[macro_use]
mod ffi;

pub mod cpp;

#[cfg(feature = "audio")]
pub mod audio;
#[cfg(feature = "graphics")]
pub mod graphics;
pub mod system;
#[cfg(feature = "window")]
pub mod window;
use std::{error::Error, fmt::Display};

/// An SFML operation has failed
#[derive(Clone, Copy, Debug)]
pub enum SfError {
    /// An string argument passed had interior nul bytes
    NulInStr,
    /// Call to SFML function returned an error
    CallFailed,
}

impl Display for SfError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            SfError::NulInStr => write!(f, "Interior nul byte in string passed to SFML"),
            SfError::CallFailed => write!(f, "Call to SFML function returned an error"),
        }
    }
}

impl From<std::ffi::NulError> for SfError {
    fn from(_value: std::ffi::NulError) -> Self {
        Self::NulInStr
    }
}

impl Error for SfError {}

/// Result of a fallible SFML operation
pub type SfResult<T> = Result<T, SfError>;

trait IntoSfResult<T> {
    fn into_sf_result(self) -> SfResult<T>;
}

impl IntoSfResult<()> for bool {
    fn into_sf_result(self) -> SfResult<()> {
        if self {
            Ok(())
        } else {
            Err(SfError::CallFailed)
        }
    }
}

impl<T: ?Sized> IntoSfResult<cpp::FBox<T>> for Option<cpp::FBox<T>> {
    fn into_sf_result(self) -> SfResult<cpp::FBox<T>> {
        self.ok_or(SfError::CallFailed)
    }
}