rust/vec2d/src/lib.rs
branchtransitional_engine
changeset 15913 c5684cc62de8
parent 15912 6e22f4390b7e
child 15915 8f093b1b18bc
equal deleted inserted replaced
15912:6e22f4390b7e 15913:c5684cc62de8
       
     1 use integral_geometry::Size;
     1 use std::{
     2 use std::{
     2     ops::{Index, IndexMut},
     3     ops::{Index, IndexMut},
     3     slice::SliceIndex
     4     slice::SliceIndex,
     4 };
     5 };
     5 use integral_geometry::Size;
       
     6 
     6 
     7 #[derive(Debug)]
     7 #[derive(Debug)]
     8 pub struct Vec2D<T> {
     8 pub struct Vec2D<T> {
     9     data: Vec<T>,
     9     data: Vec<T>,
    10     size: Size,
    10     size: Size,
    32 
    32 
    33         &mut self.data[pos..pos + self.size.width]
    33         &mut self.data[pos..pos + self.size.width]
    34     }
    34     }
    35 }
    35 }
    36 
    36 
    37 impl <T> Vec2D<T> {
    37 impl<T> Vec2D<T> {
    38     #[inline]
    38     #[inline]
    39     pub fn width(&self) -> usize {
    39     pub fn width(&self) -> usize {
    40         self.size.width
    40         self.size.width
    41     }
    41     }
    42 
    42 
    50         self.size
    50         self.size
    51     }
    51     }
    52 }
    52 }
    53 
    53 
    54 impl<T: Copy> Vec2D<T> {
    54 impl<T: Copy> Vec2D<T> {
    55     pub fn new(size: Size, value: T) -> Self {
    55     pub fn new(size: &Size, value: T) -> Self {
    56         Self { size, data: vec![value; size.area()] }
    56         Self {
       
    57             size: *size,
       
    58             data: vec![value; size.area()],
       
    59         }
    57     }
    60     }
    58 
    61 
    59     #[inline]
    62     #[inline]
    60     pub fn as_slice(&self) -> &[T] {
    63     pub fn as_slice(&self) -> &[T] {
    61         self.data.as_slice()
    64         self.data.as_slice()
    66         self.data.as_mut_slice()
    69         self.data.as_mut_slice()
    67     }
    70     }
    68 
    71 
    69     #[inline]
    72     #[inline]
    70     pub fn get(&self, row: usize, column: usize) -> Option<&<usize as SliceIndex<[T]>>::Output> {
    73     pub fn get(&self, row: usize, column: usize) -> Option<&<usize as SliceIndex<[T]>>::Output> {
    71         self.data.get(row * self.width() + column)
    74         if row < self.height() && column < self.width() {
       
    75             Some(unsafe { self.data.get_unchecked(row * self.width() + column) })
       
    76         } else {
       
    77             None
       
    78         }
    72     }
    79     }
    73 
    80 
    74     #[inline]
    81     #[inline]
    75     pub fn get_mut(&mut self, row: usize, column: usize) -> Option<&mut <usize as SliceIndex<[T]>>::Output> {
    82     pub fn get_mut(
    76         self.data.get_mut(row * self.size.width + column)
    83         &mut self,
       
    84         row: usize,
       
    85         column: usize,
       
    86     ) -> Option<&mut <usize as SliceIndex<[T]>>::Output> {
       
    87         if row < self.height() && column < self.width() {
       
    88             Some(unsafe { self.data.get_unchecked_mut(row * self.size.width + column) })
       
    89         } else {
       
    90             None
       
    91         }
    77     }
    92     }
    78 
    93 
    79     #[inline]
    94     #[inline]
    80     pub unsafe fn get_unchecked(&self, row: usize, column: usize) -> &<usize as SliceIndex<[T]>>::Output {
    95     pub unsafe fn get_unchecked(
       
    96         &self,
       
    97         row: usize,
       
    98         column: usize,
       
    99     ) -> &<usize as SliceIndex<[T]>>::Output {
    81         self.data.get_unchecked(row * self.width() + column)
   100         self.data.get_unchecked(row * self.width() + column)
    82     }
   101     }
    83 
   102 
    84     #[inline]
   103     #[inline]
    85     pub unsafe fn get_unchecked_mut(&mut self, row: usize, column: usize) -> &mut <usize as SliceIndex<[T]>>::Output {
   104     pub unsafe fn get_unchecked_mut(
       
   105         &mut self,
       
   106         row: usize,
       
   107         column: usize,
       
   108     ) -> &mut <usize as SliceIndex<[T]>>::Output {
    86         self.data.get_unchecked_mut(row * self.size.width + column)
   109         self.data.get_unchecked_mut(row * self.size.width + column)
    87     }
   110     }
    88 
   111 
    89     #[inline]
   112     #[inline]
    90     pub fn rows(&self) -> impl DoubleEndedIterator<Item = &[T]> {
   113     pub fn rows(&self) -> impl DoubleEndedIterator<Item = &[T]> {
    97         self.data.chunks_exact_mut(width)
   120         self.data.chunks_exact_mut(width)
    98     }
   121     }
    99 
   122 
   100     #[inline]
   123     #[inline]
   101     pub unsafe fn as_bytes(&self) -> &[u8] {
   124     pub unsafe fn as_bytes(&self) -> &[u8] {
   102         use std::{
   125         use std::{mem, slice};
   103             slice,
       
   104             mem
       
   105         };
       
   106 
   126 
   107         slice::from_raw_parts(
   127         slice::from_raw_parts(
   108             self.data.as_ptr() as *const u8,
   128             self.data.as_ptr() as *const u8,
   109             self.data.len() * mem::size_of::<T>(),
   129             self.data.len() * mem::size_of::<T>(),
   110         )
   130         )