Simplify a couple of null checking code

Author: crumblingstatue

examples/borrowed-resources.rs

@@ -32,7 +32,7 @@ fn main() {
     sprite.set_scale2f(0.5, 0.5);
 
     // Create a ConvexShape using the same texture.
-    let mut convex_shape = ConvexShape::with_texture(&frank, 6);
+    let mut convex_shape = ConvexShape::with_texture(6, &frank);
     convex_shape.set_point(0,
                            &Vector2f {
                                 x: 400.0,

src/audio/sound.rs

@@ -47,30 +47,18 @@ impl<'s> Sound<'s> {
     /// Create a new Sound
     pub fn new() -> Sound<'s> {
         let s = unsafe { ffi::sfSound_create() };
-        if s.is_null() {
-            panic!("sfSound_create returned null.")
-        } else {
-            Sound {
-                sound: s,
-                buffer: PhantomData,
-            }
+        assert!(!s.is_null(), "Failed to create Sound");
+        Sound {
+            sound: s,
+            buffer: PhantomData,
         }
     }
 
     /// Create a new Sound with a buffer
     pub fn with_buffer(buffer: &SoundBufferRef) -> Sound {
-        let s = unsafe { ffi::sfSound_create() };
-        if s.is_null() {
-            panic!("sfSound_create returned null.")
-        } else {
-            unsafe {
-                ffi::sfSound_setBuffer(s, buffer as *const _ as _);
-            }
-            Sound {
-                sound: s,
-                buffer: PhantomData,
-            }
-        }
+        let mut s = Sound::new();
+        s.set_buffer(buffer);
+        s
     }
 
     /// Sets whether this sound should loop or not.
@@ -170,13 +158,10 @@ impl<'a> Default for Sound<'a> {
 impl<'s> Clone for Sound<'s> {
     fn clone(&self) -> Self {
         let s = unsafe { ffi::sfSound_copy(self.sound) };
-        if s.is_null() {
-            panic!("Sound is null");
-        } else {
-            Sound {
-                sound: s,
-                buffer: self.buffer,
-            }
+        assert!(!s.is_null(), "Failed to copy Sound");
+        Sound {
+            sound: s,
+            buffer: self.buffer,
         }
     }
 }

src/audio/sound_buffer.rs

@@ -198,11 +198,8 @@ impl ToOwned for SoundBufferRef {
 
     fn to_owned(&self) -> Self::Owned {
         let sound_buffer = unsafe { ffi::sfSoundBuffer_copy(self.raw()) };
-        if sound_buffer.is_null() {
-            panic!("Sound buffer is null");
-        } else {
-            SoundBuffer { sound_buffer: sound_buffer }
-        }
+        assert!(!sound_buffer.is_null(), "Failed to copy SoundBuffer");
+        SoundBuffer { sound_buffer: sound_buffer }
     }
 }
 

src/audio/sound_buffer_recorder.rs

@@ -20,11 +20,8 @@ impl SoundBufferRecorder {
     /// Create a new sound buffer recorder
     pub fn new() -> SoundBufferRecorder {
         let buffer = unsafe { ffi::sfSoundBufferRecorder_create() };
-        if buffer.is_null() {
-            panic!("sfSoundBufferRecorder_create returned null.")
-        } else {
-            SoundBufferRecorder { sound_buffer_recorder: buffer }
-        }
+        assert!(!buffer.is_null(), "Failed to create SoundBufferRecorder");
+        SoundBufferRecorder { sound_buffer_recorder: buffer }
     }
 
     /// Start the capture of a sound buffer recorder
@@ -70,11 +67,8 @@ impl SoundBufferRecorder {
     /// Return Read-only access to the sound buffer
     pub fn buffer(&self) -> &SoundBufferRef {
         let buff = unsafe { ffi::sfSoundBufferRecorder_getBuffer(self.sound_buffer_recorder) };
-        if buff.is_null() {
-            panic!("sound_buffer_recorder::get_buffer: buffer was null");
-        } else {
-            unsafe { &*(buff as *const SoundBufferRef) }
-        }
+        assert!(!buff.is_null(), "sfSoundBufferRecorder_getBuffer failed");
+        unsafe { &*(buff as *const SoundBufferRef) }
     }
 
     /// Get the name of the current audio capture device.

src/graphics/circle_shape.rs

@@ -19,18 +19,13 @@ pub struct CircleShape<'s> {
 }
 
 impl<'s> CircleShape<'s> {
-    /// Create a new circle shape
-    ///
-    /// Return Some(CircleShape) or None
+    /// Creates a new circle shape.
     pub fn new() -> CircleShape<'s> {
         let circle = unsafe { ffi::sfCircleShape_create() };
-        if circle.is_null() {
-            panic!("sfCircleShape_create returned null.")
-        } else {
-            CircleShape {
-                circle_shape: circle,
-                texture: PhantomData,
-            }
+        assert!(!circle.is_null(), "Failed to create CircleShape");
+        CircleShape {
+            circle_shape: circle,
+            texture: PhantomData,
         }
     }
 
@@ -41,18 +36,9 @@ impl<'s> CircleShape<'s> {
     ///
     /// Return Some(CircleShape) or None
     pub fn with_texture(texture: &'s TextureRef) -> CircleShape<'s> {
-        let circle = unsafe { ffi::sfCircleShape_create() };
-        if circle.is_null() {
-            panic!("sfCircleShape_create returned null.")
-        } else {
-            unsafe {
-                ffi::sfCircleShape_setTexture(circle, texture.raw(), sfTrue);
-            }
-            CircleShape {
-                circle_shape: circle,
-                texture: PhantomData,
-            }
-        }
+        let mut shape = CircleShape::new();
+        shape.set_texture(texture, true);
+        shape
     }
 
     /// Create a new CircleShape and initialize it.
@@ -63,19 +49,10 @@ impl<'s> CircleShape<'s> {
     ///
     /// Default value on SFML are radius = 0 / pointCount = 30
     pub fn new_init(radius: f32, point_count: u32) -> CircleShape<'s> {
-        let circle = unsafe { ffi::sfCircleShape_create() };
-        if circle.is_null() {
-            panic!("sfCircleShape_create returned null.")
-        } else {
-            unsafe {
-                ffi::sfCircleShape_setRadius(circle, radius);
-                ffi::sfCircleShape_setPointCount(circle, point_count as usize);
-            }
-            CircleShape {
-                circle_shape: circle,
-                texture: PhantomData,
-            }
-        }
+        let mut shape = CircleShape::new();
+        shape.set_radius(radius);
+        shape.set_point_count(point_count);
+        shape
     }
 
     /// Set the radius of a circle

src/graphics/convex_shape.rs

@@ -34,38 +34,24 @@ impl<'s> ConvexShape<'s> {
     /// * points_count - The number of point for the convex shape
     pub fn new(points_count: u32) -> ConvexShape<'s> {
         let shape = unsafe { ffi::sfConvexShape_create() };
-        if shape.is_null() {
-            panic!("sfConvexShape_create returned null.")
-        } else {
-            unsafe {
-                ffi::sfConvexShape_setPointCount(shape, points_count as usize);
-            }
-            ConvexShape {
-                convex_shape: shape,
-                texture: PhantomData,
-            }
-        }
+        assert!(!shape.is_null(), "Failed to create ConvexShape");
+        let mut shape = ConvexShape {
+            convex_shape: shape,
+            texture: PhantomData,
+        };
+        shape.set_point_count(points_count);
+        shape
     }
 
     /// Create a new convex shape with a texture
     ///
     /// # Arguments
     /// * texture - The texture to apply to the convex shape
     /// * points_count - The number of point for the convex shape
-    pub fn with_texture(texture: &'s TextureRef, points_count: u32) -> ConvexShape<'s> {
-        let shape = unsafe { ffi::sfConvexShape_create() };
-        if shape.is_null() {
-            panic!("sfConvexShape_create returned null.")
-        } else {
-            unsafe {
-                ffi::sfConvexShape_setTexture(shape, texture.raw(), sfTrue);
-                ffi::sfConvexShape_setPointCount(shape, points_count as usize)
-            }
-            ConvexShape {
-                convex_shape: shape,
-                texture: PhantomData,
-            }
-        }
+    pub fn with_texture(points_count: u32, texture: &'s TextureRef) -> ConvexShape<'s> {
+        let mut shape = ConvexShape::new(points_count);
+        shape.set_texture(texture, true);
+        shape
     }
 
     /// Set the position of a point.

src/graphics/custom_shape.rs

@@ -58,14 +58,11 @@ impl<'s> CustomShape<'s> {
                                 Some(get_point_callback),
                                 raw_impl as *mut _)
         };
-        if sp.is_null() {
-            panic!("sfShape_create returned null.")
-        } else {
-            CustomShape {
-                shape: sp,
-                texture: PhantomData,
-                points: raw_impl,
-            }
+        assert!(!sp.is_null(), "Failed to create CustomShape");
+        CustomShape {
+            shape: sp,
+            texture: PhantomData,
+            points: raw_impl,
         }
     }
 
@@ -77,24 +74,9 @@ impl<'s> CustomShape<'s> {
     pub fn with_texture(points: Box<CustomShapePoints + Send>,
                         texture: &'s TextureRef)
                         -> CustomShape<'s> {
-        let raw_impl = Box::into_raw(Box::new(points));
-        let sp = unsafe {
-            ffi::sfShape_create(Some(get_point_count_callback),
-                                Some(get_point_callback),
-                                raw_impl as *mut _)
-        };
-        if sp.is_null() {
-            panic!("sfShape_create returned null.")
-        } else {
-            unsafe {
-                ffi::sfShape_setTexture(sp, texture.raw(), sfTrue);
-            }
-            CustomShape {
-                shape: sp,
-                texture: PhantomData,
-                points: raw_impl,
-            }
-        }
+        let mut shape = Self::new(points);
+        shape.set_texture(texture, true);
+        shape
     }
 
     /// Recompute the internal geometry of a shape

src/graphics/font.rs

@@ -157,11 +157,8 @@ impl Font {
     /// Return the texture
     pub fn texture(&mut self, character_size: u32) -> &TextureRef {
         let tex = unsafe { ffi::sfFont_getTexture(self.raw_mut(), character_size) };
-        if tex.is_null() {
-            panic!("Font::texture: texture is null");
-        } else {
-            unsafe { &*(tex as *const TextureRef) }
-        }
+        assert!(!tex.is_null(), "sfFont_getTexture failed");
+        unsafe { &*(tex as *const TextureRef) }
     }
 }
 

src/graphics/image.rs

@@ -27,11 +27,8 @@ impl Image {
     /// * height - Height of the image
     pub fn new(width: u32, height: u32) -> Image {
         let image = unsafe { ffi::sfImage_create(width, height) };
-        if image.is_null() {
-            panic!("sfImage_create returned null.")
-        } else {
-            Image { image: image }
-        }
+        assert!(!image.is_null(), "Failed to create Image");
+        Image { image: image }
     }
 
     /// Create an image from a stream.

src/graphics/rectangle_shape.rs

@@ -20,46 +20,25 @@ impl<'s> RectangleShape<'s> {
     /// Returns a new `RectangleShape`.
     pub fn new() -> RectangleShape<'s> {
         let rectangle = unsafe { ffi::sfRectangleShape_create() };
-        if rectangle.is_null() {
-            panic!("sfRectangleShape_create returned null.")
-        } else {
-            RectangleShape {
-                rectangle_shape: rectangle,
-                texture: PhantomData,
-            }
+        assert!(!rectangle.is_null(), "Failed to create RectangleShape");
+        RectangleShape {
+            rectangle_shape: rectangle,
+            texture: PhantomData,
         }
     }
 
     /// Returns a new `RectangleShape` with the provided texture.
     pub fn with_texture(texture: &'s TextureRef) -> RectangleShape<'s> {
-        let rectangle = unsafe { ffi::sfRectangleShape_create() };
-        if rectangle.is_null() {
-            panic!("sfRectangleShape_create returned null.")
-        } else {
-            unsafe {
-                ffi::sfRectangleShape_setTexture(rectangle, texture.raw(), sfTrue);
-            }
-            RectangleShape {
-                rectangle_shape: rectangle,
-                texture: PhantomData,
-            }
-        }
+        let mut shape = Self::new();
+        shape.set_texture(texture, true);
+        shape
     }
 
     /// Returns a new `RectangleShape` with the provided size.
     pub fn with_size(size: &Vector2f) -> RectangleShape<'s> {
-        let rectangle = unsafe { ffi::sfRectangleShape_create() };
-        if rectangle.is_null() {
-            panic!("sfRectangleShape_create returned null.")
-        } else {
-            unsafe {
-                ffi::sfRectangleShape_setSize(rectangle, size.raw());
-            }
-            RectangleShape {
-                rectangle_shape: rectangle,
-                texture: PhantomData,
-            }
-        }
+        let mut shape = Self::new();
+        shape.set_size(size);
+        shape
     }
 
     /// Get the size of a rectangle shape

src/graphics/render_texture.rs

@@ -52,11 +52,8 @@ impl RenderTexture {
     /// Return the target texture
     pub fn texture(&self) -> &TextureRef {
         let tex = unsafe { ffi::sfRenderTexture_getTexture(self.render_texture) };
-        if tex.is_null() {
-            panic!("RenderTexture::texture: Texture is null")
-        } else {
-            unsafe { &*(tex as *const TextureRef) }
-        }
+        assert!(!tex.is_null(), "sfRenderTexture_getTexture failed");
+        unsafe { &*(tex as *const TextureRef) }
     }
 
     /// Enable or disable the smooth filter on a render texture