Crate readable

Readable

Human readable strings.

This library:

• Transforms various data types into human-readable strings
• Parses raw string data into human-readable versions
• Provides various string types and utilities

Most of the strings are implemented as fixed sized stack allocated arrays that are Copy-able.

In general, readable types are often used where you need to quickly format some data into a more human-friendly string, display it, then throw it away (although most readable types are perfectly fine to permanently store).

Creation of readable types is relatively performant.

Examples

Unsigned

use readable::*;
assert_eq!(Unsigned::from(1000_u64), "1,000");

Int

use readable::*;
assert_eq!(Int::from(-1000), "-1,000");

Float

use readable::*;
assert_eq!(Float::from(1000.123), "1,000.123");

Percent

use readable::*;
assert_eq!(Percent::from(1000.123), "1,000.12%");

Runtime

use readable::*;
assert_eq!(Runtime::from(311.123),      "5:11");
assert_eq!(RuntimePad::from(311.123),   "00:05:11");
assert_eq!(RuntimeMilli::from(311.123), "00:05:11.123");

Uptime

use readable::*;
assert_eq!(Uptime::from(172799_u32),     "1d, 23h, 59m, 59s");
assert_eq!(UptimeFull::from(172799_u32), "1 day, 23 hours, 59 minutes, 59 seconds");
assert_eq!(Htop::from(172799_u32),       "1 day, 23:59:59");

Date

use readable::*;
assert_eq!(Date::from_ymd(2014, 12, 31).unwrap(), "2014-12-31");
assert_eq!(Nichi::new(2014, 12, 31).unwrap(),     "Wed, Dec 31, 2014");
assert_eq!(NichiFull::new(2014, 12, 31).unwrap(), "Wednesday, December 31st, 2014");

Time

use readable::*;
assert_eq!(Time::new(86399),     "11:59:59 PM");
assert_eq!(Military::new(86399), "23:59:59");

Byte

use readable::*;
assert_eq!(Byte::from(1234), "1.234 KB");

Comparison

All number types implement PartialEq against str and their internal numbers.

This is comparing b’s inner String:

use readable::*;
let a = std::time::Duration::from_secs(86399);
let b = UptimeFull::from(a);
assert_eq!(b, "23 hours, 59 minutes, 59 seconds");

This is comparing a’s inner i64:

use readable::*;
let a = Int::from(-1000);
assert_eq!(a, -1000);

This compares both the u64 AND String inside a and b:

use readable::*;
let a = Unsigned::from(1000_u64);
let b = Unsigned::from(1000_u64);
assert_eq!(a, b);

Arithmetic

All number types implement the common arithmetic operators +, -, /, *, %, outputting a new Self.

+ Addition

use readable::*;
let f1 = Float::from(1.0);
let f2 = Float::from(2.0);
assert_eq!(f1 + f2, 3.0);

- Subtraction

use readable::*;
let p50 = Percent::from(50.0);
let p25 = Percent::from(25.0);
assert_eq!(p50 - p25, "25.00%");

/ Division

use readable::*;
let u100 = Unsigned::from(100_u64);
let u10  = Unsigned::from(10_u64);
assert_eq!(u100 / u10, 10);

* Multiplication

use readable::*;
let u10 = Unsigned::from(10_u64);
assert_eq!(u10 * u10, Unsigned::from(100_u64));

% Modulo

use readable::*;
let u10 = Unsigned::from(10_u64);
assert_eq!(u10 % u10, 0);

Feature Flags

Flag	Purpose
serde	Enables serde on most types
bincode	Enables bincode 2.0.0-rc.3’s Encode/Decode on most types

Re-exports

Types are separated per module depending on what type of data they take as input, and what type of data they output.

use readable::num::{ // Number formatting
	Unsigned, // Formats u8, u16, u32, etc...
	Int,      // Formats i8, i16, i32, etc...
};

All major types are exported to the root, so they can be imported without specifying the full path:

// shorter
use readable::HeadTail;

// longer
// use readable::str::HeadTail;

Re-exports

• pub use str::Str;
• pub use str::HeadTail;
• pub use num::Unsigned;
• pub use num::Int;
• pub use num::Float;
• pub use num::Percent;
• pub use run::Runtime;
• pub use run::RuntimePad;
• pub use run::RuntimeMilli;
• pub use run::RuntimeUnion;
• pub use up::Uptime;
• pub use up::UptimeFull;
• pub use up::Htop;
• pub use up::SysUptime;
• pub use time::SysTime;
• pub use time::Time;
• pub use time::TimeUnit;
• pub use time::Military;
• pub use date::Date;
• pub use date::Nichi;
• pub use date::NichiFull;
• pub use date::SysDate;
• pub use toa::Itoa;
• pub use toa::ItoaTmp;
• pub use toa::Dtoa;
• pub use toa::DtoaTmp;
• pub use byte::Byte;

Modules

• byte
  Byte formatting
• date
  Date formatting
• num
  Number formatting
• run
  Runtime formatting
• str
  General string utilities
• time
  Time formatting
• toa
  Fast integer/float to string conversion
• up
  Uptime formatting

Macros

• dtoa
  Quickly format a float to a &str
• itoa
  Quickly format an integer to a &str