Drop NAE name space

Author: termoshtt

src/array.rs

@@ -1,4 +1,4 @@
-use super::{FFTW_MUTEX, c32, c64};
+use types::*;
 use error::*;
 use ffi;
 
@@ -147,9 +147,7 @@ impl<T> DerefMut for AlignedVec<T> {
 
 impl<T> Drop for AlignedVec<T> {
     fn drop(&mut self) {
-        let lock = FFTW_MUTEX.lock().expect("Cannot get lock");
-        unsafe { ffi::fftw_free(self.data as *mut c_void) };
-        drop(lock);
+        excall! { ffi::fftw_free(self.data as *mut c_void) };
     }
 }
 
@@ -159,9 +157,7 @@ where
 {
     /// Create array with `fftw_malloc` (`fftw_free` is automatically called when the arrya is `Drop`-ed)
     pub fn new(n: usize) -> Self {
-        let lock = FFTW_MUTEX.lock().expect("Cannot get lock");
-        let ptr = unsafe { T::alloc(n) };
-        drop(lock);
+        let ptr = excall! { T::alloc(n) };
         let mut vec = AlignedVec { n: n, data: ptr };
         for v in vec.iter_mut() {
             *v = T::zero();

src/error.rs

@@ -2,7 +2,7 @@ use ndarray::ShapeError;
 
 pub type Result<T> = ::std::result::Result<T, Error>;
 
-use super::nae::NAEInputMismatchError;
+use super::plan::NAEInputMismatchError;
 
 #[derive(Debug, IntoEnum)]
 pub enum Error {

src/lib.rs

@@ -18,72 +18,14 @@ lazy_static! {
 
 macro_rules! excall {
     ($call:expr) => {
-        let _lock = FFTW_MUTEX.lock().expect("Cannot get lock");
-        unsafe { $call }
+        {
+            let _lock = $crate::FFTW_MUTEX.lock().expect("Cannot get lock");
+            unsafe { $call }
+        }
     }
 }
 
 pub mod array;
 pub mod error;
-pub mod nae;
-
-pub use ffi::fftw_complex as c64;
-pub use ffi::fftwf_complex as c32;
-
-#[repr(i32)]
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
-pub enum Sign {
-    Forward = -1,
-    Backward = 1,
-}
-
-impl ::std::ops::Neg for Sign {
-    type Output = Sign;
-    fn neg(self) -> Self::Output {
-        match self {
-            Sign::Forward => Sign::Backward,
-            Sign::Backward => Sign::Forward,
-        }
-    }
-}
-
-#[derive(Debug, Clone, Copy, Eq, PartialEq)]
-pub enum Flag {
-    Measure,
-    DestroyInput,
-    Unaligned,
-    ConserveMemory,
-    Exhausive,
-    PreserveInput,
-    Patient,
-    Estimate,
-    WisdowmOnly,
-    Mixed(u32),
-}
-
-impl Into<u32> for Flag {
-    fn into(self) -> u32 {
-        use Flag::*;
-        match self {
-            Measure => 0,
-            DestroyInput => 1 << 0,
-            Unaligned => 1 << 1,
-            ConserveMemory => 1 << 2,
-            Exhausive => 1 << 3,
-            PreserveInput => 1 << 4,
-            Patient => 1 << 5,
-            Estimate => 1 << 6,
-            WisdowmOnly => 1 << 21,
-            Mixed(u) => u,
-        }
-    }
-}
-
-impl ::std::ops::BitOr for Flag {
-    type Output = Self;
-    fn bitor(self, rhs: Self) -> Self {
-        let lhs: u32 = self.into();
-        let rhs: u32 = rhs.into();
-        Flag::Mixed(lhs | rhs)
-    }
-}
+pub mod plan;
+pub mod types;

src/nae.rs renamed to src/plan.rs

@@ -1,4 +1,4 @@
-use super::*;
+use types::*;
 use error::*;
 use ffi::*;
 
@@ -104,8 +104,6 @@ where
     }
 }
 
-pub type R2RKind = ffi::fftw_r2r_kind;
-
 #[derive(Debug)]
 pub struct R2RPlan<R: FFTW> {
     plan: R::Plan,

src/types.rs

@@ -0,0 +1,65 @@
+
+use ffi;
+
+pub use ffi::fftw_complex as c64;
+pub use ffi::fftwf_complex as c32;
+
+pub type R2RKind = ffi::fftw_r2r_kind;
+
+#[repr(i32)]
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+pub enum Sign {
+    Forward = -1,
+    Backward = 1,
+}
+
+impl ::std::ops::Neg for Sign {
+    type Output = Sign;
+    fn neg(self) -> Self::Output {
+        match self {
+            Sign::Forward => Sign::Backward,
+            Sign::Backward => Sign::Forward,
+        }
+    }
+}
+
+#[derive(Debug, Clone, Copy, Eq, PartialEq)]
+pub enum Flag {
+    Measure,
+    DestroyInput,
+    Unaligned,
+    ConserveMemory,
+    Exhausive,
+    PreserveInput,
+    Patient,
+    Estimate,
+    WisdowmOnly,
+    Mixed(u32),
+}
+
+impl Into<u32> for Flag {
+    fn into(self) -> u32 {
+        use self::Flag::*;
+        match self {
+            Measure => 0,
+            DestroyInput => 1 << 0,
+            Unaligned => 1 << 1,
+            ConserveMemory => 1 << 2,
+            Exhausive => 1 << 3,
+            PreserveInput => 1 << 4,
+            Patient => 1 << 5,
+            Estimate => 1 << 6,
+            WisdowmOnly => 1 << 21,
+            Mixed(u) => u,
+        }
+    }
+}
+
+impl ::std::ops::BitOr for Flag {
+    type Output = Self;
+    fn bitor(self, rhs: Self) -> Self {
+        let lhs: u32 = self.into();
+        let rhs: u32 = rhs.into();
+        Flag::Mixed(lhs | rhs)
+    }
+}