279 lines
8.5 KiB
Rust
279 lines
8.5 KiB
Rust
|
#![unstable]
|
|||
|
|
|
|||
|
|
use std::default::Default;
|
|||
|
|
|
|||
|
|
//------------------------------------------------------------------------------
|
|||
|
|
//{{{ QrResult
|
|||
|
|
|
|||
|
|
/// `QrError` encodes the error encountered when generating a QR code.
|
|||
|
|
#[unstable]
|
|||
|
|
#[deriving(Show, PartialEq, Eq)]
|
|||
|
|
pub enum QrError {
|
|||
|
|
/// The data is too long to encode into a QR code for the given version.
|
|||
|
|
DataTooLong,
|
|||
|
|
|
|||
|
|
/// The provided version / error correction level combination is invalid.
|
|||
|
|
InvalidVersion,
|
|||
|
|
|
|||
|
|
/// Some characters in the data cannot be supported by the provided QR code
|
|||
|
|
/// version.
|
|||
|
|
UnsupportedCharacterSet,
|
|||
|
|
|
|||
|
|
/// The provided ECI designator is invalid. A valid designator should be
|
|||
|
|
/// between 0 and 999999.
|
|||
|
|
InvalidEciDesignator,
|
|||
|
|
|
|||
|
|
/// A character not belonging to the character set is found.
|
|||
|
|
InvalidCharacter,
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// `QrResult` is a convenient alias for a QR code generation result.
|
|||
|
|
#[stable]
|
|||
|
|
pub type QrResult<T> = Result<T, QrError>;
|
|||
|
|
|
|||
|
|
//}}}
|
|||
|
|
//------------------------------------------------------------------------------
|
|||
|
|
//{{{ Error correction level
|
|||
|
|
|
|||
|
|
/// The error correction level. It allows the original information be recovered
|
|||
|
|
/// even if parts of the code is damaged.
|
|||
|
|
#[deriving(Show, PartialEq, Eq, Copy, Clone, PartialOrd, Ord)]
|
|||
|
|
#[unstable]
|
|||
|
|
pub enum ErrorCorrectionLevel {
|
|||
|
|
/// Low error correction. Allows up to 7% of wrong blocks.
|
|||
|
|
L = 0,
|
|||
|
|
|
|||
|
|
/// Medium error correction (default). Allows up to 15% of wrong blocks.
|
|||
|
|
M = 1,
|
|||
|
|
|
|||
|
|
/// "Quartile" error correction. Allows up to 25% of wrong blocks.
|
|||
|
|
Q = 2,
|
|||
|
|
|
|||
|
|
/// High error correction. Allows up to 30% of wrong blocks.
|
|||
|
|
H = 3,
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
//}}}
|
|||
|
|
//------------------------------------------------------------------------------
|
|||
|
|
//{{{ Version
|
|||
|
|
|
|||
|
|
/// In QR code terminology, `Version` means the size of the generated image.
|
|||
|
|
/// Larger version means the size of code is larger, and therefore can carry
|
|||
|
|
/// more information.
|
|||
|
|
///
|
|||
|
|
/// The smallest version is `Version(1)` of size 21×21, and the largest is
|
|||
|
|
/// `Version(40)` of size 177×177.
|
|||
|
|
#[unstable]
|
|||
|
|
#[deriving(Show, PartialEq, Eq, Copy, Clone)]
|
|||
|
|
pub enum Version {
|
|||
|
|
/// A normal QR code version. The parameter should be between 1 and 40.
|
|||
|
|
#[unstable]
|
|||
|
|
Version(i16),
|
|||
|
|
|
|||
|
|
/// A Micro QR code version. The parameter should be between 1 and 4.
|
|||
|
|
MicroVersion(i16),
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
impl Version {
|
|||
|
|
/// Get the number of "modules" on each size of the QR code, i.e. the width
|
|||
|
|
/// and height of the code.
|
|||
|
|
#[unstable]
|
|||
|
|
pub fn width(&self) -> i16 {
|
|||
|
|
match *self {
|
|||
|
|
Version(v) => v * 4 + 17,
|
|||
|
|
MicroVersion(v) => v * 2 + 9,
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// Obtains an object from a hard-coded table.
|
|||
|
|
///
|
|||
|
|
/// The table must be a 44×4 array. The outer array represents the content
|
|||
|
|
/// for each version. The first 40 entry corresponds to QR code versions 1
|
|||
|
|
/// to 40, and the last 4 corresponds to Micro QR code version 1 to 4. The
|
|||
|
|
/// inner array represents the content in each error correction level, in
|
|||
|
|
/// the order [L, M, Q, H].
|
|||
|
|
///
|
|||
|
|
/// If the entry compares equal to the default value of T, this method
|
|||
|
|
/// returns `Err(InvalidVersion)`.
|
|||
|
|
pub fn fetch<T: PartialEq + Default + Copy>(&self,
|
|||
|
|
ec_level: ErrorCorrectionLevel,
|
|||
|
|
table: &[[T, ..4]]) -> QrResult<T> {
|
|||
|
|
match *self {
|
|||
|
|
Version(v @ 1..40) => Ok(table[v as uint - 1][ec_level as uint]),
|
|||
|
|
MicroVersion(v @ 1..4) => {
|
|||
|
|
let obj = table[v as uint + 39][ec_level as uint];
|
|||
|
|
if obj != Default::default() {
|
|||
|
|
Ok(obj)
|
|||
|
|
} else {
|
|||
|
|
Err(InvalidVersion)
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
_ => Err(InvalidVersion)
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// The number of bits needed to encode the mode indicator.
|
|||
|
|
#[unstable]
|
|||
|
|
pub fn mode_bits_count(&self) -> uint {
|
|||
|
|
match *self {
|
|||
|
|
MicroVersion(a) => (a - 1) as uint,
|
|||
|
|
_ => 4,
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// Check whether is version refers to a Micro QR code.
|
|||
|
|
#[unstable]
|
|||
|
|
pub fn is_micro(&self) -> bool {
|
|||
|
|
match *self {
|
|||
|
|
Version(_) => false,
|
|||
|
|
MicroVersion(_) => true,
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
//}}}
|
|||
|
|
//------------------------------------------------------------------------------
|
|||
|
|
//{{{ Mode indicator
|
|||
|
|
|
|||
|
|
/// The mode indicator, which specifies the character set of the encoded data.
|
|||
|
|
#[unstable]
|
|||
|
|
#[deriving(Show, PartialEq, Eq)]
|
|||
|
|
pub enum Mode {
|
|||
|
|
/// The data contains only characters 0 to 9.
|
|||
|
|
Numeric,
|
|||
|
|
|
|||
|
|
/// The data contains only uppercase letters (A–Z), numbers (0–9) and a few
|
|||
|
|
/// punctuations marks (space, `$`, `%`, `*`, `+`, `-`, `.`, `/`, `:`).
|
|||
|
|
Alphanumeric,
|
|||
|
|
|
|||
|
|
/// The data contains arbitrary binary data.
|
|||
|
|
Byte,
|
|||
|
|
|
|||
|
|
/// The data contains Shift-JIS-encoded double-byte text.
|
|||
|
|
Kanji,
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
impl Mode {
|
|||
|
|
/// Computes the number of bits needed to encode the data length.
|
|||
|
|
///
|
|||
|
|
/// use qrcode::types::{Version, Numeric};
|
|||
|
|
///
|
|||
|
|
/// assert_eq!(Numeric.length_bits_count(Version(1)), 10);
|
|||
|
|
///
|
|||
|
|
/// This method will return `Err(UnsupportedCharacterSet)` if the is not
|
|||
|
|
/// supported in the given version.
|
|||
|
|
#[unstable]
|
|||
|
|
pub fn length_bits_count(&self, version: Version) -> uint {
|
|||
|
|
match version {
|
|||
|
|
MicroVersion(a) => {
|
|||
|
|
let a = a as uint;
|
|||
|
|
match *self {
|
|||
|
|
Numeric => 2 + a,
|
|||
|
|
Alphanumeric | Byte => 1 + a,
|
|||
|
|
Kanji => a,
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
Version(1..9) => match *self {
|
|||
|
|
Numeric => 10,
|
|||
|
|
Alphanumeric => 9,
|
|||
|
|
Byte => 8,
|
|||
|
|
Kanji => 8,
|
|||
|
|
},
|
|||
|
|
Version(10..26) => match *self {
|
|||
|
|
Numeric => 12,
|
|||
|
|
Alphanumeric => 11,
|
|||
|
|
Byte => 16,
|
|||
|
|
Kanji => 10,
|
|||
|
|
},
|
|||
|
|
Version(_) => match *self {
|
|||
|
|
Numeric => 14,
|
|||
|
|
Alphanumeric => 13,
|
|||
|
|
Byte => 16,
|
|||
|
|
Kanji => 12,
|
|||
|
|
},
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// Computes the number of bits needed to some data of a given raw length.
|
|||
|
|
///
|
|||
|
|
/// use qrcode::types::Numeric;
|
|||
|
|
///
|
|||
|
|
/// assert_eq!(Numeric.data_bits_count(7), 24);
|
|||
|
|
///
|
|||
|
|
/// Note that in Kanji mode, the `raw_data_len` is the number of Kanjis,
|
|||
|
|
/// i.e. half the total size of bytes.
|
|||
|
|
#[unstable]
|
|||
|
|
pub fn data_bits_count(&self, raw_data_len: uint) -> uint {
|
|||
|
|
match *self {
|
|||
|
|
Numeric => (raw_data_len * 10 + 2) / 3,
|
|||
|
|
Alphanumeric => (raw_data_len * 11 + 1) / 2,
|
|||
|
|
Byte => raw_data_len * 8,
|
|||
|
|
Kanji => raw_data_len * 13,
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// Find the lowest common mode which both modes are compatible with.
|
|||
|
|
///
|
|||
|
|
/// use qrcode::types::{Numeric, Kanji};
|
|||
|
|
///
|
|||
|
|
/// let a = Numeric;
|
|||
|
|
/// let b = Kanji;
|
|||
|
|
/// let c = a.max(b);
|
|||
|
|
/// assert!(a <= c);
|
|||
|
|
/// assert!(b <= c);
|
|||
|
|
///
|
|||
|
|
pub fn max(&self, other: Mode) -> Mode {
|
|||
|
|
match self.partial_cmp(&other) {
|
|||
|
|
Some(Less) | Some(Equal) => other,
|
|||
|
|
Some(Greater) => *self,
|
|||
|
|
None => Byte,
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
impl PartialOrd for Mode {
|
|||
|
|
/// Defines a partial ordering between modes. If `a <= b`, then `b` contains
|
|||
|
|
/// a superset of all characters supported by `a`.
|
|||
|
|
fn partial_cmp(&self, other: &Mode) -> Option<Ordering> {
|
|||
|
|
match (*self, *other) {
|
|||
|
|
(Numeric, Alphanumeric) => Some(Less),
|
|||
|
|
(Alphanumeric, Numeric) => Some(Greater),
|
|||
|
|
(Numeric, Byte) => Some(Less),
|
|||
|
|
(Byte, Numeric) => Some(Greater),
|
|||
|
|
(Alphanumeric, Byte) => Some(Less),
|
|||
|
|
(Byte, Alphanumeric) => Some(Greater),
|
|||
|
|
(Kanji, Byte) => Some(Less),
|
|||
|
|
(Byte, Kanji) => Some(Greater),
|
|||
|
|
(a, b) if a == b => Some(Equal),
|
|||
|
|
_ => None,
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
#[cfg(test)]
|
|||
|
|
mod mode_tests {
|
|||
|
|
use types::{Numeric, Alphanumeric, Byte, Kanji};
|
|||
|
|
|
|||
|
|
#[test]
|
|||
|
|
fn test_mode_order() {
|
|||
|
|
assert!(Numeric < Alphanumeric);
|
|||
|
|
assert!(Byte > Kanji);
|
|||
|
|
assert!(!(Numeric < Kanji));
|
|||
|
|
assert!(!(Numeric >= Kanji));
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
#[test]
|
|||
|
|
fn test_max() {
|
|||
|
|
assert_eq!(Byte.max(Kanji), Byte);
|
|||
|
|
assert_eq!(Numeric.max(Alphanumeric), Alphanumeric);
|
|||
|
|
assert_eq!(Alphanumeric.max(Alphanumeric), Alphanumeric);
|
|||
|
|
assert_eq!(Numeric.max(Kanji), Byte);
|
|||
|
|
assert_eq!(Kanji.max(Numeric), Byte);
|
|||
|
|
assert_eq!(Alphanumeric.max(Numeric), Alphanumeric);
|
|||
|
|
assert_eq!(Kanji.max(Kanji), Kanji);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
//}}}
|
|||
|
|
|