Struct TransactionFlow 

#[repr(C, align(64))]
pub struct TransactionFlow {
    pub source_account_index: u16,
    pub target_account_index: u16,
    pub amount: Decimal128,
    pub journal_entry_id: Uuid,
    pub debit_line_index: u16,
    pub credit_line_index: u16,
    pub timestamp: HybridTimestamp,
    pub confidence: f32,
    pub method_used: SolvingMethod,
    pub flags: FlowFlags,
    pub _pad: [u8; 2],
    pub _reserved: [u8; 8],
}

A directed edge in the accounting network representing monetary flow. GPU-aligned to 64 bytes.

Fields

source_account_index: u16

Source account index (debited account)

target_account_index: u16

Target account index (credited account)

amount: Decimal128

Monetary amount transferred

journal_entry_id: Uuid

Original journal entry ID

debit_line_index: u16

Line item index in the journal entry

credit_line_index: u16

Corresponding credit line index

timestamp: HybridTimestamp

When this flow was recorded

confidence: f32

Confidence score (0.0 - 1.0)

method_used: SolvingMethod

Transformation method used

flags: FlowFlags

Flags

_pad: [u8; 2]

Padding

_reserved: [u8; 8]

Reserved for future use.

Implementations

impl TransactionFlow

pub fn new( source: u16, target: u16, amount: Decimal128, journal_entry_id: Uuid, timestamp: HybridTimestamp, ) -> Self

Create a new transaction flow.

pub fn with_provenance( source: u16, target: u16, amount: Decimal128, journal_entry_id: Uuid, debit_line_index: u16, credit_line_index: u16, timestamp: HybridTimestamp, method: SolvingMethod, confidence: f32, ) -> Self

Create a flow with full provenance.

pub fn is_self_loop(&self) -> bool

Check if this flow is a self-loop (same source and target).

pub fn is_high_confidence(&self) -> bool

Check if this flow has high confidence.

pub fn is_anomalous(&self) -> bool

Check if this flow is flagged as anomalous.

Trait Implementations

impl Archive for TransactionFlow

where u16: Archive, Decimal128: Archive, Uuid: Archive, HybridTimestamp: Archive, f32: Archive, SolvingMethod: Archive, FlowFlags: Archive, [u8; 2]: Archive, [u8; 8]: Archive,

type Archived = ArchivedTransactionFlow

The archived representation of this type.

type Resolver = TransactionFlowResolver

The resolver for this type. It must contain all the additional information from serializing needed to make the archived type from the normal type.

unsafe fn resolve( &self, pos: usize, resolver: Self::Resolver, out: *mut Self::Archived, )

Creates the archived version of this value at the given position and writes it to the given output.

impl Clone for TransactionFlow

fn clone(&self) -> TransactionFlow

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TransactionFlow

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

Formats the value using the given formatter.

impl<__D: Fallible + ?Sized> Deserialize<TransactionFlow, __D> for Archived<TransactionFlow>

where u16: Archive, Archived<u16>: Deserialize<u16, __D>, Decimal128: Archive, Archived<Decimal128>: Deserialize<Decimal128, __D>, Uuid: Archive, Archived<Uuid>: Deserialize<Uuid, __D>, HybridTimestamp: Archive, Archived<HybridTimestamp>: Deserialize<HybridTimestamp, __D>, f32: Archive, Archived<f32>: Deserialize<f32, __D>, SolvingMethod: Archive, Archived<SolvingMethod>: Deserialize<SolvingMethod, __D>, FlowFlags: Archive, Archived<FlowFlags>: Deserialize<FlowFlags, __D>, [u8; 2]: Archive, Archived<[u8; 2]>: Deserialize<[u8; 2], __D>, [u8; 8]: Archive, Archived<[u8; 8]>: Deserialize<[u8; 8], __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<TransactionFlow, __D::Error>

Deserializes using the given deserializer

impl<__S: Fallible + ?Sized> Serialize<__S> for TransactionFlow

where u16: Serialize<__S>, Decimal128: Serialize<__S>, Uuid: Serialize<__S>, HybridTimestamp: Serialize<__S>, f32: Serialize<__S>, SolvingMethod: Serialize<__S>, FlowFlags: Serialize<__S>, [u8; 2]: Serialize<__S>, [u8; 8]: Serialize<__S>,

fn serialize(&self, serializer: &mut __S) -> Result<Self::Resolver, __S::Error>

Writes the dependencies for the object and returns a resolver that can create the archived type.