node_tree 0.15.0

An extendable scene graph made up of autonomous execution services known as nodes organized in a tree of processes. Inspired by Godot!
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

use std::ops::Deref;

use crate::traits::exportable::Exportable;
use crate::structs::node_field::{ Field, ExportableField, UniqueField, DefaultField };


/*
 * Element
 *      Trait
 */


/// Used for function arguments that should be flexible and take in types in both their raw form and their `NodeField` forms.
pub trait Element<T> {
    
    /// Converts the element into its inferred type.
    fn as_inner(&self) -> &T;
}

impl <T> Element<T> for T {
    fn as_inner(&self) -> &T {
        self
    }
}

impl <T> Element<T> for Field<T> {
    fn as_inner(&self) -> &T {
        self.deref()
    }
}

impl <T: Exportable> Element<T> for ExportableField<T> {
    fn as_inner(&self) -> &T {
        self.deref()
    }
}

impl <T> Element<T> for UniqueField<T> {
    fn as_inner(&self) -> &T {
        self.deref()
    }
}

impl <T: Default> Element<T> for DefaultField<T> {
    fn as_inner(&self) -> &T {
        self.deref()
    }
}


/*
 * As Element
 *      Trait
 */


/// Used for the simple unambiguous conversion between a type and a type wrapped by a field.
mod private {
    pub trait Sealed {}
    impl <T> Sealed for T {}
}

pub trait AsElement<F>: private::Sealed {

    /// Wraps a type with a field wrapper.
    fn wrap(self) -> F;
}

impl <T> AsElement<Field<T>> for T {
    fn wrap(self) -> Field<T> {
        Field::Valid(self)
    }
}

impl <T: Exportable> AsElement<ExportableField<T>> for T {
    fn wrap(self) -> ExportableField<T> {
        ExportableField::new(self)
    }
}

impl <T> AsElement<UniqueField<T>> for T {
    fn wrap(self) -> UniqueField<T> {
        UniqueField::Valid(self)
    }
}

impl <T: Default> AsElement<DefaultField<T>> for T {
    fn wrap(self) -> DefaultField<T> {
        DefaultField::new(self)
    }
}