tina-core 0.0.2

//! base64
use crate::app_error_from;
use crate::tina::data::AppResult;
use std::io::{Cursor, Read, Write};

/// Base64 工具
pub struct Base64;

impl Base64 {
    /// 转码 字符串 -> 字符串
    pub fn encode_string(src: &str) -> AppResult<String> {
        if src.is_empty() {
            return Ok(src.to_owned());
        }
        let mut enc = base64::write::EncoderStringWriter::new(&base64::engine::general_purpose::STANDARD);
        match enc.write_all(src.as_bytes()) {
            Ok(_) => Ok(enc.into_inner()),
            Err(err) => Err(app_error_from!(err)),
        }
    }

    /// 转码 字符串 -> 二进制
    pub fn encode_string_to_bytes(src: &str) -> AppResult<Vec<u8>> {
        if src.is_empty() {
            return Ok(src.as_bytes().to_vec());
        }
        let mut enc = base64::write::EncoderStringWriter::new(&base64::engine::general_purpose::STANDARD);
        match enc.write_all(src.as_bytes()) {
            Ok(_) => Ok(enc.into_inner().into_bytes()),
            Err(err) => Err(app_error_from!(err)),
        }
    }

    /// 转码 二进制 -> 二进制
    pub fn encode_bytes(buf: &[u8]) -> AppResult<Vec<u8>> {
        if buf.is_empty() {
            return Ok(buf.to_vec());
        }
        let mut enc = base64::write::EncoderStringWriter::new(&base64::engine::general_purpose::STANDARD);
        match enc.write_all(buf) {
            Ok(_) => Ok(enc.into_inner().into_bytes()),
            Err(err) => Err(app_error_from!(err)),
        }
    }

    /// 转码 二进制 -> 字符串
    pub fn encode_bytes_to_string(buf: &[u8]) -> AppResult<String> {
        if buf.is_empty() {
            return match String::from_utf8(buf.to_vec()) {
                Ok(s) => Ok(s),
                Err(err) => Err(app_error_from!(err)),
            };
        }
        let mut enc = base64::write::EncoderStringWriter::new(&base64::engine::general_purpose::STANDARD);
        match enc.write_all(buf) {
            Ok(_) => Ok(enc.into_inner()),
            Err(err) => Err(app_error_from!(err)),
        }
    }

    /// 解码 字符串 -> 字符串
    pub fn decode_string(src: &str) -> AppResult<String> {
        if src.is_empty() {
            return Ok(src.to_owned());
        }
        let mut wrapped_reader = Cursor::new(src);
        let mut decoder = base64::read::DecoderReader::new(&mut wrapped_reader, &base64::engine::general_purpose::STANDARD);
        let mut result = Vec::new();
        match decoder.read_to_end(&mut result) {
            Ok(_) => match String::from_utf8(result) {
                Ok(s) => Ok(s),
                Err(err) => Err(app_error_from!(err)),
            },
            Err(err) => Err(app_error_from!(err)),
        }
    }

    /// 解码 字符串 -> 二进制
    pub fn decode_string_to_bytes(src: &str) -> AppResult<Vec<u8>> {
        if src.is_empty() {
            return Ok(src.as_bytes().to_vec());
        }
        let mut wrapped_reader = Cursor::new(src);
        let mut decoder = base64::read::DecoderReader::new(&mut wrapped_reader, &base64::engine::general_purpose::STANDARD);
        let mut result = Vec::new();
        match decoder.read_to_end(&mut result) {
            Ok(_) => Ok(result),
            Err(err) => Err(app_error_from!(err)),
        }
    }

    /// 解码 二进制 -> 二进制
    pub fn decode_bytes(buf: &[u8]) -> AppResult<Vec<u8>> {
        if buf.is_empty() {
            return Ok(buf.to_vec());
        }
        let mut wrapped_reader = Cursor::new(buf);
        let mut decoder = base64::read::DecoderReader::new(&mut wrapped_reader, &base64::engine::general_purpose::STANDARD);
        let mut result = Vec::new();
        match decoder.read_to_end(&mut result) {
            Ok(_) => Ok(result),
            Err(err) => Err(app_error_from!(err)),
        }
    }

    /// 解码 二进制 -> 字符串
    pub fn decode_bytes_to_string(buf: &[u8]) -> AppResult<String> {
        if buf.is_empty() {
            return match String::from_utf8(buf.to_vec()) {
                Ok(s) => Ok(s),
                Err(err) => Err(app_error_from!(err)),
            };
        }
        let mut wrapped_reader = Cursor::new(buf);
        let mut decoder = base64::read::DecoderReader::new(&mut wrapped_reader, &base64::engine::general_purpose::STANDARD);
        let mut result = Vec::new();
        match decoder.read_to_end(&mut result) {
            Ok(_) => match String::from_utf8(result) {
                Ok(s) => Ok(s),
                Err(err) => Err(app_error_from!(err)),
            },
            Err(err) => Err(app_error_from!(err)),
        }
    }
}