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
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131

static ALPHABET16:&'static[char]=&['0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'];

pub struct B16<T>(T);

pub trait B16Encode<I,O>{
    fn encode(data:I)->O;
}

impl B16Encode<u8,String> for B16<String>{
    fn encode(data:u8)->String{
        let mut s=String::with_capacity(2);
        s.push(ALPHABET16[((data>>04)&0b00001111) as usize]);
        s.push(ALPHABET16[((data>>00)&0b00001111) as usize]);
        return  s;
    }
}

impl B16Encode<u16,String> for B16<String>{
    fn encode(data:u16)->String{
        let mut s=String::with_capacity(4);
        s.push(ALPHABET16[((data>>12)&0b00001111) as usize]);
        s.push(ALPHABET16[((data>>08)&0b00001111) as usize]);
        s.push(ALPHABET16[((data>>04)&0b00001111) as usize]);
        s.push(ALPHABET16[((data>>00)&0b00001111) as usize]);
        return  s;
    }
}

impl B16Encode<u32,String> for B16<String>{
    fn encode(data:u32)->String{
        let mut s=String::with_capacity(8);
        s.push(ALPHABET16[((data>>28)&0b00001111) as usize]);
        s.push(ALPHABET16[((data>>24)&0b00001111) as usize]);
        s.push(ALPHABET16[((data>>20)&0b00001111) as usize]);
        s.push(ALPHABET16[((data>>16)&0b00001111) as usize]);
        s.push(ALPHABET16[((data>>12)&0b00001111) as usize]);
        s.push(ALPHABET16[((data>>08)&0b00001111) as usize]);
        s.push(ALPHABET16[((data>>04)&0b00001111) as usize]);
        s.push(ALPHABET16[((data>>00)&0b00001111) as usize]);
        return  s;
    }
}

impl B16Encode<u64,String> for B16<String>{
    fn encode(data:u64)->String{
        let mut s=String::with_capacity(16);
        s.push(ALPHABET16[((data>>60)&0b00001111) as usize]);
        s.push(ALPHABET16[((data>>56)&0b00001111) as usize]);
        s.push(ALPHABET16[((data>>52)&0b00001111) as usize]);
        s.push(ALPHABET16[((data>>48)&0b00001111) as usize]);
        s.push(ALPHABET16[((data>>44)&0b00001111) as usize]);
        s.push(ALPHABET16[((data>>40)&0b00001111) as usize]);
        s.push(ALPHABET16[((data>>36)&0b00001111) as usize]);
        s.push(ALPHABET16[((data>>32)&0b00001111) as usize]);
        s.push(ALPHABET16[((data>>28)&0b00001111) as usize]);
        s.push(ALPHABET16[((data>>24)&0b00001111) as usize]);
        s.push(ALPHABET16[((data>>20)&0b00001111) as usize]);
        s.push(ALPHABET16[((data>>16)&0b00001111) as usize]);
        s.push(ALPHABET16[((data>>12)&0b00001111) as usize]);
        s.push(ALPHABET16[((data>>08)&0b00001111) as usize]);
        s.push(ALPHABET16[((data>>04)&0b00001111) as usize]);
        s.push(ALPHABET16[((data>>00)&0b00001111) as usize]);
        return  s;
    }
}

pub trait B16Decode<I,O>{
    fn decode(data:I)->O;
}

impl B16Decode<String,u64> for B16<u64>{
    fn decode(data:String)->u64{
        let mut n=0u64;
        let b=data.into_bytes();
        n|=if b[15]<58 {((b[15]-48) as u64)<<(00)} else {((b[15]-55) as u64)<<(00)};
        n|=if b[14]<58 {((b[14]-48) as u64)<<(04)} else {((b[14]-55) as u64)<<(04)};
        n|=if b[13]<58 {((b[13]-48) as u64)<<(08)} else {((b[13]-55) as u64)<<(08)};
        n|=if b[12]<58 {((b[12]-48) as u64)<<(12)} else {((b[12]-55) as u64)<<(12)};
        n|=if b[11]<58 {((b[11]-48) as u64)<<(16)} else {((b[11]-55) as u64)<<(16)};
        n|=if b[10]<58 {((b[10]-48) as u64)<<(20)} else {((b[10]-55) as u64)<<(20)};
        n|=if b[09]<58 {((b[09]-48) as u64)<<(24)} else {((b[09]-55) as u64)<<(24)};
        n|=if b[08]<58 {((b[08]-48) as u64)<<(28)} else {((b[08]-55) as u64)<<(28)};
        n|=if b[07]<58 {((b[07]-48) as u64)<<(32)} else {((b[07]-55) as u64)<<(32)};
        n|=if b[06]<58 {((b[06]-48) as u64)<<(36)} else {((b[06]-55) as u64)<<(36)};
        n|=if b[05]<58 {((b[05]-48) as u64)<<(40)} else {((b[05]-55) as u64)<<(40)};
        n|=if b[04]<58 {((b[04]-48) as u64)<<(44)} else {((b[04]-55) as u64)<<(44)};
        n|=if b[03]<58 {((b[03]-48) as u64)<<(48)} else {((b[03]-55) as u64)<<(48)};
        n|=if b[02]<58 {((b[02]-48) as u64)<<(52)} else {((b[02]-55) as u64)<<(52)};
        n|=if b[01]<58 {((b[01]-48) as u64)<<(56)} else {((b[01]-55) as u64)<<(56)};
        n|=if b[00]<58 {((b[00]-48) as u64)<<(60)} else {((b[00]-55) as u64)<<(60)};
        return n;
    }
}

impl B16Decode<String,u32> for B16<u32>{
    fn decode(data:String)->u32{
        let mut n=0u32;
        let b=data.into_bytes();
        n|=if b[7]<58 {((b[7]-48) as u32)<<(00)} else {((b[7]-55) as u32)<<(00)};
        n|=if b[6]<58 {((b[6]-48) as u32)<<(04)} else {((b[6]-55) as u32)<<(04)};
        n|=if b[5]<58 {((b[5]-48) as u32)<<(08)} else {((b[5]-55) as u32)<<(08)};
        n|=if b[4]<58 {((b[4]-48) as u32)<<(12)} else {((b[4]-55) as u32)<<(12)};
        n|=if b[3]<58 {((b[3]-48) as u32)<<(16)} else {((b[3]-55) as u32)<<(16)};
        n|=if b[2]<58 {((b[2]-48) as u32)<<(20)} else {((b[2]-55) as u32)<<(20)};
        n|=if b[1]<58 {((b[1]-48) as u32)<<(24)} else {((b[1]-55) as u32)<<(24)};
        n|=if b[0]<58 {((b[0]-48) as u32)<<(28)} else {((b[0]-55) as u32)<<(28)};
        return n;
    }
}

impl B16Decode<String,u16> for B16<u16>{
    fn decode(data:String)->u16{
        let mut n=0u16;
        let b=data.into_bytes();
        n|=if b[3]<58 {((b[3]-48) as u16)<<(00)} else {((b[3]-55) as u16)<<(00)};
        n|=if b[2]<58 {((b[2]-48) as u16)<<(04)} else {((b[2]-55) as u16)<<(04)};
        n|=if b[1]<58 {((b[1]-48) as u16)<<(08)} else {((b[1]-55) as u16)<<(08)};
        n|=if b[0]<58 {((b[0]-48) as u16)<<(12)} else {((b[0]-55) as u16)<<(12)};
        return n;
    }
}

impl B16Decode<String,u8> for B16<u8>{
    fn decode(data:String)->u8{
        let mut n=0u8;
        let b=data.into_bytes();
        n|=if b[1]<58 {((b[1]-48) as u8)<<(00)} else {((b[1]-55) as u8)<<(00)};
        n|=if b[0]<58 {((b[0]-48) as u8)<<(04)} else {((b[0]-55) as u8)<<(04)};
        return n;
    }
}