Struct AddressBalanceLocationInner 

pub struct AddressBalanceLocationInner<C: Constraint + Copy + Debug> {
    balance: Amount<C>,
    received: u64,
    location: OutputLocation,
}

The inner type of AddressBalanceLocation and AddressBalanceLocationChange.

Fields

balance: Amount<C>

The total balance of all UTXOs sent to an address.

received: u64

The total balance of all spent and unspent outputs sent to an address.

location: OutputLocation

The location of the first transparent::Output sent to an address.

Implementations

impl<C: Constraint + Copy + Debug> AddressBalanceLocationInner<C>

pub(crate) fn new(first_output: OutputLocation) -> Self

Creates a new AddressBalanceLocationInner from the location of the first transparent::Output sent to an address.

The returned value has a zero initial balance and received balance.

pub fn balance(&self) -> Amount<C>

Returns the current balance for the address.

pub fn received(&self) -> u64

Returns the current received balance for the address.

pub fn balance_mut(&mut self) -> &mut Amount<C>

Returns a mutable reference to the current balance for the address.

pub fn received_mut(&mut self) -> &mut u64

Returns a mutable reference to the current received balance for the address.

pub fn address_location(&self) -> OutputLocation

Returns the location of the first transparent::Output sent to an address.

pub fn height_mut(&mut self) -> &mut Height

Allows tests to set the height of the address location.

pub fn receive_output(&mut self, unspent_output: &Output) -> Result<(), Error>

Updates the current balance by adding the supplied output’s value.

pub fn spend_output(&mut self, spent_output: &Output) -> Result<(), Error>

Updates the current balance by subtracting the supplied output’s value.

Trait Implementations

impl<C: Constraint + Copy + Debug> Add for AddressBalanceLocationInner<C>

type Output = Result<AddressBalanceLocationInner<C>, Error>

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self::Output

Performs the + operation.

impl<C: Constraint + Copy + Debug + Arbitrary> Arbitrary for AddressBalanceLocationInner<C>

type Parameters = (<Amount<C> as Arbitrary>::Parameters, <u64 as Arbitrary>::Parameters, <OutputLocation as Arbitrary>::Parameters)

The type of parameters that arbitrary_with accepts for configuration of the generated Strategy. Parameters must implement Default.

type Strategy = Map<(<Amount<C> as Arbitrary>::Strategy, <u64 as Arbitrary>::Strategy, <OutputLocation as Arbitrary>::Strategy), fn((Amount<C>, u64, OutputLocation)) -> AddressBalanceLocationInner<C>>

The type of Strategy used to generate values of type Self.

fn arbitrary_with(_top: Self::Parameters) -> Self::Strategy

Generates a Strategy for producing arbitrary values of type the implementing type (Self). The strategy is passed the arguments given in args.

fn arbitrary() -> Self::Strategy

Generates a Strategy for producing arbitrary values of type the implementing type (Self).

impl<C: Clone + Constraint + Copy + Debug> Clone for AddressBalanceLocationInner<C>

fn clone(&self) -> AddressBalanceLocationInner<C>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<C: Debug + Constraint + Copy + Debug> Debug for AddressBalanceLocationInner<C>

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

Formats the value using the given formatter.

impl<'de, C> Deserialize<'de> for AddressBalanceLocationInner<C>

where C: Constraint + Clone + Copy + Debug,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<AddressBalanceLocationInner<NegativeAllowed>> for AddressBalanceLocationChange

fn from(value: AddressBalanceLocationInner<NegativeAllowed>) -> Self

Converts to this type from the input type.

impl From<AddressBalanceLocationInner<NonNegative>> for AddressBalanceLocation

fn from(value: AddressBalanceLocationInner<NonNegative>) -> Self

Converts to this type from the input type.

impl<C: Constraint + Copy + Debug> FromDisk for AddressBalanceLocationInner<C>

fn from_bytes(disk_bytes: impl AsRef<[u8]>) -> Self

Converts raw disk bytes back into the deserialized type.

impl<C: Constraint + Copy + Debug> IntoDisk for AddressBalanceLocationInner<C>

type Bytes = [u8; 24]

The type used to write bytes to disk, and compare a value as a key to on-disk keys.

fn as_bytes(&self) -> Self::Bytes

Converts the current type into serialized raw bytes.

impl<C: PartialEq + Constraint + Copy + Debug> PartialEq for AddressBalanceLocationInner<C>

fn eq(&self, other: &AddressBalanceLocationInner<C>) -> bool

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

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

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

impl<C> Serialize for AddressBalanceLocationInner<C>

where C: Constraint + Clone + Copy + Debug,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<C: Copy + Constraint + Copy + Debug> Copy for AddressBalanceLocationInner<C>

impl<C: Eq + Constraint + Copy + Debug> Eq for AddressBalanceLocationInner<C>

impl<C: Constraint + Copy + Debug> StructuralPartialEq for AddressBalanceLocationInner<C>

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: 32 bytes