Struct soroban_env_host::budget::Budget

pub struct Budget(_);

Implementations

impl Budget

pub fn charge(&self, ty: CostType, input: u64) -> Result<(), HostError>

pub fn get_input(&self, ty: CostType) -> u64

pub fn get_cpu_insns_count(&self) -> u64

pub fn get_mem_bytes_count(&self) -> u64

pub fn reset_default(&self)

pub fn reset_unlimited(&self)

pub fn reset_unlimited_cpu(&self)

pub fn reset_unlimited_mem(&self)

pub fn reset_inputs(&self)

Trait Implementations

impl AsBudget for Budget

fn as_budget(&self) -> &Budget

impl Clone for Budget

fn clone(&self) -> Budget

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Compare<&[u8]> for Budget

type Error = HostError

fn compare(&self, a: &&[u8], b: &&[u8]) -> Result<Ordering, Self::Error>

impl<const N: usize> Compare<[u8; N]> for Budget

type Error = HostError

fn compare(&self, a: &[u8; N], b: &[u8; N]) -> Result<Ordering, Self::Error>

impl Compare<AccessType> for Budget

type Error = HostError

fn compare(&self, a: &AccessType, b: &AccessType) -> Result<Ordering, Self::Error>

impl Compare<AccountEntry> for Budget

type Error = HostError

fn compare(
&self,
a: &AccountEntry,
b: &AccountEntry
) -> Result<Ordering, Self::Error>

impl Compare<AccountId> for Budget

type Error = HostError

fn compare(&self, a: &AccountId, b: &AccountId) -> Result<Ordering, Self::Error>

impl Compare<ClaimableBalanceEntry> for Budget

type Error = HostError

fn compare(
&self,
a: &ClaimableBalanceEntry,
b: &ClaimableBalanceEntry
) -> Result<Ordering, Self::Error>

impl Compare<ConfigSettingEntry> for Budget

type Error = HostError

fn compare(
&self,
a: &ConfigSettingEntry,
b: &ConfigSettingEntry
) -> Result<Ordering, Self::Error>

impl Compare<ContractCodeEntry> for Budget

type Error = HostError

fn compare(
&self,
a: &ContractCodeEntry,
b: &ContractCodeEntry
) -> Result<Ordering, Self::Error>

impl Compare<DataEntry> for Budget

type Error = HostError

fn compare(&self, a: &DataEntry, b: &DataEntry) -> Result<Ordering, Self::Error>

impl Compare<Hash> for Budget

type Error = HostError

fn compare(&self, a: &Hash, b: &Hash) -> Result<Ordering, Self::Error>

impl Compare<LedgerEntry> for Budget

type Error = HostError

fn compare(
&self,
a: &LedgerEntry,
b: &LedgerEntry
) -> Result<Ordering, Self::Error>

impl Compare<LedgerEntryData> for Budget

type Error = HostError

fn compare(
&self,
a: &LedgerEntryData,
b: &LedgerEntryData
) -> Result<Ordering, Self::Error>

impl Compare<LedgerEntryExt> for Budget

type Error = HostError

fn compare(
&self,
a: &LedgerEntryExt,
b: &LedgerEntryExt
) -> Result<Ordering, Self::Error>

impl Compare<LedgerKey> for Budget

type Error = HostError

fn compare(&self, a: &LedgerKey, b: &LedgerKey) -> Result<Ordering, Self::Error>

impl Compare<LedgerKeyAccount> for Budget

type Error = HostError

fn compare(
&self,
a: &LedgerKeyAccount,
b: &LedgerKeyAccount
) -> Result<Ordering, Self::Error>

impl Compare<LedgerKeyClaimableBalance> for Budget

type Error = HostError

fn compare(
&self,
a: &LedgerKeyClaimableBalance,
b: &LedgerKeyClaimableBalance
) -> Result<Ordering, Self::Error>

impl Compare<LedgerKeyConfigSetting> for Budget

type Error = HostError

fn compare(
&self,
a: &LedgerKeyConfigSetting,
b: &LedgerKeyConfigSetting
) -> Result<Ordering, Self::Error>

impl Compare<LedgerKeyContractCode> for Budget

type Error = HostError

fn compare(
&self,
a: &LedgerKeyContractCode,
b: &LedgerKeyContractCode
) -> Result<Ordering, Self::Error>

impl Compare<LedgerKeyData> for Budget

type Error = HostError

fn compare(
&self,
a: &LedgerKeyData,
b: &LedgerKeyData
) -> Result<Ordering, Self::Error>

impl Compare<LedgerKeyLiquidityPool> for Budget

type Error = HostError

fn compare(
&self,
a: &LedgerKeyLiquidityPool,
b: &LedgerKeyLiquidityPool
) -> Result<Ordering, Self::Error>

impl Compare<LedgerKeyOffer> for Budget

type Error = HostError

fn compare(
&self,
a: &LedgerKeyOffer,
b: &LedgerKeyOffer
) -> Result<Ordering, Self::Error>

impl Compare<LedgerKeyTrustLine> for Budget

type Error = HostError

fn compare(
&self,
a: &LedgerKeyTrustLine,
b: &LedgerKeyTrustLine
) -> Result<Ordering, Self::Error>

impl Compare<LiquidityPoolEntry> for Budget

type Error = HostError

fn compare(
&self,
a: &LiquidityPoolEntry,
b: &LiquidityPoolEntry
) -> Result<Ordering, Self::Error>

impl<K, V> Compare<MeteredOrdMap<K, V, Budget>> for Budgetwhere
K: MeteredClone,
V: MeteredClone,
Budget: Compare<K, Error = HostError> + Compare<V, Error = HostError>,

type Error = HostError

fn compare(
&self,
a: &MeteredOrdMap<K, V, Budget>,
b: &MeteredOrdMap<K, V, Budget>
) -> Result<Ordering, Self::Error>

impl<Elt: MeteredClone> Compare<MeteredVector<Elt>> for Budgetwhere
Budget: Compare<Elt, Error = HostError>,

type Error = HostError

fn compare(
&self,
a: &MeteredVector<Elt>,
b: &MeteredVector<Elt>
) -> Result<Ordering, Self::Error>

impl Compare<OfferEntry> for Budget

type Error = HostError

fn compare(&self, a: &OfferEntry, b: &OfferEntry) -> Result<Ordering, Self::Error>

impl Compare<PublicKey> for Budget

type Error = HostError

fn compare(&self, a: &PublicKey, b: &PublicKey) -> Result<Ordering, Self::Error>

impl Compare<ScAddress> for Budget

type Error = HostError

fn compare(&self, a: &ScAddress, b: &ScAddress) -> Result<Ordering, Self::Error>

impl Compare<ScContractCode> for Budget

type Error = HostError

fn compare(
&self,
a: &ScContractCode,
b: &ScContractCode
) -> Result<Ordering, Self::Error>

impl Compare<ScMap> for Budget

type Error = HostError

fn compare(&self, a: &ScMap, b: &ScMap) -> Result<Ordering, Self::Error>

impl Compare<ScVal> for Budget

type Error = HostError

fn compare(&self, a: &ScVal, b: &ScVal) -> Result<Ordering, Self::Error>

impl Compare<ScVec> for Budget

type Error = HostError

fn compare(&self, a: &ScVec, b: &ScVec) -> Result<Ordering, Self::Error>

impl Compare<Static> for Budget

type Error = HostError

fn compare(&self, a: &Static, b: &Static) -> Result<Ordering, Self::Error>

impl Compare<Status> for Budget

type Error = HostError

fn compare(&self, a: &Status, b: &Status) -> Result<Ordering, Self::Error>

impl Compare<Symbol> for Budget

type Error = HostError

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

impl Compare<TrustLineAsset> for Budget

type Error = HostError

fn compare(
&self,
a: &TrustLineAsset,
b: &TrustLineAsset
) -> Result<Ordering, Self::Error>

impl Compare<TrustLineEntry> for Budget

type Error = HostError

fn compare(
&self,
a: &TrustLineEntry,
b: &TrustLineEntry
) -> Result<Ordering, Self::Error>

impl Compare<Uint256> for Budget

type Error = HostError

fn compare(&self, a: &Uint256, b: &Uint256) -> Result<Ordering, Self::Error>

impl Compare<bool> for Budget

type Error = HostError

fn compare(&self, a: &bool, b: &bool) -> Result<Ordering, Self::Error>

impl Compare<i128> for Budget

type Error = HostError

fn compare(&self, a: &i128, b: &i128) -> Result<Ordering, Self::Error>

impl Compare<i32> for Budget

type Error = HostError

fn compare(&self, a: &i32, b: &i32) -> Result<Ordering, Self::Error>

impl Compare<i64> for Budget

type Error = HostError

fn compare(&self, a: &i64, b: &i64) -> Result<Ordering, Self::Error>

impl Compare<u128> for Budget

type Error = HostError

fn compare(&self, a: &u128, b: &u128) -> Result<Ordering, Self::Error>

impl Compare<u32> for Budget

type Error = HostError

fn compare(&self, a: &u32, b: &u32) -> Result<Ordering, Self::Error>

impl Compare<u64> for Budget

type Error = HostError

fn compare(&self, a: &u64, b: &u64) -> Result<Ordering, Self::Error>

impl Debug for Budget

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

Formats the value using the given formatter.

impl Default for Budget

fn default() -> Budget

Returns the “default value” for a type.

impl Ord for Budget

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

This method returns an Ordering between self and other.

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

Compares and returns the maximum of two values.

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

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Selfwhere
Self: Sized + PartialOrd<Self>,

Restrict a value to a certain interval.

impl PartialEq<Budget> for Budget

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialOrd<Budget> for Budget

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

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

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

This method tests less than (for self and other) and is used by the < operator.

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

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

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

This method tests greater than (for self and other) and is used by the > operator.

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

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

impl Eq for Budget

impl StructuralEq for Budget

impl StructuralPartialEq for Budget