Struct QByteArray 

pub struct QByteArray { /* private fields */ }

The QByteArray class provides an array of bytes.

Qt Documentation: QByteArray

Implementations

impl QByteArray

pub fn clear(&mut self)

Clears the contents of the byte array and makes it null.

pub fn is_empty(&self) -> bool

Returns true if the byte array has size 0; otherwise returns false.

pub fn is_lower(&self) -> bool

Returns true if this byte array is lowercase, that is, if it’s identical to its to_lower folding.

pub fn is_null(&self) -> bool

Returns true if this byte array is null; otherwise returns false.

pub fn is_upper(&self) -> bool

Returns true if this byte array is uppercase, that is, if it’s identical to its to_upper folding.

pub fn squeeze(&mut self)

Releases any memory not required to store the array’s data.

pub fn to_base64(&self, options: QByteArrayBase64Options) -> QByteArray

Returns a copy of the byte array, encoded using the options options.

impl QByteArray

pub fn append(&mut self, ch: u8)

Inserts value at the end of the list.

pub fn as_mut_slice(&mut self) -> &mut [u8]

Extracts a mutable slice of the entire vector.

pub fn as_slice(&self) -> &[u8]

Extracts a slice containing the entire byte array.

pub fn fill(&mut self, ch: u8, size: isize)

Sets every byte in the byte array to ch. If size is different from -1, the byte array is resized to size size beforehand.

pub fn from_base64_encoding( base64: &Self, options: QByteArrayBase64Options, ) -> Result<Self, QByteArrayFromBase64Error>

Decodes the Base64 array base64, using the options defined by options.

pub unsafe fn from_raw_bytes(bytes: &Bytes) -> Self

Available on crate feature bytes only.

Construct a QByteArray from a bytes::Bytes without a deep copy

Safety

The caller must ensure that the original bytes::Bytes outlives the QByteArray and that the QByteArray is not modified

pub unsafe fn from_raw_data(bytes: &[u8]) -> Self

Construct a QByteArray from a &[u8] without a deep copy

Safety

The caller must ensure that the original slice outlives the QByteArray and that the QByteArray is not modified

pub fn insert(&mut self, pos: isize, ch: u8)

Inserts byte ch at index position pos in the byte array.

This array grows to accommodate the insertion. If pos is beyond the end of the array, the array is first extended with space characters to reach this pos.

pub fn len(&self) -> isize

Returns the number of bytes in this byte array.

pub fn prepend(&mut self, ch: u8)

Prepends the byte ch to this byte array.

pub fn remove(&mut self, pos: isize, len: isize)

Removes len bytes from the array, starting at index position pos.

If pos is out of range, nothing happens. If pos is valid, but pos + len is larger than the size of the array, the array is truncated at position pos.

pub fn reserve(&mut self, size: isize)

Attempts to allocate memory for at least size bytes.

If you know in advance how large the byte array will be, you can call this function, and if you call resize often you are likely to get better performance.

If in doubt about how much space shall be needed, it is usually better to use an upper bound as size, or a high estimate of the most likely size, if a strict upper bound would be much bigger than this. If size is an underestimate, the array will grow as needed once the reserved size is exceeded, which may lead to a larger allocation than your best overestimate would have and will slow the operation that triggers it.

The sole purpose of this function is to provide a means of fine tuning QByteArray’s memory usage. In general, you will rarely ever need to call this function.

pub fn resize(&mut self, size: isize)

Sets the size of the byte array to size bytes.

If size is greater than the current size, the byte array is extended to make it size bytes with the extra bytes added to the end. The new bytes are uninitialized.

If size is less than the current size, bytes beyond position size are excluded from the byte array.

Note: While resize will grow the capacity if needed, it never shrinks capacity.

pub fn simplified(&self) -> Self

Returns a copy of this byte array that has spacing characters removed from the start and end, and in which each sequence of internal spacing characters is replaced with a single space.

The spacing characters are the ASCII characters tabulation '\t', line feed '\n', carriage return '\r', vertical tabulation '\x08' ('\v' in C), form feed '\x0C' ('\f' in C), and space ' '.

pub fn to_lower(&self) -> Self

Returns a copy of the byte array in which each ASCII uppercase letter converted to lowercase.

pub fn to_upper(&self) -> Self

Returns a copy of the byte array in which each ASCII lowercase letter converted to uppercase.

pub fn trimmed(&self) -> Self

Returns a copy of this byte array with spacing characters removed from the start and end.

The spacing characters are the ASCII characters tabulation '\t', line feed '\n', carriage return '\r', vertical tabulation '\x08' ('\v' in C), form feed '\x0C' ('\f' in C), and space ' '.

Trait Implementations

impl AsRef<[u8]> for QByteArray

fn as_ref(&self) -> &[u8]

Construct a slice of u8 from a QByteArray.

impl Clone for QByteArray

fn clone(&self) -> Self

Constructs a copy of self.

This operation takes constant time, because QByteArray is implicitly shared similar to a Cow. This makes returning a QByteArray from a function very fast. If a shared instance is modified, it will be copied (copy-on-write), and that takes linear time.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for QByteArray

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for QByteArray

fn default() -> Self

Constructs an empty byte array.

impl<'de> Deserialize<'de> for QByteArray

Available on crate feature serde only.

fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error>

Deserialize this value from the given Serde deserializer.

impl Display for QByteArray

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Convert the QByteArray to a Rust string.

impl Drop for QByteArray

fn drop(&mut self)

Destroys the byte array.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl Eq for QByteArray

impl ExternType for QByteArray

type Id = (Q, B, y, t, e, A, r, r, a, y)

A type-level representation of the type’s C++ namespace and type name.

type Kind = Trivial

Either cxx::kind::Opaque or cxx::kind::Trivial.

impl<'a> From<&'a QByteArray> for QAnyStringView<'a>

Available on cxxqt_qt_version_major=6 only.

fn from(bytes: &'a QByteArray) -> Self

Constructs a QAnyStringView from a QByteArray.

impl From<&Bytes> for QByteArray

Available on crate feature bytes only.

fn from(value: &Bytes) -> Self

Convert bytes::Bytes to a QByteArray. This makes a deep copy of the data.

impl From<&QByteArray> for Vec<u8>

fn from(bytearray: &QByteArray) -> Self

Convert the QByteArray to a Vec<u8>. This makes a deep copy of the data.

impl From<&QByteArray> for Bytes

Available on crate feature bytes only.

fn from(value: &QByteArray) -> Self

Convert QByteArray to a bytes::Bytes. This makes a deep copy of the data.

impl From<&QByteArray> for QUuid

fn from(value: &QByteArray) -> Self

See QUuid::from_rfc_4122.

impl From<&String> for QByteArray

fn from(str: &String) -> Self

Constructs a QByteArray from a Rust string. This makes a deep copy of the data.

impl<const N: usize> From<&[u8; N]> for QByteArray

fn from(bytes: &[u8; N]) -> Self

Converts to this type from the input type.

impl From<&[u8]> for QByteArray

fn from(bytes: &[u8]) -> Self

Constructs a QByteArray from a &[u8]. This makes a deep copy of the data.

impl From<&str> for QByteArray

fn from(str: &str) -> Self

Constructs a QByteArray from a Rust string slice. This makes a deep copy of the data.

impl From<QUuid> for QByteArray

fn from(value: QUuid) -> Self

See QUuid::to_rfc_4122.

impl PartialEq for QByteArray

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl QListElement for QByteArray

type TypeId = (Q, L, i, s, t, __, Q, B, y, t, e, A, r, r, a, y)

fn append(list: &mut QList<Self>, value: Self)

fn append_clone(list: &mut QList<Self>, value: &Self)

fn clear(list: &mut QList<Self>)

fn clone(list: &QList<Self>) -> QList<Self>

fn contains(list: &QList<Self>, value: &Self) -> bool

fn default() -> QList<Self>

fn drop(list: &mut QList<Self>)

unsafe fn get_unchecked(list: &QList<Self>, pos: isize) -> &Self

Safety

fn index_of(list: &QList<Self>, value: &Self) -> isize

fn insert(list: &mut QList<Self>, pos: isize, value: Self)

fn insert_clone(list: &mut QList<Self>, pos: isize, value: &Self)

fn len(list: &QList<Self>) -> isize

fn remove(list: &mut QList<Self>, pos: isize)

fn reserve(list: &mut QList<Self>, size: isize)

impl QSetElement for QByteArray

type TypeId = (Q, S, e, t, __, Q, B, y, t, e, A, r, r, a, y)

fn clear(set: &mut QSet<Self>)

fn clone(set: &QSet<Self>) -> QSet<Self>

fn contains(set: &QSet<Self>, value: &Self) -> bool

fn default() -> QSet<Self>

fn drop(set: &mut QSet<Self>)

unsafe fn get_unchecked(set: &QSet<Self>, pos: isize) -> &Self

Safety

fn insert(set: &mut QSet<Self>, value: Self)

fn insert_clone(set: &mut QSet<Self>, value: &Self)

fn len(set: &QSet<Self>) -> isize

fn remove(set: &mut QSet<Self>, value: &Self) -> bool

fn reserve(set: &mut QSet<Self>, size: isize)

impl QVariantValue for QByteArray

fn can_convert(variant: &QVariant) -> bool

fn construct(value: &Self) -> QVariant

fn value_or_default(variant: &QVariant) -> Self

impl QVectorElement for QByteArray

type TypeId = (Q, V, e, c, t, o, r, __, Q, B, y, t, e, A, r, r, a, y)

fn append(vector: &mut QVector<Self>, value: Self)

fn append_clone(vector: &mut QVector<Self>, value: &Self)

fn clear(vector: &mut QVector<Self>)

fn clone(vector: &QVector<Self>) -> QVector<Self>

fn contains(vector: &QVector<Self>, value: &Self) -> bool

fn default() -> QVector<Self>

fn drop(vector: &mut QVector<Self>)

unsafe fn get_unchecked(vector: &QVector<Self>, pos: isize) -> &Self

Safety

fn index_of(vector: &QVector<Self>, value: &Self) -> isize

fn insert(vector: &mut QVector<Self>, pos: isize, value: Self)

fn insert_clone(vector: &mut QVector<Self>, pos: isize, value: &Self)

fn len(vector: &QVector<Self>) -> isize

fn remove(vector: &mut QVector<Self>, pos: isize)

fn reserve(vector: &mut QVector<Self>, size: isize)

impl Serialize for QByteArray

Available on crate feature serde only.

fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error>

Serialize this value into the given Serde serializer.