Enum Markets 

pub enum Markets {
    Allowed(BTreeSet<Market>),
    Excluded(BTreeSet<Market>),
}

Variants

Allowed(BTreeSet<Market>)

Any markets a package may be installed in.

Excluded(BTreeSet<Market>)

Any markets a package may not be installed in.

Implementations

impl Markets

pub const MAX_ITEMS: usize = 256usize

pub const fn new_allowed() -> Self

Makes a new, empty, allowed Markets.

Does not allocate anything on its own.

Examples

use winget_types::installer::Markets;

let mut markets = Markets::new_allowed();

pub fn allowed_from_iter<I, T>(markets: I) -> Result<Self, MarketsError>

where I: IntoIterator<Item = T>, T: AsRef<str>,

Creates a new allowed Markets from an iterator of any type that implements AsRef<str.

Errors

Returns an Err if any of the iterator items are not exactly 2 ASCII uppercase characters or if the number of unique markets exceeds 256.

Examples

use winget_types::installer::{Market, Markets};

let markets = Markets::allowed_from_iter(["US", "UK"]).unwrap();

let v: Vec<_> = markets.into_iter().collect();
assert_eq!(v, [Market::new("UK").unwrap(), Market::new("US").unwrap()]);

pub unsafe fn allowed_from_iter_unchecked<I, T>(markets: I) -> Self

where I: IntoIterator<Item = T>, T: AsRef<str>,

Creates a new allowed Markets from an iterator of any type that implements AsRef<str without checking whether each item is exactly 2 ASCII uppercase characters or if the number of unique markets exceeds 256. This results in undefined behaviour if any item is not exactly 2 ASCII uppercase characters or the number of unique markets exceeds 256.

Safety

Each item must be exactly 2 ASCII uppercase characters and the number of unique markets must not exceed 256.

pub const fn new_excluded() -> Self

Makes a new, empty excluded Markets.

Does not allocate anything on its own.

Examples

use winget_types::installer::Markets;

let mut markets = Markets::new_excluded();

pub fn excluded_from_iter<I, T>(markets: I) -> Result<Self, MarketsError>

where I: IntoIterator<Item = T>, T: AsRef<str>,

Creates a new excluded Markets from an iterator of any type that implements AsRef<str.

Errors

Returns an Err if any of the iterator items are not exactly 2 ASCII uppercase characters or if the number of unique markets exceeds 256.

Examples

use winget_types::installer::{Market, Markets};

let markets = Markets::excluded_from_iter(["US", "UK"]).unwrap();

let v: Vec<_> = markets.into_iter().collect();
assert_eq!(v, [Market::new("UK").unwrap(), Market::new("US").unwrap()]);

pub unsafe fn excluded_from_iter_unchecked<I, T>(markets: I) -> Self

where I: IntoIterator<Item = T>, T: AsRef<str>,

Creates a new excluded Markets from an iterator of any type that implements AsRef<str without checking whether each item is exactly 2 ASCII uppercase characters or if the number of unique markets exceeds 256. This results in undefined behaviour if any item is not exactly 2 ASCII uppercase characters or the number of unique markets exceeds 256.

Safety

Each item must be exactly 2 ASCII uppercase characters and the number of unique markets must not exceed 256.

pub fn add<T: AsRef<str>>(&mut self, market: T) -> Result<bool, MarketsError>

Adds a market to the set.

Returns whether the market was newly inserted. That is:

• If the markets did not previously contain an equal market, true is returned.
• If the markets already contained an equal market, false is returned, and the markets are not updated.

Errors

Returns an error if adding the market would result in more than 256 markets.

pub fn contains<Q>(&self, market: &Q) -> bool

where Market: Borrow<Q> + Ord, Q: Ord + ?Sized,

Returns true if the set contains a market equal to the value.

The value may be any borrowed form of Market, but the ordering on the borrowed form must match the ordering on the element type.

Examples

use winget_types::installer::Markets;

let markets = Markets::allowed_from_iter(["US", "UK"]).unwrap();
assert_eq!(markets.contains("US"), true);
assert_eq!(markets.contains("DE"), false);

pub fn remove<Q>(&mut self, market: &Q) -> bool

where Market: Borrow<Q> + Ord, Q: Ord + ?Sized,

If the set contains a market equal to the value, removes it from the set and drops it. Returns whether such a market was present.

The value may be any borrowed form of the set’s element type, but the ordering on the borrowed form must match the ordering on the element type.

Examples

use winget_types::installer::Markets;

let mut markets = Markets::new_allowed();

markets.add("US").unwrap();
assert_eq!(markets.remove("US"), true);
assert_eq!(markets.remove("US"), false);

pub fn clear(&mut self)

Clears the set, removing all markets.

Examples

use winget_types::installer::Markets;

let mut markets = Markets::new_allowed();
markets.add("US").unwrap();
markets.clear();
assert!(markets.is_empty());

pub fn len(&self) -> usize

Returns the number of markets in the set.

Examples

use winget_types::installer::Markets;

let mut markets = Markets::new_allowed();
assert_eq!(markets.len(), 0);
markets.add("US").unwrap();
assert_eq!(markets.len(), 1);

pub fn is_empty(&self) -> bool

Returns true if the set contains no markets.

Examples

use winget_types::installer::Markets;

let mut markets = Markets::new_allowed();
assert!(markets.is_empty());
markets.add("US").unwrap();
assert!(!markets.is_empty());

pub fn iter(&self) -> Iter<'_, Market>

Gets an iterator that visits the elements in Markets in ascending order.

Trait Implementations

impl Clone for Markets

fn clone(&self) -> Markets

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Markets

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

Formats the value using the given formatter.

impl Hash for Markets

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'market> IntoIterator for &'market Markets

type Item = &'market Market

The type of the elements being iterated over.

type IntoIter = Iter<'market, Market>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl IntoIterator for Markets

type Item = Market

The type of the elements being iterated over.

type IntoIter = IntoIter<Market>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl Ord for Markets

fn cmp(&self, other: &Markets) -> 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,

Restrict a value to a certain interval.

impl PartialEq for Markets

fn eq(&self, other: &Markets) -> 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 PartialOrd for Markets

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

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

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

Tests less than (for self and other) and is used by the < operator.

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

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

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

Tests greater than (for self and other) and is used by the > operator.

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

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

impl Eq for Markets

impl StructuralPartialEq for Markets