A good overview of transactions, splits and accounts can be found in the texinfo documentation, together with an overview of how to use this API. More...

Files
file	Split.h
	API for Transactions and Splits (journal entries)

Macros
#define	GNC_TYPE_SPLIT (gnc_split_get_type ())

#define	GNC_SPLIT(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), GNC_TYPE_SPLIT, Split))

#define	GNC_SPLIT_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), GNC_TYPE_SPLIT, SplitClass))

#define	GNC_IS_SPLIT(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), GNC_TYPE_SPLIT))

#define	GNC_IS_SPLIT_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), GNC_TYPE_SPLIT))

#define	GNC_SPLIT_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GNC_TYPE_SPLIT, SplitClass))

#define	xaccSplitGetGUID(X) qof_entity_get_guid(QOF_INSTANCE(X))

Functions
GType	gnc_split_get_type (void)

gnc_numeric	xaccSplitConvertAmount (const Split split, const Account account)

Split general getters/setters
Split *	xaccMallocSplit (QofBook *book)
	Constructor.

void	xaccSplitReinit (Split *split)

gboolean	xaccSplitDestroy (Split *split)
	Destructor.

void	xaccSplitCopyOnto (const Split from_split, Split to_split)
	This is really a helper for xaccTransCopyOnto.

QofBook *	xaccSplitGetBook (const Split *split)
	Returns the book of this split, i.e.

Account *	xaccSplitGetAccount (const Split *split)
	Returns the account of this split, which was set through xaccAccountInsertSplit().

void	xaccSplitSetAccount (Split s, Account acc)

Transaction *	xaccSplitGetParent (const Split *split)
	Returns the parent transaction of the split.

void	xaccSplitSetParent (Split split, Transaction trans)

GNCLot *	xaccSplitGetLot (const Split *split)
	Returns the pointer to the debited/credited Lot where this split belongs to, or NULL if it doesn't belong to any.

void	xaccSplitSetLot (Split split, GNCLot lot)
	Assigns the split to a specific Lot.

void	xaccSplitSetMemo (Split split, const char memo)
	The memo is an arbitrary string associated with a split.

const char *	xaccSplitGetMemo (const Split *split)
	Returns the memo string.

void	xaccSplitSetOnlineID (Split split, const char id)
	The online_id is the OFX/HBCI "FITID" recorded on a split when it is imported.

const char *	xaccSplitGetOnlineID (const Split *split)
	Returns the split's online_id.

gboolean	xaccSplitHasOnlineID (const Split *split)
	Returns TRUE if the split has a non-empty online_id.

void	xaccSplitSetAction (Split split, const char action)
	The Action is an arbitrary user-assigned string.

const char *	xaccSplitGetAction (const Split *split)
	Returns the action string.

Split Date getters/setters
void	xaccSplitSetReconcile (Split *split, char reconciled_flag)
	Set the reconcile flag.

char	xaccSplitGetReconcile (const Split *split)
	Returns the value of the reconcile flag.

void	xaccSplitSetDateReconciledSecs (Split *split, time64 time)
	Set the date on which this split was reconciled by specifying the time as time64.

time64	xaccSplitGetDateReconciled (const Split *split)
	Retrieve the date when the Split was reconciled.

Split amount getters/setters
'value' vs. 'amount' of a Split: The 'value' is the amount of the transaction balancing commodity (i.e. currency) involved, 'amount' is the amount of the account's commodity involved.
void	xaccSplitSetAmount (Split *split, gnc_numeric amount)
	The xaccSplitSetAmount() method sets the amount in the account's commodity that the split should have.

gnc_numeric	xaccSplitGetAmount (const Split *split)
	Returns the amount of the split in the account's commodity.

void	xaccSplitSetValue (Split *split, gnc_numeric value)
	The xaccSplitSetValue() method sets the value of this split in the transaction's commodity.

gnc_numeric	xaccSplitGetValue (const Split *split)
	Returns the value of this split in the transaction's commodity.

void	xaccSplitSetSharePriceAndAmount (Split *split, gnc_numeric price, gnc_numeric amount)
	The xaccSplitSetSharePriceAndAmount() method will simultaneously update the share price and the number of shares.

gnc_numeric	xaccSplitGetSharePrice (const Split *split)
	Returns the price of the split, that is, the value divided by the amount.

void	xaccSplitSetBaseValue (Split split, gnc_numeric value, const gnc_commodity base_currency)
	Depending on the base_currency, set either the value or the amount of this split or both: If the base_currency is the transaction's commodity, set the value.

gnc_numeric	xaccSplitGetBaseValue (const Split split, const gnc_commodity base_currency)
	Depending on the base_currency, return either the value or the amount of this split: If the base_curreny is the transaction's commodity, return the value.

gnc_numeric	xaccSplitGetBalance (const Split *split)
	Returns the running balance up to and including the indicated split.

gnc_numeric	xaccSplitGetNoclosingBalance (const Split *split)
	The noclosing-balance is the currency-denominated balance of all transactions except 'closing' transactions.

gnc_numeric	xaccSplitGetClearedBalance (const Split *split)
	The cleared-balance is the currency-denominated balance of all transactions that have been marked as cleared or reconciled.

gnc_numeric	xaccSplitGetReconciledBalance (const Split *split)
	Returns the reconciled-balance of this split.

void	xaccSplitSetAdjustedAmount (Split *split, gnc_numeric amount)
	Sets the stock split adjusted amount of a split.

gnc_numeric	xaccSplitGetAdjustedAmount (const Split *split)
	Returns the stock-split adjusted amount of the split in the account's commodity.

Split utility functions
gboolean	xaccSplitEqual (const Split sa, const Split sb, gboolean check_guids, gboolean check_balances, gboolean check_txn_splits)
	Equality.

Split *	xaccSplitLookup (const GncGUID guid, QofBook book)
	The xaccSplitLookup() subroutine will return the split associated with the given id, or NULL if there is no such split.

void	xaccSplitAddPeerSplit (Split split, const Split other_split, const time64 timestamp)
	Add a peer split to this split's lot-split list.

gboolean	xaccSplitHasPeers (const Split *split)
	Does this split have peers?

gboolean	xaccSplitIsPeerSplit (const Split split, const Split other_split)
	Report if a split is a peer of this one.

void	xaccSplitRemovePeerSplit (Split split, const Split other_split)
	Remove a peer split from this split's lot-split list.

void	xaccSplitMergePeerSplits (Split split, const Split other_split)
	Merge the other_split's peer splits into split's peers.

Split *	xaccSplitGetOtherSplit (const Split *split)
	The xaccSplitGetOtherSplit() is a convenience routine that returns the other of a pair of splits.

const char *	xaccSplitGetType (Split *s)
	Returns the split type, which is either the string "normal", or "stock-split" for a split from a stock split.

void	xaccSplitMakeStockSplit (Split *s)
	Mark a split to be of type stock split - after this, you shouldn't modify the value anymore, just the amount.

gboolean	xaccSplitIsStockSplit (Split *s)
	Returns true if the split is of type stock split.

gint	xaccSplitOrder (const Split sa, const Split sb)
	The xaccSplitOrder(sa,sb) method is useful for sorting.

gint	xaccSplitOrderDateOnly (const Split sa, const Split sb)

int	xaccSplitCompareAccountFullNames (const Split sa, const Split sb)
	Compare two splits by full name of account.

int	xaccSplitCompareAccountCodes (const Split sa, const Split sb)
	Compare two splits by code of account.

int	xaccSplitCompareOtherAccountFullNames (const Split sa, const Split sb)
	Compare two splits by full name of the other account.

int	xaccSplitCompareOtherAccountCodes (const Split sa, const Split sb)
	Compare two splits by code of the other account.

char *	xaccSplitGetCorrAccountFullName (const Split *sa)
	These functions take a split, get the corresponding split on the "other side" of the transaction, and extract either the name or code of that split, reverting to returning a constant "Split" if the transaction has more than one split on the "other side".

const char *	xaccSplitGetCorrAccountName (const Split *sa)
	document me

const char *	xaccSplitGetCorrAccountCode (const Split *sa)
	document me

#define	xaccSplitLookupDirect(g, b) xaccSplitLookup(&(g),b)

Split deprecated functions
void	xaccSplitSetSharePrice (Split *split, gnc_numeric price)

Split voiding
gnc_numeric	xaccSplitVoidFormerAmount (const Split *split)
	Returns the original pre-void amount of a split.

gnc_numeric	xaccSplitVoidFormerValue (const Split *split)
	Returns the original pre-void value of a split.

Split Reconciled field values
These define the various reconciliations states a split can be in. If you change these be sure to change gnc-ui-util.c:gnc_get_reconciled_str() and associated functions
#define	CREC 'c'
	The Split has been cleared

#define	YREC 'y'
	The Split has been reconciled.

#define	FREC 'f'
	frozen into accounting period

#define	NREC 'n'
	not reconciled or cleared

#define	VREC 'v'
	split is void

Split Parameter names
Note, if you want to get the equivalent of "ACCT_MATCH_ALL" you need to create a search on the following parameter list: SPLIT->SPLIT_TRANS->TRANS_SPLITLIST->SPLIT_ACCOUNT_GUID. If you do this, you might want to use the ACCOUNT_MATCH_ALL_TYPE as the override so the gnome-search dialog displays the right type.
#define	SPLIT_DATE_RECONCILED "date-reconciled"

#define	SPLIT_BALANCE "balance"

#define	SPLIT_CLEARED_BALANCE "cleared-balance"

#define	SPLIT_RECONCILED_BALANCE "reconciled-balance"

#define	SPLIT_MEMO "memo"

#define	SPLIT_ACTION "action"

#define	SPLIT_RECONCILE "reconcile-flag"

#define	SPLIT_AMOUNT "amount"

#define	SPLIT_SHARE_PRICE "share-price"

#define	SPLIT_VALUE "value"

#define	SPLIT_TYPE "type"

#define	SPLIT_VOIDED_AMOUNT "voided-amount"

#define	SPLIT_VOIDED_VALUE "voided-value"

#define	SPLIT_LOT "lot"

#define	SPLIT_TRANS "trans"

#define	SPLIT_ACCOUNT "account"

#define	SPLIT_ACCOUNT_GUID "account-guid"
	for guid_match_all

#define	SPLIT_ACCT_FULLNAME "acct-fullname"

#define	SPLIT_CORR_ACCT_NAME "corr-acct-fullname"

#define	SPLIT_CORR_ACCT_CODE "corr-acct-code"

Detailed Description

A good overview of transactions, splits and accounts can be found in the texinfo documentation, together with an overview of how to use this API.

Splits, or "Ledger Entries" are the fundamental accounting units. Each Split consists of an amount (number of dollar bills, number of shares, etc.), the value of that amount expressed in a (possibly) different currency than the amount, a Memo, a pointer to the parent Transaction, a pointer to the debited Account, a reconciled flag and timestamp, an "Action" field, and a key-value frame which can store arbitrary data.

Transactions embody the notion of "double entry" accounting. A Transaction consists of a date, a description, an ID number, a list of one or more Splits, and a key-value frame. The transaction also specifies the currency with which all of the splits will be valued. When double-entry rules are enforced, the sum total value of the splits are zero. If there are only two splits, then the value of one must be positive, the other negative: this denotes that one account is debited, and another is credited by an equal amount. By forcing the value of the splits to always 'add up' to zero, we can guarantee that the balances of the accounts are always correctly balanced.

The engine does not enforce double-entry accounting, but provides an API to enable user-code to find unbalanced transactions and 'repair' them so that they are in balance.

Note the sum of the values of Splits in a Transaction is always computed with respect to a currency; thus splits can be balanced even when they are in different currencies, as long as they share a common currency. This feature allows currency-trading accounts to be established.

Every Split must point to its parent Transaction, and that Transaction must in turn include that Split in the Transaction's list of Splits. A Split can belong to at most one Transaction. These relationships are enforced by the engine. The engine user cannot accidentally destroy this relationship as long as they stick to using the API and never access internal structures directly.

Splits are grouped into Accounts which are also known as "Ledgers" in accounting practice. Each Account consists of a list of Splits that debit that Account. To ensure consistency, if a Split points to an Account, then the Account must point to the Split, and vice-versa. A Split can belong to at most one Account. Besides merely containing a list of Splits, the Account structure also gives the Account a name, a code number, description and notes fields, a key-value frame, a pointer to the commodity that is used for all splits in this account. The commodity can be the name of anything traded and tradable: a stock (e.g. "IBM", "McDonald's"), a currency (e.g. "USD", "GBP"), or anything added to the commodity table.

Accounts can be arranged in a hierarchical tree. The nodes of the tree are called "Account Groups". By accounting convention, the value of an Account is equal to the value of all of its Splits plus the value of all of its sub-Accounts.

@{

Macro Definition Documentation

◆ CREC

#define CREC 'c'

The Split has been cleared

Definition at line 73 of file Split.h.

◆ FREC

#define FREC 'f'

frozen into accounting period

Definition at line 75 of file Split.h.

◆ GNC_IS_SPLIT

#define GNC_IS_SPLIT ( o ) (G_TYPE_CHECK_INSTANCE_TYPE ((o), GNC_TYPE_SPLIT))

Definition at line 54 of file Split.h.

◆ GNC_IS_SPLIT_CLASS

#define GNC_IS_SPLIT_CLASS ( k ) (G_TYPE_CHECK_CLASS_TYPE ((k), GNC_TYPE_SPLIT))

Definition at line 56 of file Split.h.

◆ GNC_SPLIT

#define GNC_SPLIT ( o ) (G_TYPE_CHECK_INSTANCE_CAST ((o), GNC_TYPE_SPLIT, Split))

Definition at line 50 of file Split.h.

◆ GNC_SPLIT_CLASS

#define GNC_SPLIT_CLASS ( k ) (G_TYPE_CHECK_CLASS_CAST((k), GNC_TYPE_SPLIT, SplitClass))

Definition at line 52 of file Split.h.

◆ GNC_SPLIT_GET_CLASS

#define GNC_SPLIT_GET_CLASS ( o ) (G_TYPE_INSTANCE_GET_CLASS ((o), GNC_TYPE_SPLIT, SplitClass))

Definition at line 58 of file Split.h.

◆ GNC_TYPE_SPLIT

#define GNC_TYPE_SPLIT (gnc_split_get_type ())

Definition at line 49 of file Split.h.

◆ NREC

#define NREC 'n'

not reconciled or cleared

Definition at line 76 of file Split.h.

◆ SPLIT_ACCOUNT

#define SPLIT_ACCOUNT "account"

Definition at line 570 of file Split.h.

◆ SPLIT_ACCOUNT_GUID

#define SPLIT_ACCOUNT_GUID "account-guid"

for guid_match_all

Definition at line 571 of file Split.h.

◆ SPLIT_ACCT_FULLNAME

#define SPLIT_ACCT_FULLNAME "acct-fullname"

Definition at line 573 of file Split.h.

◆ SPLIT_ACTION

#define SPLIT_ACTION "action"

Definition at line 560 of file Split.h.

◆ SPLIT_AMOUNT

#define SPLIT_AMOUNT "amount"

Definition at line 562 of file Split.h.

◆ SPLIT_BALANCE

#define SPLIT_BALANCE "balance"

Definition at line 556 of file Split.h.

◆ SPLIT_CLEARED_BALANCE

#define SPLIT_CLEARED_BALANCE "cleared-balance"

Definition at line 557 of file Split.h.

◆ SPLIT_CORR_ACCT_CODE

#define SPLIT_CORR_ACCT_CODE "corr-acct-code"

Definition at line 575 of file Split.h.

◆ SPLIT_CORR_ACCT_NAME

#define SPLIT_CORR_ACCT_NAME "corr-acct-fullname"

Definition at line 574 of file Split.h.

◆ SPLIT_DATE_RECONCILED

#define SPLIT_DATE_RECONCILED "date-reconciled"

Definition at line 555 of file Split.h.

◆ SPLIT_LOT

#define SPLIT_LOT "lot"

Definition at line 568 of file Split.h.

◆ SPLIT_MEMO

#define SPLIT_MEMO "memo"

Definition at line 559 of file Split.h.

◆ SPLIT_RECONCILE

#define SPLIT_RECONCILE "reconcile-flag"

Definition at line 561 of file Split.h.

◆ SPLIT_RECONCILED_BALANCE

#define SPLIT_RECONCILED_BALANCE "reconciled-balance"

Definition at line 558 of file Split.h.

◆ SPLIT_SHARE_PRICE

#define SPLIT_SHARE_PRICE "share-price"

Definition at line 563 of file Split.h.

◆ SPLIT_TRANS

#define SPLIT_TRANS "trans"

Definition at line 569 of file Split.h.

◆ SPLIT_TYPE

#define SPLIT_TYPE "type"

Definition at line 565 of file Split.h.

◆ SPLIT_VALUE

#define SPLIT_VALUE "value"

Definition at line 564 of file Split.h.

◆ SPLIT_VOIDED_AMOUNT

#define SPLIT_VOIDED_AMOUNT "voided-amount"

Definition at line 566 of file Split.h.

◆ SPLIT_VOIDED_VALUE

#define SPLIT_VOIDED_VALUE "voided-value"

Definition at line 567 of file Split.h.

◆ VREC

#define VREC 'v'

split is void

Definition at line 77 of file Split.h.

◆ xaccSplitGetGUID

#define xaccSplitGetGUID ( X ) qof_entity_get_guid(QOF_INSTANCE(X))

Deprecated:

Definition at line 579 of file Split.h.

◆ xaccSplitLookupDirect

#define xaccSplitLookupDirect	(	g,
		b
	)	xaccSplitLookup(&(g),b)

Definition at line 390 of file Split.h.

◆ YREC

#define YREC 'y'

The Split has been reconciled.

Definition at line 74 of file Split.h.

Function Documentation

◆ gnc_split_get_type()

GType gnc_split_get_type ( void )

Definition at line 31 of file gmock-Split.cpp.

{
    return gnc_mocksplit_get_type();
}

◆ xaccMallocSplit()

Split * xaccMallocSplit ( QofBook * book )

Constructor.

Definition at line 37 of file gmock-Split.cpp.

{
    SCOPED_TRACE("");
    QofMockBook* mockbook = qof_mockbook(book);
    return mockbook ? mockbook->malloc_split() : nullptr;
}

◆ xaccSplitAddPeerSplit()

void xaccSplitAddPeerSplit	(	Split *	split,
		const Split *	other_split,
		const time64	timestamp
	)

Add a peer split to this split's lot-split list.

Parameters

other_split	The split whose guid to add
timestamp	The time to be recorded for the split.

Definition at line 2084 of file Split.cpp.

{
    const GncGUID* guid;
 
    g_return_if_fail (split != nullptr);
    g_return_if_fail (other_split != nullptr);
 
    guid = qof_instance_get_guid (QOF_INSTANCE (other_split));
    xaccTransBeginEdit (split->parent);
    qof_instance_kvp_add_guid (QOF_INSTANCE (split), "lot-split",
                               gnc_time(nullptr), "peer_guid", guid_copy(guid));
    mark_split (split);
    qof_instance_set_dirty (QOF_INSTANCE (split));
    xaccTransCommitEdit (split->parent);
}

◆ xaccSplitCompareAccountCodes()

int xaccSplitCompareAccountCodes	(	const Split *	sa,
		const Split *	sb
	)

Compare two splits by code of account.

Returns similar to strcmp.

Definition at line 1712 of file Split.cpp.

{
    Account *aa, *ab;
    if (!sa && !sb) return 0;
    if (!sa) return -1;
    if (!sb) return 1;
 
    aa = sa->acc;
    ab = sb->acc;
 
    return g_strcmp0(xaccAccountGetCode(aa), xaccAccountGetCode(ab));
}

◆ xaccSplitCompareAccountFullNames()

int xaccSplitCompareAccountFullNames	(	const Split *	sa,
		const Split *	sb
	)

Compare two splits by full name of account.

Returns similar to strcmp.

Definition at line 1688 of file Split.cpp.

{
    Account *aa, *ab;
    if (sa == sb) return 0;
    if (!sa) return -1;
    if (!sb) return 1;
 
    aa = sa->acc;
    ab = sb->acc;
    if (aa == ab) return 0;
 
    auto path_a = gnc_account_get_all_parents (aa);
    auto path_b = gnc_account_get_all_parents (ab);
    auto mismatch_pair = std::mismatch (path_a.rbegin(), path_a.rend(),
                                        path_b.rbegin(), path_b.rend());
 
    return mismatch_pair.first == path_a.rend() ? -1
        : mismatch_pair.second == path_b.rend() ? 1
        : g_utf8_collate (xaccAccountGetName (*mismatch_pair.first),
                          xaccAccountGetName (*mismatch_pair.second));
}

◆ xaccSplitCompareOtherAccountCodes()

int xaccSplitCompareOtherAccountCodes	(	const Split *	sa,
		const Split *	sb
	)

Compare two splits by code of the other account.

Returns similar to strcmp. This function attempts to find the split on the other side of a transaction and compare on it.

Definition at line 1747 of file Split.cpp.

{
    const char *ca, *cb;
    if (!sa && !sb) return 0;
    if (!sa) return -1;
    if (!sb) return 1;
 
    ca = xaccSplitGetCorrAccountCode(sa);
    cb = xaccSplitGetCorrAccountCode(sb);
    return g_strcmp0(ca, cb);
}

◆ xaccSplitCompareOtherAccountFullNames()

int xaccSplitCompareOtherAccountFullNames	(	const Split *	sa,
		const Split *	sb
	)

Compare two splits by full name of the other account.

Returns similar to strcmp. This function attempts to find the split on the other side of a transaction and compare on it.

Definition at line 1726 of file Split.cpp.

{
    char *ca, *cb;
    int retval;
    if (!sa && !sb) return 0;
    if (!sa) return -1;
    if (!sb) return 1;
 
    /* doesn't matter what separator we use
     * as long as they are the same
     */
 
    ca = xaccSplitGetCorrAccountFullName(sa);
    cb = xaccSplitGetCorrAccountFullName(sb);
    retval = g_strcmp0(ca, cb);
    g_free(ca);
    g_free(cb);
    return retval;
}

◆ xaccSplitConvertAmount()

gnc_numeric xaccSplitConvertAmount	(	const Split *	split,
		const Account *	account
	)

Definition at line 1433 of file Split.cpp.

{
    gnc_commodity *acc_com, *to_commodity;
    Transaction *txn;
    gnc_numeric amount, value, convrate;
    Account * split_acc;
 
    amount = xaccSplitGetAmount (split);
 
    /* If this split is attached to this account, OR */
    split_acc = xaccSplitGetAccount (split);
    if (split_acc == account)
        return amount;
 
    /* If split->account->commodity == to_commodity, return the amount */
    acc_com = xaccAccountGetCommodity (split_acc);
    to_commodity = xaccAccountGetCommodity (account);
    if (acc_com && gnc_commodity_equal (acc_com, to_commodity))
        return amount;
 
    /* Ok, this split is not for the viewed account, and the commodity
     * does not match.  So we need to do some conversion.
     *
     * First, we can cheat.  If this transaction is balanced and has
     * exactly two splits, then we can implicitly determine the exchange
     * rate and just return the 'other' split amount.
     */
    txn = xaccSplitGetParent (split);
    if (txn && xaccTransIsBalanced (txn))
    {
        const Split *osplit = xaccSplitGetOtherSplit (split);
 
        if (osplit)
        {
            gnc_commodity* split_comm =
                xaccAccountGetCommodity(xaccSplitGetAccount(osplit));
            if (!gnc_commodity_equal(to_commodity, split_comm))
            {
                gchar guidstr[GUID_ENCODING_LENGTH+1];
                guid_to_string_buff(xaccSplitGetGUID(osplit),guidstr);
                PERR("The split's (%s) amount can't be converted from %s into %s.",
                     guidstr,
                     gnc_commodity_get_mnemonic(split_comm),
                     gnc_commodity_get_mnemonic(to_commodity)
                    );
                return gnc_numeric_zero();
            }
            return gnc_numeric_neg (xaccSplitGetAmount (osplit));
        }
    }
 
    /* ... otherwise, we need to compute the amount from the conversion
     * rate into _this account_.  So, find the split into this account,
     * compute the conversion rate (based on amount/value), and then multiply
     * this times the split value.
     */
    value = xaccSplitGetValue (split);
 
    if (gnc_numeric_zero_p (value))
    {
        return value;
    }
 
    convrate = xaccTransGetAccountConvRate(txn, account);
    return gnc_numeric_mul (value, convrate,
                            gnc_commodity_get_fraction (to_commodity),
                            GNC_HOW_RND_ROUND_HALF_UP);
}

◆ xaccSplitCopyOnto()

void xaccSplitCopyOnto	(	const Split *	from_split,
		Split *	to_split
	)

This is really a helper for xaccTransCopyOnto.

It doesn't reparent the 'to' split to from's transaction, because xaccTransCopyOnto is responsible for parenting the split to the correct transaction. Also, from's parent transaction may not even be a valid transaction, so this function may not modify anything about 'from' or from's transaction.

Definition at line 648 of file Split.cpp.

{
    if (!from_split || !to_split) return;
    xaccTransBeginEdit (to_split->parent);
 
    xaccSplitSetMemo(to_split, xaccSplitGetMemo(from_split));
    xaccSplitSetAction(to_split, xaccSplitGetAction(from_split));
    xaccSplitSetAmount(to_split, xaccSplitGetAmount(from_split));
    xaccSplitSetValue(to_split, xaccSplitGetValue(from_split));
    /* Setting the account is okay here because, even though the from
       split might not really belong to the account it claims to,
       setting the account won't cause any event involving from. */
    xaccSplitSetAccount(to_split, xaccSplitGetAccount(from_split));
    /* N.B. Don't set parent. */
 
    qof_instance_set_dirty(QOF_INSTANCE(to_split));
    xaccTransCommitEdit(to_split->parent);
}

◆ xaccSplitDestroy()

gboolean xaccSplitDestroy ( Split * split )

Destructor.

The xaccSplitDestroy() method will update its parent account and transaction in a consistent manner, resulting in the complete unlinking of the split, and the freeing of its associated memory. The goal of this routine is to perform the removal and destruction of the split in an atomic fashion, with no chance of accidentally leaving the accounting structure out-of-balance or otherwise inconsistent.

It begins and commits an edit on the transaction, so if after the split is removed the transaction has no more splits and if is not open it too will be destroyed, as it will if the outer edits are committed without adding transactions.

Returns: TRUE upon successful deletion of the split. FALSE when the parenting Transaction is a read-only one.

Definition at line 1506 of file Split.cpp.

{
    Account *acc;
    Transaction *trans;
    GncEventData ed;
 
    if (!split) return TRUE;
 
    acc = split->acc;
    trans = split->parent;
    if (acc && !qof_instance_get_destroying(acc)
        && !qof_instance_get_destroying(trans)
        && xaccTransGetReadOnly(trans))
        return FALSE;
 
    xaccTransBeginEdit(trans);
    ed.node = split;
    ed.idx = xaccTransGetSplitIndex(trans, split);
    qof_instance_set_dirty(QOF_INSTANCE(split));
    qof_instance_set_destroying(split, TRUE);
    qof_event_gen(&trans->inst, GNC_EVENT_ITEM_REMOVED, &ed);
    xaccTransCommitEdit(trans);
 
    return TRUE;
}

◆ xaccSplitEqual()

gboolean xaccSplitEqual	(	const Split *	sa,
		const Split *	sb,
		gboolean	check_guids,
		gboolean	check_balances,
		gboolean	check_txn_splits
	)

Equality.

Parameters

sa	First split to compare
sb	Second split to compare
check_guids	If TRUE, try a guid_equal() on the GUIDs of both splits if their pointers are not equal in the first place.
check_balances	If TRUE, compare balances between the two splits. Balances are recalculated whenever a split is added or removed from an account, so YMMV on whether this should be set.
check_txn_splits	If the pointers are not equal, but everything else so far is equal (including memo, amount, value, kvp), then, when comparing the parenting transactions with xaccTransEqual(), set its argument check_splits to be TRUE.

Definition at line 819 of file Split.cpp.

{
    gboolean same_book;
 
    if (!sa && !sb) return TRUE; /* Arguable. FALSE is better, methinks */
 
    if (!sa || !sb)
    {
        PINFO ("one is nullptr");
        return FALSE;
    }
 
    if (sa == sb) return TRUE;
 
    same_book = qof_instance_get_book(QOF_INSTANCE(sa)) == qof_instance_get_book(QOF_INSTANCE(sb));
 
    if (check_guids)
    {
        if (qof_instance_guid_compare(sa, sb) != 0)
        {
            PINFO ("GUIDs differ");
            return FALSE;
        }
    }
 
    /* If the same book, since these strings are cached we can just use pointer equality */
    if ((same_book && sa->memo != sb->memo) || (!same_book && g_strcmp0(sa->memo, sb->memo) != 0))
    {
        PINFO ("memos differ: (%p)%s vs (%p)%s",
               sa->memo, sa->memo, sb->memo, sb->memo);
        return FALSE;
    }
 
    if ((same_book && sa->action != sb->action) || (!same_book && g_strcmp0(sa->action, sb->action) != 0))
    {
        PINFO ("actions differ: %s vs %s", sa->action, sb->action);
        return FALSE;
    }
 
    if (qof_instance_compare_kvp (QOF_INSTANCE (sa), QOF_INSTANCE (sb)) != 0)
    {
        char *frame_a;
        char *frame_b;
 
        frame_a = qof_instance_kvp_as_string (QOF_INSTANCE (sa));
        frame_b = qof_instance_kvp_as_string (QOF_INSTANCE (sb));
 
        PINFO ("kvp frames differ:\n%s\n\nvs\n\n%s", frame_a, frame_b);
 
        g_free (frame_a);
        g_free (frame_b);
 
        return FALSE;
    }
 
    if (sa->reconciled != sb->reconciled)
    {
        PINFO ("reconcile flags differ: %c vs %c", sa->reconciled, sb->reconciled);
        return FALSE;
    }
 
    if (sa->date_reconciled != sb->date_reconciled)
    {
        PINFO ("reconciled date differs");
        return FALSE;
    }
 
    if (!gnc_numeric_eq(xaccSplitGetAmount (sa), xaccSplitGetAmount (sb)))
    {
        char *str_a;
        char *str_b;
 
        str_a = gnc_numeric_to_string (xaccSplitGetAmount (sa));
        str_b = gnc_numeric_to_string (xaccSplitGetAmount (sb));
 
        PINFO ("amounts differ: %s vs %s", str_a, str_b);
 
        g_free (str_a);
        g_free (str_b);
 
        return FALSE;
    }
 
    if (!gnc_numeric_eq(xaccSplitGetValue (sa), xaccSplitGetValue (sb)))
    {
        char *str_a;
        char *str_b;
 
        str_a = gnc_numeric_to_string (xaccSplitGetValue (sa));
        str_b = gnc_numeric_to_string (xaccSplitGetValue (sb));
 
        PINFO ("values differ: %s vs %s", str_a, str_b);
 
        g_free (str_a);
        g_free (str_b);
 
        return FALSE;
    }
 
    if (check_balances)
    {
        if (!xaccSplitEqualCheckBal ("", sa->balance, sb->balance))
            return FALSE;
        if (!xaccSplitEqualCheckBal ("cleared ", sa->cleared_balance,
                                     sb->cleared_balance))
            return FALSE;
        if (!xaccSplitEqualCheckBal ("reconciled ", sa->reconciled_balance,
                                     sb->reconciled_balance))
            return FALSE;
        if (!xaccSplitEqualCheckBal ("noclosing ", sa->noclosing_balance,
                                     sb->noclosing_balance))
            return FALSE;
        if (!xaccSplitEqualCheckBal ("adjusted ", sa->adjusted_amount,
                                     sb->adjusted_amount))
            return FALSE;
    }
 
    if (!xaccTransEqual(sa->parent, sb->parent, check_guids, check_txn_splits,
                        check_balances, FALSE))
    {
        PINFO ("transactions differ");
        return FALSE;
    }
 
    return TRUE;
}

◆ xaccSplitGetAccount()

Account * xaccSplitGetAccount ( const Split * split )

Returns the account of this split, which was set through xaccAccountInsertSplit().

Definition at line 53 of file gmock-Split.cpp.

{
    SCOPED_TRACE("");
    auto mocksplit = gnc_mocksplit(split);
    return mocksplit ? mocksplit->get_account() : nullptr;
}

◆ xaccSplitGetAction()

const char * xaccSplitGetAction ( const Split * split )

Returns the action string.

Rather than use this function directly, see 'gnc_get_num_action' and 'gnc_get_action_num'in engine/engine-helpers.c & .h which takes a user-set book option for selecting the source for the num-cell (the transaction-number or the split-action field) in registers/reports into account automatically

Definition at line 151 of file gmock-Split.cpp.

{
    SCOPED_TRACE("");
    auto mocksplit = gnc_mocksplit(split);
    return mocksplit ? mocksplit->get_action() : "";
}

◆ xaccSplitGetAdjustedAmount()

gnc_numeric xaccSplitGetAdjustedAmount ( const Split * split )

Returns the stock-split adjusted amount of the split in the account's commodity.

Definition at line 1340 of file Split.cpp.

{
    return s ? s->adjusted_amount : gnc_numeric_zero();
}

◆ xaccSplitGetAmount()

gnc_numeric xaccSplitGetAmount ( const Split * split )

Returns the amount of the split in the account's commodity.

Note that for cap-gains splits, this is slaved to the transaction that is causing the gains to occur.

Definition at line 69 of file gmock-Split.cpp.

{
    SCOPED_TRACE("");
    auto mocksplit = gnc_mocksplit(split);
    return mocksplit ? mocksplit->get_amount() : gnc_numeric_zero();
}

◆ xaccSplitGetBalance()

gnc_numeric xaccSplitGetBalance ( const Split * split )

Returns the running balance up to and including the indicated split.

The balance is the currency-denominated balance. For accounts with non-unit share prices, it is correctly adjusted for share prices.

Returns the running balance up to & including the indicated split.

Definition at line 1316 of file Split.cpp.

{
    return s ? s->balance : gnc_numeric_zero();
}

◆ xaccSplitGetBaseValue()

gnc_numeric xaccSplitGetBaseValue	(	const Split *	split,
		const gnc_commodity *	base_currency
	)

Depending on the base_currency, return either the value or the amount of this split: If the base_curreny is the transaction's commodity, return the value.

If it is the account's commodity, return the amount. If it is neither print a warning message and return gnc_numeric_zero().

Definition at line 1410 of file Split.cpp.

{
    if (!s || !s->acc || !s->parent) return gnc_numeric_zero();
 
    /* be more precise -- the value depends on the currency we want it
     * expressed in.  */
    if (gnc_commodity_equiv(xaccTransGetCurrency(s->parent), base_currency))
        return xaccSplitGetValue(s);
    if (gnc_commodity_equiv(xaccAccountGetCommodity(s->acc), base_currency))
        return xaccSplitGetAmount(s);
 
    PERR ("inappropriate base currency %s "
          "given split currency=%s and commodity=%s\n",
          gnc_commodity_get_printname(base_currency),
          gnc_commodity_get_printname(xaccTransGetCurrency (s->parent)),
          gnc_commodity_get_printname(xaccAccountGetCommodity(s->acc)));
    return gnc_numeric_zero();
}

◆ xaccSplitGetBook()

QofBook * xaccSplitGetBook ( const Split * split )

Returns the book of this split, i.e.

the entity where this split is stored.

Definition at line 45 of file gmock-Split.cpp.

{
    SCOPED_TRACE("");
    auto mocksplit = gnc_mocksplit(split);
    return mocksplit ? mocksplit->get_book() : nullptr;
}

◆ xaccSplitGetClearedBalance()

gnc_numeric xaccSplitGetClearedBalance ( const Split * split )

The cleared-balance is the currency-denominated balance of all transactions that have been marked as cleared or reconciled.

It is correctly adjusted for price fluctuations.

Returns the running balance up to & including the indicated split.

Definition at line 1328 of file Split.cpp.

{
    return s ? s->cleared_balance : gnc_numeric_zero();
}

◆ xaccSplitGetCorrAccountCode()

const char * xaccSplitGetCorrAccountCode ( const Split * sa )

document me

Definition at line 1671 of file Split.cpp.

{
    static const char *split_const = nullptr;
    const Split *other_split;
 
    if (!get_corr_account_split(sa, &other_split))
    {
        if (!split_const)
            split_const = C_("Displayed account code of the other account in a multi-split transaction", "Split");
 
        return split_const;
    }
    return xaccAccountGetCode(other_split->acc);
}

◆ xaccSplitGetCorrAccountFullName()

char * xaccSplitGetCorrAccountFullName ( const Split * sa )

These functions take a split, get the corresponding split on the "other side" of the transaction, and extract either the name or code of that split, reverting to returning a constant "Split" if the transaction has more than one split on the "other side".

These were added for the transaction report, and is in C because the code was already written in C for the above functions and duplication is silly.

Note that this will only return a real value in case of a two-split transaction as that is the only situation in which a reliable value can be returned. In other situations "-- Split Transaction --" will be returned as Account Name or "Split" for Account Code.

Definition at line 1655 of file Split.cpp.

{
    static const char *split_const = nullptr;
    const Split *other_split;
 
    if (!get_corr_account_split(sa, &other_split))
    {
        if (!split_const)
            split_const = _("-- Split Transaction --");
 
        return g_strdup(split_const);
    }
    return gnc_account_get_full_name(other_split->acc);
}

◆ xaccSplitGetCorrAccountName()

const char * xaccSplitGetCorrAccountName ( const Split * sa )

document me

Definition at line 1638 of file Split.cpp.

{
    static const char *split_const = nullptr;
    const Split *other_split;
 
    if (!get_corr_account_split(sa, &other_split))
    {
        if (!split_const)
            split_const = _("-- Split Transaction --");
 
        return split_const;
    }
 
    return xaccAccountGetName(other_split->acc);
}

◆ xaccSplitGetDateReconciled()

time64 xaccSplitGetDateReconciled ( const Split * split )

Retrieve the date when the Split was reconciled.

Definition at line 1859 of file Split.cpp.

{
    return split ? split->date_reconciled : 0;
}

◆ xaccSplitGetLot()

GNCLot * xaccSplitGetLot ( const Split * split )

Returns the pointer to the debited/credited Lot where this split belongs to, or NULL if it doesn't belong to any.

Definition at line 1920 of file Split.cpp.

{
    return split ? split->lot : nullptr;
}

◆ xaccSplitGetMemo()

const char * xaccSplitGetMemo ( const Split * split )

Returns the memo string.

Definition at line 99 of file gmock-Split.cpp.

{
    SCOPED_TRACE("");
    auto mocksplit = gnc_mocksplit(split);
    return mocksplit ? mocksplit->get_memo() : "";
}

◆ xaccSplitGetNoclosingBalance()

gnc_numeric xaccSplitGetNoclosingBalance ( const Split * split )

The noclosing-balance is the currency-denominated balance of all transactions except 'closing' transactions.

It is correctly adjusted for price fluctuations.

Returns the running balance up to & including the indicated split.

Definition at line 1322 of file Split.cpp.

{
    return s ? s->noclosing_balance : gnc_numeric_zero();
}

◆ xaccSplitGetOnlineID()

const char * xaccSplitGetOnlineID ( const Split * split )

Returns the split's online_id.

The returned string is owned by the split and must NOT be freed; it is valid until the online_id is changed or the split is destroyed. Returns NULL if no online_id is set.

Definition at line 114 of file gmock-Split.cpp.

{
    SCOPED_TRACE("");
    auto mocksplit = gnc_mocksplit(split);
    return mocksplit ? mocksplit->get_online_id() : nullptr;
}

◆ xaccSplitGetOtherSplit()

Split * xaccSplitGetOtherSplit ( const Split * split )

The xaccSplitGetOtherSplit() is a convenience routine that returns the other of a pair of splits.

If there are more than two splits, it returns NULL.

Definition at line 159 of file gmock-Split.cpp.

{
    SCOPED_TRACE("");
    auto mocksplit = gnc_mocksplit(split);
    return mocksplit ? mocksplit->get_other_split() : nullptr;
}

◆ xaccSplitGetParent()

Transaction * xaccSplitGetParent ( const Split * split )

Returns the parent transaction of the split.

Definition at line 167 of file gmock-Split.cpp.

{
    SCOPED_TRACE("");
    auto mocksplit = gnc_mocksplit(split);
    return mocksplit ? mocksplit->get_parent() : nullptr;
}

◆ xaccSplitGetReconcile()

char xaccSplitGetReconcile ( const Split * split )

Returns the value of the reconcile flag.

Definition at line 129 of file gmock-Split.cpp.

{
    SCOPED_TRACE("");
    auto mocksplit = gnc_mocksplit(split);
    return mocksplit ? mocksplit->get_reconcile() : VREC;
}

◆ xaccSplitGetReconciledBalance()

gnc_numeric xaccSplitGetReconciledBalance ( const Split * split )

Returns the reconciled-balance of this split.

The reconciled-balance is the currency-denominated balance of all transactions that have been marked as reconciled.

Returns the running balance up to & including the indicated split.

Definition at line 1334 of file Split.cpp.

{
    return s ? s->reconciled_balance : gnc_numeric_zero();
}

◆ xaccSplitGetSharePrice()

gnc_numeric xaccSplitGetSharePrice ( const Split * split )

Returns the price of the split, that is, the value divided by the amount.

If the amount is zero, returns a gnc_numeric of value one.

Definition at line 1995 of file Split.cpp.

{
    gnc_numeric amt, val, price;
    if (!split) return gnc_numeric_create(0, 1);
 
 
    /* if amount == 0, return 0
     * otherwise return value/amount
     */
 
    amt = xaccSplitGetAmount(split);
    val = xaccSplitGetValue(split);
    if (gnc_numeric_zero_p(amt))
        return gnc_numeric_create(0, 1);
 
    price = gnc_numeric_div(val, amt,
                            GNC_DENOM_AUTO,
                            GNC_HOW_RND_ROUND_HALF_UP);
 
    /* During random checks we can get some very weird prices.  Let's
     * handle some overflow and other error conditions by returning
     * zero.  But still print an error to let us know it happened.
     */
    if (gnc_numeric_check(price))
    {
        PERR("Computing share price failed (%d): [ %" G_GINT64_FORMAT " / %"
             G_GINT64_FORMAT " ] / [ %" G_GINT64_FORMAT " / %" G_GINT64_FORMAT " ]",
             gnc_numeric_check(price), val.num, val.denom, amt.num, amt.denom);
        return gnc_numeric_create(0, 1);
    }
 
    return price;
}

◆ xaccSplitGetType()

const char * xaccSplitGetType ( Split * s )

Returns the split type, which is either the string "normal", or "stock-split" for a split from a stock split.

Definition at line 2039 of file Split.cpp.

{
    if (!s) return nullptr;
 
    if (!s->split_type)
    {
        auto type{qof_instance_get_path_kvp<const char*> (QOF_INSTANCE(s), {"split-type"})};
 
        if (!type || !g_strcmp0 (*type, split_type_normal))
            s->split_type = split_type_normal;
        else if (!g_strcmp0 (*type, split_type_stock_split))
            s->split_type = split_type_stock_split;
        else
        {
            PERR ("unexpected split-type %s, reset to normal.", *type);
            s->split_type = split_type_normal;
        }
    }
    return s->split_type;
}

◆ xaccSplitGetValue()

gnc_numeric xaccSplitGetValue ( const Split * split )

Returns the value of this split in the transaction's commodity.

Note that for cap-gains splits, this is slaved to the transaction that is causing the gains to occur.

Definition at line 84 of file gmock-Split.cpp.

{
    SCOPED_TRACE("");
    auto mocksplit = gnc_mocksplit(split);
    return mocksplit ? mocksplit->get_value() : gnc_numeric_zero();
}

◆ xaccSplitHasOnlineID()

gboolean xaccSplitHasOnlineID ( const Split * split )

Returns TRUE if the split has a non-empty online_id.

Definition at line 1963 of file Split.cpp.

{
    auto id = xaccSplitGetOnlineID (split);
    return (id && *id);
}

◆ xaccSplitHasPeers()

gboolean xaccSplitHasPeers ( const Split * split )

Does this split have peers?

Definition at line 2102 of file Split.cpp.

{
    return qof_instance_has_slot (QOF_INSTANCE (split), "lot-split");
}

◆ xaccSplitIsPeerSplit()

gboolean xaccSplitIsPeerSplit	(	const Split *	split,
		const Split *	other_split
	)

Report if a split is a peer of this one.

Parameters

other_split The split to test for being a peer of this one.

Returns: : True if other_split is registered as a peer of this one.

Definition at line 2108 of file Split.cpp.

{
    const GncGUID* guid;
 
    g_return_val_if_fail (split != nullptr, FALSE);
    g_return_val_if_fail (other_split != nullptr, FALSE);
 
    guid = qof_instance_get_guid (QOF_INSTANCE (other_split));
    return qof_instance_kvp_has_guid (QOF_INSTANCE (split), "lot-split",
                                      "peer_guid", guid);
}

◆ xaccSplitIsStockSplit()

gboolean xaccSplitIsStockSplit ( Split * s )

Returns true if the split is of type stock split.

Definition at line 2078 of file Split.cpp.

{
    return g_strcmp0(split_type_stock_split, xaccSplitGetType(s)) == 0;
}

◆ xaccSplitLookup()

Split * xaccSplitLookup	(	const GncGUID *	guid,
		QofBook *	book
	)

The xaccSplitLookup() subroutine will return the split associated with the given id, or NULL if there is no such split.

Definition at line 1091 of file Split.cpp.

{
    QofCollection *col;
    if (!guid || !book) return nullptr;
    col = qof_book_get_collection (book, GNC_ID_SPLIT);
    return (Split *) qof_collection_lookup_entity (col, guid);
}

◆ xaccSplitMakeStockSplit()

void xaccSplitMakeStockSplit ( Split * s )

Mark a split to be of type stock split - after this, you shouldn't modify the value anymore, just the amount.

Definition at line 2063 of file Split.cpp.

{
    xaccTransBeginEdit (s->parent);
 
    s->value = gnc_numeric_zero();
    s->split_type = split_type_stock_split;
    qof_instance_set_path_kvp<const char*> (QOF_INSTANCE(s), g_strdup(split_type_stock_split),
                                            {"split-type"});
    SET_GAINS_VDIRTY(s);
    mark_split(s);
    qof_instance_set_dirty(QOF_INSTANCE(s));
    xaccTransCommitEdit(s->parent);
}

◆ xaccSplitMergePeerSplits()

void xaccSplitMergePeerSplits	(	Split *	split,
		const Split *	other_split
	)

Merge the other_split's peer splits into split's peers.

Parameters

other_split The split donating the peer splits.

Definition at line 2138 of file Split.cpp.

{
    xaccTransBeginEdit (split->parent);
    qof_instance_kvp_merge_guids (QOF_INSTANCE (split),
                                  QOF_INSTANCE (other_split), "lot-split");
    mark_split (split);
    qof_instance_set_dirty (QOF_INSTANCE (split));
    xaccTransCommitEdit (split->parent);
}

◆ xaccSplitOrder()

gint xaccSplitOrder	(	const Split *	sa,
		const Split *	sb
	)

The xaccSplitOrder(sa,sb) method is useful for sorting.

if sa and sb have different transactions, return their xaccTransOrder return a negative value if split sa has a smaller currency-value than sb, return a positive value if split sa has a larger currency-value than sb, return a negative value if split sa has a smaller share-price than sb, return a positive value if split sa has a larger share-price than sb, then compares memo and action using the strcmp() c-library routine, returning what strcmp would return. Then it compares the reconciled flags, then the reconciled dates, Finally, it returns zero if all of the above match.

Definition at line 1536 of file Split.cpp.

{
    int retval;
    int comp;
    const char *da, *db;
    gboolean action_for_num;
 
    if (sa == sb) return 0;
    /* nothing is always less than something */
    if (!sa) return -1;
    if (!sb) return +1;
 
    /* sort in transaction order, but use split action rather than trans num
     * according to book option */
    action_for_num = qof_book_use_split_action_for_num_field
        (xaccSplitGetBook (sa));
    if (action_for_num)
        retval = xaccTransOrder_num_action (sa->parent, sa->action,
                                            sb->parent, sb->action);
    else
        retval = xaccTransOrder (sa->parent, sb->parent);
    if (retval) return retval;
 
    /* otherwise, sort on memo strings */
    da = sa->memo ? sa->memo : "";
    db = sb->memo ? sb->memo : "";
    retval = g_utf8_collate (da, db);
    if (retval)
        return retval;
 
    /* otherwise, sort on action strings */
    da = sa->action ? sa->action : "";
    db = sb->action ? sb->action : "";
    retval = g_utf8_collate (da, db);
    if (retval != 0)
        return retval;
 
    /* the reconciled flag ... */
    if (sa->reconciled < sb->reconciled) return -1;
    if (sa->reconciled > sb->reconciled) return +1;
 
    /* compare amounts */
    comp = gnc_numeric_compare(xaccSplitGetAmount(sa), xaccSplitGetAmount (sb));
    if (comp < 0) return -1;
    if (comp > 0) return +1;
 
    comp = gnc_numeric_compare(xaccSplitGetValue(sa), xaccSplitGetValue (sb));
    if (comp < 0) return -1;
    if (comp > 0) return +1;
 
    /* if dates differ, return */
    if (sa->date_reconciled < sb->date_reconciled)
        return -1;
    else if (sa->date_reconciled > sb->date_reconciled)
        return 1;
 
    /* else, sort on guid - keeps sort stable. */
    retval = qof_instance_guid_compare(sa, sb);
    if (retval) return retval;
 
    return 0;
}

◆ xaccSplitOrderDateOnly()

gint xaccSplitOrderDateOnly	(	const Split *	sa,
		const Split *	sb
	)

Definition at line 1600 of file Split.cpp.

{
    Transaction *ta, *tb;
 
    if (sa == sb) return 0;
    /* nothing is always less than something */
    if (!sa) return -1;
    if (!sb) return +1;
 
    ta = sa->parent;
    tb = sb->parent;
    if ( !ta && !tb ) return 0;
    if ( !tb ) return -1;
    if ( !ta ) return +1;
 
    if (ta->date_posted == tb->date_posted)
        return -1; // Keep the same order
    return (ta->date_posted > tb->date_posted) - (ta->date_posted < tb->date_posted);
}

◆ xaccSplitReinit()

void xaccSplitReinit ( Split * split )

Definition at line 505 of file Split.cpp.

{
    /* fill in some sane defaults */
    split->acc         = nullptr;
    split->orig_acc    = nullptr;
    split->parent      = nullptr;
    split->lot         = nullptr;
 
    CACHE_REPLACE(split->action, "");
    CACHE_REPLACE(split->memo, "");
    split->reconciled  = NREC;
    split->amount      = gnc_numeric_zero();
    split->value       = gnc_numeric_zero();
 
    split->date_reconciled  = 0;
 
    split->balance             = gnc_numeric_zero();
    split->cleared_balance     = gnc_numeric_zero();
    split->reconciled_balance  = gnc_numeric_zero();
    split->noclosing_balance   = gnc_numeric_zero();
 
    split->adjusted_amount     = gnc_numeric_zero();
    split->split_type          = nullptr;
 
    qof_instance_set_idata(split, 0);
 
    split->gains = GAINS_STATUS_UNKNOWN;
    split->gains_split = nullptr;
}

◆ xaccSplitRemovePeerSplit()

void xaccSplitRemovePeerSplit	(	Split *	split,
		const Split *	other_split
	)

Remove a peer split from this split's lot-split list.

Parameters

other_split The split whose guid to remove

Definition at line 2121 of file Split.cpp.

{
    const GncGUID* guid;
 
    g_return_if_fail (split != nullptr);
    g_return_if_fail (other_split != nullptr);
 
    guid = qof_instance_get_guid (QOF_INSTANCE (other_split));
    xaccTransBeginEdit (split->parent);
    qof_instance_kvp_remove_guid (QOF_INSTANCE (split), "lot-split",
                                  "peer_guid", guid);
    mark_split (split);
    qof_instance_set_dirty (QOF_INSTANCE (split));
    xaccTransCommitEdit (split->parent);
}

◆ xaccSplitSetAccount()

void xaccSplitSetAccount	(	Split *	s,
		Account *	acc
	)

Definition at line 61 of file gmock-Split.cpp.

{
    ASSERT_TRUE(GNC_IS_MOCKSPLIT(split));
    ASSERT_TRUE(GNC_IS_ACCOUNT(acc));
    gnc_mocksplit(split)->set_account(acc);
}

◆ xaccSplitSetAction()

void xaccSplitSetAction	(	Split *	split,
		const char *	action
	)

The Action is an arbitrary user-assigned string.

The action field is an arbitrary user-assigned value. It is meant to be a very short (one to ten character) string that signifies the "type" of this split, such as e.g. Buy, Sell, Div, Withdraw, Deposit, ATM, Check, etc. The idea is that this field can be used to create custom reports or graphs of data. Note that the business features auto-fill this value, but doesn't depend on it. Rather than use this function directly, see 'gnc_set_num_action' in engine/engine-helpers.c & .h which takes a user-set book option for selecting the source for the num-cell (the transaction-number or the split-action field) in registers/reports into account automatically

Definition at line 1786 of file Split.cpp.

{
    if (!split || !actn) return;
    xaccTransBeginEdit (split->parent);
 
    CACHE_REPLACE(split->action, actn);
    qof_instance_set_dirty(QOF_INSTANCE(split));
    xaccTransCommitEdit(split->parent);
 
}

◆ xaccSplitSetAdjustedAmount()

void xaccSplitSetAdjustedAmount	(	Split *	split,
		gnc_numeric	amount
	)

Sets the stock split adjusted amount of a split.

Note: The adjusted amount will be reset when the account is rebalanced.

Definition at line 1346 of file Split.cpp.

{
    if  (!s) return;
    if (gnc_numeric_check (amt)) return;
 
    s->adjusted_amount = amt;
}

◆ xaccSplitSetAmount()

void xaccSplitSetAmount	(	Split *	split,
		gnc_numeric	amount
	)

The xaccSplitSetAmount() method sets the amount in the account's commodity that the split should have.

The following four setter functions set the prices and amounts. All of the routines always maintain balance: that is, invoking any of them will cause other splits in the transaction to be modified so that the net value of the transaction is zero.

IMPORTANT: The split should be parented by an account before any of these routines are invoked! This is because the actual setting of amounts/values requires SCU settings from the account. If these are not available, then amounts/values will be set to -1/0, which is an invalid value. I believe this order dependency is a bug, but I'm too lazy to find, fix & test at the moment ...

Note: If you use this on a newly created transaction, make sure that the 'value' is also set so that it doesn't remain zero.

Definition at line 77 of file gmock-Split.cpp.

{
    ASSERT_TRUE(GNC_IS_MOCKSPLIT(split));
    gnc_mocksplit(split)->set_amount(amt);
}

◆ xaccSplitSetBaseValue()

void xaccSplitSetBaseValue	(	Split *	split,
		gnc_numeric	value,
		const gnc_commodity *	base_currency
	)

Depending on the base_currency, set either the value or the amount of this split or both: If the base_currency is the transaction's commodity, set the value.

If it is the account's commodity, set the amount. If both, set both.

Note: WATCH OUT: When using this function and the transaction's and account's commodities are different, the amount or the value will be left as zero. This might screw up the multi-currency handling code in the register. So please think twice whether you need this function – using xaccSplitSetValue() together with xaccSplitSetAmount() is definitely the better and safer solution!

Definition at line 1355 of file Split.cpp.

{
    const gnc_commodity *currency;
    const gnc_commodity *commodity;
 
    if (!s) return;
    xaccTransBeginEdit (s->parent);
 
    if (!s->acc)
    {
        PERR ("split must have a parent account");
        return;
    }
 
    currency = xaccTransGetCurrency (s->parent);
    commodity = xaccAccountGetCommodity (s->acc);
 
    /* If the base_currency is the transaction's commodity ('currency'),
     * set the value.  If it's the account commodity, set the
     * amount. If both, set both. */
    if (gnc_commodity_equiv(currency, base_currency))
    {
        if (gnc_commodity_equiv(commodity, base_currency))
        {
            s->amount = gnc_numeric_convert(value,
                                            get_commodity_denom(s),
                                            GNC_HOW_RND_ROUND_HALF_UP);
        }
        s->value = gnc_numeric_convert(value,
                                       get_currency_denom(s),
                                       GNC_HOW_RND_ROUND_HALF_UP);
    }
    else if (gnc_commodity_equiv(commodity, base_currency))
    {
        s->amount = gnc_numeric_convert(value, get_commodity_denom(s),
                                        GNC_HOW_RND_ROUND_HALF_UP);
    }
    else
    {
        PERR ("inappropriate base currency %s "
              "given split currency=%s and commodity=%s\n",
              gnc_commodity_get_printname(base_currency),
              gnc_commodity_get_printname(currency),
              gnc_commodity_get_printname(commodity));
        return;
    }
 
    SET_GAINS_A_VDIRTY(s);
    mark_split (s);
    qof_instance_set_dirty(QOF_INSTANCE(s));
    xaccTransCommitEdit(s->parent);
}

◆ xaccSplitSetDateReconciledSecs()

void xaccSplitSetDateReconciledSecs	(	Split *	split,
		time64	time
	)

Set the date on which this split was reconciled by specifying the time as time64.

Definition at line 144 of file gmock-Split.cpp.

{
    ASSERT_TRUE(GNC_IS_MOCKSPLIT(split));
    gnc_mocksplit(split)->set_date_reconciled_secs(secs);
}

◆ xaccSplitSetLot()

void xaccSplitSetLot	(	Split *	split,
		GNCLot *	lot
	)

Assigns the split to a specific Lot.

Definition at line 1926 of file Split.cpp.

{
    xaccTransBeginEdit (split->parent);
    split->lot = lot;
    qof_instance_set_dirty(QOF_INSTANCE(split));
    xaccTransCommitEdit(split->parent);
}

◆ xaccSplitSetMemo()

void xaccSplitSetMemo	(	Split *	split,
		const char *	memo
	)

The memo is an arbitrary string associated with a split.

It is intended to hold a short (zero to forty character) string that is displayed by the GUI along with this split. Users typically type in free form text from the GUI.

Definition at line 107 of file gmock-Split.cpp.

{
    ASSERT_TRUE(GNC_IS_MOCKSPLIT(split));
    gnc_mocksplit(split)->set_memo(memo);
}

◆ xaccSplitSetOnlineID()

void xaccSplitSetOnlineID	(	Split *	split,
		const char *	id
	)

The online_id is the OFX/HBCI "FITID" recorded on a split when it is imported.

It is used to recognise the split on re-import so that overlapping or re-downloaded statements don't create duplicates. This is the same value (engine KVP slot "online_id") that the desktop OFX/HBCI importer reads and writes.

The setter only changes engine data: call it inside the parent transaction's edit (xaccTransBeginEdit()/xaccTransCommitEdit()), and a session save persists it. Passing NULL or "" clears the online_id.

Definition at line 122 of file gmock-Split.cpp.

{
    ASSERT_TRUE(GNC_IS_MOCKSPLIT(split));
    gnc_mocksplit(split)->set_online_id(id);
}

◆ xaccSplitSetParent()

void xaccSplitSetParent	(	Split *	split,
		Transaction *	trans
	)

Definition at line 175 of file gmock-Split.cpp.

{
    ASSERT_TRUE(GNC_IS_MOCKSPLIT(split));
    ASSERT_TRUE(GNC_IS_TRANSACTION(trans));
    gnc_mocksplit(split)->set_parent(trans);
}

◆ xaccSplitSetReconcile()

void xaccSplitSetReconcile	(	Split *	split,
		char	reconciled_flag
	)

Set the reconcile flag.

The Reconcile flag is a single char, whose values are typically are 'n', 'y', 'c'. In Transaction.h, macros are defined for typical values (e.g. CREC, YREC).

Definition at line 137 of file gmock-Split.cpp.

{
    ASSERT_TRUE(GNC_IS_MOCKSPLIT(split));
    gnc_mocksplit(split)->set_reconcile(recn);
}

◆ xaccSplitSetSharePrice()

void xaccSplitSetSharePrice	(	Split *	split,
		gnc_numeric	price
	)

Deprecated:: The xaccSplitSetSharePrice() method sets the price of the split. DEPRECATED - set the value and amount instead.

Definition at line 1205 of file Split.cpp.

{
    if (!s) return;
 
    if (gnc_numeric_zero_p (price))
        return;
 
    ENTER (" ");
    xaccTransBeginEdit (s->parent);
 
    s->value = gnc_numeric_mul(xaccSplitGetAmount(s),
                               price, get_currency_denom(s),
                               GNC_HOW_RND_ROUND_HALF_UP);
 
    SET_GAINS_VDIRTY(s);
    mark_split (s);
    qof_instance_set_dirty(QOF_INSTANCE(s));
    xaccTransCommitEdit(s->parent);
    LEAVE ("");
}

◆ xaccSplitSetSharePriceAndAmount()

void xaccSplitSetSharePriceAndAmount	(	Split *	split,
		gnc_numeric	price,
		gnc_numeric	amount
	)

The xaccSplitSetSharePriceAndAmount() method will simultaneously update the share price and the number of shares.

This is a utility routine that is equivalent to a xaccSplitSetSharePrice() followed by and xaccSplitSetAmount(), except that it incurs the processing overhead of balancing only once, instead of twice.

Definition at line 1177 of file Split.cpp.

{
    if (!s) return;
    ENTER (" ");
    xaccTransBeginEdit (s->parent);
 
    s->amount = gnc_numeric_convert(amt, get_commodity_denom(s),
                                    GNC_HOW_RND_ROUND_HALF_UP);
    s->value  = gnc_numeric_mul(s->amount, price,
                                get_currency_denom(s), GNC_HOW_RND_ROUND_HALF_UP);
 
    SET_GAINS_A_VDIRTY(s);
    mark_split (s);
    qof_instance_set_dirty(QOF_INSTANCE(s));
    xaccTransCommitEdit(s->parent);
    LEAVE ("");
}

◆ xaccSplitSetValue()

void xaccSplitSetValue	(	Split *	split,
		gnc_numeric	value
	)

The xaccSplitSetValue() method sets the value of this split in the transaction's commodity.

Note: If you use this on a newly created transaction, make sure that the 'amount' is also set so that it doesn't remain zero.

Definition at line 92 of file gmock-Split.cpp.

{
    ASSERT_TRUE(GNC_IS_MOCKSPLIT(split));
    gnc_mocksplit(split)->set_value(val);
}

◆ xaccSplitVoidFormerAmount()

gnc_numeric xaccSplitVoidFormerAmount ( const Split * split )

Returns the original pre-void amount of a split.

Parameters

split The split in question.

Returns: A gnc_numeric containing the original value of this split. Returns a gnc_numeric of zero upon error.

Definition at line 2191 of file Split.cpp.

{
    g_return_val_if_fail(split, gnc_numeric_zero());
    auto num{qof_instance_get_path_kvp<gnc_numeric> (QOF_INSTANCE(split), {void_former_amt_str})};
    return num ? *num : gnc_numeric_zero();
}

◆ xaccSplitVoidFormerValue()

gnc_numeric xaccSplitVoidFormerValue ( const Split * split )

Returns the original pre-void value of a split.

Parameters

split The split in question.

Returns: A gnc_numeric containing the original amount of this split. Returns a gnc_numeric of zero upon error.

Definition at line 2199 of file Split.cpp.

{
    g_return_val_if_fail(split, gnc_numeric_zero());
    auto num{qof_instance_get_path_kvp<gnc_numeric> (QOF_INSTANCE(split), {void_former_val_str})};
    return num ? *num : gnc_numeric_zero();
}

Files

Macros

Functions

Split general getters/setters

Split Date getters/setters

Split amount getters/setters

Split utility functions

Split deprecated functions

Split voiding

Split Reconciled field values

Split Parameter names

Detailed Description

Macro Definition Documentation

◆ CREC

◆ FREC

◆ GNC_IS_SPLIT

◆ GNC_IS_SPLIT_CLASS

◆ GNC_SPLIT

◆ GNC_SPLIT_CLASS

◆ GNC_SPLIT_GET_CLASS

◆ GNC_TYPE_SPLIT

◆ NREC

◆ SPLIT_ACCOUNT

◆ SPLIT_ACCOUNT_GUID

◆ SPLIT_ACCT_FULLNAME

◆ SPLIT_ACTION

◆ SPLIT_AMOUNT

◆ SPLIT_BALANCE

◆ SPLIT_CLEARED_BALANCE

◆ SPLIT_CORR_ACCT_CODE

◆ SPLIT_CORR_ACCT_NAME

◆ SPLIT_DATE_RECONCILED

◆ SPLIT_LOT

◆ SPLIT_MEMO

◆ SPLIT_RECONCILE

◆ SPLIT_RECONCILED_BALANCE

◆ SPLIT_SHARE_PRICE

◆ SPLIT_TRANS

◆ SPLIT_TYPE

◆ SPLIT_VALUE

◆ SPLIT_VOIDED_AMOUNT

◆ SPLIT_VOIDED_VALUE

◆ VREC

◆ xaccSplitGetGUID

◆ xaccSplitLookupDirect

◆ YREC

Function Documentation

◆ gnc_split_get_type()

◆ xaccMallocSplit()

◆ xaccSplitAddPeerSplit()

◆ xaccSplitCompareAccountCodes()

◆ xaccSplitCompareAccountFullNames()

◆ xaccSplitCompareOtherAccountCodes()

◆ xaccSplitCompareOtherAccountFullNames()

◆ xaccSplitConvertAmount()

◆ xaccSplitCopyOnto()

◆ xaccSplitDestroy()

◆ xaccSplitEqual()

◆ xaccSplitGetAccount()

◆ xaccSplitGetAction()

◆ xaccSplitGetAdjustedAmount()

◆ xaccSplitGetAmount()

◆ xaccSplitGetBalance()

◆ xaccSplitGetBaseValue()

◆ xaccSplitGetBook()

◆ xaccSplitGetClearedBalance()

◆ xaccSplitGetCorrAccountCode()

◆ xaccSplitGetCorrAccountFullName()

◆ xaccSplitGetCorrAccountName()

◆ xaccSplitGetDateReconciled()

◆ xaccSplitGetLot()

◆ xaccSplitGetMemo()

◆ xaccSplitGetNoclosingBalance()

◆ xaccSplitGetOnlineID()

◆ xaccSplitGetOtherSplit()

◆ xaccSplitGetParent()

◆ xaccSplitGetReconcile()

◆ xaccSplitGetReconciledBalance()

◆ xaccSplitGetSharePrice()

◆ xaccSplitGetType()