Struct soroban_sdk::Env

impl Env

pub fn storage(&self) -> Storage

Get a Storage for accessing and updating persistent data owned by the currently executing contract.

pub fn events(&self) -> Events

Get Events for publishing events associated with the currently executing contract.

pub fn ledger(&self) -> Ledger

Get a Ledger for accessing the current ledger.

pub fn deployer(&self) -> Deployer

Get a deployer for deploying contracts.

pub fn crypto(&self) -> Crypto

Get a Crypto for accessing the current cryptographic functions.

pub fn prng(&self) -> Prng

Get a Prng for accessing the current functions which provide pseudo-randomness.

§Warning

The pseudo-random generator returned is not suitable for security-sensitive work.

pub fn current_contract_address(&self) -> Address

Get the Address object corresponding to the current executing contract.

pub fn invoke_contract<T>( &self, contract_address: &Address, func: &Symbol, args: Vec<Val> ) -> T
where T: TryFromVal<Env, Val>,

Invokes a function of a contract that is registered in the Env.

§Panics

Will panic if the contract_id does not match a registered contract, func does not match a function of the referenced contract, or the number of args do not match the argument count of the referenced contract function.

Will panic if the contract that is invoked fails or aborts in anyway.

Will panic if the value returned from the contract cannot be converted into the type T.

pub fn try_invoke_contract<T, E>( &self, contract_address: &Address, func: &Symbol, args: Vec<Val> ) -> Result<Result<T, T::Error>, Result<E, InvokeError>>
where T: TryFromVal<Env, Val>, E: TryFrom<Error>, E::Error: Into<InvokeError>,

Invokes a function of a contract that is registered in the Env, returns an error if the invocation fails for any reason.

pub fn authorize_as_current_contract( &self, auth_entries: Vec<InvokerContractAuthEntry> )

Authorizes sub-contract calls on behalf of the current contract.

All the direct calls that the current contract performs are always considered to have been authorized. This is only needed to authorize deeper calls that originate from the next contract call from the current contract.

For example, if the contract A calls contract B, contract B calls contract C and contract C calls A.require_auth(), then an entry corresponding to C call has to be passed in auth_entries. It doesn’t matter if contract B called require_auth or not. If contract A calls contract B again, then authorize_as_current_contract has to be called again with the respective entries.

pub fn logs(&self) -> Logs

Get the Logs for logging debug events.

impl Env

pub fn new_with_config(config: EnvTestConfig) -> Env

Available on crate feature testutils only.

pub fn register_contract<'a, T: ContractFunctionSet + 'static>( &self, contract_id: impl Into<Option<&'a Address>>, contract: T ) -> Address

Available on crate feature testutils only.

Register a contract with the Env for testing.

Passing a contract ID for the first arguments registers the contract with that contract ID. Providing None causes the Env to generate a new contract ID that is assigned to the contract.

Registering a contract that is already registered replaces it.

Returns the contract ID of the registered contract.

§Examples

use soroban_sdk::{contract, contractimpl, BytesN, Env, Symbol};

#[contract]
pub struct HelloContract;

#[contractimpl]
impl HelloContract {
    pub fn hello(env: Env, recipient: Symbol) -> Symbol {
        todo!()
    }
}

#[test]
fn test() {
    let env = Env::default();
    let contract_id = env.register_contract(None, HelloContract);
}

pub fn register_contract_wasm<'a>( &self, contract_id: impl Into<Option<&'a Address>>, contract_wasm: impl IntoVal<Env, Bytes> ) -> Address

Available on crate feature testutils only.

Register a contract in a WASM file with the Env for testing.

Passing a contract ID for the first arguments registers the contract with that contract ID. Providing None causes the Env to generate a new contract ID that is assigned to the contract.

Registering a contract that is already registered replaces it.

Returns the contract ID of the registered contract.

§Examples

use soroban_sdk::{BytesN, Env};

const WASM: &[u8] = include_bytes!("../doctest_fixtures/contract.wasm");

#[test]
fn test() {
    let env = Env::default();
    env.register_contract_wasm(None, WASM);
}

pub fn register_stellar_asset_contract(&self, admin: Address) -> Address

Available on crate feature testutils only.

Register the built-in Stellar Asset Contract with provided admin address.

Returns the contract ID of the registered token contract.

The contract will wrap a randomly-generated Stellar asset. This function is useful for using in the tests when an arbitrary token contract instance is needed.

pub fn set_auths(&self, auths: &[SorobanAuthorizationEntry])

Available on crate feature testutils only.

Set authorizations and signatures in the environment which will be consumed by contracts when they invoke Address::require_auth or Address::require_auth_for_args functions.

Requires valid signatures for the authorization to be successful.

This function can also be called on contract clients.

To mock auth for testing, without requiring valid signatures, use mock_all_auths or mock_auths. If mocking of auths is enabled, calling set_auths disables any mocking.

pub fn mock_auths(&self, auths: &[MockAuth<'_>])

Available on crate feature testutils only.

Mock authorizations in the environment which will cause matching invokes of Address::require_auth and Address::require_auth_for_args to pass.

This function can also be called on contract clients.

Authorizations not matching a mocked auth will fail.

To mock all auths, use mock_all_auths.

§Examples

use soroban_sdk::{contract, contractimpl, Env, Address, testutils::{Address as _, MockAuth, MockAuthInvoke}, IntoVal};

#[contract]
pub struct HelloContract;

#[contractimpl]
impl HelloContract {
    pub fn hello(env: Env, from: Address) {
        from.require_auth();
        // TODO
    }
}

#[test]
fn test() {
    let env = Env::default();
    let contract_id = env.register_contract(None, HelloContract);

    let client = HelloContractClient::new(&env, &contract_id);
    let addr = Address::generate(&env);
    client.mock_auths(&[
        MockAuth {
            address: &addr,
            invoke: &MockAuthInvoke {
                contract: &contract_id,
                fn_name: "hello",
                args: (&addr,).into_val(&env),
                sub_invokes: &[],
            },
        },
    ]).hello(&addr);
}

pub fn mock_all_auths(&self)

Available on crate feature testutils only.

Mock all calls to the Address::require_auth and Address::require_auth_for_args functions in invoked contracts, having them succeed as if authorization was provided.

When mocking is enabled, if the Address being authorized is the address of a contract, that contract’s __check_auth function will not be called, and the contract does not need to exist or be registered in the test.

When mocking is enabled, if the Address being authorized is the address of an account, the account does not need to exist.

This function can also be called on contract clients.

To disable mocking, see set_auths.

To access a list of auths that have occurred, see auths.

It is not currently possible to mock a subset of auths.

§Examples

use soroban_sdk::{contract, contractimpl, Env, Address, testutils::Address as _};

#[contract]
pub struct HelloContract;

#[contractimpl]
impl HelloContract {
    pub fn hello(env: Env, from: Address) {
        from.require_auth();
        // TODO
    }
}

#[test]
fn test() {
    let env = Env::default();
    let contract_id = env.register_contract(None, HelloContract);

    env.mock_all_auths();

    let client = HelloContractClient::new(&env, &contract_id);
    let addr = Address::generate(&env);
    client.hello(&addr);
}

pub fn mock_all_auths_allowing_non_root_auth(&self)

Available on crate feature testutils only.

A version of mock_all_auths that allows authorizations that are not present in the root invocation.

Refer to mock_all_auths documentation for general information and prefer using mock_all_auths unless non-root authorization is required.

The only difference from mock_all_auths is that this won’t return an error when require_auth hasn’t been called in the root invocation for any given address. This is useful to test contracts that bundle calls to another contract without atomicity requirements (i.e. any contract call can be frontrun).

§Examples

use soroban_sdk::{contract, contractimpl, Env, Address, testutils::Address as _};

#[contract]
pub struct ContractA;

#[contractimpl]
impl ContractA {
    pub fn do_auth(env: Env, addr: Address) {
        addr.require_auth();
    }
}
#[contract]
pub struct ContractB;

#[contractimpl]
impl ContractB {
    pub fn call_a(env: Env, contract_a: Address, addr: Address) {
        // Notice there is no `require_auth` call here.
        ContractAClient::new(&env, &contract_a).do_auth(&addr);
    }
}
#[test]
fn test() {
    let env = Env::default();
    let contract_a = env.register_contract(None, ContractA);
    let contract_b = env.register_contract(None, ContractB);
    // The regular `env.mock_all_auths()` would result in the call
    // failure.
    env.mock_all_auths_allowing_non_root_auth();

    let client = ContractBClient::new(&env, &contract_b);
    let addr = Address::generate(&env);
    client.call_a(&contract_a, &addr);
}

pub fn auths(&self) -> Vec<(Address, AuthorizedInvocation)>

Available on crate feature testutils only.

Returns a list of authorization trees that were seen during the last contract or authorized host function invocation.

Use this in tests to verify that the expected authorizations with the expected arguments are required.

The return value is a vector of authorizations represented by tuples of (address, AuthorizedInvocation). AuthorizedInvocation describes the tree of require_auth_for_args(address, args) from the contract functions (or require_auth with all the arguments of the function invocation). It also might contain the authorized host functions ( currently CreateContract is the only such function) in case if corresponding host functions have been called.

Refer to documentation for AuthorizedInvocation for detailed information on its contents.

The order of the returned vector is defined by the order of Address::require_auth calls. Repeated calls to Address::require_auth with the same address and args in the same tree of contract invocations will appear only once in the vector.

§Examples

use soroban_sdk::{contract, contractimpl, testutils::{Address as _, AuthorizedFunction, AuthorizedInvocation}, symbol_short, Address, Symbol, Env, IntoVal};

#[contract]
pub struct Contract;

#[contractimpl]
impl Contract {
    pub fn transfer(env: Env, address: Address, amount: i128) {
        address.require_auth();
    }
    pub fn transfer2(env: Env, address: Address, amount: i128) {
        address.require_auth_for_args((amount / 2,).into_val(&env));
    }
}

#[test]
fn test() {
    extern crate std;
    let env = Env::default();
    let contract_id = env.register_contract(None, Contract);
    let client = ContractClient::new(&env, &contract_id);
    env.mock_all_auths();
    let address = Address::generate(&env);
    client.transfer(&address, &1000_i128);
    assert_eq!(
        env.auths(),
        std::vec![(
            address.clone(),
            AuthorizedInvocation {
                function: AuthorizedFunction::Contract((
                    client.address.clone(),
                    symbol_short!("transfer"),
                    (&address, 1000_i128,).into_val(&env)
                )),
                sub_invocations: std::vec![]
            }
        )]
    );

    client.transfer2(&address, &1000_i128);
    assert_eq!(
        env.auths(),
       std::vec![(
            address.clone(),
            AuthorizedInvocation {
                function: AuthorizedFunction::Contract((
                    client.address.clone(),
                    symbol_short!("transfer2"),
                    // `transfer2` requires auth for (amount / 2) == (1000 / 2) == 500.
                    (500_i128,).into_val(&env)
                )),
                sub_invocations: std::vec![]
            }
        )]
    );
}

pub fn try_invoke_contract_check_auth<E>( &self, contract: &Address, signature_payload: &BytesN<32>, signature: Val, auth_context: &Vec<Context> ) -> Result<(), Result<E, InvokeError>>
where E: TryFrom<Error>, E::Error: Into<InvokeError>,

Available on crate feature testutils only.

Invokes the special __check_auth function of contracts that implement the custom account interface.

__check_auth can’t be called outside of the host-managed require_auth calls. This test utility allows testing custom account contracts without the need to setup complex contract call trees and enabling the enforcing auth on the host side.

This function requires to provide the template argument for error. Use soroban_sdk::Error if __check_auth doesn’t return a special contract error and use the error with contracterror attribute otherwise.

§Examples

use soroban_sdk::{contract, contracterror, contractimpl, testutils::{Address as _, BytesN as _}, vec, auth::Context, BytesN, Env, Vec, Val};

#[contracterror]
#[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd, Ord)]
#[repr(u32)]
pub enum NoopAccountError {
    SomeError = 1,
}
#[contract]
struct NoopAccountContract;
#[contractimpl]
impl NoopAccountContract {

    #[allow(non_snake_case)]
    pub fn __check_auth(
        _env: Env,
        _signature_payload: BytesN<32>,
        signature: Val,
        _auth_context: Vec<Context>,
    ) -> Result<(), NoopAccountError> {
        if signature.is_void() {
            Err(NoopAccountError::SomeError)
        } else {
            Ok(())
        }
    }
}
#[test]
fn test() {
    let e: Env = Default::default();
    let account_contract = NoopAccountContractClient::new(&e, &e.register_contract(None, NoopAccountContract));
    // Non-succesful call of `__check_auth` with a `contracterror` error.
    assert_eq!(
        e.try_invoke_contract_check_auth::<NoopAccountError>(
            &account_contract.address,
            &BytesN::from_array(&e, &[0; 32]),
            ().into(),
            &vec![&e],
        ),
        // The inner `Result` is for conversion error and will be Ok
        // as long as a valid error type used.
        Err(Ok(NoopAccountError::SomeError))
    );
    // Successful call of `__check_auth` with a `soroban_sdk::InvokeError`
    // error - this should be compatible with any error type.
    assert_eq!(
        e.try_invoke_contract_check_auth::<soroban_sdk::InvokeError>(
            &account_contract.address,
            &BytesN::from_array(&e, &[0; 32]),
            0_i32.into(),
            &vec![&e],
        ),
        Ok(())
    );
}

pub fn as_contract<T>(&self, id: &Address, f: impl FnOnce() -> T) -> T

Available on crate feature testutils only.

Run the function as if executed by the given contract ID.

Used to write or read contract data, or take other actions in tests for setting up tests or asserting on internal state.

pub fn from_snapshot(s: Snapshot) -> Env

Available on crate feature testutils only.

Creates a new Env loaded with the Snapshot.

The ledger info and state in the snapshot are loaded into the Env.

Events, as an output source only, are not loaded into the Env.

pub fn from_snapshot_file(p: impl AsRef<Path>) -> Env

Available on crate feature testutils only.

Creates a new Env loaded with the ledger snapshot loaded from the file.

The ledger info and state in the snapshot are loaded into the Env.

Events, as an output source only, are not loaded into the Env.

§Panics

If there is any error reading the file.

pub fn to_snapshot(&self) -> Snapshot

Available on crate feature testutils only.

Create a snapshot from the Env’s current state.

pub fn to_snapshot_file(&self, p: impl AsRef<Path>)

Available on crate feature testutils only.

Create a snapshot file from the Env’s current state.

§Panics

If there is any error writing the file.

pub fn from_ledger_snapshot(s: LedgerSnapshot) -> Env

Available on crate feature testutils only.

Creates a new Env loaded with the LedgerSnapshot.

The ledger info and state in the snapshot are loaded into the Env.

pub fn from_ledger_snapshot_file(p: impl AsRef<Path>) -> Env

Available on crate feature testutils only.

Creates a new Env loaded with the ledger snapshot loaded from the file.

§Panics

If there is any error reading the file.

pub fn to_ledger_snapshot(&self) -> LedgerSnapshot

Available on crate feature testutils only.

Create a snapshot from the Env’s current state.

pub fn to_ledger_snapshot_file(&self, p: impl AsRef<Path>)

Available on crate feature testutils only.

Create a snapshot file from the Env’s current state.

§Panics

If there is any error writing the file.

pub fn budget(&self) -> Budget

Available on crate feature testutils only.

Get the budget that tracks the resources consumed for the environment.

Trait Implementations§

impl Clone for Env

fn clone(&self) -> Env

Returns a copy of the value. Read more

1.0.0 · source§

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

Performs copy-assignment from source. Read more

impl Default for Env

fn default() -> Self

Returns the “default value” for a type. Read more

impl Drop for Env

fn drop(&mut self)

Executes the destructor for this type. Read more

impl<T0, T1> TryFromVal<Env, (T0, T1)> for Vec<Val>
where T0: IntoVal<Env, Val>, T1: IntoVal<Env, Val>,

type Error = ConversionError

fn try_from_val(env: &Env, v: &(T0, T1)) -> Result<Self, Self::Error>

impl<T0, T1, T2> TryFromVal<Env, (T0, T1, T2)> for Vec<Val>
where T0: IntoVal<Env, Val>, T1: IntoVal<Env, Val>, T2: IntoVal<Env, Val>,

type Error = ConversionError

fn try_from_val(env: &Env, v: &(T0, T1, T2)) -> Result<Self, Self::Error>

impl<T0, T1, T2, T3> TryFromVal<Env, (T0, T1, T2, T3)> for Vec<Val>
where T0: IntoVal<Env, Val>, T1: IntoVal<Env, Val>, T2: IntoVal<Env, Val>, T3: IntoVal<Env, Val>,

type Error = ConversionError

fn try_from_val(env: &Env, v: &(T0, T1, T2, T3)) -> Result<Self, Self::Error>

impl<T0, T1, T2, T3, T4> TryFromVal<Env, (T0, T1, T2, T3, T4)> for Vec<Val>
where T0: IntoVal<Env, Val>, T1: IntoVal<Env, Val>, T2: IntoVal<Env, Val>, T3: IntoVal<Env, Val>, T4: IntoVal<Env, Val>,

type Error = ConversionError

fn try_from_val( env: &Env, v: &(T0, T1, T2, T3, T4) ) -> Result<Self, Self::Error>

impl<T0, T1, T2, T3, T4, T5> TryFromVal<Env, (T0, T1, T2, T3, T4, T5)> for Vec<Val>
where T0: IntoVal<Env, Val>, T1: IntoVal<Env, Val>, T2: IntoVal<Env, Val>, T3: IntoVal<Env, Val>, T4: IntoVal<Env, Val>, T5: IntoVal<Env, Val>,

type Error = ConversionError

fn try_from_val( env: &Env, v: &(T0, T1, T2, T3, T4, T5) ) -> Result<Self, Self::Error>

impl<T0, T1, T2, T3, T4, T5, T6> TryFromVal<Env, (T0, T1, T2, T3, T4, T5, T6)> for Vec<Val>
where T0: IntoVal<Env, Val>, T1: IntoVal<Env, Val>, T2: IntoVal<Env, Val>, T3: IntoVal<Env, Val>, T4: IntoVal<Env, Val>, T5: IntoVal<Env, Val>, T6: IntoVal<Env, Val>,

type Error = ConversionError

fn try_from_val( env: &Env, v: &(T0, T1, T2, T3, T4, T5, T6) ) -> Result<Self, Self::Error>

impl<T0, T1, T2, T3, T4, T5, T6, T7> TryFromVal<Env, (T0, T1, T2, T3, T4, T5, T6, T7)> for Vec<Val>
where T0: IntoVal<Env, Val>, T1: IntoVal<Env, Val>, T2: IntoVal<Env, Val>, T3: IntoVal<Env, Val>, T4: IntoVal<Env, Val>, T5: IntoVal<Env, Val>, T6: IntoVal<Env, Val>, T7: IntoVal<Env, Val>,

type Error = ConversionError

fn try_from_val( env: &Env, v: &(T0, T1, T2, T3, T4, T5, T6, T7) ) -> Result<Self, Self::Error>

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> TryFromVal<Env, (T0, T1, T2, T3, T4, T5, T6, T7, T8)> for Vec<Val>
where T0: IntoVal<Env, Val>, T1: IntoVal<Env, Val>, T2: IntoVal<Env, Val>, T3: IntoVal<Env, Val>, T4: IntoVal<Env, Val>, T5: IntoVal<Env, Val>, T6: IntoVal<Env, Val>, T7: IntoVal<Env, Val>, T8: IntoVal<Env, Val>,

type Error = ConversionError

fn try_from_val( env: &Env, v: &(T0, T1, T2, T3, T4, T5, T6, T7, T8) ) -> Result<Self, Self::Error>

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> TryFromVal<Env, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)> for Vec<Val>
where T0: IntoVal<Env, Val>, T1: IntoVal<Env, Val>, T2: IntoVal<Env, Val>, T3: IntoVal<Env, Val>, T4: IntoVal<Env, Val>, T5: IntoVal<Env, Val>, T6: IntoVal<Env, Val>, T7: IntoVal<Env, Val>, T8: IntoVal<Env, Val>, T9: IntoVal<Env, Val>,

type Error = ConversionError

fn try_from_val( env: &Env, v: &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) ) -> Result<Self, Self::Error>

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> TryFromVal<Env, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> for Vec<Val>
where T0: IntoVal<Env, Val>, T1: IntoVal<Env, Val>, T2: IntoVal<Env, Val>, T3: IntoVal<Env, Val>, T4: IntoVal<Env, Val>, T5: IntoVal<Env, Val>, T6: IntoVal<Env, Val>, T7: IntoVal<Env, Val>, T8: IntoVal<Env, Val>, T9: IntoVal<Env, Val>, T10: IntoVal<Env, Val>,

type Error = ConversionError

fn try_from_val( env: &Env, v: &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) ) -> Result<Self, Self::Error>

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> TryFromVal<Env, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)> for Vec<Val>
where T0: IntoVal<Env, Val>, T1: IntoVal<Env, Val>, T2: IntoVal<Env, Val>, T3: IntoVal<Env, Val>, T4: IntoVal<Env, Val>, T5: IntoVal<Env, Val>, T6: IntoVal<Env, Val>, T7: IntoVal<Env, Val>, T8: IntoVal<Env, Val>, T9: IntoVal<Env, Val>, T10: IntoVal<Env, Val>, T11: IntoVal<Env, Val>,

type Error = ConversionError

fn try_from_val( env: &Env, v: &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) ) -> Result<Self, Self::Error>

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> TryFromVal<Env, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)> for Vec<Val>
where T0: IntoVal<Env, Val>, T1: IntoVal<Env, Val>, T2: IntoVal<Env, Val>, T3: IntoVal<Env, Val>, T4: IntoVal<Env, Val>, T5: IntoVal<Env, Val>, T6: IntoVal<Env, Val>, T7: IntoVal<Env, Val>, T8: IntoVal<Env, Val>, T9: IntoVal<Env, Val>, T10: IntoVal<Env, Val>, T11: IntoVal<Env, Val>, T12: IntoVal<Env, Val>,

type Error = ConversionError

fn try_from_val( env: &Env, v: &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) ) -> Result<Self, Self::Error>

impl TryFromVal<Env, Address> for Val

type Error = ConversionError

fn try_from_val(_env: &Env, v: &Address) -> Result<Self, Self::Error>

impl TryFromVal<Env, AddressObject> for Address

type Error = Infallible

fn try_from_val(env: &Env, val: &AddressObject) -> Result<Self, Self::Error>

impl TryFromVal<Env, Bytes> for Bytes

type Error = ConversionError

fn try_from_val(_env: &Env, v: &Bytes) -> Result<Self, Self::Error>

impl TryFromVal<Env, Bytes> for Val

type Error = ConversionError

fn try_from_val(_env: &Env, v: &Bytes) -> Result<Self, Self::Error>

impl<const N: usize> TryFromVal<Env, BytesN<N>> for [u8; N]

type Error = ConversionError

fn try_from_val(_env: &Env, v: &BytesN<N>) -> Result<Self, Self::Error>

impl<const N: usize> TryFromVal<Env, BytesN<N>> for Bytes

type Error = ConversionError

fn try_from_val(_env: &Env, v: &BytesN<N>) -> Result<Self, Self::Error>

impl<const N: usize> TryFromVal<Env, BytesN<N>> for BytesN<N>

type Error = ConversionError

fn try_from_val(_env: &Env, v: &BytesN<N>) -> Result<Self, Self::Error>

impl<const N: usize> TryFromVal<Env, BytesN<N>> for Val

type Error = ConversionError

fn try_from_val(_env: &Env, v: &BytesN<N>) -> Result<Self, Self::Error>

impl TryFromVal<Env, BytesObject> for Bytes

type Error = Infallible

fn try_from_val(env: &Env, val: &BytesObject) -> Result<Self, Self::Error>

impl<const N: usize> TryFromVal<Env, BytesObject> for BytesN<N>

type Error = ConversionError

fn try_from_val(env: &Env, obj: &BytesObject) -> Result<Self, Self::Error>

impl TryFromVal<Env, Context> for Val

type Error = ConversionError

fn try_from_val(env: &Env, val: &Context) -> Result<Self, ConversionError>

impl TryFromVal<Env, ContractContext> for Val

type Error = ConversionError

fn try_from_val( env: &Env, val: &ContractContext ) -> Result<Self, ConversionError>

impl TryFromVal<Env, ContractExecutable> for Val

type Error = ConversionError

fn try_from_val( env: &Env, val: &ContractExecutable ) -> Result<Self, ConversionError>

impl TryFromVal<Env, CreateContractHostFnContext> for Val

type Error = ConversionError

fn try_from_val( env: &Env, val: &CreateContractHostFnContext ) -> Result<Self, ConversionError>

impl TryFromVal<Env, Duration> for Val

type Error = ConversionError

fn try_from_val(_env: &Env, v: &Duration) -> Result<Self, Self::Error>

impl TryFromVal<Env, DurationVal> for Duration

type Error = Infallible

fn try_from_val(env: &Env, val: &DurationVal) -> Result<Self, Self::Error>

impl TryFromVal<Env, Error> for Error

type Error = ConversionError

fn try_from_val(_env: &Env, v: &Error) -> Result<Self, Self::Error>

impl TryFromVal<Env, I256> for Val

type Error = ConversionError

fn try_from_val(_env: &Env, v: &I256) -> Result<Self, Self::Error>

impl TryFromVal<Env, I256Val> for I256

type Error = Infallible

fn try_from_val(env: &Env, val: &I256Val) -> Result<Self, Self::Error>

impl TryFromVal<Env, InvokerContractAuthEntry> for Val

type Error = ConversionError

fn try_from_val( env: &Env, val: &InvokerContractAuthEntry ) -> Result<Self, ConversionError>

impl<K, V> TryFromVal<Env, Map<K, V>> for ScVal

type Error = ConversionError

fn try_from_val(_e: &Env, v: &Map<K, V>) -> Result<Self, ConversionError>

impl<K, V> TryFromVal<Env, Map<K, V>> for Val
where K: IntoVal<Env, Val> + TryFromVal<Env, Val>, V: IntoVal<Env, Val> + TryFromVal<Env, Val>,

type Error = Infallible

fn try_from_val(_env: &Env, v: &Map<K, V>) -> Result<Self, Self::Error>

impl<K, V> TryFromVal<Env, MapObject> for Map<K, V>
where K: IntoVal<Env, Val> + TryFromVal<Env, Val>, V: IntoVal<Env, Val> + TryFromVal<Env, Val>,

type Error = Infallible

fn try_from_val(env: &Env, obj: &MapObject) -> Result<Self, Self::Error>

impl TryFromVal<Env, ScAddress> for Address

type Error = ConversionError

fn try_from_val(env: &Env, val: &ScAddress) -> Result<Self, Self::Error>

impl TryFromVal<Env, ScMap> for ContractContext

type Error = Error

fn try_from_val(env: &Env, val: &ScMap) -> Result<Self, Error>

impl TryFromVal<Env, ScMap> for CreateContractHostFnContext

type Error = Error

fn try_from_val(env: &Env, val: &ScMap) -> Result<Self, Error>

impl TryFromVal<Env, ScMap> for SubContractInvocation

type Error = Error

fn try_from_val(env: &Env, val: &ScMap) -> Result<Self, Error>

impl TryFromVal<Env, ScSymbol> for Symbol

type Error = ConversionError

fn try_from_val(env: &Env, val: &ScSymbol) -> Result<Self, Self::Error>

impl TryFromVal<Env, ScVal> for Address

type Error = ConversionError

fn try_from_val(env: &Env, val: &ScVal) -> Result<Self, Self::Error>

impl TryFromVal<Env, ScVal> for Bytes

type Error = ConversionError

fn try_from_val(env: &Env, val: &ScVal) -> Result<Self, Self::Error>

impl<const N: usize> TryFromVal<Env, ScVal> for BytesN<N>

type Error = ConversionError

fn try_from_val(env: &Env, val: &ScVal) -> Result<Self, Self::Error>

impl TryFromVal<Env, ScVal> for Context

type Error = Error

fn try_from_val(env: &Env, val: &ScVal) -> Result<Self, Error>

impl TryFromVal<Env, ScVal> for ContractContext

type Error = Error

fn try_from_val(env: &Env, val: &ScVal) -> Result<Self, Error>

impl TryFromVal<Env, ScVal> for ContractExecutable

type Error = Error

fn try_from_val(env: &Env, val: &ScVal) -> Result<Self, Error>

impl TryFromVal<Env, ScVal> for CreateContractHostFnContext

type Error = Error

fn try_from_val(env: &Env, val: &ScVal) -> Result<Self, Error>

impl TryFromVal<Env, ScVal> for Duration

type Error = ConversionError

fn try_from_val(env: &Env, val: &ScVal) -> Result<Self, Self::Error>

impl TryFromVal<Env, ScVal> for I256

type Error = ConversionError

fn try_from_val(env: &Env, val: &ScVal) -> Result<Self, Self::Error>

impl TryFromVal<Env, ScVal> for InvokerContractAuthEntry

type Error = Error

fn try_from_val(env: &Env, val: &ScVal) -> Result<Self, Error>

impl<K, V> TryFromVal<Env, ScVal> for Map<K, V>
where K: IntoVal<Env, Val> + TryFromVal<Env, Val>, V: IntoVal<Env, Val> + TryFromVal<Env, Val>,

type Error = ConversionError

fn try_from_val(env: &Env, val: &ScVal) -> Result<Self, Self::Error>

impl TryFromVal<Env, ScVal> for String

type Error = ConversionError

fn try_from_val(env: &Env, val: &ScVal) -> Result<Self, Self::Error>

impl TryFromVal<Env, ScVal> for SubContractInvocation

type Error = Error

fn try_from_val(env: &Env, val: &ScVal) -> Result<Self, Error>

impl TryFromVal<Env, ScVal> for Symbol

type Error = ConversionError

fn try_from_val(env: &Env, val: &ScVal) -> Result<Self, Self::Error>

impl TryFromVal<Env, ScVal> for Timepoint

type Error = ConversionError

fn try_from_val(env: &Env, val: &ScVal) -> Result<Self, Self::Error>

impl TryFromVal<Env, ScVal> for U256

type Error = ConversionError

fn try_from_val(env: &Env, val: &ScVal) -> Result<Self, Self::Error>

impl<T> TryFromVal<Env, ScVal> for Vec<T>
where T: IntoVal<Env, Val> + TryFromVal<Env, Val>,

type Error = ConversionError

fn try_from_val(env: &Env, val: &ScVal) -> Result<Self, ConversionError>

impl TryFromVal<Env, ScVec> for Context

type Error = Error

fn try_from_val(env: &Env, val: &ScVec) -> Result<Self, Error>

impl TryFromVal<Env, ScVec> for ContractExecutable

type Error = Error

fn try_from_val(env: &Env, val: &ScVec) -> Result<Self, Error>

impl TryFromVal<Env, ScVec> for InvokerContractAuthEntry

type Error = Error

fn try_from_val(env: &Env, val: &ScVec) -> Result<Self, Error>

impl<T> TryFromVal<Env, ScVec> for Vec<T>
where T: IntoVal<Env, Val> + TryFromVal<Env, Val>,

type Error = ConversionError

fn try_from_val(env: &Env, val: &ScVec) -> Result<Self, Self::Error>

impl TryFromVal<Env, String> for String

type Error = ConversionError

fn try_from_val(_env: &Env, v: &String) -> Result<Self, Self::Error>

impl TryFromVal<Env, String> for Val

type Error = ConversionError

fn try_from_val(_env: &Env, v: &String) -> Result<Self, Self::Error>

impl TryFromVal<Env, StringObject> for String

type Error = Infallible

fn try_from_val(env: &Env, val: &StringObject) -> Result<Self, Self::Error>

impl TryFromVal<Env, SubContractInvocation> for Val

type Error = ConversionError

fn try_from_val( env: &Env, val: &SubContractInvocation ) -> Result<Self, ConversionError>

impl TryFromVal<Env, Symbol> for ScVal

type Error = ConversionError

fn try_from_val(_e: &Env, v: &Symbol) -> Result<Self, ConversionError>

impl TryFromVal<Env, Symbol> for Symbol

type Error = Infallible

fn try_from_val(env: &Env, val: &SymbolVal) -> Result<Self, Self::Error>

impl TryFromVal<Env, Symbol> for Val

type Error = ConversionError

fn try_from_val(_env: &Env, v: &Symbol) -> Result<Self, Self::Error>

impl TryFromVal<Env, Timepoint> for Val

type Error = ConversionError

fn try_from_val(_env: &Env, v: &Timepoint) -> Result<Self, Self::Error>

impl TryFromVal<Env, TimepointVal> for Timepoint

type Error = Infallible

fn try_from_val(env: &Env, val: &TimepointVal) -> Result<Self, Self::Error>

impl TryFromVal<Env, U256> for Val

type Error = ConversionError

fn try_from_val(_env: &Env, v: &U256) -> Result<Self, Self::Error>

impl TryFromVal<Env, U256Val> for U256

type Error = Infallible

fn try_from_val(env: &Env, val: &U256Val) -> Result<Self, Self::Error>

impl TryFromVal<Env, Val> for Address

type Error = ConversionError

fn try_from_val(env: &Env, val: &Val) -> Result<Self, Self::Error>

impl TryFromVal<Env, Val> for Bytes

type Error = ConversionError

fn try_from_val(env: &Env, val: &Val) -> Result<Self, Self::Error>

impl<const N: usize> TryFromVal<Env, Val> for BytesN<N>

type Error = ConversionError

fn try_from_val(env: &Env, val: &Val) -> Result<Self, Self::Error>

impl TryFromVal<Env, Val> for Context

type Error = ConversionError

fn try_from_val(env: &Env, val: &Val) -> Result<Self, ConversionError>

impl TryFromVal<Env, Val> for ContractContext

type Error = ConversionError

fn try_from_val(env: &Env, val: &Val) -> Result<Self, ConversionError>

impl TryFromVal<Env, Val> for ContractExecutable

type Error = ConversionError

fn try_from_val(env: &Env, val: &Val) -> Result<Self, ConversionError>

impl TryFromVal<Env, Val> for CreateContractHostFnContext

type Error = ConversionError

fn try_from_val(env: &Env, val: &Val) -> Result<Self, ConversionError>

impl TryFromVal<Env, Val> for Duration

type Error = ConversionError

fn try_from_val(env: &Env, val: &Val) -> Result<Self, Self::Error>

impl TryFromVal<Env, Val> for I256

type Error = ConversionError

fn try_from_val(env: &Env, val: &Val) -> Result<Self, Self::Error>

impl TryFromVal<Env, Val> for InvokerContractAuthEntry

type Error = ConversionError

fn try_from_val(env: &Env, val: &Val) -> Result<Self, ConversionError>

impl<K, V> TryFromVal<Env, Val> for Map<K, V>
where K: IntoVal<Env, Val> + TryFromVal<Env, Val>, V: IntoVal<Env, Val> + TryFromVal<Env, Val>,

type Error = ConversionError

fn try_from_val(env: &Env, val: &Val) -> Result<Self, Self::Error>

impl TryFromVal<Env, Val> for String

type Error = ConversionError

fn try_from_val(env: &Env, val: &Val) -> Result<Self, Self::Error>

impl TryFromVal<Env, Val> for SubContractInvocation

type Error = ConversionError

fn try_from_val(env: &Env, val: &Val) -> Result<Self, ConversionError>

impl TryFromVal<Env, Val> for Symbol

type Error = ConversionError

fn try_from_val(env: &Env, val: &Val) -> Result<Self, Self::Error>

impl TryFromVal<Env, Val> for Timepoint

type Error = ConversionError

fn try_from_val(env: &Env, val: &Val) -> Result<Self, Self::Error>

impl TryFromVal<Env, Val> for U256

type Error = ConversionError

fn try_from_val(env: &Env, val: &Val) -> Result<Self, Self::Error>

impl<T> TryFromVal<Env, Val> for Vec<T>
where T: IntoVal<Env, Val> + TryFromVal<Env, Val>,

type Error = ConversionError

fn try_from_val(env: &Env, val: &Val) -> Result<Self, Self::Error>

impl<T> TryFromVal<Env, Vec<T>> for Val

type Error = ConversionError

fn try_from_val(_env: &Env, v: &Vec<T>) -> Result<Self, Self::Error>

impl<T> TryFromVal<Env, Vec<T>> for Vec<Val>

type Error = Infallible

fn try_from_val(env: &Env, v: &Vec<T>) -> Result<Self, Self::Error>

impl<T> TryFromVal<Env, VecM<ScVal>> for Vec<T>
where T: IntoVal<Env, Val> + TryFromVal<Env, Val>,

type Error = ConversionError

fn try_from_val(env: &Env, val: &VecM<ScVal>) -> Result<Self, Self::Error>

impl<T> TryFromVal<Env, VecObject> for Vec<T>
where T: IntoVal<Env, Val> + TryFromVal<Env, Val>,

type Error = Infallible

fn try_from_val(env: &Env, obj: &VecObject) -> Result<Self, Self::Error>

impl TryFromVal<Env, bool> for bool

type Error = ConversionError

fn try_from_val(_env: &Env, v: &bool) -> Result<Self, Self::Error>

impl TryFromVal<Env, i128> for i128

type Error = ConversionError

fn try_from_val(_env: &Env, v: &i128) -> Result<Self, Self::Error>

impl TryFromVal<Env, i32> for i32

type Error = ConversionError

fn try_from_val(_env: &Env, v: &i32) -> Result<Self, Self::Error>

impl TryFromVal<Env, i64> for i64

type Error = ConversionError

fn try_from_val(_env: &Env, v: &i64) -> Result<Self, Self::Error>

impl TryFromVal<Env, u128> for u128

type Error = ConversionError

fn try_from_val(_env: &Env, v: &u128) -> Result<Self, Self::Error>

impl TryFromVal<Env, u32> for u32

type Error = ConversionError

fn try_from_val(_env: &Env, v: &u32) -> Result<Self, Self::Error>

impl TryFromVal<Env, u64> for u64

type Error = ConversionError

fn try_from_val(_env: &Env, v: &u64) -> Result<Self, Self::Error>

Auto Trait Implementations§

impl Freeze for Env

impl !RefUnwindSafe for Env

impl !Send for Env

impl !Sync for Env

impl Unpin for Env

impl !UnwindSafe for Env

Blanket Implementations§

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

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more

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

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

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

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

Mutably borrows from an owned value. Read more

impl<T, C> Compare<&T> for C
where C: Compare<T>,

type Error = <C as Compare<T>>::Error

fn compare(&self, a: &&T, b: &&T) -> Result<Ordering, <C as Compare<&T>>::Error>

impl<T, U, E, C> Compare<(T, U)> for C
where C: Compare<T, Error = E, Error = E> + Compare,

type Error = E

fn compare( &self, a: &(T, U), b: &(T, U) ) -> Result<Ordering, <C as Compare<(T, U)>>::Error>

impl<T, U, V, E, C> Compare<(T, U, V)> for C
where C: Compare<T, Error = E, Error = E, Error = E> + Compare + Compare<V>,

type Error = E

fn compare( &self, a: &(T, U, V), b: &(T, U, V) ) -> Result<Ordering, <C as Compare<(T, U, V)>>::Error>

impl<T, U, V, W, E, C> Compare<(T, U, V, W)> for C
where C: Compare<T, Error = E, Error = E, Error = E, Error = E> + Compare + Compare<V> + Compare<W>,

type Error = E

fn compare( &self, a: &(T, U, V, W), b: &(T, U, V, W) ) -> Result<Ordering, <C as Compare<(T, U, V, W)>>::Error>

impl<T, U, V, W, X, E, C> Compare<(T, U, V, W, X)> for C
where C: Compare<T, Error = E, Error = E, Error = E, Error = E, Error = E> + Compare + Compare<V> + Compare<W> + Compare<X>,

type Error = E

fn compare( &self, a: &(T, U, V, W, X), b: &(T, U, V, W, X) ) -> Result<Ordering, <C as Compare<(T, U, V, W, X)>>::Error>

impl<E> Compare<AddressObject> for E
where E: Env,

type Error = <E as EnvBase>::Error

fn compare( &self, a: &AddressObject, b: &AddressObject ) -> Result<Ordering, <E as Compare<AddressObject>>::Error>

impl<E> Compare<Bool> for E
where E: Env,

type Error = <E as EnvBase>::Error

fn compare( &self, a: &Bool, b: &Bool ) -> Result<Ordering, <E as Compare<Bool>>::Error>

impl<T, C> Compare<Box<T>> for C
where C: Compare<T>,

type Error = <C as Compare<T>>::Error

fn compare( &self, a: &Box<T>, b: &Box<T> ) -> Result<Ordering, <C as Compare<Box<T>>>::Error>

impl<E> Compare<BytesObject> for E
where E: Env,

type Error = <E as EnvBase>::Error

fn compare( &self, a: &BytesObject, b: &BytesObject ) -> Result<Ordering, <E as Compare<BytesObject>>::Error>

impl<E> Compare<DurationObject> for E
where E: Env,

type Error = <E as EnvBase>::Error

fn compare( &self, a: &DurationObject, b: &DurationObject ) -> Result<Ordering, <E as Compare<DurationObject>>::Error>

impl<E> Compare<DurationSmall> for E
where E: Env,

type Error = <E as EnvBase>::Error

fn compare( &self, a: &DurationSmall, b: &DurationSmall ) -> Result<Ordering, <E as Compare<DurationSmall>>::Error>

impl<E> Compare<Error> for E
where E: Env,

type Error = <E as EnvBase>::Error

fn compare( &self, a: &Error, b: &Error ) -> Result<Ordering, <E as Compare<Error>>::Error>

impl<E> Compare<I128Object> for E
where E: Env,

type Error = <E as EnvBase>::Error

fn compare( &self, a: &I128Object, b: &I128Object ) -> Result<Ordering, <E as Compare<I128Object>>::Error>

impl<E> Compare<I128Small> for E
where E: Env,

type Error = <E as EnvBase>::Error

fn compare( &self, a: &I128Small, b: &I128Small ) -> Result<Ordering, <E as Compare<I128Small>>::Error>

impl<E> Compare<I256Object> for E
where E: Env,

type Error = <E as EnvBase>::Error

fn compare( &self, a: &I256Object, b: &I256Object ) -> Result<Ordering, <E as Compare<I256Object>>::Error>

impl<E> Compare<I256Small> for E
where E: Env,

type Error = <E as EnvBase>::Error

fn compare( &self, a: &I256Small, b: &I256Small ) -> Result<Ordering, <E as Compare<I256Small>>::Error>

impl<E> Compare<I32Val> for E
where E: Env,

type Error = <E as EnvBase>::Error

fn compare( &self, a: &I32Val, b: &I32Val ) -> Result<Ordering, <E as Compare<I32Val>>::Error>

impl<E> Compare<I64Object> for E
where E: Env,

type Error = <E as EnvBase>::Error

fn compare( &self, a: &I64Object, b: &I64Object ) -> Result<Ordering, <E as Compare<I64Object>>::Error>

impl<E> Compare<I64Small> for E
where E: Env,

type Error = <E as EnvBase>::Error

fn compare( &self, a: &I64Small, b: &I64Small ) -> Result<Ordering, <E as Compare<I64Small>>::Error>

impl<E> Compare<MapObject> for E
where E: Env,

type Error = <E as EnvBase>::Error

fn compare( &self, a: &MapObject, b: &MapObject ) -> Result<Ordering, <E as Compare<MapObject>>::Error>

impl<E> Compare<Object> for E
where E: Env,

type Error = <E as EnvBase>::Error

fn compare( &self, a: &Object, b: &Object ) -> Result<Ordering, <E as Compare<Object>>::Error>

impl<T, C> Compare<Option<T>> for C
where C: Compare<T>,

type Error = <C as Compare<T>>::Error

fn compare( &self, a: &Option<T>, b: &Option<T> ) -> Result<Ordering, <C as Compare<Option<T>>>::Error>

impl<T, C> Compare<Rc<T>> for C
where C: Compare<T>,

type Error = <C as Compare<T>>::Error

fn compare( &self, a: &Rc<T>, b: &Rc<T> ) -> Result<Ordering, <C as Compare<Rc<T>>>::Error>

impl<E> Compare<StringObject> for E
where E: Env,

type Error = <E as EnvBase>::Error

fn compare( &self, a: &StringObject, b: &StringObject ) -> Result<Ordering, <E as Compare<StringObject>>::Error>

impl<E> Compare<Symbol> for E
where E: Env,

type Error = <E as EnvBase>::Error

fn compare( &self, a: &Symbol, b: &Symbol ) -> Result<Ordering, <E as Compare<Symbol>>::Error>

impl<E> Compare<SymbolObject> for E
where E: Env,

type Error = <E as EnvBase>::Error

fn compare( &self, a: &SymbolObject, b: &SymbolObject ) -> Result<Ordering, <E as Compare<SymbolObject>>::Error>

impl<E> Compare<SymbolSmall> for E
where E: Env,

type Error = <E as EnvBase>::Error

fn compare( &self, a: &SymbolSmall, b: &SymbolSmall ) -> Result<Ordering, <E as Compare<SymbolSmall>>::Error>

impl<E> Compare<TimepointObject> for E
where E: Env,

type Error = <E as EnvBase>::Error

fn compare( &self, a: &TimepointObject, b: &TimepointObject ) -> Result<Ordering, <E as Compare<TimepointObject>>::Error>

impl<E> Compare<TimepointSmall> for E
where E: Env,

type Error = <E as EnvBase>::Error

fn compare( &self, a: &TimepointSmall, b: &TimepointSmall ) -> Result<Ordering, <E as Compare<TimepointSmall>>::Error>

impl<E> Compare<U128Object> for E
where E: Env,

type Error = <E as EnvBase>::Error

fn compare( &self, a: &U128Object, b: &U128Object ) -> Result<Ordering, <E as Compare<U128Object>>::Error>

impl<E> Compare<U128Small> for E
where E: Env,

type Error = <E as EnvBase>::Error

fn compare( &self, a: &U128Small, b: &U128Small ) -> Result<Ordering, <E as Compare<U128Small>>::Error>

impl<E> Compare<U256Object> for E
where E: Env,

type Error = <E as EnvBase>::Error

fn compare( &self, a: &U256Object, b: &U256Object ) -> Result<Ordering, <E as Compare<U256Object>>::Error>

impl<E> Compare<U256Small> for E
where E: Env,

type Error = <E as EnvBase>::Error

fn compare( &self, a: &U256Small, b: &U256Small ) -> Result<Ordering, <E as Compare<U256Small>>::Error>

impl<E> Compare<U32Val> for E
where E: Env,

type Error = <E as EnvBase>::Error

fn compare( &self, a: &U32Val, b: &U32Val ) -> Result<Ordering, <E as Compare<U32Val>>::Error>

impl<E> Compare<U64Object> for E
where E: Env,

type Error = <E as EnvBase>::Error

fn compare( &self, a: &U64Object, b: &U64Object ) -> Result<Ordering, <E as Compare<U64Object>>::Error>

impl<E> Compare<U64Small> for E
where E: Env,

type Error = <E as EnvBase>::Error

fn compare( &self, a: &U64Small, b: &U64Small ) -> Result<Ordering, <E as Compare<U64Small>>::Error>

impl<E> Compare<Val> for E
where E: Env,

type Error = <E as EnvBase>::Error

fn compare( &self, a: &Val, b: &Val ) -> Result<Ordering, <E as Compare<Val>>::Error>

impl<T, C> Compare<Vec<T>> for C
where C: Compare<T>,

type Error = <C as Compare<T>>::Error

fn compare( &self, a: &Vec<T>, b: &Vec<T> ) -> Result<Ordering, <C as Compare<Vec<T>>>::Error>

impl<E> Compare<VecObject> for E
where E: Env,

type Error = <E as EnvBase>::Error

fn compare( &self, a: &VecObject, b: &VecObject ) -> Result<Ordering, <E as Compare<VecObject>>::Error>

impl<E> Compare<Void> for E
where E: Env,

type Error = <E as EnvBase>::Error

fn compare( &self, _a: &Void, _b: &Void ) -> Result<Ordering, <E as Compare<Void>>::Error>

impl<T> Downcast for T
where T: Any,

fn into_any(self: Box<T>) -> Box<dyn Any>

Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can then be further downcast into Box<ConcreteType> where ConcreteType implements Trait.

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be further downcast into Rc<ConcreteType> where ConcreteType implements Trait.