// This file was generated by gir (https://github.com/gtk-rs/gir)
// from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT

use crate::ListModel;
use glib::object::Cast;
use glib::object::IsA;
use glib::translate::*;
use glib::StaticType;
use glib::ToValue;
use std::fmt;
#[cfg(any(feature = "v2_64", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2_64")))]
use std::mem;

glib::wrapper! {
    /// [`ListStore`][crate::ListStore] is a simple implementation of [`ListModel`][crate::ListModel] that stores all
    /// items in memory.
    ///
    /// It provides insertions, deletions, and lookups in logarithmic time
    /// with a fast path for the common case of iterating the list linearly.
    ///
    /// # Implements
    ///
    /// [`trait@glib::ObjectExt`], [`ListModelExt`][trait@crate::prelude::ListModelExt], [`ListStoreExtManual`][trait@crate::prelude::ListStoreExtManual]
    #[doc(alias = "GListStore")]
    pub struct ListStore(Object<ffi::GListStore, ffi::GListStoreClass>) @implements ListModel;

    match fn {
        type_ => || ffi::g_list_store_get_type(),
    }
}

impl ListStore {
    /// Creates a new [`ListStore`][crate::ListStore] with items of type `item_type`. `item_type`
    /// must be a subclass of [`glib::Object`][crate::glib::Object].
    /// ## `item_type`
    /// the `GType` of items in the list
    ///
    /// # Returns
    ///
    /// a new [`ListStore`][crate::ListStore]
    #[doc(alias = "g_list_store_new")]
    pub fn new(item_type: glib::types::Type) -> ListStore {
        unsafe { from_glib_full(ffi::g_list_store_new(item_type.into_glib())) }
    }

    // rustdoc-stripper-ignore-next
    /// Creates a new builder-pattern struct instance to construct [`ListStore`] objects.
    ///
    /// This method returns an instance of [`ListStoreBuilder`] which can be used to create [`ListStore`] objects.
    pub fn builder() -> ListStoreBuilder {
        ListStoreBuilder::default()
    }

    /// Appends `item` to `self`. `item` must be of type `property::ListStore::item-type`.
    ///
    /// This function takes a ref on `item`.
    ///
    /// Use [`splice()`][Self::splice()] to append multiple items at the same time
    /// efficiently.
    /// ## `item`
    /// the new item
    #[doc(alias = "g_list_store_append")]
    pub fn append<P: IsA<glib::Object>>(&self, item: &P) {
        unsafe {
            ffi::g_list_store_append(self.to_glib_none().0, item.as_ref().to_glib_none().0);
        }
    }

    /// Looks up the given `item` in the list store by looping over the items until
    /// the first occurrence of `item`. If `item` was not found, then `position` will
    /// not be set, and this method will return [`false`].
    ///
    /// If you need to compare the two items with a custom comparison function, use
    /// `g_list_store_find_with_equal_func()` with a custom `GEqualFunc` instead.
    /// ## `item`
    /// an item
    ///
    /// # Returns
    ///
    /// Whether `self` contains `item`. If it was found, `position` will be
    /// set to the position where `item` occurred for the first time.
    ///
    /// ## `position`
    /// the first position of `item`, if it was found.
    #[cfg(any(feature = "v2_64", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_64")))]
    #[doc(alias = "g_list_store_find")]
    pub fn find<P: IsA<glib::Object>>(&self, item: &P) -> Option<u32> {
        unsafe {
            let mut position = mem::MaybeUninit::uninit();
            let ret = from_glib(ffi::g_list_store_find(
                self.to_glib_none().0,
                item.as_ref().to_glib_none().0,
                position.as_mut_ptr(),
            ));
            let position = position.assume_init();
            if ret {
                Some(position)
            } else {
                None
            }
        }
    }

    //#[cfg(any(feature = "v2_64", feature = "dox"))]
    //#[cfg_attr(feature = "dox", doc(cfg(feature = "v2_64")))]
    //#[doc(alias = "g_list_store_find_with_equal_func")]
    //pub fn find_with_equal_func<P: IsA<glib::Object>>(&self, item: &P, equal_func: /*Unimplemented*/FnMut(/*Unimplemented*/Option<Fundamental: Pointer>, /*Unimplemented*/Option<Fundamental: Pointer>) -> bool) -> Option<u32> {
    //    unsafe { TODO: call ffi:g_list_store_find_with_equal_func() }
    //}

    /// Inserts `item` into `self` at `position`. `item` must be of type
    /// `property::ListStore::item-type` or derived from it. `position` must be smaller
    /// than the length of the list, or equal to it to append.
    ///
    /// This function takes a ref on `item`.
    ///
    /// Use [`splice()`][Self::splice()] to insert multiple items at the same time
    /// efficiently.
    /// ## `position`
    /// the position at which to insert the new item
    /// ## `item`
    /// the new item
    #[doc(alias = "g_list_store_insert")]
    pub fn insert<P: IsA<glib::Object>>(&self, position: u32, item: &P) {
        unsafe {
            ffi::g_list_store_insert(
                self.to_glib_none().0,
                position,
                item.as_ref().to_glib_none().0,
            );
        }
    }

    /// Removes the item from `self` that is at `position`. `position` must be
    /// smaller than the current length of the list.
    ///
    /// Use [`splice()`][Self::splice()] to remove multiple items at the same time
    /// efficiently.
    /// ## `position`
    /// the position of the item that is to be removed
    #[doc(alias = "g_list_store_remove")]
    pub fn remove(&self, position: u32) {
        unsafe {
            ffi::g_list_store_remove(self.to_glib_none().0, position);
        }
    }

    /// Removes all items from `self`.
    #[doc(alias = "g_list_store_remove_all")]
    pub fn remove_all(&self) {
        unsafe {
            ffi::g_list_store_remove_all(self.to_glib_none().0);
        }
    }

    /// Changes `self` by removing `n_removals` items and adding `n_additions`
    /// items to it. `additions` must contain `n_additions` items of type
    /// `property::ListStore::item-type`. [`None`] is not permitted.
    ///
    /// This function is more efficient than [`insert()`][Self::insert()] and
    /// [`remove()`][Self::remove()], because it only emits
    /// `signal::ListModel::items-changed` once for the change.
    ///
    /// This function takes a ref on each item in `additions`.
    ///
    /// The parameters `position` and `n_removals` must be correct (ie:
    /// `position` + `n_removals` must be less than or equal to the length of
    /// the list at the time this function is called).
    /// ## `position`
    /// the position at which to make the change
    /// ## `n_removals`
    /// the number of items to remove
    /// ## `additions`
    /// the items to add
    #[doc(alias = "g_list_store_splice")]
    pub fn splice(&self, position: u32, n_removals: u32, additions: &[glib::Object]) {
        let n_additions = additions.len() as u32;
        unsafe {
            ffi::g_list_store_splice(
                self.to_glib_none().0,
                position,
                n_removals,
                additions.to_glib_none().0,
                n_additions,
            );
        }
    }
}

#[derive(Clone, Default)]
// rustdoc-stripper-ignore-next
/// A [builder-pattern] type to construct [`ListStore`] objects.
///
/// [builder-pattern]: https://doc.rust-lang.org/1.0.0/style/ownership/builders.html
pub struct ListStoreBuilder {
    item_type: Option<glib::types::Type>,
}

impl ListStoreBuilder {
    // rustdoc-stripper-ignore-next
    /// Create a new [`ListStoreBuilder`].
    pub fn new() -> Self {
        Self::default()
    }

    // rustdoc-stripper-ignore-next
    /// Build the [`ListStore`].
    pub fn build(self) -> ListStore {
        let mut properties: Vec<(&str, &dyn ToValue)> = vec![];
        if let Some(ref item_type) = self.item_type {
            properties.push(("item-type", item_type));
        }
        glib::Object::new::<ListStore>(&properties)
            .expect("Failed to create an instance of ListStore")
    }

    /// The type of items contained in this list store. Items must be
    /// subclasses of [`glib::Object`][crate::glib::Object].
    pub fn item_type(mut self, item_type: glib::types::Type) -> Self {
        self.item_type = Some(item_type);
        self
    }
}

impl fmt::Display for ListStore {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        f.write_str("ListStore")
    }
}