LCOV - code coverage report
Current view: top level - src - common.rs (source / functions) Coverage Total Hit
Test: lief.lcov Lines: 65.9 % 44 29
Test Date: 2024-10-27:00:00:00 Functions: 56.1 % 289 162

            Line data    Source code
       1              : use lief_ffi as ffi;
       2              : use cxx::memory::UniquePtrTarget;
       3              : use std::marker::PhantomData;
       4              : 
       5              : use crate::Range;
       6              : 
       7              : #[doc(hidden)]
       8              : pub trait FromFFI<T: UniquePtrTarget> {
       9              :     fn from_ffi(ptr: cxx::UniquePtr<T>) -> Self;
      10              : }
      11              : 
      12              : #[doc(hidden)]
      13      1619640 : pub fn into_optional<T: FromFFI<U>, U: UniquePtrTarget>(raw_ffi: cxx::UniquePtr<U>) -> Option<T> {
      14      1619640 :     if raw_ffi.is_null() {
      15       905944 :         None
      16              :     } else {
      17       713696 :         Some(T::from_ffi(raw_ffi))
      18              :     }
      19      1619640 : }
      20              : 
      21              : 
      22              : #[doc(hidden)]
      23            0 : pub fn into_ranges(raw_ffi: cxx::UniquePtr<cxx::CxxVector<ffi::Range>>) -> Vec<Range> {
      24            0 :     let cxx_vec = raw_ffi.as_ref().unwrap();
      25            0 :     if cxx_vec.is_empty() {
      26            0 :         return Vec::new();
      27            0 :     }
      28            0 : 
      29            0 :     let mut rust_range: Vec<Range> = Vec::with_capacity(cxx_vec.len());
      30              : 
      31            0 :     for ffi_range in cxx_vec {
      32            0 :         rust_range.push(Range::from_ffi(ffi_range));
      33            0 :     }
      34              : 
      35            0 :     rust_range
      36            0 : }
      37              : 
      38              : pub struct Iterator<'a, Parent: UniquePtrTarget, It: UniquePtrTarget> {
      39              :     #[doc(hidden)]
      40              :     pub it: cxx::UniquePtr<It>,
      41              :     _owner: PhantomData<&'a Parent>,
      42              : }
      43              : 
      44              : impl<'a, Parent: UniquePtrTarget, It: UniquePtrTarget> Iterator<'a, Parent, It> {
      45              :     #[doc(hidden)]
      46        22024 :     pub fn new(it: cxx::UniquePtr<It>) -> Self {
      47        22024 :         Self {
      48        22024 :             it,
      49        22024 :             _owner: PhantomData,
      50        22024 :         }
      51        22024 :     }
      52              : }
      53              : 
      54              : #[doc(hidden)]
      55              : #[macro_export]
      56              : macro_rules! declare_iterator_conv {
      57              :     ($name:ident, $from:ty, $ffi:ty, $parent:ty, $ffi_iterator:ty, $conv: expr) => {
      58              :         pub type $name<'a> = $crate::common::Iterator<'a, $parent, $ffi_iterator>;
      59              :         impl<'a> Iterator for $name<'a> {
      60              :             type Item = $from;
      61      1827024 :             fn next(&mut self) -> Option<Self::Item> {
      62      1827024 :                 let next = self.it.as_mut().unwrap().next();
      63      1827024 :                 if next.is_null() {
      64        22024 :                     None
      65              :                 } else {
      66      1805000 :                     Some($conv(next))
      67              :                 }
      68      1827024 :             }
      69              :         }
      70              :         impl<'a> ExactSizeIterator for $name<'a> {
      71            0 :             fn len(&self) -> usize {
      72            0 :                 self.it.as_ref().unwrap().size().try_into().unwrap()
      73            0 :             }
      74              :         }
      75              :     };
      76              : }
      77              : 
      78              : #[doc(hidden)]
      79              : #[macro_export]
      80              : macro_rules! declare_iterator {
      81              :     ($name:ident, $from:ty, $ffi:ty, $parent:ty, $ffi_iterator:ty) => {
      82              :         crate::declare_iterator_conv!($name, $from, $ffi, $parent, $ffi_iterator, |n| {
      83              :             Self::Item::from_ffi(n)
      84              :         });
      85              :     };
      86              : }
      87              : 
      88              : pub struct ForwardIterator<'a, Parent: UniquePtrTarget, It: UniquePtrTarget> {
      89              :     #[doc(hidden)]
      90              :     pub it: cxx::UniquePtr<It>,
      91              :     _owner: PhantomData<&'a Parent>,
      92              : }
      93              : 
      94              : impl<'a, Parent: UniquePtrTarget, It: UniquePtrTarget> ForwardIterator<'a, Parent, It> {
      95              :     #[doc(hidden)]
      96          112 :     pub fn new(it: cxx::UniquePtr<It>) -> Self {
      97          112 :         Self {
      98          112 :             it,
      99          112 :             _owner: PhantomData,
     100          112 :         }
     101          112 :     }
     102              : }
     103              : 
     104              : #[doc(hidden)]
     105              : #[macro_export]
     106              : macro_rules! declare_fwd_iterator_conv {
     107              :     ($name:ident, $from:ty, $ffi:ty, $parent:ty, $ffi_iterator:ty, $conv: expr) => {
     108              :         pub type $name<'a> = $crate::common::ForwardIterator<'a, $parent, $ffi_iterator>;
     109              :         impl<'a> Iterator for $name<'a> {
     110              :             type Item = $from;
     111        52664 :             fn next(&mut self) -> Option<Self::Item> {
     112        52664 :                 let next = self.it.as_mut().unwrap().next();
     113        52664 :                 if next.is_null() {
     114          112 :                     None
     115              :                 } else {
     116        52552 :                     Some($conv(next))
     117              :                 }
     118        52664 :             }
     119              :         }
     120              :     };
     121              : }
     122              : 
     123              : #[doc(hidden)]
     124              : #[macro_export]
     125              : macro_rules! declare_fwd_iterator {
     126              :     ($name:ident, $from:ty, $ffi:ty, $parent:ty, $ffi_iterator:ty) => {
     127              :         crate::declare_fwd_iterator_conv!($name, $from, $ffi, $parent, $ffi_iterator, |n| {
     128              :             Self::Item::from_ffi(n)
     129              :         });
     130              :     };
     131              : }
     132              : 
     133              : 
     134              : #[doc(hidden)]
     135              : #[macro_export]
     136              : macro_rules! to_slice {
     137              :     ($e:expr) => {
     138              :         let content_ptr = $e;
     139              :         unsafe {
     140              :             if content_ptr.size > 0 {
     141              :                 return std::slice::from_raw_parts_mut(content_ptr.ptr, content_ptr.size as usize);
     142              :             }
     143              :             return &[];
     144              :         }
     145              :     };
     146              : }
     147              : 
     148              : 
     149              : #[doc(hidden)]
     150              : #[macro_export]
     151              : macro_rules! to_result {
     152              :     ($func: expr, $self: expr, $($arg:tt)*) => {
     153              :         let mut err: u32 = 0;
     154              : 
     155              :         let value = $func(&$self.ptr, $($arg),*, std::pin::Pin::new(&mut err));
     156              :         if err > 0 {
     157              :             return Err(crate::Error::from(err));
     158              :         }
     159              :         return Ok(value);
     160              :     };
     161              :     ($func: expr, $self: expr) => {
     162              :         let mut err: u32 = 0;
     163              :         let value = $func(&$self.ptr, std::pin::Pin::new(&mut err));
     164              : 
     165              :         if err > 0 {
     166              :             return Err(crate::Error::from(err));
     167              :         }
     168              :         return Ok(value);
     169              :     };
     170              : }
     171              : 
     172              : #[doc(hidden)]
     173              : #[macro_export]
     174              : macro_rules! to_conv_result {
     175              :     ($func: expr, $self: expr, $conv: expr, $($arg:tt)*) => {
     176              :         let mut err: u32 = 0;
     177              :         let value = $func(&$self, $($arg),*, std::pin::Pin::new(&mut err));
     178              :         if err > 0 {
     179              :             return Err(crate::Error::from(err));
     180              :         }
     181              :         return Ok($conv(value));
     182              :     };
     183              :     ($func: expr, $self: expr, $conv: expr) => {
     184              :         let mut err: u32 = 0;
     185              :         let value = $func(&$self, std::pin::Pin::new(&mut err));
     186              :         if err > 0 {
     187              :             return Err(crate::Error::from(err));
     188              :         }
     189              :         return Ok($conv(value));
     190              :     };
     191              : }
        

Generated by: LCOV version 2.1-1