godot-ffi 0.5.2

Internal crate used by godot-rust
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

/*
 * Copyright (c) godot-rust; Bromeon and contributors.
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at https://mozilla.org/MPL/2.0/.
 */

//! Assertion macros for compile-time and runtime checks with different safeguard levels.

// ----------------------------------------------------------------------------------------------------------------------------------------------
// Compile-time assertions

/// Verifies a condition at compile time.
// https://blog.rust-lang.org/2021/12/02/Rust-1.57.0.html#panic-in-const-contexts
#[macro_export]
macro_rules! static_assert {
    ($cond:expr_2021) => {
        const _: () = assert!($cond);
    };
    ($cond:expr_2021, $msg:literal) => {
        const _: () = assert!($cond, $msg);
    };
}

/// Verifies at compile time that two types `T` and `U` have the same size and alignment.
#[macro_export]
macro_rules! static_assert_eq_size_align {
    ($T:ty, $U:ty) => {
        godot_ffi::static_assert!(
            std::mem::size_of::<$T>() == std::mem::size_of::<$U>()
                && std::mem::align_of::<$T>() == std::mem::align_of::<$U>()
        );
    };
    ($T:ty, $U:ty, $msg:literal) => {
        godot_ffi::static_assert!(
            std::mem::size_of::<$T>() == std::mem::size_of::<$U>()
                && std::mem::align_of::<$T>() == std::mem::align_of::<$U>(),
            $msg
        );
    };
}

// ----------------------------------------------------------------------------------------------------------------------------------------------
// Runtime assertions - strict mode

/// Acts like `assert!` when `safeguards_strict` is enabled (default in debug builds), and becomes a no-op otherwise.
#[macro_export]
macro_rules! strict_assert {
    ($($arg:tt)*) => {
        #[cfg(safeguards_strict)] #[cfg_attr(published_docs, doc(cfg(safeguards_strict)))]
        assert!($($arg)*);
    };
}

/// Acts like `assert_eq!` when `safeguards_strict` is enabled (default in debug builds), and becomes a no-op otherwise.
#[macro_export]
macro_rules! strict_assert_eq {
    ($actual:expr_2021, $expected:expr_2021) => {
        #[cfg(safeguards_strict)] #[cfg_attr(published_docs, doc(cfg(safeguards_strict)))]
        assert_eq!($actual, $expected);
    };
    ($actual:expr_2021, $expected:expr_2021, $($arg:tt)*) => {
        #[cfg(safeguards_strict)] #[cfg_attr(published_docs, doc(cfg(safeguards_strict)))]
        assert_eq!($actual, $expected, $($arg)*);
    };
}

/// Acts like `assert_ne!` when `safeguards_strict` is enabled (default in debug builds), and becomes a no-op otherwise.
#[macro_export]
macro_rules! strict_assert_ne {
    ($actual:expr_2021, $expected:expr_2021) => {
        #[cfg(safeguards_strict)] #[cfg_attr(published_docs, doc(cfg(safeguards_strict)))]
        assert_ne!($actual, $expected);
    };
    ($actual:expr_2021, $expected:expr_2021, $($arg:tt)*) => {
        #[cfg(safeguards_strict)] #[cfg_attr(published_docs, doc(cfg(safeguards_strict)))]
        assert_ne!($actual, $expected, $($arg)*);
    };
}

// ----------------------------------------------------------------------------------------------------------------------------------------------
// Runtime assertions - balanced mode

/// Acts like `assert!` when `safeguards_balanced` is enabled, and becomes a no-op otherwise.
#[macro_export]
macro_rules! balanced_assert {
    ($($arg:tt)*) => {
        #[cfg(safeguards_balanced)] #[cfg_attr(published_docs, doc(cfg(safeguards_balanced)))]
        assert!($($arg)*);
    };
}

/// Acts like `assert_eq!` when `safeguards_balanced` is enabled, and becomes a no-op otherwise.
#[macro_export]
macro_rules! balanced_assert_eq {
    ($actual:expr_2021, $expected:expr_2021) => {
        #[cfg(safeguards_balanced)] #[cfg_attr(published_docs, doc(cfg(safeguards_balanced)))]
        assert_eq!($actual, $expected);
    };
    ($actual:expr_2021, $expected:expr_2021, $($arg:tt)*) => {
        #[cfg(safeguards_balanced)] #[cfg_attr(published_docs, doc(cfg(safeguards_balanced)))]
        assert_eq!($actual, $expected, $($arg)*);
    };
}

/// Acts like `assert_ne!` when `safeguards_balanced` is enabled, and becomes a no-op otherwise.
#[macro_export]
macro_rules! balanced_assert_ne {
    ($actual:expr_2021, $expected:expr_2021) => {
        #[cfg(safeguards_balanced)] #[cfg_attr(published_docs, doc(cfg(safeguards_balanced)))]
        assert_ne!($actual, $expected);
    };
    ($actual:expr_2021, $expected:expr_2021, $($arg:tt)*) => {
        #[cfg(safeguards_balanced)] #[cfg_attr(published_docs, doc(cfg(safeguards_balanced)))]
        assert_ne!($actual, $expected, $($arg)*);
    };
}