danielpclark
diff --git a/Collapse file
‎Cargo.toml‎
Copy file name to clipboardExpand all lines: Cargo.toml
+1-1Lines changed: 1 addition & 1 deletion b/Collapse file
‎Cargo.toml‎
Copy file name to clipboardExpand all lines: Cargo.toml
+1-1Lines changed: 1 addition & 1 deletion
diff --git a/Collapse file
‎src/lib.rs‎
Copy file name to clipboardExpand all lines: src/lib.rs
+18-16Lines changed: 18 additions & 16 deletions b/Collapse file
‎src/lib.rs‎
Copy file name to clipboardExpand all lines: src/lib.rs
+18-16Lines changed: 18 additions & 16 deletions
diff --git a/Collapse file
‎tests/lib.rs‎
Copy file name to clipboardExpand all lines: tests/lib.rs
+8-8Lines changed: 8 additions & 8 deletions b/Collapse file
‎tests/lib.rs‎
Copy file name to clipboardExpand all lines: tests/lib.rs
+8-8Lines changed: 8 additions & 8 deletions
@@ -1,6 +1,6 @@
 [package]
 name = "base_custom"
-version = "0.1.4"
+version = "0.1.5"
 authors = ["Daniel P. Clark <6ftdan@gmail.com>"]
 description = "Use any characters as your own numeric base and convert to and from decimal."
 documentation = "http://danielpclark.github.io/base_custom/index.html"
 
@@ -64,8 +64,8 @@ use std::ops::Range;
 /// by the delimiter provided.
 pub struct BaseCustom<T> {
   primitives: Vec<T>,
-  primitives_hash: HashMap<T, u32>,
-  base: u32,
+  primitives_hash: HashMap<T, u8>,
+  base: u64,
   delim: Option<char>,
 }
 
@@ -96,20 +96,21 @@ impl BaseCustom<char> {
   /// for measuring the custom numeric base will only be one character long each.
   pub fn new(chars: Vec<char>) -> BaseCustom<char> {
     if chars.iter().count() < 2 { panic!("Too few numeric units! Provide two or more.") }
+    if chars.iter().count() > 255 { panic!("Too many numeric units!") }
     let mut mapped = HashMap::with_capacity(chars.iter().count());
     for (i,c) in chars.iter().enumerate() {
-      mapped.insert(c.clone(), i as u32);
+      mapped.insert(c.clone(), i as u8);
     }
     BaseCustom::<char> {
       primitives: chars.clone(),
       primitives_hash: mapped,
-      base: chars.iter().count() as u32,
+      base: chars.iter().count() as u64,
       delim: None,
     }
   }
 
   /// `gen` returns a String computed from the character mapping and 
-  /// positional values the given u32 parameter evalutes to for your
+  /// positional values the given u64 parameter evalutes to for your
   /// custom base
   ///
   /// # Example
@@ -124,7 +125,7 @@ impl BaseCustom<char> {
   /// ```text
   /// "11"
   /// ```
-  pub fn gen(&self, input_val: u32) -> String {
+  pub fn gen(&self, input_val: u64) -> String {
     if input_val == 0 {
       return format!("{}", self.primitives[0]);
     }
@@ -139,7 +140,7 @@ impl BaseCustom<char> {
   }
 
 
-  /// `decimal` returns a u32 value on computed from the units that form
+  /// `decimal` returns a u64 value on computed from the units that form
   /// the custom base.
   ///
   /// # Example
@@ -154,12 +155,12 @@ impl BaseCustom<char> {
   /// ```text
   /// 3
   /// ```
-  pub fn decimal<S>(&self, input_val: S) -> u32
+  pub fn decimal<S>(&self, input_val: S) -> u64
     where S: Into<String> {
     let input_val = input_val.into();
 
     input_val.chars().rev().enumerate().fold(0, |sum, (i, chr)|
-      sum + self.primitives_hash[&chr] * self.base.pow(i as u32)
+      sum + (self.primitives_hash[&chr] as u64) * self.base.pow(i as u32)
     )
   }
 
@@ -216,23 +217,24 @@ impl BaseCustom<String> {
       None => chars.chars().map(|c| format!("{}", c)).collect(),
     };
     if strings.iter().count() < 2 { panic!("Too few numeric units! Provide two or more.") }
+    if strings.iter().count() > 255 { panic!("Too many numeric units!") }
     let mut enumerator = strings.iter().enumerate();
     loop {
       match enumerator.next() {
-        Some((i,c)) => mapped.insert(format!("{}", c), i as u32),
+        Some((i,c)) => mapped.insert(format!("{}", c), i as u8),
         None => break,
       };
     }
     BaseCustom::<String> {
       primitives: strings.iter().map(|s| format!("{}", s)).collect(),
       primitives_hash: mapped,
-      base: strings.len() as u32,
+      base: strings.len() as u64,
       delim: delim,
     }
   }
 
   /// `gen` returns a String computed from the character mapping and 
-  /// positional values the given u32 parameter evalutes to for your
+  /// positional values the given u64 parameter evalutes to for your
   /// custom base
   ///
   /// # Example
@@ -247,7 +249,7 @@ impl BaseCustom<String> {
   /// ```text
   /// "11"
   /// ```
-  pub fn gen(&self, input_val: u32) -> String {
+  pub fn gen(&self, input_val: u64) -> String {
     if input_val == 0 {
       return format!("{}", self.primitives[0]);
     }
@@ -262,7 +264,7 @@ impl BaseCustom<String> {
     format!("{}", result)
   }
 
-  /// `decimal` returns a u32 value on computed from the units that form
+  /// `decimal` returns a u64 value on computed from the units that form
   /// the custom base.
   ///
   /// # Example
@@ -277,7 +279,7 @@ impl BaseCustom<String> {
   /// ```text
   /// 3
   /// ```
-  pub fn decimal<S>(&self, input_val: S) -> u32
+  pub fn decimal<S>(&self, input_val: S) -> u64
     where S: Into<String> {
     let input_val = input_val.into();
     let strings: Vec<String> = match self.delim {
@@ -286,7 +288,7 @@ impl BaseCustom<String> {
     };
 
     strings.iter().rev().enumerate().fold(0, |sum, (i, chr)|
-      sum + self.primitives_hash[&chr[..]] * self.base.pow(i as u32)
+      sum + (self.primitives_hash[&chr[..]] as u64) * self.base.pow(i as u32)
     )
   }
 
 
@@ -42,8 +42,8 @@ fn it_shows_zero_one_and_nth_for_string() {
 #[test]
 fn it_works_with_binary_for_char() {
   let base2 = BaseCustom::<char>::new(vec!['0','1']);
-  assert_eq!(base2.decimal("00001"), 1_u32);
-  assert_eq!(base2.decimal("100110101"), 309_u32);
+  assert_eq!(base2.decimal("00001"), 1_u64);
+  assert_eq!(base2.decimal("100110101"), 309_u64);
   assert_eq!(base2.gen(340), "101010100");
   assert_eq!(base2.gen(0xF45), "111101000101");
   assert_eq!(base2.gen(0b111), "111");
@@ -52,8 +52,8 @@ fn it_works_with_binary_for_char() {
 #[test]
 fn it_works_with_binary_for_char_from_ordinal_range() {
   let base2 = BaseCustom::<char>::from_ordinal_range(48..50);
-  assert_eq!(base2.decimal("00001"), 1_u32);
-  assert_eq!(base2.decimal("100110101"), 309_u32);
+  assert_eq!(base2.decimal("00001"), 1_u64);
+  assert_eq!(base2.decimal("100110101"), 309_u64);
   assert_eq!(base2.gen(340), "101010100");
   assert_eq!(base2.gen(0xF45), "111101000101");
   assert_eq!(base2.gen(0b111), "111");
@@ -63,23 +63,23 @@ fn it_works_with_binary_for_char_from_ordinal_range() {
 fn it_works_with_binary_for_char_from_min_of_ordinal_range() {
   let base2 = BaseCustom::<char>::from_ordinal_range(0..34);
   println!("{}", base2.gen(3));
-  assert_eq!(base2.decimal("!"), 1_u32);
+  assert_eq!(base2.decimal("!"), 1_u64);
   assert_eq!(base2.gen(340), "! ! ! !  ");
 }
 
 #[test]
 fn it_works_with_binary_for_char_from_max_of_ordinal_range() {
   let base2 = BaseCustom::<char>::from_ordinal_range(125..500);
   println!("{}", base2.gen(3));
-  assert_eq!(base2.decimal("~"), 1_u32);
+  assert_eq!(base2.decimal("~"), 1_u64);
   assert_eq!(base2.gen(340), "~}~}~}~}}");
 }
 
 #[test]
 fn it_works_with_binary_for_string() {
   let base2 = BaseCustom::<String>::new("01", None);
-  assert_eq!(base2.decimal("00001"), 1_u32);
-  assert_eq!(base2.decimal("100110101"), 309_u32);
+  assert_eq!(base2.decimal("00001"), 1_u64);
+  assert_eq!(base2.decimal("100110101"), 309_u64);
   assert_eq!(base2.gen(340), "101010100");
   assert_eq!(base2.gen(0xF45), "111101000101");
   assert_eq!(base2.gen(0b111), "111");