Struct cxx_qt_lib::QString

#[repr(C)]
pub struct QString { /* private fields */ }

The QString class provides a Unicode character string.

Note that QString is a UTF-16 whereas Rust strings are a UTF-8

Implementations

impl<'a> QString

pub fn append(&'a mut self, str: &QString) -> &'a mut QString

Appends the string str onto the end of this string.

impl QString

pub fn clear(&mut self)

Clears the contents of the string and makes it null.

impl QString

pub fn contains(&self, str: &QString, cs: CaseSensitivity) -> bool

Returns true if this string contains an occurrence of the string str; otherwise returns false.

impl QString

pub fn ends_with(&self, s: &QString, cs: CaseSensitivity) -> bool

Returns true if the string ends with s; otherwise returns false.

impl QString

pub fn is_empty(&self) -> bool

Returns true if the string has no characters; otherwise returns false.

impl QString

pub fn is_lower(&self) -> bool

Returns true if the string is lowercase, that is, it’s identical to its toLower() folding.

impl QString

pub fn is_null(&self) -> bool

Returns true if this string is null; otherwise returns false.

impl QString

pub fn is_right_to_left(&self) -> bool

Returns true if the string is read right to left.

impl QString

pub fn is_upper(&self) -> bool

Returns true if the string is uppercase, that is, it’s identical to its toUpper() folding.

impl<'a> QString

pub fn prepend(&'a mut self, str: &QString) -> &'a mut QString

Prepends the string str to the beginning of this string and returns a reference to this string.

impl<'a> QString

pub fn remove( &'a mut self, str: &QString, cs: CaseSensitivity ) -> &'a mut QString

Removes every occurrence of the given str string in this string, and returns a reference to this string.

impl<'a> QString

pub fn replace( &'a mut self, before: &QString, after: &QString, cs: CaseSensitivity ) -> &'a mut QString

Replaces every occurrence of the string before with the string after and returns a reference to this string.

impl QString

pub fn starts_with(&self, s: &QString, cs: CaseSensitivity) -> bool

Returns true if the string starts with s; otherwise returns false.

impl QString

pub fn arg(&self, a: &QString) -> Self

Returns a copy of this string with the lowest numbered place marker replaced by string a, i.e., %1, %2, …, %99.

pub fn compare(&self, other: &QString, cs: CaseSensitivity) -> Ordering

Lexically compares this string with the other string and returns if this string is less than, equal to, or greater than the other string.

pub fn index_of(&self, str: &QString, from: isize, cs: CaseSensitivity) -> isize

Returns the index position of the first occurrence of the string str in this string, searching forward from index position from. Returns -1 if str is not found.

pub fn insert<'a>(&'a mut self, pos: isize, str: &Self) -> &'a mut Self

Inserts the string str at the given index position and returns a mutable reference to this string.

pub fn left(&self, n: isize) -> Self

Returns a substring that contains the n leftmost characters of the string.

pub fn len(self: &QString) -> isize

Returns the number of characters in this string.

pub fn mid(&self, position: isize, n: isize) -> Self

Returns a string that contains n characters of this string, starting at the specified position index.

pub fn right(&self, n: isize) -> Self

Returns a substring that contains the n rightmost characters of the string.

pub fn simplified(&self) -> Self

Returns a string that has whitespace removed from the start and the end, and that has each sequence of internal whitespace replaced with a single space.

pub fn split( &self, sep: &QString, behavior: SplitBehaviorFlags, cs: CaseSensitivity ) -> QStringList

Splits the string into substrings wherever sep occurs, and returns the list of those strings. If sep does not match anywhere in the string, split() returns a single-element list containing this string.

pub fn to_latin1(&self) -> QByteArray

Returns a Latin-1 representation of the string as a QByteArray.

pub fn to_local8bit(&self) -> QByteArray

Returns the local 8-bit representation of the string as a QByteArray. The returned byte array is undefined if the string contains characters not supported by the local 8-bit encoding.

pub fn to_lower(&self) -> Self

Returns a lowercase copy of the string.

pub fn to_upper(&self) -> Self

Returns an uppercase copy of the string.

pub fn to_utf8(&self) -> QByteArray

Returns a UTF-8 representation of the string as a QByteArray.

pub fn trimmed(&self) -> Self

Returns a string that has whitespace removed from the start and the end.

Trait Implementations

impl Add for QString

type Output = QString

The resulting type after applying the + operator.

fn add(self, other: Self) -> Self

Performs the + operation.

impl Clone for QString

fn clone(&self) -> Self

Constructs a copy of other.

This operation takes constant time, because QString is implicitly shared. This makes returning a QString 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 QString

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

Formats the value using the given formatter.

impl Default for QString

fn default() -> Self

Constructs a null string. Null strings are also empty.

impl Display for QString

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

Convert the QString to a Rust string

Note that this converts from UTF-16 to UTF-8

impl Drop for QString

fn drop(&mut self)

Destroys the string.

impl ExternType for QString

type Id = (Q, S, t, r, i, n, g)

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 From<&QString> for QStringList

fn from(string: &QString) -> Self

Constructs a string list that contains the given string

impl From<&QString> for QUrl

fn from(str: &QString) -> Self

Constructs a QUrl from a QString

impl From<&QString> for String

fn from(qstring: &QString) -> Self

Convert the QString to a Rust string

Note that this converts from UTF-16 to UTF-8

impl From<&String> for QString

fn from(str: &String) -> Self

Constructs a QString from a Rust string

Note that this converts from UTF-8 to UTF-16

impl From<&str> for QString

fn from(str: &str) -> Self

Constructs a QString from a Rust string

Note that this converts from UTF-8 to UTF-16

impl Ord for QString

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized + PartialOrd,

Restrict a value to a certain interval.

impl PartialEq for QString

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialOrd for QString

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

This method tests less than (for self and other) and is used by the < operator.

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

This method tests less than or equal to (for self and other) and is used by the <= operator.

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

This method tests greater than (for self and other) and is used by the > operator.

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

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl QListElement for QString

type TypeId = (Q, L, i, s, t, __, Q, S, t, r, i, n, g)

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 QString

type TypeId = (Q, S, e, t, __, Q, S, t, r, i, n, g)

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

impl QVariantValue for QString

fn can_convert(variant: &QVariant) -> bool

fn construct(value: &Self) -> QVariant

fn value_or_default(variant: &QVariant) -> Self

impl QVectorElement for QString

type TypeId = (Q, V, e, c, t, o, r, __, Q, S, t, r, i, n, g)

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 TryFrom<&QString> for QColor

type Error = &'static str

The type returned in the event of a conversion error.

fn try_from(value: &QString) -> Result<Self, Self::Error>

Performs the conversion.

impl Eq for QString