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

// To Support Bulk Insert Operation
#[macro_export]
macro_rules! prepare_bulk_operation {
    (
        $subject:expr, $($field:ident:$field_type:ty),*
    ) => {
        $(
            let mut $field:Vec<$field_type> = Vec::with_capacity($subject.len());
        )*

        $subject.iter().for_each(|subj|{
            $(
                $field.push(subj.$field.clone());
            )*
        }
        )

    };
    (
        $subject:expr, $($field:ident():$field_type:ty),*
    ) =>{
        $(
            let mut $field:Vec<$field_type> = Vec::with_capacity($subject.len());
        )*

        $subject.iter().for_each(|subj|{
            $(
                $field.push(subj.$field().to_owned());
            )*
        }
        )
    }
}

#[macro_export]
macro_rules! make_smart_pointer {
    ($name:ident $(<$($gens:ident),*>)?, $inner:ty) => {
        impl$(<$($gens),*>)? std::ops::Deref for $name$(<$($gens),*>)? {
            type Target = $inner;
            fn deref(&self) -> &Self::Target {
                &self.0
            }
        }
        impl$(<$($gens),*>)? std::ops::DerefMut for $name$(<$($gens),*>)? {
            fn deref_mut(&mut self) -> &mut Self::Target {
                &mut self.0
            }
        }
    };

    ($name:ident $(<$($gens:ident),*>)?, $inner:ty, $identifier:ident)=>{
        impl$(<$($gens),*>)? std::ops::Deref for $name$(<$($gens),*>)? {
            type Target = $inner;
            fn deref(&self) -> &Self::Target {
                &self.$identifier
            }
        }
        impl$(<$($gens),*>)? std::ops::DerefMut for $name$(<$($gens),*>)? {
            fn deref_mut(&mut self) -> &mut Self::Target {
                &mut self.$identifier
            }
        }
    }

}

#[macro_export]
macro_rules! make_conversion {
	($type_name:ident, $($target:ty),*) => {
        $(
            impl ::core::convert::From<$target> for $type_name {
                fn from(value: $target) -> $type_name {
                    $type_name(value.into())
                }
            }
        )*
    };
	($type_name:ident<$target:ty>) => {
		impl ::core::convert::From<$target> for $type_name<$target> {
			fn from(value: $target) -> $type_name<$target> {
				$type_name(value.into())
			}
		}
    };
}

#[macro_export]
macro_rules! error {

		(

		) => {
			|err| {
                ::ruva::tracing::error!("{:?} {}:{}", err, file!(),line!()); err
            }
		};
        (
            $stmt:expr

            $(, $arg:expr)* $(,)?

        ) => {
            ::ruva::tracing::error!("{} {}:{}", format!($stmt, $($arg),*),file!(),line!())
        };
	}