object-type 0.1.1

struct Object - wrapper for anything type.
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
118
119
120

use std::fmt::{Display, Formatter};



/// Wrapper for anything type
#[derive(Debug, Clone, Copy, PartialOrd, PartialEq)]
pub struct Object {
    ptr: *mut (),
}


impl Object {
    pub fn new<T>(val: *mut T) -> Self {
        Self {
            ptr: val as *mut ()
        }
    }


    /// Returns the cloned value from struct
    /// ------------------------------------
    /// *If (T != type of value in struct) => ???*
    /// Example:
    /// ```
    /// let int_object = object_type::obj!(6982_i32);
    /// let _ = int_object.get::<i32>(); // Ok
    /// // let _ = int_object.get::<i64>(); => ???
    /// ```
    pub fn get<T: Clone>(&self) -> T {
        unsafe { self.__get_unsafe() }
    }

    unsafe fn __get_unsafe<T: Clone>(&self) -> T {
        (*(self.ptr as *mut T)).clone()
    }


    /// Returns the value pointer casted to <*T*> type
    /// --------------------------------------------
    /// *If (T != type of value in struct) => ???*
    /// Example:
    /// ```
    /// let int_object = object_type::obj!(6982_i32);
    /// let _ = int_object.get_ptr::<i32>(); // Ok
    /// // let _ = int_object.get_ptr::<i64>(); => ???
    /// ```
    pub fn get_ptr<T>(&self) -> *mut T {
        unsafe { self.__get_ptr_unsafe() }
    }

    unsafe fn __get_ptr_unsafe<T>(&self) -> *mut T {
        self.ptr as *mut T
    }


    /// Returns the raw mutable pointer to value as unit type
    pub fn raw(&self) -> *mut () {
        self.ptr
    }


    /// Unstable? 
    ///
    /// Example:
    /// ```
    /// let int_object = object_type::obj!(2372_i16);
    /// println!("=> {}", int_object.__value_to_string::<i16>());
    /// ```
    pub fn __value_to_string<T: ToString>(&self) -> String {
        unsafe { self.__value_to_string_unsafe::<T>() }
    }

    unsafe fn __value_to_string_unsafe<T: ToString>(&self) -> String {
        (*self.get_ptr::<T>()).to_string()
    }


    pub fn equals<T>(&self, other: T) -> bool
        where T: PartialEq + Clone,
    {
        other.eq(&self.get::<T>())
    }
}


impl Default for Object {
    fn default() -> Self {
        Self { ptr: std::ptr::null_mut(), }
    }
}


impl Display for Object {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        write!(f, "Object({:?})", self.ptr)
    }
}



/// Returns an instance of Object
/// -----------------------------
/// Example:
/// ```
/// let object = object_type::obj!("str test");
/// ```
#[macro_export]
macro_rules! obj {
    ($val:expr) => {
        $crate::Object::new(&mut $val)
    };
    () => {
        $crate::Object::default()
    }
}