cxx-qt-lib: QByteArray:from_base64_encoding and QByteArray::to_base64 (#1305)

Author: jnbooth

CHANGELOG.md

@@ -38,6 +38,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Add `QScopedMetaObjectConnectionGuard`, which is `QMetaObjectConnectionGuard` with a scoped lifetime. `QMetaObjectConnectionGuard` is now a type alias for `QScopedMetaObjectConnectionGuard<'static>`.
 - Support for setting Qt log message patterns with `q_set_message_pattern` and formatting log messages ith `q_format_log_message`.
 - Implement `IntoIterator` for `&QHash`, `&QList`, `&QMap`, `&QSet`, and `&QVector`.
+- Add `QByteArray:from_base64_encoding` and `QByteArray::to_base64`.
 
 ### Removed
 

crates/cxx-qt-lib/include/core/qbytearray.h

@@ -20,11 +20,20 @@ template<>
 struct IsRelocatable<QByteArray> : ::std::true_type
 {};
 
+template<>
+struct IsRelocatable<QByteArray::FromBase64Result> : ::std::true_type
+{};
+
 } // namespace rust
 
 namespace rust {
 namespace cxxqtlib1 {
 
+using QByteArrayBase64Option = QByteArray::Base64Option;
+using QByteArrayBase64Options = QByteArray::Base64Options;
+using QByteArrayBase64DecodingStatus = QByteArray::Base64DecodingStatus;
+using QByteArrayFromBase64Result = QByteArray::FromBase64Result;
+
 QByteArray
 qbytearrayFromSliceU8(::rust::Slice<const ::std::uint8_t> slice);
 ::rust::Vec<::std::uint8_t>
@@ -41,6 +50,9 @@ void
 qbytearrayAppend(QByteArray& byteArray, ::std::uint8_t ch);
 void
 qbytearrayFill(QByteArray& byteArray, ::std::uint8_t ch, ::rust::isize size);
+QByteArray::FromBase64Result
+qbytearrayFromBase64Encoding(const QByteArray& base64,
+                             QByteArray::Base64Options options);
 void
 qbytearrayInsert(QByteArray& byteArray, ::rust::isize pos, ::std::uint8_t ch);
 ::rust::isize

crates/cxx-qt-lib/src/core/mod.rs

@@ -4,7 +4,9 @@
 // SPDX-License-Identifier: MIT OR Apache-2.0
 
 mod qbytearray;
-pub use qbytearray::QByteArray;
+pub use qbytearray::{
+    QByteArray, QByteArrayBase64Option, QByteArrayBase64Options, QByteArrayFromBase64Error,
+};
 
 mod qcoreapplication;
 pub use qcoreapplication::QCoreApplication;

crates/cxx-qt-lib/src/core/qbytearray.cpp

@@ -34,6 +34,22 @@ static_assert(!::std::is_trivially_destructible<QByteArray>::value);
 
 static_assert(QTypeInfo<QByteArray>::isRelocatable);
 
+using QByteArrayFromBase64Result = QByteArray::FromBase64Result;
+assert_alignment_and_size(QByteArrayFromBase64Result, {
+  QByteArray decoded;
+  QByteArray::Base64DecodingStatus decodingStatus;
+});
+
+static_assert(
+  !::std::is_trivially_copy_assignable<QByteArray::FromBase64Result>::value);
+static_assert(
+  !::std::is_trivially_copy_constructible<QByteArray::FromBase64Result>::value);
+
+static_assert(
+  !::std::is_trivially_destructible<QByteArray::FromBase64Result>::value);
+
+static_assert(QTypeInfo<QByteArray::FromBase64Result>::isRelocatable);
+
 namespace rust {
 namespace cxxqtlib1 {
 
@@ -104,6 +120,13 @@ qbytearrayFill(QByteArray& byteArray, ::std::uint8_t ch, ::rust::isize size)
 #endif
 }
 
+QByteArray::FromBase64Result
+qbytearrayFromBase64Encoding(const QByteArray& base64,
+                             QByteArray::Base64Options options)
+{
+  return QByteArray::fromBase64Encoding(base64, options);
+}
+
 void
 qbytearrayInsert(QByteArray& byteArray, ::rust::isize pos, ::std::uint8_t ch)
 {

crates/cxx-qt-lib/src/core/qbytearray.rs

@@ -7,29 +7,64 @@ use std::fmt;
 use std::mem::MaybeUninit;
 use std::str;
 
+use crate::{unsafe_impl_qflag, QFlags};
+
 #[cxx::bridge]
 mod ffi {
-    unsafe extern "C++" {
+    /// This enum contains the options available for encoding and decoding Base64. Base64 is defined by [RFC 4648](https://datatracker.ietf.org/doc/html/rfc4648).
+    ///
+    /// An empty `QFlags<QByteArrayBase64Option>` will use the regular Base64 alphabet, called simply "base64".
+    #[namespace = "rust::cxxqtlib1"]
+    #[repr(u32)]
+    enum QByteArrayBase64Option {
+        /// An alternate alphabet, called "base64url", which replaces two characters in the alphabet to be more friendly to URLs.
+        Base64UrlEncoding = 1,
+        /// Omits adding the padding equal signs at the end of the encoded data.
+        OmitTrailingEquals = 2,
+    }
+
+    #[namespace = "rust::cxxqtlib1"]
+    #[repr(i32)]
+    enum QByteArrayBase64DecodingStatus {
+        Ok,
+        IllegalInputLength,
+        IllegalCharacter,
+        IllegalPadding,
+    }
+
+    #[namespace = "rust::cxxqtlib1"]
+    extern "C++" {
         include!("cxx-qt-lib/qbytearray.h");
 
+        type QByteArrayBase64DecodingStatus;
+        type QByteArrayFromBase64Result = super::QByteArrayFromBase64Result;
+        type QByteArrayBase64Option;
+        type QByteArrayBase64Options = super::QByteArrayBase64Options;
+    }
+
+    unsafe extern "C++" {
         type QByteArray = super::QByteArray;
 
         /// Clears the contents of the byte array and makes it null.
-        fn clear(self: &mut Self);
+        fn clear(&mut self);
+
         /// Returns `true` if the byte array has size 0; otherwise returns `false`.
         #[rust_name = "is_empty"]
-        fn isEmpty(self: &Self) -> bool;
+        fn isEmpty(&self) -> bool;
         /// Returns `true` if this byte array is lowercase, that is, if it's identical to its [`to_lower`](Self::to_lower) folding.
         #[rust_name = "is_lower"]
-        fn isLower(self: &Self) -> bool;
+        fn isLower(&self) -> bool;
         /// Returns `true` if this byte array is null; otherwise returns `false`.
         #[rust_name = "is_null"]
-        fn isNull(self: &Self) -> bool;
+        fn isNull(&self) -> bool;
         /// Returns `true` if this byte array is uppercase, that is, if it's identical to its [`to_upper`](Self::to_upper) folding.
         #[rust_name = "is_upper"]
-        fn isUpper(self: &Self) -> bool;
+        fn isUpper(&self) -> bool;
         /// Releases any memory not required to store the array's data.
-        fn squeeze(self: &mut Self);
+        fn squeeze(&mut self);
+        /// Returns a copy of the byte array, encoded using the options `options`.
+        #[rust_name = "to_base64"]
+        fn toBase64(&self, options: QByteArrayBase64Options) -> QByteArray;
     }
 
     #[namespace = "rust::cxxqtlib1"]
@@ -75,6 +110,12 @@ mod ffi {
         #[rust_name = "qbytearray_fill"]
         fn qbytearrayFill(bytearray: &mut QByteArray, ch: u8, size: isize);
         #[doc(hidden)]
+        #[rust_name = "qbytearrray_from_base64_encoding"]
+        fn qbytearrayFromBase64Encoding(
+            base64: &QByteArray,
+            options: QByteArrayBase64Options,
+        ) -> QByteArrayFromBase64Result;
+        #[doc(hidden)]
         #[rust_name = "qbytearray_insert"]
         fn qbytearrayInsert(bytearray: &mut QByteArray, pos: isize, ch: u8);
         #[doc(hidden)]
@@ -107,6 +148,17 @@ mod ffi {
     }
 }
 
+use ffi::QByteArrayBase64DecodingStatus;
+pub use ffi::QByteArrayBase64Option;
+
+/// [`QFlags`] of [`QByteArrayBase64Option`].
+pub type QByteArrayBase64Options = QFlags<QByteArrayBase64Option>;
+unsafe_impl_qflag!(
+    QByteArrayBase64Option,
+    "rust::cxxqtlib1::QByteArrayBase64Options",
+    u32
+);
+
 /// The `QByteArray` class provides an array of bytes.
 ///
 /// Qt Documentation: [QByteArray](https://doc.qt.io/qt/qbytearray.html#details)
@@ -247,6 +299,26 @@ impl QByteArray {
         ffi::qbytearray_fill(self, ch, size)
     }
 
+    /// Decodes the Base64 array `base64`, using the options defined by `options`.
+    pub fn from_base64_encoding(
+        base64: &Self,
+        options: QByteArrayBase64Options,
+    ) -> Result<Self, QByteArrayFromBase64Error> {
+        let result = ffi::qbytearrray_from_base64_encoding(base64, options);
+        match result.decoding_status {
+            QByteArrayBase64DecodingStatus::IllegalInputLength => {
+                Err(QByteArrayFromBase64Error::IllegalInputLength)
+            }
+            QByteArrayBase64DecodingStatus::IllegalCharacter => {
+                Err(QByteArrayFromBase64Error::IllegalCharacter)
+            }
+            QByteArrayBase64DecodingStatus::IllegalPadding => {
+                Err(QByteArrayFromBase64Error::IllegalPadding)
+            }
+            _ => Ok(result.decoded),
+        }
+    }
+
     /// Construct a `QByteArray` from a `bytes::Bytes` without a deep copy
     ///
     /// # Safety
@@ -340,6 +412,40 @@ impl QByteArray {
     }
 }
 
+#[repr(C)]
+struct QByteArrayFromBase64Result {
+    decoded: QByteArray,
+    decoding_status: QByteArrayBase64DecodingStatus,
+}
+
+// Safety:
+//
+// Static checks on the C++ side to ensure the size is the same.
+unsafe impl ExternType for QByteArrayFromBase64Result {
+    type Id = type_id!("rust::cxxqtlib1::QByteArrayFromBase64Result");
+    type Kind = cxx::kind::Trivial;
+}
+
+#[allow(clippy::enum_variant_names)]
+#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub enum QByteArrayFromBase64Error {
+    IllegalInputLength = 1,
+    IllegalCharacter,
+    IllegalPadding,
+}
+
+impl fmt::Display for QByteArrayFromBase64Error {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.write_str(match self {
+            Self::IllegalInputLength => "illegal input length",
+            Self::IllegalCharacter => "illegal character",
+            Self::IllegalPadding => "illegal padding",
+        })
+    }
+}
+
+impl std::error::Error for QByteArrayFromBase64Error {}
+
 #[cfg(feature = "serde")]
 impl serde::Serialize for QByteArray {
     fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
@@ -407,6 +513,24 @@ mod tests {
         assert_eq!(crate::serde_impl::roundtrip(&qbytearray), qbytearray)
     }
 
+    #[test]
+    fn qbytearray_base64() {
+        let qbytearray = QByteArray::from("KDAB");
+        let options = QByteArrayBase64Options::default();
+        let encoded = qbytearray.to_base64(options);
+        let decoded = QByteArray::from_base64_encoding(&encoded, options);
+        assert_eq!(decoded, Ok(qbytearray));
+    }
+
+    #[test]
+    fn qbytearray_base64_url() {
+        let qbytearray = QByteArray::from("KDAB");
+        let options = QByteArrayBase64Option::Base64UrlEncoding.into();
+        let encoded = qbytearray.to_base64(options);
+        let decoded = QByteArray::from_base64_encoding(&encoded, options);
+        assert_eq!(decoded, Ok(qbytearray));
+    }
+
     #[cfg(feature = "bytes")]
     #[test]
     fn test_bytes() {
@@ -421,6 +545,6 @@ mod tests {
     #[test]
     fn test_display_fmt() {
         let qbytearray = QByteArray::from("KDAB");
-        assert_eq!(format!("{:-<8}", qbytearray), "KDAB----")
+        assert_eq!(format!("{qbytearray:-<8}"), "KDAB----")
     }
 }