wdg-base32 0.5.6

impl B32Encode<u64,String> for B32<String>{
    fn encode(data:u64)->String{
        let mut string:String=String::with_capacity(16);
        unsafe{
            let vec=&mut string.as_mut_vec();
            vec.set_len(16);
            b32_encode_8(&data,1,ALPHABET32_ENCODE.as_ptr(),vec.as_mut_ptr());
        }
        return string;
    }
}

macro_rules! array_impls_u64 {
    ($($N:expr)+) => {
        $(

            impl B32Decode<[u8;$N],u64> for B32<u64>{
                fn validation(data:[u8;$N])->B32DecodeError{
                    return b32_validation(data.as_ptr(),data.len(),8,ALPHABET32_DECODE.as_ptr(),3,0b1000,16,16,16);
                }
                fn decode(data:[u8;$N])->Result<u64,B32DecodeError>{
                    let ptr_input=data.as_ptr();
                    let len_input=data.len();
                    let ptr_alphabet=ALPHABET32_DECODE.as_ptr();

                    let error=b32_validation(ptr_input,len_input,8,ptr_alphabet,3,0b1000,16,16,16);
                    if error!=B32DecodeError::Null {return Err(error)};

                    let mut n=0u64;
                    b32_decode_8(ptr_input,len_input,ptr_alphabet,&mut n,3);
                    return Ok(n);
                }
                unsafe fn unsafe_decode(data:[u8;$N])->u64{
                    let mut n=0u64;
                    b32_decode_8(data.as_ptr(),data.len(),ALPHABET32_DECODE.as_ptr(),&mut n,3);
                    return n;
                }
            }

            impl B32Decode<&'static [u8;$N],u64> for B32<u64>{
                fn validation(data:&'static [u8;$N])->B32DecodeError{
                    return b32_validation(data.as_ptr(),data.len(),8,ALPHABET32_DECODE.as_ptr(),3,0b1000,16,16,16);
                }
                fn decode(data:&'static [u8;$N])->Result<u64,B32DecodeError>{
                    let ptr_input=data.as_ptr();
                    let len_input=data.len();
                    let ptr_alphabet=ALPHABET32_DECODE.as_ptr();

                    let error=b32_validation(ptr_input,len_input,8,ptr_alphabet,3,0b1000,16,16,16);
                    if error!=B32DecodeError::Null {return Err(error)};

                    let mut n=0u64;
                    b32_decode_8(ptr_input,len_input,ptr_alphabet,&mut n,3);
                    return Ok(n);
                }
                unsafe fn unsafe_decode(data:&'static [u8;$N])->u64{
                    let mut n=0u64;
                    b32_decode_8(data.as_ptr(),data.len(),ALPHABET32_DECODE.as_ptr(),&mut n,3);
                    return n;
                }
            }

        )+
    }
}

array_impls_u64! {
    00 01 02 03 04 05 06 07 08 09
    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
}

impl B32Decode<String,u64> for B32<u64>{
    fn validation(data:String)->B32DecodeError{
        return b32_validation(data.as_ptr(),data.len(),8,ALPHABET32_DECODE.as_ptr(),3,0b1000,16,16,16);
    }
    fn decode(data:String)->Result<u64,B32DecodeError>{
        let ptr_input=data.as_ptr();
        let len_input=data.len();
        let ptr_alphabet=ALPHABET32_DECODE.as_ptr();

        let error=b32_validation(ptr_input,len_input,8,ptr_alphabet,3,0b1000,16,16,16);
        if error!=B32DecodeError::Null {return Err(error)};

        let mut n=0u64;
        b32_decode_8(ptr_input,len_input,ptr_alphabet,&mut n,3);
        return Ok(n);
    }
    unsafe fn unsafe_decode(data:String)->u64{
        let mut n=0u64;
        b32_decode_8(data.as_ptr(),data.len(),ALPHABET32_DECODE.as_ptr(),&mut n,3);
        return n;
    }
}

impl B32Decode<&'static str,u64> for B32<u64>{
    fn validation(data:&'static str)->B32DecodeError{
        return b32_validation(data.as_ptr(),data.len(),8,ALPHABET32_DECODE.as_ptr(),3,0b1000,16,16,16);
    }
    fn decode(data:&'static str)->Result<u64,B32DecodeError>{
        let ptr_input=data.as_ptr();
        let len_input=data.len();
        let ptr_alphabet=ALPHABET32_DECODE.as_ptr();

        let error=b32_validation(ptr_input,len_input,8,ptr_alphabet,3,0b1000,16,16,16);
        if error!=B32DecodeError::Null {return Err(error)};

        let mut n=0u64;
        b32_decode_8(ptr_input,len_input,ptr_alphabet,&mut n,3);
        return Ok(n);
    }
    unsafe fn unsafe_decode(data:&'static str)->u64{
        let mut n=0u64;
        b32_decode_8(data.as_ptr(),data.len(),ALPHABET32_DECODE.as_ptr(),&mut n,3);
        return n;
    }
}