Struct Byte 

pub struct Byte(/* private fields */);

Represent the n-bytes data. Use associated functions: from_unit, from_bytes, from_str, to create the instance.

Implementations

impl Byte

pub fn from_unit(value: f64, unit: ByteUnit) -> Result<Byte, ByteError>

Create a new Byte object from a specified value and a unit. Accuracy should be taken care of.

Examples

use byte_unit::{Byte, ByteUnit};

let result = Byte::from_unit(1500f64, ByteUnit::KB).unwrap();

assert_eq!(1500000, result.get_bytes());

pub const fn from_bytes(bytes: u128) -> Byte

Create a new Byte object from bytes.

Examples

use byte_unit::{Byte, ByteUnit};

let result = Byte::from_bytes(1500000);

assert_eq!(1500000, result.get_bytes());

Examples found in repository

examples/end_to_end.rs (line 26)

async fn main() {
    // Get keypair
    let keypair_file: String = std::env::args()
        .skip(1)
        .next()
        .expect("no keypair file provided");
    let keypair: Keypair = read_keypair_file(keypair_file).expect("failed to read keypair file");
    println!("loaded keypair");

    // Initialize client
    let client = ShadowDriveClient::new(keypair, SOLANA_MAINNET_RPC);
    println!("initialized client");

    // Create account
    let response = client
        .create_storage_account(
            "test",
            Byte::from_bytes(2_u128.pow(20)),
            shadow_drive_sdk::StorageAccountVersion::V2,
        )
        .await
        .expect("failed to create storage account");
    let account = Pubkey::from_str(&response.shdw_bucket.unwrap()).unwrap();
    println!("created storage account");

    // Upload files
    let files: Vec<ShadowFile> = vec![
        ShadowFile::file("alpha.txt".to_string(), "./examples/files/alpha.txt"),
        ShadowFile::file(
            "not_alpha.txt".to_string(),
            "./examples/files/not_alpha.txt",
        ),
    ];
    let response = client
        .store_files(&account, files.clone())
        .await
        .expect("failed to upload files");
    println!("uploaded files");
    for url in &response.finalized_locations {
        println!("    {url}")
    }
    // Try editing
    for file in files {
        let response = client
            .edit_file(&account, file)
            .await
            .expect("failed to upload files");
        assert!(!response.finalized_location.is_empty(), "failed edit");
        println!("edited file: {}", response.finalized_location);
    }

    // Delete files
    for url in response.finalized_locations {
        client
            .delete_file(&account, url)
            .await
            .expect("failed to delete files");
    }
    println!("deleted files");

    // Delete account
    client
        .delete_storage_account(&account)
        .await
        .expect("failed to delete storage account");
    println!("deleted account");
}

pub fn from_str<S>(s: S) -> Result<Byte, ByteError>

where S: AsRef<str>,

Create a new Byte object from string. Accuracy should be taken care of.

Examples

use byte_unit::{Byte, ByteUnit};

let result = Byte::from_str("123KiB").unwrap();

assert_eq!(Byte::from_unit(123f64, ByteUnit::KiB).unwrap(), result);

use byte_unit::{Byte, ByteUnit};

let result = Byte::from_str("50.84 MB").unwrap();

assert_eq!(Byte::from_unit(50.84f64, ByteUnit::MB).unwrap(), result);

use byte_unit::{Byte, ByteUnit};

let result = Byte::from_str("8 B").unwrap(); // 8 bytes

assert_eq!(8, result.get_bytes());

use byte_unit::{Byte, ByteUnit};

let result = Byte::from_str("8").unwrap(); // 8 bytes

assert_eq!(8, result.get_bytes());

use byte_unit::{Byte, ByteUnit};

let result = Byte::from_str("8 b").unwrap(); // 8 bytes

assert_eq!(8, result.get_bytes());

use byte_unit::{Byte, ByteUnit};

let result = Byte::from_str("8 kb").unwrap(); // 8 kilobytes

assert_eq!(8000, result.get_bytes());

use byte_unit::{Byte, ByteUnit};

let result = Byte::from_str("8 kib").unwrap(); // 8 kibibytes

assert_eq!(8192, result.get_bytes());

use byte_unit::{Byte, ByteUnit};

let result = Byte::from_str("8 k").unwrap(); // 8 kilobytes

assert_eq!(8000, result.get_bytes());

impl Byte

pub const fn get_bytes(&self) -> u128

Get bytes represented by a Byte object.

Examples

use byte_unit::Byte;

let byte = Byte::from_str("123KiB").unwrap();

let result = byte.get_bytes();

assert_eq!(125952, result);

use byte_unit::Byte;

let byte = Byte::from_str("50.84 MB").unwrap();

let result = byte.get_bytes();

assert_eq!(50840000, result);

pub fn get_adjusted_unit(&self, unit: ByteUnit) -> AdjustedByte

Adjust the unit and value for Byte object. Accuracy should be taken care of.

Examples

use byte_unit::{Byte, ByteUnit};

let byte = Byte::from_str("123KiB").unwrap();

let adjusted_byte = byte.get_adjusted_unit(ByteUnit::KB);

assert_eq!("125.95 KB", adjusted_byte.to_string());

use byte_unit::{Byte, ByteUnit};

let byte = Byte::from_str("50.84 MB").unwrap();

let adjusted_byte = byte.get_adjusted_unit(ByteUnit::MiB);

assert_eq!("48.48 MiB", adjusted_byte.to_string());

pub fn get_appropriate_unit(&self, binary_multiples: bool) -> AdjustedByte

Find the appropriate unit and value for Byte object. Accuracy should be taken care of.

Examples

use byte_unit::Byte;

let byte = Byte::from_str("123KiB").unwrap();

let adjusted_byte = byte.get_appropriate_unit(false);

assert_eq!("125.95 KB", adjusted_byte.to_string());

use byte_unit::Byte;

let byte = Byte::from_str("50.84 MB").unwrap();

let adjusted_byte = byte.get_appropriate_unit(true);

assert_eq!("48.48 MiB", adjusted_byte.to_string());

Trait Implementations

impl Clone for Byte

fn clone(&self) -> Byte

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Byte

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Default for Byte

fn default() -> Byte

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Byte

fn deserialize<D>( deserializer: D, ) -> Result<Byte, <D as Deserializer<'de>>::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Byte

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl From<AdjustedByte> for Byte

fn from(other: AdjustedByte) -> Byte

Converts to this type from the input type.

impl From<u128> for Byte

fn from(u: u128) -> Byte

Converts to this type from the input type.

impl From<u16> for Byte

fn from(u: u16) -> Byte

Converts to this type from the input type.

impl From<u32> for Byte

fn from(u: u32) -> Byte

Converts to this type from the input type.

impl From<u64> for Byte

fn from(u: u64) -> Byte

Converts to this type from the input type.

impl From<u8> for Byte

fn from(u: u8) -> Byte

Converts to this type from the input type.

impl From<usize> for Byte

fn from(u: usize) -> Byte

Converts to this type from the input type.

impl FromStr for Byte

type Err = ByteError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Byte, <Byte as FromStr>::Err>

Parses a string s to return a value of this type.

impl Hash for Byte

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for Byte

fn cmp(&self, other: &Byte) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for Byte

fn eq(&self, other: &Byte) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for Byte

fn partial_cmp(&self, other: &Byte) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for Byte

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl TryFrom<&str> for Byte

type Error = ByteError

The type returned in the event of a conversion error.

fn try_from(s: &str) -> Result<Byte, <Byte as TryFrom<&str>>::Error>

Performs the conversion.

impl Copy for Byte

impl Eq for Byte

impl StructuralPartialEq for Byte