Put str_id macro into a separate module

For better modularity.

Signed-off-by: mulhern <amulhern@redhat.com>

Author: mulkieran

src/id_macros.rs

@@ -0,0 +1,83 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+// A module to contain functionality used for generating DM ids which
+// are restricted in length and format by devicemapper.
+
+/// Define borrowed and owned versions of string types that guarantee
+/// conformance to DM restrictions, such as maximum length.
+// This implementation follows the example of Path/PathBuf as closely as
+// possible.
+macro_rules! str_id {
+    ($B:ident, $O:ident, $MAX:ident, $check:ident) => {
+        /// The borrowed version of the DM identifier.
+        #[derive(Debug, PartialEq, Eq, Hash)]
+        pub struct $B {
+            inner: str,
+        }
+
+        /// The owned version of the DM identifier.
+        #[derive(Debug, Clone, PartialEq, Eq, Hash)]
+        pub struct $O {
+            inner: String,
+        }
+
+        impl $B {
+            /// Create a new borrowed identifier from a `&str`.
+            #[allow(clippy::new_ret_no_self)]
+            pub fn new(value: &str) -> DmResult<&$B> {
+                $check(value, $MAX - 1)?;
+                Ok(unsafe { &*(value as *const str as *const $B) })
+            }
+
+            /// Get the inner value as bytes
+            pub fn as_bytes(&self) -> &[u8] {
+                self.inner.as_bytes()
+            }
+        }
+
+        impl ToOwned for $B {
+            type Owned = $O;
+            fn to_owned(&self) -> $O {
+                $O {
+                    inner: self.inner.to_owned(),
+                }
+            }
+        }
+
+        impl fmt::Display for $B {
+            fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+                write!(f, "{}", &self.inner)
+            }
+        }
+
+        impl $O {
+            /// Construct a new owned identifier.
+            #[allow(clippy::new_ret_no_self)]
+            pub fn new(value: String) -> DmResult<$O> {
+                $check(&value, $MAX - 1)?;
+                Ok($O { inner: value })
+            }
+        }
+
+        impl AsRef<$B> for $O {
+            fn as_ref(&self) -> &$B {
+                self
+            }
+        }
+
+        impl Borrow<$B> for $O {
+            fn borrow(&self) -> &$B {
+                self.deref()
+            }
+        }
+
+        impl Deref for $O {
+            type Target = $B;
+            fn deref(&self) -> &$B {
+                $B::new(&self.inner).expect("inner satisfies all correctness criteria for $B::new")
+            }
+        }
+    };
+}

src/lib.rs

@@ -93,6 +93,9 @@ extern crate uuid;
 /// Range macros
 #[macro_use]
 mod range_macros;
+/// ID macros
+#[macro_use]
+mod id_macros;
 /// shared constants
 mod consts;
 /// rust definitions of ioctl structs and consts

src/types.rs

@@ -84,83 +84,6 @@ fn str_check(value: &str, max_allowed_chars: usize) -> DmResult<()> {
     Ok(())
 }
 
-/// Define borrowed and owned versions of string types that guarantee
-/// conformance to DM restrictions, such as maximum length.
-// This implementation follows the example of Path/PathBuf as closely as
-// possible.
-macro_rules! str_id {
-    ($B:ident, $O:ident, $MAX:ident, $check:ident) => {
-        /// The borrowed version of the DM identifier.
-        #[derive(Debug, PartialEq, Eq, Hash)]
-        pub struct $B {
-            inner: str,
-        }
-
-        /// The owned version of the DM identifier.
-        #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-        pub struct $O {
-            inner: String,
-        }
-
-        impl $B {
-            /// Create a new borrowed identifier from a `&str`.
-            #[allow(clippy::new_ret_no_self)]
-            pub fn new(value: &str) -> DmResult<&$B> {
-                $check(value, $MAX - 1)?;
-                Ok(unsafe { &*(value as *const str as *const $B) })
-            }
-
-            /// Get the inner value as bytes
-            pub fn as_bytes(&self) -> &[u8] {
-                self.inner.as_bytes()
-            }
-        }
-
-        impl ToOwned for $B {
-            type Owned = $O;
-            fn to_owned(&self) -> $O {
-                $O {
-                    inner: self.inner.to_owned(),
-                }
-            }
-        }
-
-        impl fmt::Display for $B {
-            fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-                write!(f, "{}", &self.inner)
-            }
-        }
-
-        impl $O {
-            /// Construct a new owned identifier.
-            #[allow(clippy::new_ret_no_self)]
-            pub fn new(value: String) -> DmResult<$O> {
-                $check(&value, $MAX - 1)?;
-                Ok($O { inner: value })
-            }
-        }
-
-        impl AsRef<$B> for $O {
-            fn as_ref(&self) -> &$B {
-                self
-            }
-        }
-
-        impl Borrow<$B> for $O {
-            fn borrow(&self) -> &$B {
-                self.deref()
-            }
-        }
-
-        impl Deref for $O {
-            type Target = $B;
-            fn deref(&self) -> &$B {
-                $B::new(&self.inner).expect("inner satisfies all correctness criteria for $B::new")
-            }
-        }
-    };
-}
-
 /// A devicemapper name. Really just a string, but also the argument type of
 /// DevId::Name. Used in function arguments to indicate that the function
 /// takes only a name, not a devicemapper uuid.