Merge pull request CosmWasm#554 from CosmWasm/convert-into-vec

Add Binary::into_vec and CanonicalAddr::into_vec

Author: webmaster128

CHANGELOG.md

@@ -32,6 +32,9 @@
 - Create trait `CustomQuery` for the generic argument in
   `QueryRequest<C: CustomQuery>`. This allows us to provide
   `impl<C: CustomQuery> From<C> for QueryRequest<C>` for any custom query.
+- Implement `From<Binary> for Vec<u8>`.
+- Implement `From<CanonicalAddr> for Vec<u8>`.
+- Add `Binary::into_vec` and `CanonicalAddr::into_vec`.
 
 **cosmwasm-storage**
 

packages/std/src/addresses.rs

@@ -67,6 +67,12 @@ impl From<Vec<u8>> for CanonicalAddr {
     }
 }
 
+impl From<CanonicalAddr> for Vec<u8> {
+    fn from(source: CanonicalAddr) -> Vec<u8> {
+        source.0.into()
+    }
+}
+
 impl CanonicalAddr {
     pub fn as_slice(&self) -> &[u8] {
         &self.0.as_slice()
@@ -79,6 +85,26 @@ impl CanonicalAddr {
     pub fn is_empty(&self) -> bool {
         self.0.is_empty()
     }
+
+    /// Converts a `CanonicalAddr` into a vector of bytes.
+    ///
+    /// This consumes the `CanonicalAddr`, so we do not need to copy its contents.
+    /// It is equivalent to both `Vec::<u8>::from(addr)` and `let v: Vec<u8> = addr.into()` and just a matter of taste which one you use.
+    ///
+    /// # Examples
+    ///
+    /// Basic usage:
+    ///
+    /// ```
+    /// # use cosmwasm_std::CanonicalAddr;
+    /// let address = CanonicalAddr::from(vec![0, 187, 61, 11, 250, 0]);
+    /// let bytes = address.into_vec();
+    ///
+    /// assert_eq!(bytes, &[0, 187, 61, 11, 250, 0]);
+    /// ```
+    pub fn into_vec(self) -> Vec<u8> {
+        self.into()
+    }
 }
 
 impl fmt::Display for CanonicalAddr {
@@ -158,6 +184,40 @@ mod test {
         assert_eq!(canonical_addr_vec.as_slice(), &[0u8, 187, 61, 11, 250, 0]);
     }
 
+    #[test]
+    fn canonical_addr_from_vec_works() {
+        // Into<CanonicalAddr> for Vec<u8>
+        let original = vec![0u8, 187, 61, 11, 250, 0];
+        let original_ptr = original.as_ptr();
+        let addr: CanonicalAddr = original.into();
+        assert_eq!(addr.as_slice(), [0u8, 187, 61, 11, 250, 0]);
+        assert_eq!((addr.0).0.as_ptr(), original_ptr, "must not be copied");
+
+        // From<Vec<u8>> for CanonicalAddr
+        let original = vec![0u8, 187, 61, 11, 250, 0];
+        let original_ptr = original.as_ptr();
+        let addr = CanonicalAddr::from(original);
+        assert_eq!(addr.as_slice(), [0u8, 187, 61, 11, 250, 0]);
+        assert_eq!((addr.0).0.as_ptr(), original_ptr, "must not be copied");
+    }
+
+    #[test]
+    fn canonical_addr_into_vec_works() {
+        // Into<Vec<u8>> for CanonicalAddr
+        let original = CanonicalAddr::from(vec![0u8, 187, 61, 11, 250, 0]);
+        let original_ptr = (original.0).0.as_ptr();
+        let vec: Vec<u8> = original.into();
+        assert_eq!(vec.as_slice(), [0u8, 187, 61, 11, 250, 0]);
+        assert_eq!(vec.as_ptr(), original_ptr, "must not be copied");
+
+        // From<CanonicalAddr> for Vec<u8>
+        let original = CanonicalAddr::from(vec![7u8, 35, 49, 101, 0, 255]);
+        let original_ptr = (original.0).0.as_ptr();
+        let vec = Vec::<u8>::from(original);
+        assert_eq!(vec.as_slice(), [7u8, 35, 49, 101, 0, 255]);
+        assert_eq!(vec.as_ptr(), original_ptr, "must not be copied");
+    }
+
     #[test]
     fn canonical_addr_len() {
         let bytes: &[u8] = &[0u8, 187, 61, 11, 250, 0];

packages/std/src/encoding.rs

@@ -25,15 +25,38 @@ impl Binary {
     pub fn to_base64(&self) -> String {
         base64::encode(&self.0)
     }
+
     pub fn as_slice(&self) -> &[u8] {
         self.0.as_slice()
     }
+
     pub fn len(&self) -> usize {
         self.0.len()
     }
+
     pub fn is_empty(&self) -> bool {
         self.0.is_empty()
     }
+
+    /// Converts a `Binary` into a vector of bytes.
+    ///
+    /// This consumes the `Binary`, so we do not need to copy its contents.
+    /// It is equivalent to both `Vec::<u8>::from(binary)` and `let v: Vec<u8> = binary.into()` and just a matter of taste which one you use.
+    ///
+    /// # Examples
+    ///
+    /// Basic usage:
+    ///
+    /// ```
+    /// # use cosmwasm_std::Binary;
+    /// let binary = Binary::from_base64("ALs9C/oA").unwrap();
+    /// let bytes = binary.into_vec();
+    ///
+    /// assert_eq!(bytes, &[0, 187, 61, 11, 250, 0]);
+    /// ```
+    pub fn into_vec(self) -> Vec<u8> {
+        self.into()
+    }
 }
 
 impl fmt::Display for Binary {
@@ -85,9 +108,9 @@ impl From<Vec<u8>> for Binary {
     }
 }
 
-impl Into<Vec<u8>> for Binary {
-    fn into(self) -> Vec<u8> {
-        self.0
+impl From<Binary> for Vec<u8> {
+    fn from(original: Binary) -> Vec<u8> {
+        original.0
     }
 }
 
@@ -278,11 +301,19 @@ mod test {
 
     #[test]
     fn into_vec_works() {
+        // Into<Vec<u8>> for Binary
         let original = Binary(vec![0u8, 187, 61, 11, 250, 0]);
         let original_ptr = original.0.as_ptr();
         let vec: Vec<u8> = original.into();
         assert_eq!(vec.as_slice(), [0u8, 187, 61, 11, 250, 0]);
         assert_eq!(vec.as_ptr(), original_ptr, "vector must not be copied");
+
+        // From<Binary> for Vec<u8>
+        let original = Binary(vec![7u8, 35, 49, 101, 0, 255]);
+        let original_ptr = original.0.as_ptr();
+        let vec = Vec::<u8>::from(original);
+        assert_eq!(vec.as_slice(), [7u8, 35, 49, 101, 0, 255]);
+        assert_eq!(vec.as_ptr(), original_ptr, "vector must not be copied");
     }
 
     #[test]