// 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 glib::translate::*;

glib::wrapper! {
    /// A [`Bitset`][crate::Bitset] represents a set of unsigned integers.
    ///
    /// Another name for this data structure is "bitmap".
    ///
    /// The current implementation is based on [roaring bitmaps](https://roaringbitmap.org/).
    ///
    /// A bitset allows adding a set of integers and provides support for set operations
    /// like unions, intersections and checks for equality or if a value is contained
    /// in the set. [`Bitset`][crate::Bitset] also contains various functions to query metadata about
    /// the bitset, such as the minimum or maximum values or its size.
    ///
    /// The fastest way to iterate values in a bitset is [`BitsetIter`][crate::BitsetIter].
    ///
    /// The main use case for [`Bitset`][crate::Bitset] is implementing complex selections for
    /// [`SelectionModel`][crate::SelectionModel].
    #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct Bitset(Shared<ffi::GtkBitset>);

    match fn {
        ref => |ptr| ffi::gtk_bitset_ref(ptr),
        unref => |ptr| ffi::gtk_bitset_unref(ptr),
        type_ => || ffi::gtk_bitset_get_type(),
    }
}

impl Bitset {
    /// Creates a new empty bitset.
    ///
    /// # Returns
    ///
    /// A new empty bitset
    #[doc(alias = "gtk_bitset_new_empty")]
    pub fn new_empty() -> Bitset {
        assert_initialized_main_thread!();
        unsafe { from_glib_full(ffi::gtk_bitset_new_empty()) }
    }

    /// Creates a bitset with the given range set.
    /// ## `start`
    /// first value to add
    /// ## `n_items`
    /// number of consecutive values to add
    ///
    /// # Returns
    ///
    /// A new bitset
    #[doc(alias = "gtk_bitset_new_range")]
    pub fn new_range(start: u32, n_items: u32) -> Bitset {
        assert_initialized_main_thread!();
        unsafe { from_glib_full(ffi::gtk_bitset_new_range(start, n_items)) }
    }

    /// Adds @value to @self if it wasn't part of it before.
    /// ## `value`
    /// value to add
    ///
    /// # Returns
    ///
    /// [`true`] if @value was not part of @self and @self
    ///   was changed
    #[doc(alias = "gtk_bitset_add")]
    pub fn add(&self, value: u32) -> bool {
        unsafe { from_glib(ffi::gtk_bitset_add(self.to_glib_none().0, value)) }
    }

    /// Adds all values from @start (inclusive) to @start + @n_items
    /// (exclusive) in @self.
    /// ## `start`
    /// first value to add
    /// ## `n_items`
    /// number of consecutive values to add
    #[doc(alias = "gtk_bitset_add_range")]
    pub fn add_range(&self, start: u32, n_items: u32) {
        unsafe {
            ffi::gtk_bitset_add_range(self.to_glib_none().0, start, n_items);
        }
    }

    /// Adds the closed range [@first, @last], so @first, @last and all
    /// values in between. @first must be smaller than @last.
    /// ## `first`
    /// first value to add
    /// ## `last`
    /// last value to add
    #[doc(alias = "gtk_bitset_add_range_closed")]
    pub fn add_range_closed(&self, first: u32, last: u32) {
        unsafe {
            ffi::gtk_bitset_add_range_closed(self.to_glib_none().0, first, last);
        }
    }

    /// Interprets the values as a 2-dimensional boolean grid with the given @stride
    /// and inside that grid, adds a rectangle with the given @width and @height.
    /// ## `start`
    /// first value to add
    /// ## `width`
    /// width of the rectangle
    /// ## `height`
    /// height of the rectangle
    /// ## `stride`
    /// row stride of the grid
    #[doc(alias = "gtk_bitset_add_rectangle")]
    pub fn add_rectangle(&self, start: u32, width: u32, height: u32, stride: u32) {
        unsafe {
            ffi::gtk_bitset_add_rectangle(self.to_glib_none().0, start, width, height, stride);
        }
    }

    /// Checks if the given @value has been added to @self
    /// ## `value`
    /// the value to check
    ///
    /// # Returns
    ///
    /// [`true`] if @self contains @value
    #[doc(alias = "gtk_bitset_contains")]
    pub fn contains(&self, value: u32) -> bool {
        unsafe { from_glib(ffi::gtk_bitset_contains(self.to_glib_none().0, value)) }
    }

    #[doc(alias = "gtk_bitset_copy")]
    #[must_use]
    pub fn copy(&self) -> Bitset {
        unsafe { from_glib_full(ffi::gtk_bitset_copy(self.to_glib_none().0)) }
    }

    /// Sets @self to be the symmetric difference of @self and @other.
    ///
    /// The symmetric difference is set @self to contain all values that
    /// were either contained in @self or in @other, but not in both.
    /// This operation is also called an XOR.
    ///
    /// It is allowed for @self and @other to be the same bitset. The bitset
    /// will be emptied in that case.
    /// ## `other`
    /// the [`Bitset`][crate::Bitset] to compute the difference from
    #[doc(alias = "gtk_bitset_difference")]
    pub fn difference(&self, other: &Bitset) {
        unsafe {
            ffi::gtk_bitset_difference(self.to_glib_none().0, other.to_glib_none().0);
        }
    }

    /// Returns [`true`] if @self and @other contain the same values.
    /// ## `other`
    /// another [`Bitset`][crate::Bitset]
    ///
    /// # Returns
    ///
    /// [`true`] if @self and @other contain the same values
    #[doc(alias = "gtk_bitset_equals")]
    pub fn equals(&self, other: &Bitset) -> bool {
        unsafe {
            from_glib(ffi::gtk_bitset_equals(
                self.to_glib_none().0,
                other.to_glib_none().0,
            ))
        }
    }

    /// Returns the largest value in @self.
    ///
    /// If @self is empty, 0 is returned.
    ///
    /// # Returns
    ///
    /// The largest value in @self
    #[doc(alias = "gtk_bitset_get_maximum")]
    #[doc(alias = "get_maximum")]
    pub fn maximum(&self) -> u32 {
        unsafe { ffi::gtk_bitset_get_maximum(self.to_glib_none().0) }
    }

    /// Returns the smallest value in @self.
    ///
    /// If @self is empty, `G_MAXUINT` is returned.
    ///
    /// # Returns
    ///
    /// The smallest value in @self
    #[doc(alias = "gtk_bitset_get_minimum")]
    #[doc(alias = "get_minimum")]
    pub fn minimum(&self) -> u32 {
        unsafe { ffi::gtk_bitset_get_minimum(self.to_glib_none().0) }
    }

    /// Returns the value of the @nth item in self.
    ///
    /// If @nth is >= the size of @self, 0 is returned.
    /// ## `nth`
    /// index of the item to get
    ///
    /// # Returns
    ///
    /// the value of the @nth item in @self
    #[doc(alias = "gtk_bitset_get_nth")]
    #[doc(alias = "get_nth")]
    pub fn nth(&self, nth: u32) -> u32 {
        unsafe { ffi::gtk_bitset_get_nth(self.to_glib_none().0, nth) }
    }

    /// Gets the number of values that were added to the set.
    ///
    /// For example, if the set is empty, 0 is returned.
    ///
    /// Note that this function returns a `guint64`, because when all
    /// values are set, the return value is `G_MAXUINT + 1`. Unless you
    /// are sure this cannot happen (it can't with `GListModel`), be sure
    /// to use a 64bit type.
    ///
    /// # Returns
    ///
    /// The number of values in the set.
    #[doc(alias = "gtk_bitset_get_size")]
    #[doc(alias = "get_size")]
    pub fn size(&self) -> u64 {
        unsafe { ffi::gtk_bitset_get_size(self.to_glib_none().0) }
    }

    /// Gets the number of values that are part of the set from @first to @last
    /// (inclusive).
    ///
    /// Note that this function returns a `guint64`, because when all values are
    /// set, the return value is `G_MAXUINT + 1`. Unless you are sure this cannot
    /// happen (it can't with `GListModel`), be sure to use a 64bit type.
    /// ## `first`
    /// the first element to include
    /// ## `last`
    /// the last element to include
    ///
    /// # Returns
    ///
    /// The number of values in the set from @first to @last.
    #[doc(alias = "gtk_bitset_get_size_in_range")]
    #[doc(alias = "get_size_in_range")]
    pub fn size_in_range(&self, first: u32, last: u32) -> u64 {
        unsafe { ffi::gtk_bitset_get_size_in_range(self.to_glib_none().0, first, last) }
    }

    /// Sets @self to be the intersection of @self and @other.
    ///
    /// In other words, remove all values from @self that are not part of @other.
    ///
    /// It is allowed for @self and @other to be the same bitset. Nothing will
    /// happen in that case.
    /// ## `other`
    /// the [`Bitset`][crate::Bitset] to intersect with
    #[doc(alias = "gtk_bitset_intersect")]
    pub fn intersect(&self, other: &Bitset) {
        unsafe {
            ffi::gtk_bitset_intersect(self.to_glib_none().0, other.to_glib_none().0);
        }
    }

    /// Check if no value is contained in bitset.
    ///
    /// # Returns
    ///
    /// [`true`] if @self is empty
    #[doc(alias = "gtk_bitset_is_empty")]
    pub fn is_empty(&self) -> bool {
        unsafe { from_glib(ffi::gtk_bitset_is_empty(self.to_glib_none().0)) }
    }

    /// Removes @value from @self if it was part of it before.
    /// ## `value`
    /// value to remove
    ///
    /// # Returns
    ///
    /// [`true`] if @value was part of @self and @self
    ///   was changed
    #[doc(alias = "gtk_bitset_remove")]
    pub fn remove(&self, value: u32) -> bool {
        unsafe { from_glib(ffi::gtk_bitset_remove(self.to_glib_none().0, value)) }
    }

    /// Removes all values from the bitset so that it is empty again.
    #[doc(alias = "gtk_bitset_remove_all")]
    pub fn remove_all(&self) {
        unsafe {
            ffi::gtk_bitset_remove_all(self.to_glib_none().0);
        }
    }

    /// Removes all values from @start (inclusive) to @start + @n_items (exclusive)
    /// in @self.
    /// ## `start`
    /// first value to remove
    /// ## `n_items`
    /// number of consecutive values to remove
    #[doc(alias = "gtk_bitset_remove_range")]
    pub fn remove_range(&self, start: u32, n_items: u32) {
        unsafe {
            ffi::gtk_bitset_remove_range(self.to_glib_none().0, start, n_items);
        }
    }

    /// Removes the closed range [@first, @last], so @first, @last and all
    /// values in between. @first must be smaller than @last.
    /// ## `first`
    /// first value to remove
    /// ## `last`
    /// last value to remove
    #[doc(alias = "gtk_bitset_remove_range_closed")]
    pub fn remove_range_closed(&self, first: u32, last: u32) {
        unsafe {
            ffi::gtk_bitset_remove_range_closed(self.to_glib_none().0, first, last);
        }
    }

    /// Interprets the values as a 2-dimensional boolean grid with the given @stride
    /// and inside that grid, removes a rectangle with the given @width and @height.
    /// ## `start`
    /// first value to remove
    /// ## `width`
    /// width of the rectangle
    /// ## `height`
    /// height of the rectangle
    /// ## `stride`
    /// row stride of the grid
    #[doc(alias = "gtk_bitset_remove_rectangle")]
    pub fn remove_rectangle(&self, start: u32, width: u32, height: u32, stride: u32) {
        unsafe {
            ffi::gtk_bitset_remove_rectangle(self.to_glib_none().0, start, width, height, stride);
        }
    }

    /// Shifts all values in @self to the left by @amount.
    ///
    /// Values smaller than @amount are discarded.
    /// ## `amount`
    /// amount to shift all values to the left
    #[doc(alias = "gtk_bitset_shift_left")]
    pub fn shift_left(&self, amount: u32) {
        unsafe {
            ffi::gtk_bitset_shift_left(self.to_glib_none().0, amount);
        }
    }

    /// Shifts all values in @self to the right by @amount.
    ///
    /// Values that end up too large to be held in a #guint are discarded.
    /// ## `amount`
    /// amount to shift all values to the right
    #[doc(alias = "gtk_bitset_shift_right")]
    pub fn shift_right(&self, amount: u32) {
        unsafe {
            ffi::gtk_bitset_shift_right(self.to_glib_none().0, amount);
        }
    }

    /// This is a support function for `GListModel` handling, by mirroring
    /// the `GlistModel::items-changed` signal.
    ///
    /// First, it "cuts" the values from @position to @removed from
    /// the bitset. That is, it removes all those values and shifts
    /// all larger values to the left by @removed places.
    ///
    /// Then, it "pastes" new room into the bitset by shifting all values
    /// larger than @position by @added spaces to the right. This frees
    /// up space that can then be filled.
    /// ## `position`
    /// position at which to slice
    /// ## `removed`
    /// number of values to remove
    /// ## `added`
    /// number of values to add
    #[doc(alias = "gtk_bitset_splice")]
    pub fn splice(&self, position: u32, removed: u32, added: u32) {
        unsafe {
            ffi::gtk_bitset_splice(self.to_glib_none().0, position, removed, added);
        }
    }

    /// Sets @self to be the subtraction of @other from @self.
    ///
    /// In other words, remove all values from @self that are part of @other.
    ///
    /// It is allowed for @self and @other to be the same bitset. The bitset
    /// will be emptied in that case.
    /// ## `other`
    /// the [`Bitset`][crate::Bitset] to subtract
    #[doc(alias = "gtk_bitset_subtract")]
    pub fn subtract(&self, other: &Bitset) {
        unsafe {
            ffi::gtk_bitset_subtract(self.to_glib_none().0, other.to_glib_none().0);
        }
    }

    /// Sets @self to be the union of @self and @other.
    ///
    /// That is, add all values from @other into @self that weren't part of it.
    ///
    /// It is allowed for @self and @other to be the same bitset. Nothing will
    /// happen in that case.
    /// ## `other`
    /// the [`Bitset`][crate::Bitset] to union with
    #[doc(alias = "gtk_bitset_union")]
    pub fn union(&self, other: &Bitset) {
        unsafe {
            ffi::gtk_bitset_union(self.to_glib_none().0, other.to_glib_none().0);
        }
    }
}