Enum Directive 

pub enum Directive {
    Transaction(Transaction),
    Balance(Balance),
    Open(Open),
    Close(Close),
    Commodity(Commodity),
    Pad(Pad),
    Event(Event),
    Query(Query),
    Note(Note),
    Document(Document),
    Price(Price),
    Custom(Custom),
}

All directive types in beancount.

Variants

Transaction(Transaction)

Transaction directive - records transfers between accounts

Balance(Balance)

Balance assertion - asserts an account balance at a point in time

Open(Open)

Open account - opens an account for use

Close(Close)

Close account - closes an account

Commodity(Commodity)

Commodity declaration - declares a currency/commodity

Pad(Pad)

Pad directive - auto-pad an account to match a balance

Event(Event)

Event directive - records a life event

Query(Query)

Query directive - stores a named BQL query

Note(Note)

Note directive - adds a note to an account

Document(Document)

Document directive - links a document to an account

Price(Price)

Price directive - records a commodity price

Custom(Custom)

Custom directive - custom user-defined directive

Implementations

impl Directive

pub const fn date(&self) -> NaiveDate

Get the date of this directive.

pub const fn meta(&self) -> &Metadata

Get the metadata of this directive.

pub const fn is_transaction(&self) -> bool

Check if this is a transaction.

pub const fn as_transaction(&self) -> Option<&Transaction>

Get as a transaction, if this is one.

pub const fn type_name(&self) -> &'static str

Get the directive type name.

pub const fn priority(&self) -> DirectivePriority

Get the sorting priority for this directive.

Used to determine order when directives have the same date.

Trait Implementations

impl Archive for Directive

where Transaction: Archive, Balance: Archive, Open: Archive, Close: Archive, Commodity: Archive, Pad: Archive, Event: Archive, Query: Archive, Note: Archive, Document: Archive, Price: Archive, Custom: Archive,

type Archived = ArchivedDirective

The archived representation of this type.

type Resolver = DirectiveResolver

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

fn resolve( &self, resolver: <Self as Archive>::Resolver, out: Place<<Self as Archive>::Archived>, )

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

const COPY_OPTIMIZATION: CopyOptimization<Self> = _

An optimization flag that allows the bytes of this type to be copied directly to a writer instead of calling serialize.

impl Clone for Directive

fn clone(&self) -> Directive

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Directive

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Directive

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

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

where Transaction: Archive, <Transaction as Archive>::Archived: Deserialize<Transaction, __D>, Balance: Archive, <Balance as Archive>::Archived: Deserialize<Balance, __D>, Open: Archive, <Open as Archive>::Archived: Deserialize<Open, __D>, Close: Archive, <Close as Archive>::Archived: Deserialize<Close, __D>, Commodity: Archive, <Commodity as Archive>::Archived: Deserialize<Commodity, __D>, Pad: Archive, <Pad as Archive>::Archived: Deserialize<Pad, __D>, Event: Archive, <Event as Archive>::Archived: Deserialize<Event, __D>, Query: Archive, <Query as Archive>::Archived: Deserialize<Query, __D>, Note: Archive, <Note as Archive>::Archived: Deserialize<Note, __D>, Document: Archive, <Document as Archive>::Archived: Deserialize<Document, __D>, Price: Archive, <Price as Archive>::Archived: Deserialize<Price, __D>, Custom: Archive, <Custom as Archive>::Archived: Deserialize<Custom, __D>,

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

Deserializes using the given deserializer

impl PartialEq for Directive

fn eq(&self, other: &Directive) -> 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<__S: Fallible + ?Sized> Serialize<__S> for Directive

where Transaction: Serialize<__S>, Balance: Serialize<__S>, Open: Serialize<__S>, Close: Serialize<__S>, Commodity: Serialize<__S>, Pad: Serialize<__S>, Event: Serialize<__S>, Query: Serialize<__S>, Note: Serialize<__S>, Document: Serialize<__S>, Price: Serialize<__S>, Custom: Serialize<__S>,

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

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

impl Serialize for Directive

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for Directive

impl StructuralPartialEq for Directive