cast

Struct SimpleCast

Source 
pub struct SimpleCast;

Implementations§

Source§

impl SimpleCast

Source

pub fn max_int(s: &str) -> Result<String>

Returns the maximum value of the given integer type

§Example
use alloy_primitives::{I256, U256};
use cast::SimpleCast;

assert_eq!(SimpleCast::max_int("uint256")?, U256::MAX.to_string());
assert_eq!(SimpleCast::max_int("int256")?, I256::MAX.to_string());
assert_eq!(SimpleCast::max_int("int32")?, i32::MAX.to_string());
Source

pub fn min_int(s: &str) -> Result<String>

Returns the maximum value of the given integer type

§Example
use alloy_primitives::{I256, U256};
use cast::SimpleCast;

assert_eq!(SimpleCast::min_int("uint256")?, "0");
assert_eq!(SimpleCast::min_int("int256")?, I256::MIN.to_string());
assert_eq!(SimpleCast::min_int("int32")?, i32::MIN.to_string());
Source

pub(crate) fn max_min_int<const MAX: bool>(s: &str) -> Result<String>

Source

pub fn from_utf8(s: &str) -> String

Converts UTF-8 text input to hex

§Example
use cast::SimpleCast as Cast;

assert_eq!(Cast::from_utf8("yo"), "0x796f");
assert_eq!(Cast::from_utf8("Hello, World!"), "0x48656c6c6f2c20576f726c6421");
assert_eq!(Cast::from_utf8("TurboDappTools"), "0x547572626f44617070546f6f6c73");
Source

pub fn to_utf8(s: &str) -> Result<String>

Converts hex input to UTF-8 text

§Example
use cast::SimpleCast as Cast;

assert_eq!(Cast::to_utf8("0x796f")?, "yo");
assert_eq!(Cast::to_utf8("0x48656c6c6f2c20576f726c6421")?, "Hello, World!");
assert_eq!(Cast::to_utf8("0x547572626f44617070546f6f6c73")?, "TurboDappTools");
assert_eq!(Cast::to_utf8("0xe4bda0e5a5bd")?, "你好");
Source

pub fn to_ascii(hex: &str) -> Result<String>

Converts hex data into text data

§Example
use cast::SimpleCast as Cast;

assert_eq!(Cast::to_ascii("0x796f")?, "yo");
assert_eq!(Cast::to_ascii("48656c6c6f2c20576f726c6421")?, "Hello, World!");
assert_eq!(Cast::to_ascii("0x547572626f44617070546f6f6c73")?, "TurboDappTools");
Source

pub fn from_fixed_point(value: &str, decimals: &str) -> Result<String>

Converts fixed point number into specified number of decimals

use alloy_primitives::U256;
use cast::SimpleCast as Cast;

assert_eq!(Cast::from_fixed_point("10", "0")?, "10");
assert_eq!(Cast::from_fixed_point("1.0", "1")?, "10");
assert_eq!(Cast::from_fixed_point("0.10", "2")?, "10");
assert_eq!(Cast::from_fixed_point("0.010", "3")?, "10");
Source

pub fn to_fixed_point(value: &str, decimals: &str) -> Result<String>

Converts integers with specified decimals into fixed point numbers

§Example
use alloy_primitives::U256;
use cast::SimpleCast as Cast;

assert_eq!(Cast::to_fixed_point("10", "0")?, "10.");
assert_eq!(Cast::to_fixed_point("10", "1")?, "1.0");
assert_eq!(Cast::to_fixed_point("10", "2")?, "0.10");
assert_eq!(Cast::to_fixed_point("10", "3")?, "0.010");

assert_eq!(Cast::to_fixed_point("-10", "0")?, "-10.");
assert_eq!(Cast::to_fixed_point("-10", "1")?, "-1.0");
assert_eq!(Cast::to_fixed_point("-10", "2")?, "-0.10");
assert_eq!(Cast::to_fixed_point("-10", "3")?, "-0.010");
Source

pub fn concat_hex<T: AsRef<str>>(values: impl IntoIterator<Item = T>) -> String

Concatencates hex strings

§Example
use cast::SimpleCast as Cast;

assert_eq!(Cast::concat_hex(["0x00", "0x01"]), "0x0001");
assert_eq!(Cast::concat_hex(["1", "2"]), "0x12");
Source

pub fn to_uint256(value: &str) -> Result<String>

Converts a number into uint256 hex string with 0x prefix

§Example
use cast::SimpleCast as Cast;

assert_eq!(
    Cast::to_uint256("100")?,
    "0x0000000000000000000000000000000000000000000000000000000000000064"
);
assert_eq!(
    Cast::to_uint256("192038293923")?,
    "0x0000000000000000000000000000000000000000000000000000002cb65fd1a3"
);
assert_eq!(
    Cast::to_uint256(
        "115792089237316195423570985008687907853269984665640564039457584007913129639935"
    )?,
    "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
);
Source

pub fn to_int256(value: &str) -> Result<String>

Converts a number into int256 hex string with 0x prefix

§Example
use cast::SimpleCast as Cast;

assert_eq!(
    Cast::to_int256("0")?,
    "0x0000000000000000000000000000000000000000000000000000000000000000"
);
assert_eq!(
    Cast::to_int256("100")?,
    "0x0000000000000000000000000000000000000000000000000000000000000064"
);
assert_eq!(
    Cast::to_int256("-100")?,
    "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff9c"
);
assert_eq!(
    Cast::to_int256("192038293923")?,
    "0x0000000000000000000000000000000000000000000000000000002cb65fd1a3"
);
assert_eq!(
    Cast::to_int256("-192038293923")?,
    "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffd349a02e5d"
);
assert_eq!(
    Cast::to_int256(
        "57896044618658097711785492504343953926634992332820282019728792003956564819967"
    )?,
    "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
);
assert_eq!(
    Cast::to_int256(
        "-57896044618658097711785492504343953926634992332820282019728792003956564819968"
    )?,
    "0x8000000000000000000000000000000000000000000000000000000000000000"
);
Source

pub fn to_unit(value: &str, unit: &str) -> Result<String>

Converts an eth amount into a specified unit

§Example
use cast::SimpleCast as Cast;

assert_eq!(Cast::to_unit("1 wei", "wei")?, "1");
assert_eq!(Cast::to_unit("1", "wei")?, "1");
assert_eq!(Cast::to_unit("1ether", "wei")?, "1000000000000000000");
Source

pub fn parse_units(value: &str, unit: u8) -> Result<String>

Convert a number into a uint with arbitrary decimals.

§Example
use cast::SimpleCast as Cast;

assert_eq!(Cast::parse_units("1.0", 6)?, "1000000"); // USDC (6 decimals)
assert_eq!(Cast::parse_units("2.5", 6)?, "2500000");
assert_eq!(Cast::parse_units("1.0", 12)?, "1000000000000"); // 12 decimals
assert_eq!(Cast::parse_units("1.23", 3)?, "1230"); // 3 decimals
Source

pub fn format_units(value: &str, unit: u8) -> Result<String>

Format a number from smallest unit to decimal with arbitrary decimals.

§Example
use cast::SimpleCast as Cast;

assert_eq!(Cast::format_units("1000000", 6)?, "1"); // USDC (6 decimals)
assert_eq!(Cast::format_units("2500000", 6)?, "2.500000");
assert_eq!(Cast::format_units("1000000000000", 12)?, "1"); // 12 decimals
assert_eq!(Cast::format_units("1230", 3)?, "1.230"); // 3 decimals
Source

pub(crate) fn format_unit_as_string(value: U256, unit: Unit) -> String

Source

pub fn from_wei(value: &str, unit: &str) -> Result<String>

Converts wei into an eth amount

§Example
use cast::SimpleCast as Cast;

assert_eq!(Cast::from_wei("1", "gwei")?, "0.000000001");
assert_eq!(Cast::from_wei("12340000005", "gwei")?, "12.340000005");
assert_eq!(Cast::from_wei("10", "ether")?, "0.000000000000000010");
assert_eq!(Cast::from_wei("100", "eth")?, "0.000000000000000100");
assert_eq!(Cast::from_wei("17", "ether")?, "0.000000000000000017");
Source

pub fn to_wei(value: &str, unit: &str) -> Result<String>

Converts an eth amount into wei

§Example
use cast::SimpleCast as Cast;

assert_eq!(Cast::to_wei("100", "gwei")?, "100000000000");
assert_eq!(Cast::to_wei("100", "eth")?, "100000000000000000000");
assert_eq!(Cast::to_wei("1000", "ether")?, "1000000000000000000000");
Source

pub fn from_rlp(value: impl AsRef<str>, as_int: bool) -> Result<String>

§Examples
use cast::SimpleCast as Cast;

assert_eq!(Cast::from_rlp("0xc0", false).unwrap(), "[]");
assert_eq!(Cast::from_rlp("0x0f", false).unwrap(), "\"0x0f\"");
assert_eq!(Cast::from_rlp("0x33", false).unwrap(), "\"0x33\"");
assert_eq!(Cast::from_rlp("0xc161", false).unwrap(), "[\"0x61\"]");
assert_eq!(Cast::from_rlp("820002", true).is_err(), true);
assert_eq!(Cast::from_rlp("820002", false).unwrap(), "\"0x0002\"");
assert_eq!(Cast::from_rlp("00", true).is_err(), true);
assert_eq!(Cast::from_rlp("00", false).unwrap(), "\"0x00\"");
Source

pub fn to_rlp(value: &str) -> Result<String>

Encodes hex data or list of hex data to hexadecimal rlp

§Example
use cast::SimpleCast as Cast;

assert_eq!(Cast::to_rlp("[]").unwrap(), "0xc0".to_string());
assert_eq!(Cast::to_rlp("0x22").unwrap(), "0x22".to_string());
assert_eq!(Cast::to_rlp("[\"0x61\"]",).unwrap(), "0xc161".to_string());
assert_eq!(Cast::to_rlp("[\"0xf1\", \"f2\"]").unwrap(), "0xc481f181f2".to_string());
Source

pub fn to_base( value: &str, base_in: Option<&str>, base_out: &str, ) -> Result<String>

Converts a number of one base to another

§Example
use alloy_primitives::I256;
use cast::SimpleCast as Cast;

assert_eq!(Cast::to_base("100", Some("10"), "16")?, "0x64");
assert_eq!(Cast::to_base("100", Some("10"), "oct")?, "0o144");
assert_eq!(Cast::to_base("100", Some("10"), "binary")?, "0b1100100");

assert_eq!(Cast::to_base("0xffffffffffffffff", None, "10")?, u64::MAX.to_string());
assert_eq!(
    Cast::to_base("0xffffffffffffffffffffffffffffffff", None, "dec")?,
    u128::MAX.to_string()
);
// U256::MAX overflows as internally it is being parsed as I256
assert_eq!(
    Cast::to_base(
        "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
        None,
        "decimal"
    )?,
    I256::MAX.to_string()
);
Source

pub fn to_bytes32(s: &str) -> Result<String>

Converts hexdata into bytes32 value

§Example
use cast::SimpleCast as Cast;

let bytes = Cast::to_bytes32("1234")?;
assert_eq!(bytes, "0x1234000000000000000000000000000000000000000000000000000000000000");

let bytes = Cast::to_bytes32("0x1234")?;
assert_eq!(bytes, "0x1234000000000000000000000000000000000000000000000000000000000000");

let err = Cast::to_bytes32("0x123400000000000000000000000000000000000000000000000000000000000011").unwrap_err();
assert_eq!(err.to_string(), "string >32 bytes");
Source

pub fn format_bytes32_string(s: &str) -> Result<String>

Encodes string into bytes32 value

Source

pub fn parse_bytes32_string(s: &str) -> Result<String>

Decodes string from bytes32 value

Source

pub fn parse_bytes32_address(s: &str) -> Result<String>

Decodes checksummed address from bytes32 value

Source

pub fn abi_decode( sig: &str, calldata: &str, input: bool, ) -> Result<Vec<DynSolValue>>

Decodes abi-encoded hex input or output

When input=true, calldata string MUST not be prefixed with function selector

§Example
use cast::SimpleCast as Cast;
use alloy_primitives::hex;

    // Passing `input = false` will decode the data as the output type.
    // The input data types and the full function sig are ignored, i.e.
    // you could also pass `balanceOf()(uint256)` and it'd still work.
    let data = "0x0000000000000000000000000000000000000000000000000000000000000001";
    let sig = "balanceOf(address, uint256)(uint256)";
    let decoded = Cast::abi_decode(sig, data, false)?[0].as_uint().unwrap().0.to_string();
    assert_eq!(decoded, "1");

    // Passing `input = true` will decode the data with the input function signature.
    // We exclude the "prefixed" function selector from the data field (the first 4 bytes).
    let data = "0x0000000000000000000000008dbd1b711dc621e1404633da156fcc779e1c6f3e000000000000000000000000d9f3c9cc99548bf3b44a43e0a2d07399eb918adc000000000000000000000000000000000000000000000000000000000000002a000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000000";
    let sig = "safeTransferFrom(address, address, uint256, uint256, bytes)";
    let decoded = Cast::abi_decode(sig, data, true)?;
    let decoded = [
        decoded[0].as_address().unwrap().to_string().to_lowercase(),
        decoded[1].as_address().unwrap().to_string().to_lowercase(),
        decoded[2].as_uint().unwrap().0.to_string(),
        decoded[3].as_uint().unwrap().0.to_string(),
        hex::encode(decoded[4].as_bytes().unwrap())
    ]
    .into_iter()
    .collect::<Vec<_>>();

    assert_eq!(
        decoded,
        vec!["0x8dbd1b711dc621e1404633da156fcc779e1c6f3e", "0xd9f3c9cc99548bf3b44a43e0a2d07399eb918adc", "42", "1", ""]
    );
Source

pub fn calldata_decode( sig: &str, calldata: &str, input: bool, ) -> Result<Vec<DynSolValue>>

Decodes calldata-encoded hex input or output

Similar to abi_decode, but calldata string MUST be prefixed with function selector

§Example
use cast::SimpleCast as Cast;
use alloy_primitives::hex;

// Passing `input = false` will decode the data as the output type.
// The input data types and the full function sig are ignored, i.e.
// you could also pass `balanceOf()(uint256)` and it'd still work.
let data = "0x0000000000000000000000000000000000000000000000000000000000000001";
let sig = "balanceOf(address, uint256)(uint256)";
let decoded = Cast::calldata_decode(sig, data, false)?[0].as_uint().unwrap().0.to_string();
assert_eq!(decoded, "1");

    // Passing `input = true` will decode the data with the input function signature.
    let data = "0xf242432a0000000000000000000000008dbd1b711dc621e1404633da156fcc779e1c6f3e000000000000000000000000d9f3c9cc99548bf3b44a43e0a2d07399eb918adc000000000000000000000000000000000000000000000000000000000000002a000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000000";
    let sig = "safeTransferFrom(address, address, uint256, uint256, bytes)";
    let decoded = Cast::calldata_decode(sig, data, true)?;
    let decoded = [
        decoded[0].as_address().unwrap().to_string().to_lowercase(),
        decoded[1].as_address().unwrap().to_string().to_lowercase(),
        decoded[2].as_uint().unwrap().0.to_string(),
        decoded[3].as_uint().unwrap().0.to_string(),
        hex::encode(decoded[4].as_bytes().unwrap()),
   ]
   .into_iter()
   .collect::<Vec<_>>();
    assert_eq!(
        decoded,
        vec!["0x8dbd1b711dc621e1404633da156fcc779e1c6f3e", "0xd9f3c9cc99548bf3b44a43e0a2d07399eb918adc", "42", "1", ""]
    );
Source

pub fn abi_encode(sig: &str, args: &[impl AsRef<str>]) -> Result<String>

Performs ABI encoding based off of the function signature. Does not include the function selector in the result.

§Example
use cast::SimpleCast as Cast;

assert_eq!(
    "0x0000000000000000000000000000000000000000000000000000000000000001",
    Cast::abi_encode("f(uint a)", &["1"]).unwrap().as_str()
);
assert_eq!(
    "0x0000000000000000000000000000000000000000000000000000000000000001",
    Cast::abi_encode("constructor(uint a)", &["1"]).unwrap().as_str()
);
Source

pub fn abi_encode_packed(sig: &str, args: &[impl AsRef<str>]) -> Result<String>

Performs packed ABI encoding based off of the function signature or tuple.

§Examplez
use cast::SimpleCast as Cast;

assert_eq!(
    "0x0000000000000000000000000000000000000000000000000000000000000064000000000000000000000000000000000000000000000000000000000000012c00000000000000c8",
    Cast::abi_encode_packed("(uint128[] a, uint64 b)", &["[100, 300]", "200"]).unwrap().as_str()
);

assert_eq!(
    "0x8dbd1b711dc621e1404633da156fcc779e1c6f3e68656c6c6f20776f726c64",
    Cast::abi_encode_packed("foo(address a, string b)", &["0x8dbd1b711dc621e1404633da156fcc779e1c6f3e", "hello world"]).unwrap().as_str()
);
Source

pub fn calldata_encode( sig: impl AsRef<str>, args: &[impl AsRef<str>], ) -> Result<String>

Performs ABI encoding to produce the hexadecimal calldata with the given arguments.

§Example
use cast::SimpleCast as Cast;

assert_eq!(
    "0xb3de648b0000000000000000000000000000000000000000000000000000000000000001",
    Cast::calldata_encode("f(uint256 a)", &["1"]).unwrap().as_str()
);
Source

pub fn index( from_type: &str, from_value: &str, slot_number: &str, ) -> Result<String>

Prints the slot number for the specified mapping type and input data.

For value types v, slot number of v is keccak256(concat(h(v), p)) where h is the padding function for v’s type, and p is slot number of the mapping.

See the Solidity documentation for more details.

§Example

// Value types.
assert_eq!(
    Cast::index("address", "0xD0074F4E6490ae3f888d1d4f7E3E43326bD3f0f5", "2").unwrap().as_str(),
    "0x9525a448a9000053a4d151336329d6563b7e80b24f8e628e95527f218e8ab5fb"
);
assert_eq!(
    Cast::index("uint256", "42", "6").unwrap().as_str(),
    "0xfc808b0f31a1e6b9cf25ff6289feae9b51017b392cc8e25620a94a38dcdafcc1"
);

// Strings and byte arrays.
assert_eq!(
    Cast::index("string", "hello", "1").unwrap().as_str(),
    "0x8404bb4d805e9ca2bd5dd5c43a107e935c8ec393caa7851b353b3192cd5379ae"
);
Source

pub fn keccak(data: &str) -> Result<String>

Keccak-256 hashes arbitrary data

§Example
use cast::SimpleCast as Cast;

assert_eq!(
    Cast::keccak("foo")?,
    "0x41b1a0649752af1b28b3dc29a1556eee781e4a4c3a1f7f53f90fa834de098c4d"
);
assert_eq!(
    Cast::keccak("123abc")?,
    "0xb1f1c74a1ba56f07a892ea1110a39349d40f66ca01d245e704621033cb7046a4"
);
assert_eq!(
    Cast::keccak("0x12")?,
    "0x5fa2358263196dbbf23d1ca7a509451f7a2f64c15837bfbb81298b1e3e24e4fa"
);
assert_eq!(
    Cast::keccak("12")?,
    "0x7f8b6b088b6d74c2852fc86c796dca07b44eed6fb3daf5e6b59f7c364db14528"
);
Source

pub fn left_shift( value: &str, bits: &str, base_in: Option<&str>, base_out: &str, ) -> Result<String>

Performs the left shift operation (<<) on a number

§Example
use cast::SimpleCast as Cast;

assert_eq!(Cast::left_shift("16", "10", Some("10"), "hex")?, "0x4000");
assert_eq!(Cast::left_shift("255", "16", Some("dec"), "hex")?, "0xff0000");
assert_eq!(Cast::left_shift("0xff", "16", None, "hex")?, "0xff0000");
Source

pub fn right_shift( value: &str, bits: &str, base_in: Option<&str>, base_out: &str, ) -> Result<String>

Performs the right shift operation (>>) on a number

§Example
use cast::SimpleCast as Cast;

assert_eq!(Cast::right_shift("0x4000", "10", None, "dec")?, "16");
assert_eq!(Cast::right_shift("16711680", "16", Some("10"), "hex")?, "0xff");
assert_eq!(Cast::right_shift("0xff0000", "16", None, "hex")?, "0xff");
Source

pub async fn etherscan_source( chain: Chain, contract_address: String, etherscan_api_key: String, ) -> Result<String>

Fetches source code of verified contracts from etherscan.

§Example
assert_eq!(
    "/*
            - Bytecode Verification performed was compared on second iteration -
            This file is part of the DAO.....",
    Cast::etherscan_source(
        NamedChain::Mainnet.into(),
        "0xBB9bc244D798123fDe783fCc1C72d3Bb8C189413".to_string(),
        "<etherscan_api_key>".to_string()
    )
    .await
    .unwrap()
    .as_str()
);
Source

pub async fn expand_etherscan_source_to_directory( chain: Chain, contract_address: String, etherscan_api_key: String, output_directory: PathBuf, ) -> Result<()>

Fetches the source code of verified contracts from etherscan and expands the resulting files to a directory for easy perusal.

§Example
Cast::expand_etherscan_source_to_directory(
    NamedChain::Mainnet.into(),
    "0xBB9bc244D798123fDe783fCc1C72d3Bb8C189413".to_string(),
    "<etherscan_api_key>".to_string(),
    PathBuf::from("output_dir"),
)
.await?;
Source

pub async fn etherscan_source_flatten( chain: Chain, contract_address: String, etherscan_api_key: String, output_path: Option<PathBuf>, ) -> Result<()>

Fetches the source code of verified contracts from etherscan, flattens it and writes it to the given path or stdout.

Source

pub fn disassemble(code: &[u8]) -> Result<String>

Disassembles hex encoded bytecode into individual / human readable opcodes

§Example
use alloy_primitives::hex;
use cast::SimpleCast as Cast;

let bytecode = "0x608060405260043610603f57600035";
let opcodes = Cast::disassemble(&hex::decode(bytecode)?)?;
println!("{}", opcodes);
Source

pub fn get_selector( signature: &str, optimize: usize, ) -> Result<(String, String)>

Gets the selector for a given function signature Optimizes if the optimize parameter is set to a number of leading zeroes

§Example
use cast::SimpleCast as Cast;

assert_eq!(Cast::get_selector("foo(address,uint256)", 0)?.0, String::from("0xbd0d639f"));
Source

pub fn extract_functions(bytecode: &str) -> Result<Vec<(String, String, &str)>>

Extracts function selectors, arguments and state mutability from bytecode

§Example
use cast::SimpleCast as Cast;

let bytecode = "6080604052348015600e575f80fd5b50600436106026575f3560e01c80632125b65b14602a575b5f80fd5b603a6035366004603c565b505050565b005b5f805f60608486031215604d575f80fd5b833563ffffffff81168114605f575f80fd5b925060208401356001600160a01b03811681146079575f80fd5b915060408401356001600160e01b03811681146093575f80fd5b80915050925092509256";
let functions = Cast::extract_functions(bytecode)?;
assert_eq!(functions, vec![("0x2125b65b".to_string(), "uint32,address,uint224".to_string(), "pure")]);
Source

pub fn decode_raw_transaction(tx: &str) -> Result<TxEnvelope>

Decodes a raw EIP2718 transaction payload Returns details about the typed transaction and ECSDA signature components

§Example
use cast::SimpleCast as Cast;

let tx = "0x02f8f582a86a82058d8459682f008508351050808303fd84948e42f2f4101563bf679975178e880fd87d3efd4e80b884659ac74b00000000000000000000000080f0c1c49891dcfdd40b6e0f960f84e6042bcb6f000000000000000000000000b97ef9ef8734c71904d8002f8b6bc66dd9c48a6e00000000000000000000000000000000000000000000000000000000007ff4e20000000000000000000000000000000000000000000000000000000000000064c001a05d429597befe2835396206781b199122f2e8297327ed4a05483339e7a8b2022aa04c23a7f70fb29dda1b4ee342fb10a625e9b8ddc6a603fb4e170d4f6f37700cb8";
let tx_envelope = Cast::decode_raw_transaction(&tx)?;
Source

pub fn decode_eof(eof: &str) -> Result<String>

Decodes EOF container bytes Pretty prints the decoded EOF container contents

§Example
use cast::SimpleCast as Cast;

let eof = "0xef0001010004020001005604002000008000046080806040526004361015e100035f80fd5f3560e01c63773d45e01415e1ffee6040600319360112e10028600435906024358201809211e100066020918152f3634e487b7160e01b5f52601160045260245ffd5f80fd0000000000000000000000000124189fc71496f8660db5189f296055ed757632";
let decoded = Cast::decode_eof(&eof)?;
println!("{}", decoded);

Auto Trait Implementations§

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
§

impl<T, R> CollectAndApply<T, R> for T

§

fn collect_and_apply<I, F>(iter: I, f: F) -> R
where I: Iterator<Item = T>, F: FnOnce(&[T]) -> R,

Equivalent to f(&iter.collect::<Vec<_>>()).

§

type Output = R

§

impl<T> Conv for T

§

fn conv<T>(self) -> T
where Self: Into<T>,

Converts self into T using Into<T>. Read more
§

impl<T> FmtForward for T

§

fn fmt_binary(self) -> FmtBinary<Self>
where Self: Binary,

Causes self to use its Binary implementation when Debug-formatted.
§

fn fmt_display(self) -> FmtDisplay<Self>
where Self: Display,

Causes self to use its Display implementation when Debug-formatted.
§

fn fmt_lower_exp(self) -> FmtLowerExp<Self>
where Self: LowerExp,

Causes self to use its LowerExp implementation when Debug-formatted.
§

fn fmt_lower_hex(self) -> FmtLowerHex<Self>
where Self: LowerHex,

Causes self to use its LowerHex implementation when Debug-formatted.
§

fn fmt_octal(self) -> FmtOctal<Self>
where Self: Octal,

Causes self to use its Octal implementation when Debug-formatted.
§

fn fmt_pointer(self) -> FmtPointer<Self>
where Self: Pointer,

Causes self to use its Pointer implementation when Debug-formatted.
§

fn fmt_upper_exp(self) -> FmtUpperExp<Self>
where Self: UpperExp,

Causes self to use its UpperExp implementation when Debug-formatted.
§

fn fmt_upper_hex(self) -> FmtUpperHex<Self>
where Self: UpperHex,

Causes self to use its UpperHex implementation when Debug-formatted.
§

fn fmt_list(self) -> FmtList<Self>
where &'a Self: for<'a> IntoIterator,

Formats each item in a sequence. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

§

impl<T> Instrument for T

§

fn instrument(self, span: Span) -> Instrumented<Self> ⓘ

Instruments this type with the provided [Span], returning an Instrumented wrapper. Read more
§

fn in_current_span(self) -> Instrumented<Self> ⓘ

Instruments this type with the current Span, returning an Instrumented wrapper. Read more
Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<T> IntoEither for T

Source§

fn into_either(self, into_left: bool) -> Either<Self, Self> ⓘ

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
Source§

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self> ⓘ
where F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
Source§

impl<T> IntoRequest<T> for T

Source§

fn into_request(self) -> Request<T>

Wrap the input message T in a tonic::Request
§

impl<Unshared, Shared> IntoShared<Shared> for Unshared
where Shared: FromUnshared<Unshared>,

§

fn into_shared(self) -> Shared

Creates a shared type from an unshared type.
§

impl<T> Paint for T
where T: ?Sized,

§

fn fg(&self, value: Color) -> Painted<&T>

Returns a styled value derived from self with the foreground set to value.

This method should be used rarely. Instead, prefer to use color-specific builder methods like red() and green(), which have the same functionality but are pithier.

§Example

Set foreground color to white using fg():

use yansi::{Paint, Color};

painted.fg(Color::White);

Set foreground color to white using white().

use yansi::Paint;

painted.white();
§

fn primary(&self) -> Painted<&T>

Returns self with the fg() set to [Color::Primary].

§Example
println!("{}", value.primary());
§

fn fixed(&self, color: u8) -> Painted<&T>

Returns self with the fg() set to [Color::Fixed].

§Example
println!("{}", value.fixed(color));
§

fn rgb(&self, r: u8, g: u8, b: u8) -> Painted<&T>

Returns self with the fg() set to [Color::Rgb].

§Example
println!("{}", value.rgb(r, g, b));
§

fn black(&self) -> Painted<&T>

Returns self with the fg() set to [Color::Black].

§Example
println!("{}", value.black());
§

fn red(&self) -> Painted<&T>

Returns self with the fg() set to [Color::Red].

§Example
println!("{}", value.red());
§

fn green(&self) -> Painted<&T>

Returns self with the fg() set to [Color::Green].

§Example
println!("{}", value.green());
§

fn yellow(&self) -> Painted<&T>

Returns self with the fg() set to [Color::Yellow].

§Example
println!("{}", value.yellow());
§

fn blue(&self) -> Painted<&T>

Returns self with the fg() set to [Color::Blue].

§Example
println!("{}", value.blue());
§

fn magenta(&self) -> Painted<&T>

Returns self with the fg() set to [Color::Magenta].

§Example
println!("{}", value.magenta());
§

fn cyan(&self) -> Painted<&T>

Returns self with the fg() set to [Color::Cyan].

§Example
println!("{}", value.cyan());
§

fn white(&self) -> Painted<&T>

Returns self with the fg() set to [Color::White].

§Example
println!("{}", value.white());
§

fn bright_black(&self) -> Painted<&T>

Returns self with the fg() set to [Color::BrightBlack].

§Example
println!("{}", value.bright_black());
§

fn bright_red(&self) -> Painted<&T>

Returns self with the fg() set to [Color::BrightRed].

§Example
println!("{}", value.bright_red());
§

fn bright_green(&self) -> Painted<&T>

Returns self with the fg() set to [Color::BrightGreen].

§Example
println!("{}", value.bright_green());
§

fn bright_yellow(&self) -> Painted<&T>

Returns self with the fg() set to [Color::BrightYellow].

§Example
println!("{}", value.bright_yellow());
§

fn bright_blue(&self) -> Painted<&T>

Returns self with the fg() set to [Color::BrightBlue].

§Example
println!("{}", value.bright_blue());
§

fn bright_magenta(&self) -> Painted<&T>

Returns self with the fg() set to [Color::BrightMagenta].

§Example
println!("{}", value.bright_magenta());
§

fn bright_cyan(&self) -> Painted<&T>

Returns self with the fg() set to [Color::BrightCyan].

§Example
println!("{}", value.bright_cyan());
§

fn bright_white(&self) -> Painted<&T>

Returns self with the fg() set to [Color::BrightWhite].

§Example
println!("{}", value.bright_white());
§

fn bg(&self, value: Color) -> Painted<&T>

Returns a styled value derived from self with the background set to value.

This method should be used rarely. Instead, prefer to use color-specific builder methods like on_red() and on_green(), which have the same functionality but are pithier.

§Example

Set background color to red using fg():

use yansi::{Paint, Color};

painted.bg(Color::Red);

Set background color to red using on_red().

use yansi::Paint;

painted.on_red();
§

fn on_primary(&self) -> Painted<&T>

Returns self with the bg() set to [Color::Primary].

§Example
println!("{}", value.on_primary());
§

fn on_fixed(&self, color: u8) -> Painted<&T>

Returns self with the bg() set to [Color::Fixed].

§Example
println!("{}", value.on_fixed(color));
§

fn on_rgb(&self, r: u8, g: u8, b: u8) -> Painted<&T>

Returns self with the bg() set to [Color::Rgb].

§Example
println!("{}", value.on_rgb(r, g, b));
§

fn on_black(&self) -> Painted<&T>

Returns self with the bg() set to [Color::Black].

§Example
println!("{}", value.on_black());
§

fn on_red(&self) -> Painted<&T>

Returns self with the bg() set to [Color::Red].

§Example
println!("{}", value.on_red());
§

fn on_green(&self) -> Painted<&T>

Returns self with the bg() set to [Color::Green].

§Example
println!("{}", value.on_green());
§

fn on_yellow(&self) -> Painted<&T>

Returns self with the bg() set to [Color::Yellow].

§Example
println!("{}", value.on_yellow());
§

fn on_blue(&self) -> Painted<&T>

Returns self with the bg() set to [Color::Blue].

§Example
println!("{}", value.on_blue());
§

fn on_magenta(&self) -> Painted<&T>

Returns self with the bg() set to [Color::Magenta].

§Example
println!("{}", value.on_magenta());
§

fn on_cyan(&self) -> Painted<&T>

Returns self with the bg() set to [Color::Cyan].

§Example
println!("{}", value.on_cyan());
§

fn on_white(&self) -> Painted<&T>

Returns self with the bg() set to [Color::White].

§Example
println!("{}", value.on_white());
§

fn on_bright_black(&self) -> Painted<&T>

Returns self with the bg() set to [Color::BrightBlack].

§Example
println!("{}", value.on_bright_black());
§

fn on_bright_red(&self) -> Painted<&T>

Returns self with the bg() set to [Color::BrightRed].

§Example
println!("{}", value.on_bright_red());
§

fn on_bright_green(&self) -> Painted<&T>

Returns self with the bg() set to [Color::BrightGreen].

§Example
println!("{}", value.on_bright_green());
§

fn on_bright_yellow(&self) -> Painted<&T>

Returns self with the bg() set to [Color::BrightYellow].

§Example
println!("{}", value.on_bright_yellow());
§

fn on_bright_blue(&self) -> Painted<&T>

Returns self with the bg() set to [Color::BrightBlue].

§Example
println!("{}", value.on_bright_blue());
§

fn on_bright_magenta(&self) -> Painted<&T>

Returns self with the bg() set to [Color::BrightMagenta].

§Example
println!("{}", value.on_bright_magenta());
§

fn on_bright_cyan(&self) -> Painted<&T>

Returns self with the bg() set to [Color::BrightCyan].

§Example
println!("{}", value.on_bright_cyan());
§

fn on_bright_white(&self) -> Painted<&T>

Returns self with the bg() set to [Color::BrightWhite].

§Example
println!("{}", value.on_bright_white());
§

fn attr(&self, value: Attribute) -> Painted<&T>

Enables the styling [Attribute] value.

This method should be used rarely. Instead, prefer to use attribute-specific builder methods like bold() and underline(), which have the same functionality but are pithier.

§Example

Make text bold using attr():

use yansi::{Paint, Attribute};

painted.attr(Attribute::Bold);

Make text bold using using bold().

use yansi::Paint;

painted.bold();
§

fn bold(&self) -> Painted<&T>

Returns self with the attr() set to [Attribute::Bold].

§Example
println!("{}", value.bold());
§

fn dim(&self) -> Painted<&T>

Returns self with the attr() set to [Attribute::Dim].

§Example
println!("{}", value.dim());
§

fn italic(&self) -> Painted<&T>

Returns self with the attr() set to [Attribute::Italic].

§Example
println!("{}", value.italic());
§

fn underline(&self) -> Painted<&T>

Returns self with the attr() set to [Attribute::Underline].

§Example
println!("{}", value.underline());

Returns self with the attr() set to [Attribute::Blink].

§Example
println!("{}", value.blink());

Returns self with the attr() set to [Attribute::RapidBlink].

§Example
println!("{}", value.rapid_blink());
§

fn invert(&self) -> Painted<&T>

Returns self with the attr() set to [Attribute::Invert].

§Example
println!("{}", value.invert());
§

fn conceal(&self) -> Painted<&T>

Returns self with the attr() set to [Attribute::Conceal].

§Example
println!("{}", value.conceal());
§

fn strike(&self) -> Painted<&T>

Returns self with the attr() set to [Attribute::Strike].

§Example
println!("{}", value.strike());
§

fn quirk(&self, value: Quirk) -> Painted<&T>

Enables the yansi [Quirk] value.

This method should be used rarely. Instead, prefer to use quirk-specific builder methods like mask() and wrap(), which have the same functionality but are pithier.

§Example

Enable wrapping using .quirk():

use yansi::{Paint, Quirk};

painted.quirk(Quirk::Wrap);

Enable wrapping using wrap().

use yansi::Paint;

painted.wrap();
§

fn mask(&self) -> Painted<&T>

Returns self with the quirk() set to [Quirk::Mask].

§Example
println!("{}", value.mask());
§

fn wrap(&self) -> Painted<&T>

Returns self with the quirk() set to [Quirk::Wrap].

§Example
println!("{}", value.wrap());
§

fn linger(&self) -> Painted<&T>

Returns self with the quirk() set to [Quirk::Linger].

§Example
println!("{}", value.linger());
§

fn clear(&self) -> Painted<&T>

👎Deprecated since 1.0.1: renamed to resetting() due to conflicts with Vec::clear(). The clear() method will be removed in a future release.

Returns self with the quirk() set to [Quirk::Clear].

§Example
println!("{}", value.clear());
§

fn resetting(&self) -> Painted<&T>

Returns self with the quirk() set to [Quirk::Resetting].

§Example
println!("{}", value.resetting());
§

fn bright(&self) -> Painted<&T>

Returns self with the quirk() set to [Quirk::Bright].

§Example
println!("{}", value.bright());
§

fn on_bright(&self) -> Painted<&T>

Returns self with the quirk() set to [Quirk::OnBright].

§Example
println!("{}", value.on_bright());
§

fn whenever(&self, value: Condition) -> Painted<&T>

Conditionally enable styling based on whether the [Condition] value applies. Replaces any previous condition.

See the crate level docs for more details.

§Example

Enable styling painted only when both stdout and stderr are TTYs:

use yansi::{Paint, Condition};

painted.red().on_yellow().whenever(Condition::STDOUTERR_ARE_TTY);
§

fn new(self) -> Painted<Self>
where Self: Sized,

Create a new [Painted] with a default [Style]. Read more
§

fn paint<S>(&self, style: S) -> Painted<&Self>
where S: Into<Style>,

Apply a style wholesale to self. Any previous style is replaced. Read more
§

impl<T> Pipe for T
where T: ?Sized,

§

fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> R
where Self: Sized,

Pipes by value. This is generally the method you want to use. Read more
§

fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R
where R: 'a,

Borrows self and passes that borrow into the pipe function. Read more
§

fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> R
where R: 'a,

Mutably borrows self and passes that borrow into the pipe function. Read more
§

fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R
where Self: Borrow<B>, B: 'a + ?Sized, R: 'a,

Borrows self, then passes self.borrow() into the pipe function. Read more
§

fn pipe_borrow_mut<'a, B, R>( &'a mut self, func: impl FnOnce(&'a mut B) -> R, ) -> R
where Self: BorrowMut<B>, B: 'a + ?Sized, R: 'a,

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more
§

fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R
where Self: AsRef<U>, U: 'a + ?Sized, R: 'a,

Borrows self, then passes self.as_ref() into the pipe function.
§

fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R
where Self: AsMut<U>, U: 'a + ?Sized, R: 'a,

Mutably borrows self, then passes self.as_mut() into the pipe function.
§

fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R
where Self: Deref<Target = T>, T: 'a + ?Sized, R: 'a,

Borrows self, then passes self.deref() into the pipe function.
§

fn pipe_deref_mut<'a, T, R>( &'a mut self, func: impl FnOnce(&'a mut T) -> R, ) -> R
where Self: DerefMut<Target = T> + Deref, T: 'a + ?Sized, R: 'a,

Mutably borrows self, then passes self.deref_mut() into the pipe function.
§

impl<T> Pointable for T

§

const ALIGN: usize = _

The alignment of pointer.
§

type Init = T

The type for initializers.
§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
Source§

impl<T> Same for T

Source§

type Output = T

Should always be Self
§

impl<T> Tap for T

§

fn tap(self, func: impl FnOnce(&Self)) -> Self

Immutable access to a value. Read more
§

fn tap_mut(self, func: impl FnOnce(&mut Self)) -> Self

Mutable access to a value. Read more
§

fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self
where Self: Borrow<B>, B: ?Sized,

Immutable access to the Borrow<B> of a value. Read more
§

fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self
where Self: BorrowMut<B>, B: ?Sized,

Mutable access to the BorrowMut<B> of a value. Read more
§

fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self
where Self: AsRef<R>, R: ?Sized,

Immutable access to the AsRef<R> view of a value. Read more
§

fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self
where Self: AsMut<R>, R: ?Sized,

Mutable access to the AsMut<R> view of a value. Read more
§

fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self
where Self: Deref<Target = T>, T: ?Sized,

Immutable access to the Deref::Target of a value. Read more
§

fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self
where Self: DerefMut<Target = T> + Deref, T: ?Sized,

Mutable access to the Deref::Target of a value. Read more
§

fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self

Calls .tap() only in debug builds, and is erased in release builds.
§

fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self

Calls .tap_mut() only in debug builds, and is erased in release builds.
§

fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self
where Self: Borrow<B>, B: ?Sized,

Calls .tap_borrow() only in debug builds, and is erased in release builds.
§

fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self
where Self: BorrowMut<B>, B: ?Sized,

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds.
§

fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self
where Self: AsRef<R>, R: ?Sized,

Calls .tap_ref() only in debug builds, and is erased in release builds.
§

fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self
where Self: AsMut<R>, R: ?Sized,

Calls .tap_ref_mut() only in debug builds, and is erased in release builds.
§

fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self
where Self: Deref<Target = T>, T: ?Sized,

Calls .tap_deref() only in debug builds, and is erased in release builds.
§

fn tap_deref_mut_dbg<T>(self, func: impl FnOnce(&mut T)) -> Self
where Self: DerefMut<Target = T> + Deref, T: ?Sized,

Calls .tap_deref_mut() only in debug builds, and is erased in release builds.
§

impl<T> TryConv for T

§

fn try_conv<T>(self) -> Result<T, Self::Error>
where Self: TryInto<T>,

Attempts to convert self into T using TryInto<T>. Read more
Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

§

fn vzip(self) -> V

§

impl<T> WithSubscriber for T

§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self> ⓘ
where S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a [WithDispatch] wrapper. Read more
§

fn with_current_subscriber(self) -> WithDispatch<Self> ⓘ

Attaches the current default Subscriber to this type, returning a [WithDispatch] wrapper. Read more
§

impl<T> ErasedDestructor for T
where T: 'static,

§

impl<T> MaybeSendSync for T

Layout§

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 0 bytes