self

Author: adamnemecek

src/dim4.rs

@@ -9,8 +9,8 @@ pub struct Dim4 {
 
 /// Default trait for Dim4 returns an Array of dimensions [1, 1, 1, 1]
 impl Default for Dim4 {
-    fn default() -> Dim4 {
-        Dim4 { dims: [1, 1, 1, 1] }
+    fn default() -> Self {
+        Self { dims: [1, 1, 1, 1] }
     }
 }
 
@@ -64,8 +64,8 @@ impl Dim4 {
     /// use arrayfire::Dim4;
     /// let dims = Dim4::new(&[4, 4, 2, 1]);
     /// ```
-    pub fn new(dims: &[u64; 4]) -> Dim4 {
-        Dim4 { dims: dims.clone() }
+    pub fn new(dims: &[u64; 4]) -> Self {
+        Self { dims: dims.clone() }
     }
 
     /// Get the number of elements represented by Dim4 object

src/error.rs

@@ -24,7 +24,7 @@ pub struct Callback {
 impl Callback {
     /// Associated function to create a new Callback object
     pub fn new(callback: ErrorCallback) -> Self {
-        Callback { cb: callback }
+        Self { cb: callback }
     }
 
     /// call invokes the error callback with `error_code`.

src/graphics.rs

@@ -225,7 +225,7 @@ impl Window {
                         cstr.as_ptr(),
                     );
                     HANDLE_ERROR(AfError::from(err_val));
-                    Window::from(temp)
+                    Self::from(temp)
                 }
                 Err(_) => {
                     panic!("String creation failed while prepping params for window creation.")

src/util.rs

@@ -71,42 +71,42 @@ pub fn free_host<T>(ptr: *mut T) {
 }
 
 impl From<i32> for AfError {
-    fn from(t: i32) -> AfError {
+    fn from(t: i32) -> Self {
         assert!(AfError::SUCCESS as i32 <= t && t <= AfError::ERR_UNKNOWN as i32);
         unsafe { mem::transmute(t) }
     }
 }
 
 impl From<u32> for DType {
-    fn from(t: u32) -> DType {
+    fn from(t: u32) -> Self {
         assert!(DType::F32 as u32 <= t && t <= DType::U64 as u32);
         unsafe { mem::transmute(t) }
     }
 }
 
 impl From<u32> for InterpType {
-    fn from(t: u32) -> InterpType {
+    fn from(t: u32) -> Self {
         assert!(InterpType::NEAREST as u32 <= t && t <= InterpType::BICUBIC_SPLINE as u32);
         unsafe { mem::transmute(t) }
     }
 }
 
 impl From<u32> for ConvMode {
-    fn from(t: u32) -> ConvMode {
+    fn from(t: u32) -> Self {
         assert!(ConvMode::DEFAULT as u32 <= t && t <= ConvMode::EXPAND as u32);
         unsafe { mem::transmute(t) }
     }
 }
 
 impl From<u32> for ConvDomain {
-    fn from(t: u32) -> ConvDomain {
+    fn from(t: u32) -> Self {
         assert!(ConvDomain::AUTO as u32 <= t && t <= ConvDomain::FREQUENCY as u32);
         unsafe { mem::transmute(t) }
     }
 }
 
 impl From<u32> for MatchType {
-    fn from(t: u32) -> MatchType {
+    fn from(t: u32) -> Self {
         assert!(MatchType::SAD as u32 <= t && t <= MatchType::SHD as u32);
         unsafe { mem::transmute(t) }
     }
@@ -129,7 +129,7 @@ pub fn to_u32(t: MatProp) -> u32 {
 }
 
 impl From<u32> for ColorMap {
-    fn from(t: u32) -> ColorMap {
+    fn from(t: u32) -> Self {
         assert!(ColorMap::DEFAULT as u32 <= t && t <= ColorMap::BLUE as u32);
         unsafe { mem::transmute(t) }
     }