Struct bill::Bill

pub struct Bill<P> {
    pub items_by_tax: BTreeMap<Tax, ItemList<P>>,
}

This is where the magic happens.

Fields

items_by_tax: BTreeMap<Tax, ItemList<P>>

Implementations

impl<P: BillProduct> Bill<P>

pub fn new() -> Self

Instantiates a new Bill

Examples found in repository

examples/catalogue.rs (line 49)

fn main() {
    let coffee = Product::new("Coffee", c(250), 0.19);
    let tee = Product::new("Tea", c(175), 0.19);
    let water = Product::new("Water", c(61), 0.19);
    let applejuice = Product::new("AppleJuice", c(164), 0.19);
    let orangejuice = Product::new("OrangeJuice", c(186), 0.19);
    let bagel = Product::new("Bagel", c(219), 0.19);
    let sandwich = Product::new("Sandwich", c(340), 0.19);
    let pie = Product::new("pie", c(94), 0.19);
    let soup = Product::new("Soup", c(310), 0.19);
    let service = Product::new("Service", c(800), 0.00);

    let mut offer = Bill::new();
    offer.add_item(8., water);
    offer.add_item(4., applejuice);
    offer.add_item(4., orangejuice);
    offer.add_item(40., sandwich);
    offer.add_item(2., service);

    let mut invoice = Bill::new();
    invoice.add_item(2., water);
    invoice.add_item(0., applejuice);
    invoice.add_item(2., orangejuice);
    invoice.add_item(50., sandwich);
    invoice.add_item(2.5, service);

    let mut invoice2 = Bill::new();
    invoice2.add_item(99.0, Product::new("Red Ballons", c(99), 0.19));

    #[cfg(not(feature = "serialization"))]
    {
        print("offer", &offer);
        print("invoice", &invoice);
        print("invoice2", &invoice2);
    }
    #[cfg(feature = "serialization")]
    {
        println!("{}", serde_json::to_string_pretty(&offer).unwrap());
        println!("{}", serde_json::to_string_pretty(&invoice).unwrap());
        println!("{}", serde_json::to_string_pretty(&invoice2).unwrap());
    }
}

pub fn to_items_with_tax(&self) -> BTreeMap<Tax, &BillItem<P>>

pub fn as_items_with_tax(&self) -> Vec<(Tax, &BillItem<P>)>

Returns a Vec of Tax and BillItem

pub fn as_items(&self) -> Vec<&BillItem<P>>

Returns a Vec of BillItem

pub fn add(&mut self, item: BillItem<P>)

Adds a new BillItem to the list.

pub fn add_item(&mut self, amount: Amount, product: P)

Instantiates and adds a new BillItem to the list.

Examples found in repository

examples/catalogue.rs (line 50)

fn main() {
    let coffee = Product::new("Coffee", c(250), 0.19);
    let tee = Product::new("Tea", c(175), 0.19);
    let water = Product::new("Water", c(61), 0.19);
    let applejuice = Product::new("AppleJuice", c(164), 0.19);
    let orangejuice = Product::new("OrangeJuice", c(186), 0.19);
    let bagel = Product::new("Bagel", c(219), 0.19);
    let sandwich = Product::new("Sandwich", c(340), 0.19);
    let pie = Product::new("pie", c(94), 0.19);
    let soup = Product::new("Soup", c(310), 0.19);
    let service = Product::new("Service", c(800), 0.00);

    let mut offer = Bill::new();
    offer.add_item(8., water);
    offer.add_item(4., applejuice);
    offer.add_item(4., orangejuice);
    offer.add_item(40., sandwich);
    offer.add_item(2., service);

    let mut invoice = Bill::new();
    invoice.add_item(2., water);
    invoice.add_item(0., applejuice);
    invoice.add_item(2., orangejuice);
    invoice.add_item(50., sandwich);
    invoice.add_item(2.5, service);

    let mut invoice2 = Bill::new();
    invoice2.add_item(99.0, Product::new("Red Ballons", c(99), 0.19));

    #[cfg(not(feature = "serialization"))]
    {
        print("offer", &offer);
        print("invoice", &invoice);
        print("invoice2", &invoice2);
    }
    #[cfg(feature = "serialization")]
    {
        println!("{}", serde_json::to_string_pretty(&offer).unwrap());
        println!("{}", serde_json::to_string_pretty(&invoice).unwrap());
        println!("{}", serde_json::to_string_pretty(&invoice2).unwrap());
    }
}

pub fn sums_by_tax(&self) -> BTreeMap<Tax, Money>

pub fn gross_total(&self) -> Money

Examples found in repository

examples/catalogue.rs (line 31)

fn print(title: &str, bill: &Bill<Product<'_>>) {
    println!("{}:", title);
    for (tax, items) in &bill.items_by_tax {
        println!("  {}%", tax);
        print_items(items);
    }
    println!("---------------------------------------");
    println!("       {}", bill.gross_total().postfix());
    println!("     + {} (tax)", bill.tax_total().postfix());
    println!("   net {}", bill.net_total().postfix());
    println!();
}

pub fn tax_total(&self) -> Money

Examples found in repository

examples/catalogue.rs (line 32)

fn print(title: &str, bill: &Bill<Product<'_>>) {
    println!("{}:", title);
    for (tax, items) in &bill.items_by_tax {
        println!("  {}%", tax);
        print_items(items);
    }
    println!("---------------------------------------");
    println!("       {}", bill.gross_total().postfix());
    println!("     + {} (tax)", bill.tax_total().postfix());
    println!("   net {}", bill.net_total().postfix());
    println!();
}

pub fn net_total(&self) -> Money

Examples found in repository

examples/catalogue.rs (line 33)

fn print(title: &str, bill: &Bill<Product<'_>>) {
    println!("{}:", title);
    for (tax, items) in &bill.items_by_tax {
        println!("  {}%", tax);
        print_items(items);
    }
    println!("---------------------------------------");
    println!("       {}", bill.gross_total().postfix());
    println!("     + {} (tax)", bill.tax_total().postfix());
    println!("   net {}", bill.net_total().postfix());
    println!();
}

Methods from Deref<Target = BTreeMap<Tax, ItemList<P>>>

pub fn get<Q>(&self, key: &Q) -> Option<&V>where K: Borrow<Q> + Ord, Q: Ord + ?Sized,

Returns a reference to the value corresponding to the key.

The key may be any borrowed form of the map’s key type, but the ordering on the borrowed form must match the ordering on the key type.

Examples

Basic usage:

use std::collections::BTreeMap;

let mut map = BTreeMap::new();
map.insert(1, "a");
assert_eq!(map.get(&1), Some(&"a"));
assert_eq!(map.get(&2), None);

pub fn get_key_value<Q>(&self, k: &Q) -> Option<(&K, &V)>where K: Borrow<Q> + Ord, Q: Ord + ?Sized,

Returns the key-value pair corresponding to the supplied key.

The supplied key may be any borrowed form of the map’s key type, but the ordering on the borrowed form must match the ordering on the key type.

Examples

use std::collections::BTreeMap;

let mut map = BTreeMap::new();
map.insert(1, "a");
assert_eq!(map.get_key_value(&1), Some((&1, &"a")));
assert_eq!(map.get_key_value(&2), None);

pub fn first_key_value(&self) -> Option<(&K, &V)>where K: Ord,

Returns the first key-value pair in the map. The key in this pair is the minimum key in the map.

Examples

Basic usage:

use std::collections::BTreeMap;

let mut map = BTreeMap::new();
assert_eq!(map.first_key_value(), None);
map.insert(1, "b");
map.insert(2, "a");
assert_eq!(map.first_key_value(), Some((&1, &"b")));

pub fn last_key_value(&self) -> Option<(&K, &V)>where K: Ord,

Returns the last key-value pair in the map. The key in this pair is the maximum key in the map.

Examples

Basic usage:

use std::collections::BTreeMap;

let mut map = BTreeMap::new();
map.insert(1, "b");
map.insert(2, "a");
assert_eq!(map.last_key_value(), Some((&2, &"a")));

pub fn contains_key<Q>(&self, key: &Q) -> boolwhere K: Borrow<Q> + Ord, Q: Ord + ?Sized,

Returns true if the map contains a value for the specified key.

The key may be any borrowed form of the map’s key type, but the ordering on the borrowed form must match the ordering on the key type.

Examples

Basic usage:

use std::collections::BTreeMap;

let mut map = BTreeMap::new();
map.insert(1, "a");
assert_eq!(map.contains_key(&1), true);
assert_eq!(map.contains_key(&2), false);

pub fn range<T, R>(&self, range: R) -> Range<'_, K, V>where T: Ord + ?Sized, K: Borrow<T> + Ord, R: RangeBounds<T>,

Constructs a double-ended iterator over a sub-range of elements in the map. The simplest way is to use the range syntax min..max, thus range(min..max) will yield elements from min (inclusive) to max (exclusive). The range may also be entered as (Bound<T>, Bound<T>), so for example range((Excluded(4), Included(10))) will yield a left-exclusive, right-inclusive range from 4 to 10.

Panics

Panics if range start > end. Panics if range start == end and both bounds are Excluded.

Examples

Basic usage:

use std::collections::BTreeMap;
use std::ops::Bound::Included;

let mut map = BTreeMap::new();
map.insert(3, "a");
map.insert(5, "b");
map.insert(8, "c");
for (&key, &value) in map.range((Included(&4), Included(&8))) {
    println!("{key}: {value}");
}
assert_eq!(Some((&5, &"b")), map.range(4..).next());

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

Gets an iterator over the entries of the map, sorted by key.

Examples

Basic usage:

use std::collections::BTreeMap;

let mut map = BTreeMap::new();
map.insert(3, "c");
map.insert(2, "b");
map.insert(1, "a");

for (key, value) in map.iter() {
    println!("{key}: {value}");
}

let (first_key, first_value) = map.iter().next().unwrap();
assert_eq!((*first_key, *first_value), (1, "a"));

pub fn keys(&self) -> Keys<'_, K, V>

Gets an iterator over the keys of the map, in sorted order.

Examples

Basic usage:

use std::collections::BTreeMap;

let mut a = BTreeMap::new();
a.insert(2, "b");
a.insert(1, "a");

let keys: Vec<_> = a.keys().cloned().collect();
assert_eq!(keys, [1, 2]);

pub fn values(&self) -> Values<'_, K, V>

Gets an iterator over the values of the map, in order by key.

Examples

Basic usage:

use std::collections::BTreeMap;

let mut a = BTreeMap::new();
a.insert(1, "hello");
a.insert(2, "goodbye");

let values: Vec<&str> = a.values().cloned().collect();
assert_eq!(values, ["hello", "goodbye"]);

pub fn len(&self) -> usize

Returns the number of elements in the map.

Examples

Basic usage:

use std::collections::BTreeMap;

let mut a = BTreeMap::new();
assert_eq!(a.len(), 0);
a.insert(1, "a");
assert_eq!(a.len(), 1);

pub fn is_empty(&self) -> bool

Returns true if the map contains no elements.

Examples

Basic usage:

use std::collections::BTreeMap;

let mut a = BTreeMap::new();
assert!(a.is_empty());
a.insert(1, "a");
assert!(!a.is_empty());

pub fn lower_bound<Q>(&self, bound: Bound<&Q>) -> Cursor<'_, K, V>where K: Borrow<Q> + Ord, Q: Ord,

🔬This is a nightly-only experimental API. (btree_cursors)

Returns a Cursor pointing at the first element that is above the given bound.

If no such element exists then a cursor pointing at the “ghost” non-element is returned.

Passing Bound::Unbounded will return a cursor pointing at the first element of the map.

Examples

Basic usage:

#![feature(btree_cursors)]

use std::collections::BTreeMap;
use std::ops::Bound;

let mut a = BTreeMap::new();
a.insert(1, "a");
a.insert(2, "b");
a.insert(3, "c");
a.insert(4, "c");
let cursor = a.lower_bound(Bound::Excluded(&2));
assert_eq!(cursor.key(), Some(&3));

pub fn upper_bound<Q>(&self, bound: Bound<&Q>) -> Cursor<'_, K, V>where K: Borrow<Q> + Ord, Q: Ord,

🔬This is a nightly-only experimental API. (btree_cursors)

Returns a Cursor pointing at the last element that is below the given bound.

If no such element exists then a cursor pointing at the “ghost” non-element is returned.

Passing Bound::Unbounded will return a cursor pointing at the last element of the map.

Examples

Basic usage:

#![feature(btree_cursors)]

use std::collections::BTreeMap;
use std::ops::Bound;

let mut a = BTreeMap::new();
a.insert(1, "a");
a.insert(2, "b");
a.insert(3, "c");
a.insert(4, "c");
let cursor = a.upper_bound(Bound::Excluded(&3));
assert_eq!(cursor.key(), Some(&2));

Trait Implementations

impl<P: Debug> Debug for Bill<P>

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

Formats the value using the given formatter.

impl<P: Default> Default for Bill<P>

fn default() -> Bill<P>

Returns the “default value” for a type.

impl<P: BillProduct> Deref for Bill<P>

type Target = BTreeMap<Tax, ItemList<P>, Global>

The resulting type after dereferencing.

fn deref(&self) -> &BTreeMap<Tax, ItemList<P>>

Dereferences the value.