From af92f779e6a8b9a0aa585f4515250b14100cd445 Mon Sep 17 00:00:00 2001 From: Zynh0722 Date: Wed, 12 Apr 2023 05:09:33 -0700 Subject: [PATCH] reorder main --- src/main.rs | 58 ++++++++++++++++++++++++++--------------------------- 1 file changed, 29 insertions(+), 29 deletions(-) diff --git a/src/main.rs b/src/main.rs index 4d8814f..bed8dc7 100644 --- a/src/main.rs +++ b/src/main.rs @@ -38,6 +38,14 @@ mod state; use state::{AppState, UploadRecord}; +pub mod error { + use std::io::{Error, ErrorKind}; + + pub fn io_other(s: &str) -> Error { + Error::new(ErrorKind::Other, s) + } +} + #[tokio::main] async fn main() -> io::Result<()> { // Set up logging @@ -162,35 +170,6 @@ fn get_random_name(len: usize) -> String { Alphanumeric.sample_string(&mut rng, len) } -#[allow(dead_code)] -static UNITS: [&str; 6] = ["KiB", "MiB", "GiB", "TiB", "PiB", "EiB"]; -// This function is actually rather interesting to me, I understand that rust is -// very powerful, and its very safe, but i find it rather amusing that the [] operator -// doesn't check bounds, meaning it can panic at runtime. Usually rust is very -// very careful about possible panics -// -// although this function shouldn't be able to panic at runtime due to known bounds -// being listened to -#[inline] -fn _bytes_to_human_readable(bytes: u64) -> String { - let mut running = bytes as f64; - let mut count = 0; - while running > 1024.0 && count <= 6 { - running /= 1024.0; - count += 1; - } - - format!("{:.2} {}", running, UNITS[count - 1]) -} - -pub mod error { - use std::io::{Error, ErrorKind}; - - pub fn io_other(s: &str) -> Error { - Error::new(ErrorKind::Other, s) - } -} - async fn write_to_cache(records: &HashMap) -> io::Result<()> where T: Serialize, @@ -221,3 +200,24 @@ async fn fetch_cache() -> AppState { AppState::new(records) } + +#[allow(dead_code)] +static UNITS: [&str; 6] = ["KiB", "MiB", "GiB", "TiB", "PiB", "EiB"]; +// This function is actually rather interesting to me, I understand that rust is +// very powerful, and its very safe, but i find it rather amusing that the [] operator +// doesn't check bounds, meaning it can panic at runtime. Usually rust is very +// very careful about possible panics +// +// although this function shouldn't be able to panic at runtime due to known bounds +// being listened to +#[inline] +fn _bytes_to_human_readable(bytes: u64) -> String { + let mut running = bytes as f64; + let mut count = 0; + while running > 1024.0 && count <= 6 { + running /= 1024.0; + count += 1; + } + + format!("{:.2} {}", running, UNITS[count - 1]) +}