Big update!

- Source code added
- Readme, gitignore, banner and the license are updated

src/impls.rs

@@ -0,0 +1,152 @@
+use crate::{
+    structs::{CharVec, Debugging, ParsingError, StringPtr, ULDDObj},
+    ULDDObjResult, ULDDObjResultVec,
+};
+use anstream::{eprintln as a_eprintln, println as a_println};
+use owo_colors::OwoColorize;
+use std::{fmt::Display, mem::ManuallyDrop, ptr::null_mut, ffi::{c_char, CString}};
+
+impl From<Vec<*mut c_char>> for CharVec {
+    fn from(value: Vec<*mut c_char>) -> Self {
+        CharVec {
+            capacity: value.capacity(),
+            length: value.len(),
+            vec: if value.is_empty() {
+                null_mut()
+            } else {
+                ManuallyDrop::new(value).as_mut_ptr()
+            },
+        }
+    }
+}
+
+impl From<Vec<ULDDObjResult>> for ULDDObjResultVec {
+    fn from(value: Vec<ULDDObjResult>) -> Self {
+        ULDDObjResultVec {
+            capacity: value.capacity(),
+            length: value.len(),
+            vec: if value.is_empty() {
+                null_mut()
+            } else {
+                ManuallyDrop::new(value).as_mut_ptr()
+            },
+        }
+    }
+}
+
+impl Default for CharVec {
+    fn default() -> Self {
+        Self {
+            capacity: 0,
+            length: 0,
+            vec: null_mut(),
+        }
+    }
+}
+
+impl From<Vec<&str>> for CharVec {
+    fn from(val: Vec<&str>) -> Self {
+        let vector: Vec<*mut c_char> = val
+            .into_iter()
+            .map(|item| unsafe {
+                CString::from_vec_unchecked(item.to_string().into_bytes()).into_raw()
+            })
+            .collect();
+        
+        CharVec::from(vector)
+    }
+}
+
+impl From<&mut Vec<&str>> for CharVec {
+    fn from(val: &mut Vec<&str>) -> Self {
+        let vector: Vec<*mut c_char> = std::mem::take(val)
+            .into_iter()
+            .map(|item| unsafe {
+                CString::from_vec_unchecked(item.to_string().into_bytes()).into_raw()
+            })
+            .collect();
+        
+        CharVec::from(vector)
+    }
+}
+
+impl From<String> for StringPtr {
+    fn from(value: String) -> Self {
+        let mut value = value;
+        value.push('\0');
+        let c_string = match CString::from_vec_with_nul(value.into_bytes()) {
+            Ok(string) => string,
+            Err(error) => {
+                Debugging::Fatal("converting the string into a C string".to_owned()).print(true);
+                panic!("{}", error)
+            }
+        };
+        StringPtr(c_string.into_raw())
+    }
+}
+
+impl From<&str> for StringPtr {
+    fn from(value: &str) -> Self {
+        StringPtr::from(value.to_owned())
+    }
+}
+
+impl<T> From<Option<T>> for StringPtr
+where
+    T: Display,
+{
+    fn from(value: Option<T>) -> Self {
+        let Some(t) = value else {
+            return StringPtr(null_mut());
+        };
+        StringPtr::from(t.to_string())
+    }
+}
+
+impl Default for ParsingError {
+    fn default() -> Self {
+        Self {
+            code: 0,
+            explanation: null_mut(),
+        }
+    }
+}
+
+impl Default for ULDDObj {
+    fn default() -> Self {
+        Self {
+            file_name: null_mut(),
+            member_name: Default::default(),
+            executable_format: null_mut(),
+            is_64: false,
+            os_type: null_mut(),
+            file_type: null_mut(),
+            is_stripped: false,
+            cpu_type: null_mut(),
+            cpu_subtype: null_mut(),
+            interpreter: null_mut(),
+            libraries: Default::default(),
+        }
+    }
+}
+
+impl Debugging {
+    pub(crate) fn print(self, debugging: bool) {
+        if debugging {
+            match self {
+                Debugging::Info(msg) => {
+                    a_println!("{} {}", "[INFO]".yellow().bold(), msg);
+                }
+                Debugging::Affirmative(msg) => {
+                    a_println!("{} {}", "[OK]".green().bold(), msg);
+                }
+                Debugging::Error(msg) => {
+                    a_eprintln!("{} {}", "[ERROR]".red().bold(), msg);
+                }
+                Debugging::Fatal(msg) => {
+                    a_eprintln!("{} Library got a fatal error while {}. Panic function will halt the library and provide a stacktrace.", "[FATAL]".red().bold(), msg);
+                }
+            }
+        }
+    }
+}