use std::{fmt, iter::FromIterator, ops::Index};
use crate::internal_prelude::*;
use crate::QString;
use super::common::QListIterator;
cpp_class!(
#[derive(Default, Clone, PartialEq, Eq)]
pub unsafe struct QStringList as "QStringList"
);
impl QStringList {
pub fn new() -> QStringList {
cpp!(unsafe [] -> QStringList as "QStringList" {
return QStringList();
})
}
pub fn insert(&mut self, index: usize, value: QString) {
cpp!(unsafe [self as "QStringList*", index as "size_t", value as "QString"] {
self->insert(index, value);
});
}
pub fn push(&mut self, value: QString) {
cpp!(unsafe [self as "QStringList*", value as "QString"] {
self->append(value);
});
}
pub fn clear(&mut self) {
cpp!(unsafe [self as "QStringList*"] {
self->clear();
});
}
pub fn remove(&mut self, index: usize) {
cpp!(unsafe [self as "QStringList*", index as "size_t"] {
self->removeAt(index);
})
}
pub fn len(&self) -> usize {
cpp!(unsafe [self as "QStringList*"] -> usize as "size_t" { return self->size(); })
}
}
impl Index<usize> for QStringList {
type Output = QString;
fn index(&self, index: usize) -> &Self::Output {
unsafe {
&*cpp!([self as "QStringList*", index as "size_t"] -> *const QString as "const QString*" {
return &(*self)[index];
})
}
}
}
impl fmt::Debug for QStringList {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_list().entries(self.into_iter()).finish()
}
}
impl<T, const N: usize> From<[T; N]> for QStringList
where
QString: From<T>,
{
fn from(s: [T; N]) -> Self {
let mut list = QStringList::new();
for i in s {
list.push(QString::from(i));
}
list
}
}
impl<T> From<Vec<T>> for QStringList
where
QString: From<T>,
{
fn from(s: Vec<T>) -> Self {
s.into_iter().map(QString::from).collect()
}
}
impl<T> From<&[T]> for QStringList
where
T: Clone,
QString: From<T>,
{
fn from(s: &[T]) -> Self {
s.iter().cloned().map(QString::from).collect()
}
}
impl<T> From<QStringList> for Vec<T>
where
T: Clone,
QString: Into<T>,
{
fn from(arr: QStringList) -> Self {
arr.into_iter().cloned().map(|x| x.into()).collect()
}
}
impl<'a> IntoIterator for &'a QStringList {
type Item = &'a QString;
type IntoIter = QListIterator<'a, QStringList, QString>;
fn into_iter(self) -> Self::IntoIter {
QListIterator::new(self, 0, self.len())
}
}
impl<T> FromIterator<T> for QStringList
where
T: Into<QString>,
{
fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
let mut l = QStringList::default();
for i in iter {
l.push(i.into());
}
l
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_qstringlist() {
let mut qstringlist = QStringList::new();
qstringlist.push("One".into());
qstringlist.push("Two".into());
assert_eq!(qstringlist.len(), 2);
assert_eq!(qstringlist[0], QString::from("One"));
qstringlist.remove(0);
assert_eq!(qstringlist[0], QString::from("Two"));
qstringlist.insert(0, "Three".into());
assert_eq!(qstringlist[0], QString::from("Three"));
qstringlist.clear();
assert_eq!(qstringlist.len(), 0);
}
#[test]
fn test_qstringlist_from_iter() {
let v = vec!["abc", "efg", "hij"];
let qvl: QStringList = v.clone().into_iter().collect();
assert_eq!(qvl.len(), 3);
assert_eq!(qvl[1].to_string(), v[1].to_string());
}
#[test]
fn test_vec_from_qstringlist() {
let qstringlist = generate_qstring_list();
let temp: Vec<String> = qstringlist.clone().into();
assert_eq!(temp, vec!["Three".to_string(), "Two".to_string()]);
let temp: Vec<QString> = qstringlist.clone().into();
assert_eq!(temp, vec![QString::from("Three"), QString::from("Two")]);
}
#[test]
fn test_qstringlist_from_slice_ref() {
let qstringlist = generate_qstring_list();
let t = ["Three", "Two"];
assert_eq!(qstringlist, QStringList::from(t));
let t = ["Three".to_string(), "Two".to_string()];
assert_eq!(qstringlist, QStringList::from(t));
let t = [QString::from("Three"), QString::from("Two")];
assert_eq!(qstringlist, QStringList::from(t));
}
#[test]
fn test_qstringlist_from_slice() {
let qstringlist = generate_qstring_list();
assert_eq!(qstringlist, QStringList::from(["Three", "Two"]));
assert_eq!(qstringlist, QStringList::from(["Three".to_string(), "Two".to_string()]));
assert_eq!(qstringlist, QStringList::from([QString::from("Three"), QString::from("Two")]));
}
#[test]
fn test_qstringlist_from_vec() {
let qstringlist = generate_qstring_list();
assert_eq!(qstringlist, QStringList::from(vec!["Three", "Two"]));
assert_eq!(qstringlist, QStringList::from(vec!["Three".to_string(), "Two".to_string()]));
assert_eq!(
qstringlist,
QStringList::from(vec![QString::from("Three"), QString::from("Two")])
);
}
fn generate_qstring_list() -> QStringList {
let mut qstringlist = QStringList::new();
qstringlist.push("Three".into());
qstringlist.push("Two".into());
return qstringlist;
}
}