1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105

//! A library that handles calculating, rounding, displaying, and parsing units of money according
//! to ISO 4217 standards. The main item exported by the library is `Money`.
//!
//! # Use
//!
//! ```edition2018
//! use rusty_money::money;
//! use rusty_money::Money;
//!
//! // The easiest way to create Money objects is by using the money! macro
//! // which accepts amounts strings or integers and currencies as strings:
//!
//! money!("-200.00", "USD") == money!(-200, "USD"); // true
//!
//! // Money objects can be initialized in a few other convenient ways:
//!
//! use rusty_money::Currency;
//! use rusty_money::Iso::*;
//!
//! Money::new(200000, Currency::get(USD));         // amount = 2000 USD
//! Money::from_major(2000, Currency::get(USD));    // amount = 2000 USD
//! Money::from_minor(200000, Currency::get(USD));  // amount = 2000 USD
//! Money::from_str("2,000.00", "USD").unwrap();    // amount = 2000 USD
//!
//! // Money objects support arithmetic operations:
//!
//! money!(100, "USD") + money!(100, "USD"); // amount = 200 USD
//! money!(100, "USD") - money!(100, "USD"); // amount = 0 USD
//! money!(1, "USD") * 3;                    // amount = 3 USD
//! money!(3, "USD") / 3;                    // amount = 0.333333333... USD
//!
//! // Money objects can be compared:
//!
//! let hundred = money!(100, "USD");
//! let thousand = money!(1000, "USD");
//! println!("{}", thousand > hundred);     // false
//! println!("{}", thousand.is_positive()); // true
//!
//! // Money objects format themselves when printed:
//!
//! let usd = money!("-2000.009", "USD");
//! let eur = money!("-2000.009", "EUR");
//! println!("{}", usd); // -$2,000.01
//! println!("{}", eur); // -€2.000,01;
//!
//!
//! // Money objects can be exchange from one currency to another by setting up an ExchangeRate:
//!
//! use rusty_money::Exchange;
//! use rusty_money::ExchangeRate;
//! use rust_decimal_macros::*;
//!
//! let rate = ExchangeRate::new(Currency::get(USD), Currency::get(EUR), dec!(1.1)).unwrap();
//! rate.convert(money!(1000, "USD")); // 1,100 EUR
//!
//! // ExchangeRate objects can be stored and retrieved from a central Exchange:
//!
//! let mut exchange = Exchange::new();
//! exchange.add_or_update_rate(&rate);
//! exchange.get_rate(Currency::get(USD), Currency::get(EUR));
//! ```
//! ### Money
//!
//! Money represents financial amounts through a Decimal (owned) and a Currency (refernce). Operations on Money
//! objects always create new instances of Money.
//!
//! ### Currency
//!
//! Currency represents an ISO-4217 currency, and stores metadata like its numeric code, full name and symbol.
//! Operations on Currencies pass around references, since they are unchanging. Only 117 currencies are supported,
//! though the next release will include all ISO-4217 currencies.
//!
//! ### Precision and Rounding
//!
//! The [Decimal](https://github.com/paupino/rust-decimal) used in Money is a 128 bit fixed precision decimal number,
//! and can represent values as large as 2<sup>96</sup> / 10<sup>28</sup>. Calculations applied on Money objects do
//! not round until this limit. You can use `format!()` to display the currency in its native precision, though the
//! Decimal will remain unaffected. `.round()` will create a new instance with permanently reduced precision.
//!
//! Money supports three types of rounding modes: [Half Up](https://en.wikipedia.org/wiki/Rounding#Round_half_up),
//! [Half Down](https://en.wikipedia.org/wiki/Rounding#Round_half_down) and
//! [Half Even](https://en.wikipedia.org/wiki/Rounding#Round_half_even), which is the default.
//!
//! ### Formatting
//!
//! `Money.format!()` converts a currency into a string and follows local conventions for formatting and displaying
//! amounts. If you need to format output in a more customized way, `Formatter` accepts a more detailed set of
//! parameters that lets you customize precisely how currencies are displayed as strings.

mod currency;
mod error;
mod exchange;
mod format;
mod locale;
mod money;

pub use currency::*;
pub use error::MoneyError;
pub use exchange::*;
pub use format::*;
pub use locale::*;
pub use money::*;

#[macro_use]
extern crate lazy_static;