Account.h

Go to the documentation of this file.

/********************************************************************\
 * This program is free software; you can redistribute it and/or    *
 * modify it under the terms of the GNU General Public License as   *
 * published by the Free Software Foundation; either version 2 of   *
 * the License, or (at your option) any later version.              *
 *                                                                  *
 * This program is distributed in the hope that it will be useful,  *
 * but WITHOUT ANY WARRANTY; without even the implied warranty of   *
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the    *
 * GNU General Public License for more details.                     *
 *                                                                  *
 * You should have received a copy of the GNU General Public License*
 * along with this program; if not, contact:                        *
 *                                                                  *
 * Free Software Foundation           Voice:  +1-617-542-5942       *
 * 51 Franklin Street, Fifth Floor    Fax:    +1-617-542-2652       *
 * Boston, MA  02110-1301,  USA       gnu@gnu.org                   *
 *                                                                  *
\********************************************************************/
#ifndef XACC_ACCOUNT_H
#define XACC_ACCOUNT_H
#include "qof.h"
#include "gnc-engine.h"
#include "policy.h"

#ifdef __cplusplus
extern "C" {
#endif
typedef gnc_numeric (*xaccGetBalanceFn)( const Account *account );

typedef gnc_numeric (*xaccGetBalanceInCurrencyFn) (
    const Account *account, const gnc_commodity *report_commodity,
    gboolean include_children);

typedef gnc_numeric (*xaccGetBalanceAsOfDateFn) (
    Account *account, time64 date);

typedef void (*AccountCb)(Account *a, gpointer data);
typedef gpointer (*AccountCb2)(Account *a, gpointer data);

typedef struct
{
    QofInstanceClass parent_class;
} AccountClass;

/* --- type macros --- */
#define GNC_TYPE_ACCOUNT            (gnc_account_get_type ())
#define GNC_ACCOUNT(o)              \
     (G_TYPE_CHECK_INSTANCE_CAST ((o), GNC_TYPE_ACCOUNT, Account))
#define GNC_ACCOUNT_CLASS(k)        \
     (G_TYPE_CHECK_CLASS_CAST((k), GNC_TYPE_ACCOUNT, AccountClass))
#define GNC_IS_ACCOUNT(o)           \
     (G_TYPE_CHECK_INSTANCE_TYPE ((o), GNC_TYPE_ACCOUNT))
#define GNC_IS_ACCOUNT_CLASS(k)     \
     (G_TYPE_CHECK_CLASS_TYPE ((k), GNC_TYPE_ACCOUNT))
#define GNC_ACCOUNT_GET_CLASS(o)    \
     (G_TYPE_INSTANCE_GET_CLASS ((o), GNC_TYPE_ACCOUNT, AccountClass))

GType gnc_account_get_type(void);

#ifdef __cplusplus
enum GNCAccountType
#else
typedef enum
#endif
{
    ACCT_TYPE_INVALID = -1, 
    ACCT_TYPE_NONE = -1,
    ACCT_TYPE_BANK = 0,    
    ACCT_TYPE_CASH = 1,    
    ACCT_TYPE_CREDIT = 3,    
    ACCT_TYPE_ASSET = 2,    
    ACCT_TYPE_LIABILITY = 4,
    ACCT_TYPE_STOCK = 5,    
    ACCT_TYPE_MUTUAL = 6,    
    ACCT_TYPE_CURRENCY = 7,
    ACCT_TYPE_INCOME = 8,    
    ACCT_TYPE_EXPENSE = 9,
    ACCT_TYPE_EQUITY = 10,
    ACCT_TYPE_RECEIVABLE = 11,
    ACCT_TYPE_PAYABLE = 12,  
    ACCT_TYPE_ROOT = 13, 
    ACCT_TYPE_TRADING = 14, 
    NUM_ACCOUNT_TYPES = 15,  
    /* bank account types */
    ACCT_TYPE_CHECKING = 15, 
    ACCT_TYPE_SAVINGS = 16, 
    ACCT_TYPE_MONEYMRKT = 17, 
    ACCT_TYPE_CREDITLINE = 18, 
    ACCT_TYPE_LAST
#ifdef __cplusplus
};
#else
} GNCAccountType;
#endif


    Account * xaccMallocAccount (QofBook *book);

    Account * gnc_account_create_root (QofBook *book);

    Account * xaccCloneAccount (const Account *source, QofBook *book);

    void xaccAccountBeginEdit (Account *account);

    void xaccAccountCommitEdit (Account *account);

    void xaccAccountDestroy (Account *account);

    void xaccAccountDestroyAllTransactions(Account *acc);

    gboolean xaccAccountEqual(const Account *a, const Account* b,
                              gboolean check_guids);

    int xaccAccountOrder (const Account *account_1, const Account *account_2);

    /* ------------------ */

    const gchar *gnc_get_account_separator_string (void);
    gunichar gnc_get_account_separator (void);
    void gnc_set_account_separator (const gchar *separator);

    /*@ dependent @*/
    Account *gnc_book_get_root_account(QofBook *book);
    void gnc_book_set_root_account(QofBook *book, Account *root);

#define xaccAccountGetGUID(X)     qof_entity_get_guid(QOF_INSTANCE(X))
#define xaccAccountReturnGUID(X) (X ? *(qof_entity_get_guid(QOF_INSTANCE(X))) : *(guid_null()))

    /*@ dependent @*/ Account * xaccAccountLookup (const GncGUID *guid, QofBook *book);
#define xaccAccountLookupDirect(g,b) xaccAccountLookup(&(g),b)

    /*  Tests account and descendants -- if all have no splits then return TRUE.
     *  Otherwise if any account or its descendants have split return FALSE.
     */

    gboolean gnc_account_and_descendants_empty (Account *acc);

    gchar *gnc_account_name_violations_errmsg (const gchar *separator, GList* invalid_account_names);

    GList *gnc_account_list_name_violations (QofBook *book, const gchar *separator);

    /* ------------------ */

    QofBook *gnc_account_get_book(const Account *account);
    void xaccAccountSetType (Account *account, GNCAccountType);
    void xaccAccountSetName (Account *account, const char *name);
    void xaccAccountSetCode (Account *account, const char *code);
    void xaccAccountSetDescription (Account *account, const char *desc);
    void xaccAccountSetColor (Account *account, const char *color);
    void xaccAccountSetFilter (Account *account, const char *filter);
    void xaccAccountSetSortOrder (Account *account, const char *sortorder);
    void xaccAccountSetSortReversed (Account *account, gboolean sortreversed);
    void xaccAccountSetNotes (Account *account, const char *notes);

    void xaccAccountSetOnlineID (Account *account, const char *id);

    void xaccAccountSetAssociatedAccount (Account *acc, const char *tag,
                                          const Account *assoc_acct);

    void xaccAccountSetLastNum (Account *account, const char *num);
    void gnc_account_set_policy (Account *account, GNCPolicy *policy);
    GNCAccountType xaccAccountGetType (const Account *account);
    gboolean xaccAccountIsPriced(const Account *acc);

    void gnc_account_set_start_balance (Account *acc,
                                        const gnc_numeric start_baln);

    void gnc_account_set_start_cleared_balance (Account *acc,
            const gnc_numeric start_baln);

    void gnc_account_set_start_reconciled_balance (Account *acc,
            const gnc_numeric start_baln);

    void gnc_account_set_balance_dirty (Account *acc);

    void gnc_account_set_sort_dirty (Account *acc);

    void gnc_account_set_defer_bal_computation (Account *acc, gboolean defer);

    gboolean gnc_account_insert_split (Account *acc, Split *s);

    gboolean gnc_account_remove_split (Account *acc, Split *s);

    const char * xaccAccountGetName (const Account *account);
    const char * xaccAccountGetCode (const Account *account);
    const char * xaccAccountGetDescription (const Account *account);
    const char * xaccAccountGetColor (const Account *account);
    const char * xaccAccountGetFilter (const Account *account);
    const char * xaccAccountGetSortOrder (const Account *account);
    gboolean xaccAccountGetSortReversed (const Account *account);
    const char * xaccAccountGetNotes (const Account *account);

    const char * xaccAccountGetOnlineID (const Account *account);

    Account* xaccAccountGetAssociatedAccount (const Account *acc, const char *tag);
    const char * xaccAccountGetLastNum (const Account *account);
    GNCPolicy *gnc_account_get_policy (Account *account);
    gboolean gnc_account_get_defer_bal_computation (Account *acc);

    void xaccAccountRecomputeBalance (Account *);

    void xaccAccountSortSplits (Account *acc, gboolean force);

    gchar * gnc_account_get_full_name (const Account *account);

    Account * xaccAccountGainsAccount (Account *acc, gnc_commodity *curr);
    void dxaccAccountSetPriceSrc (Account *account, const char *src);
    const char * dxaccAccountGetPriceSrc (const Account *account);
    void xaccAccountSetCommodity (Account *account, gnc_commodity *comm);

    /*@ dependent @*/
    gnc_commodity * xaccAccountGetCommodity (const Account *account);

    gnc_commodity * gnc_account_get_currency_or_parent(const Account* account);

    int xaccAccountGetCommoditySCU (const Account *account);

    int xaccAccountGetCommoditySCUi (const Account *account);

    void xaccAccountSetCommoditySCU (Account *account, int frac);

    void xaccAccountSetNonStdSCU (Account *account, gboolean flag);

    gboolean  xaccAccountGetNonStdSCU (const Account *account);
    gnc_numeric xaccAccountGetBalance (const Account *account);
    gnc_numeric xaccAccountGetClearedBalance (const Account *account);
    gnc_numeric xaccAccountGetReconciledBalance (const Account *account);
    gnc_numeric xaccAccountGetPresentBalance (const Account *account);
    gnc_numeric xaccAccountGetProjectedMinimumBalance (const Account *account);
    gnc_numeric xaccAccountGetBalanceAsOfDate (Account *account,
            time64 date);

    gnc_numeric xaccAccountGetReconciledBalanceAsOfDate (Account *account, time64 date);

    /* These two functions convert a given balance from one commodity to
       another.  The account argument is only used to get the Book, and
       may have nothing to do with the supplied balance.  Likewise, the
       date argument is only used for commodity conversion and may have
       nothing to do with supplied balance.

       Since they really have nothing to do with Accounts, there's
       probably some better place for them, but where?  gnc-commodity.h?
    */
    gnc_numeric xaccAccountConvertBalanceToCurrency(
        const Account *account, /* for book */
        gnc_numeric balance,
        const gnc_commodity *balance_currency,
        const gnc_commodity *new_currency);
    gnc_numeric xaccAccountConvertBalanceToCurrencyAsOfDate(
        const Account *account, /* for book */
        gnc_numeric balance, const gnc_commodity *balance_currency,
        const gnc_commodity *new_currency, time64 date);

    /* These functions get some type of balance in the desired commodity.
       'report_commodity' may be NULL to use the account's commodity. */
    gnc_numeric xaccAccountGetBalanceInCurrency (
        const Account *account, const gnc_commodity *report_commodity,
        gboolean include_children);
    gnc_numeric xaccAccountGetClearedBalanceInCurrency (
        const Account *account, const gnc_commodity *report_commodity,
        gboolean include_children);
    gnc_numeric xaccAccountGetReconciledBalanceInCurrency (
        const Account *account, const gnc_commodity *report_commodity,
        gboolean include_children);
    gnc_numeric xaccAccountGetPresentBalanceInCurrency (
        const Account *account, const gnc_commodity *report_commodity,
        gboolean include_children);
    gnc_numeric xaccAccountGetProjectedMinimumBalanceInCurrency (
        const Account *account, const gnc_commodity *report_commodity,
        gboolean include_children);

    gnc_numeric xaccAccountGetNoclosingBalanceAsOfDateInCurrency(
        Account *acc, time64 date, gnc_commodity *report_commodity,
        gboolean include_children);
    gnc_numeric xaccAccountGetBalanceAsOfDateInCurrency(
        Account *account, time64 date, gnc_commodity *report_commodity,
        gboolean include_children);

    gnc_numeric xaccAccountGetNoclosingBalanceChangeForPeriod (
        Account *acc, time64 date1, time64 date2, gboolean recurse);
    gnc_numeric xaccAccountGetNoclosingBalanceChangeInCurrencyForPeriod (
        Account *acc, time64 date1, time64 date2, gboolean recurse);          
    gnc_numeric xaccAccountGetBalanceChangeForPeriod (
        Account *acc, time64 date1, time64 date2, gboolean recurse);

    gboolean xaccAccountHasStockSplit (const Account *acc);

    void gnc_account_append_child (Account *new_parent, Account *child);

    void gnc_account_remove_child (Account *parent, Account *child);

    /*@ dependent @*/
    Account * gnc_account_get_parent (const Account *account);

    Account * gnc_account_get_root (Account *account);

    gboolean gnc_account_is_root (const Account *account);

    GList *gnc_account_get_children (const Account *account);

    GList *gnc_account_get_children_sorted (const Account *account);

    gint gnc_account_n_children (const Account *account);

    gint gnc_account_child_index (const Account *parent, const Account *child);

    Account *gnc_account_nth_child (const Account *parent, gint num);

    GList * gnc_account_get_descendants (const Account *account);

    GList *gnc_account_get_descendants_sorted (const Account *account);

    gint gnc_account_n_descendants (const Account *account);

    gint gnc_account_get_current_depth (const Account *account);

    gint gnc_account_get_tree_depth (const Account *account);

    void gnc_account_foreach_child (const Account *account,
                                    AccountCb func, /*@ null @*/ gpointer user_data);

    void gnc_account_foreach_descendant (const Account *account,
                                         AccountCb func, /*@ null @*/ gpointer user_data);

    gpointer gnc_account_foreach_descendant_until (const Account *account,
            AccountCb2 func, /*@ null @*/ gpointer user_data);


    void gnc_account_join_children (Account *to_parent, Account *from_parent);

    void gnc_account_merge_children (Account *parent);

    void xaccAccountSetReconcileChildrenStatus(Account *account, gboolean status);

    gboolean xaccAccountGetReconcileChildrenStatus(const Account *account);

    gboolean xaccAccountHasAncestor(const Account *acc, const Account *ancestor);

    Account *gnc_account_lookup_by_name (const Account *parent, const char *name);

    Account *gnc_account_lookup_by_full_name (const Account *any_account,
            const gchar *name);

    Account *gnc_account_lookup_by_code (const Account *parent,
                                         const char *code);

    Account *gnc_account_lookup_by_opening_balance (Account *account, gnc_commodity *commodity);

    GList *gnc_account_lookup_by_type_and_commodity (Account* root,
                                                     const char* name,
                                                     GNCAccountType acctype,
                                                     gnc_commodity* commodity);
    /* ------------------ */

    const char * xaccAccountTypeEnumAsString (GNCAccountType type);
    gboolean xaccAccountStringToType (const char* str, GNCAccountType *type);
    GNCAccountType xaccAccountStringToEnum (const char* str);

    const char * xaccAccountGetTypeStr (GNCAccountType type);

    guint32 xaccAccountTypesCompatibleWith (GNCAccountType type);

    guint32 xaccParentAccountTypesCompatibleWith (GNCAccountType type);

    gboolean xaccAccountTypesCompatible (GNCAccountType parent_type,
                                         GNCAccountType child_type);

    guint32 xaccAccountTypesValid(void);

    gboolean xaccAccountIsAssetLiabType(GNCAccountType t);

    GNCAccountType xaccAccountTypeGetFundamental (GNCAccountType t);


    gboolean xaccAccountIsAPARType(GNCAccountType t);

    gboolean xaccAccountIsEquityType(GNCAccountType t);


    /* ------------------ */

#define xaccAccountInsertSplit(acc, s)  xaccSplitSetAccount((s), (acc))

    SplitList* xaccAccountGetSplitList (const Account *account);

    size_t xaccAccountGetSplitsSize (const Account *account);

    void xaccAccountMoveAllSplits (Account *accfrom, Account *accto);

    gint xaccAccountForEachTransaction(const Account *account,
                                       TransactionCallback proc,
                                       void *data);

    Transaction * xaccAccountFindTransByDesc(const Account *account,
            const char *description);

    Split * xaccAccountFindSplitByDesc(const Account *account,
                                       const char *description);

    /* ------------------ */

    void xaccAccountInsertLot (Account *, GNCLot *);
    void xaccAccountRemoveLot (Account *, GNCLot *);

    LotList* xaccAccountGetLotList (const Account *account);

    gpointer xaccAccountForEachLot(
        const Account *acc,
        gpointer (*proc)(GNCLot *lot, gpointer user_data), /*@ null @*/ gpointer user_data);


    LotList * xaccAccountFindOpenLots (const Account *acc,
                                       gboolean (*match_func)(GNCLot *lot,
                                               gpointer user_data),
                                       /*@ null @*/ gpointer user_data, GCompareFunc sort_func);

    /* ------------------ */

    gboolean xaccAccountGetReconcileLastDate (const Account *account,
            time64 *last_date);
    void xaccAccountSetReconcileLastDate (Account *account, time64 last_date);

    gboolean xaccAccountGetReconcileLastInterval (const Account *account,
            int *months, int *days);
    void xaccAccountSetReconcileLastInterval (Account *account,
            int months, int days);
    gboolean xaccAccountGetReconcilePostponeDate (const Account *account,
            time64 *postpone_date);
    void xaccAccountSetReconcilePostponeDate (Account *account,
            time64 postpone_date);

    gboolean xaccAccountGetReconcilePostponeBalance (const Account *account,
            gnc_numeric *balance);
    void xaccAccountSetReconcilePostponeBalance (Account *account,
            gnc_numeric balance);

    void xaccAccountClearReconcilePostpone (Account *account);
    gboolean xaccAccountGetHigherBalanceLimit (const Account *account,
                                               gnc_numeric *balance);

    void xaccAccountSetHigherBalanceLimit (Account *account, gnc_numeric balance);

    void xaccAccountClearHigherBalanceLimit (Account *account);

    gboolean xaccAccountGetLowerBalanceLimit (const Account *account,
                                              gnc_numeric *balance);

    void xaccAccountSetLowerBalanceLimit (Account *account, gnc_numeric balance);

    void xaccAccountClearLowerBalanceLimit (Account *account);

    gboolean xaccAccountGetIncludeSubAccountBalances (const Account *account);

    void xaccAccountSetIncludeSubAccountBalances (Account *account, gboolean include);
    typedef enum
    {
        PLACEHOLDER_NONE,
        PLACEHOLDER_THIS,
        PLACEHOLDER_CHILD,
    } GNCPlaceholderType;

    gboolean xaccAccountGetPlaceholder (const Account *account);

    void xaccAccountSetPlaceholder (Account *account, gboolean val);

    gboolean xaccAccountGetAppendText (const Account *account);

    void xaccAccountSetAppendText (Account *account, gboolean val);

    gboolean xaccAccountGetIsOpeningBalance (const Account *account);

    void xaccAccountSetIsOpeningBalance (Account *account, gboolean val);

    GNCPlaceholderType xaccAccountGetDescendantPlaceholder(const Account *account);
    gboolean xaccAccountGetHidden (const Account *acc);

    void xaccAccountSetHidden (Account *acc, gboolean val);

    gboolean xaccAccountIsHidden (const Account *acc);
    gboolean xaccAccountGetAutoInterest (const Account *acc);

    void xaccAccountSetAutoInterest (Account *acc, gboolean val);

    gboolean xaccAccountGetTaxRelated (const Account *account);
    void xaccAccountSetTaxRelated (Account *account, gboolean tax_related);
    const char * xaccAccountGetTaxUSCode (const Account *account);
    void xaccAccountSetTaxUSCode (Account *account, const char *code);
    const char * xaccAccountGetTaxUSPayerNameSource (const Account *account);
    void xaccAccountSetTaxUSPayerNameSource (Account *account, const char *source);
    gint64 xaccAccountGetTaxUSCopyNumber (const Account *account);
    void xaccAccountSetTaxUSCopyNumber (Account *account, gint64 copy_number);
    const char *gnc_account_get_debit_string (GNCAccountType acct_type);
    const char *gnc_account_get_credit_string (GNCAccountType acct_type);

    void xaccAccountSetMark (Account *account, short mark);

    void xaccClearMark (Account *account, short val);

    void xaccClearMarkDown (Account *account, short val);
    void gnc_account_tree_begin_staged_transaction_traversals(Account *acc);

    void xaccAccountBeginStagedTransactionTraversals(const Account *account);

    gboolean xaccTransactionTraverse(Transaction *trans, int stage);

    int xaccAccountStagedTransactionTraversal(const Account *a,
            unsigned int stage,
            TransactionCallback thunk,
            void *data);

    int gnc_account_tree_staged_transaction_traversal(const Account *account,
            unsigned int stage,
            TransactionCallback thunk,
            void *data);

    int xaccAccountTreeForEachTransaction(Account *acc,
                                          TransactionCallback proc, void *data);

    time64 gnc_account_get_earliest_date (const Account* account);

    /* Look up an Account in the map non-Baysian
     */
    Account* gnc_account_imap_find_account (Account* acc, const char* category,
                                            const char *key);

    /* Look up an Account in the map non-Baysian, searching through the
     * import map data of all accounts. Returns first match.
     */
    Account* gnc_account_imap_find_any (QofBook *book, const char* category, const char *key);

    /* Store an Account in the map non Baysian
     */
    void gnc_account_imap_add_account (Account* acc, const char *category,
                                       const char *key, Account *added_acc);

    /* Remove a reference to an Account in the map non Baysian
     */
    void gnc_account_imap_delete_account(Account* acc, const char* category, const char* key);

    Account* gnc_account_imap_find_account_bayes (Account* acc, GList* tokens);

    void gnc_account_imap_add_account_bayes (Account* acc, GList* tokens,
                                             Account *added_acc);

    typedef struct imap_info
    {
        Account        *source_account;
        Account        *map_account;
        GList          *list;
        char           *head;
        char           *category;
        char           *match_string;
        char           *count;
    }GncImapInfo;

    void gnc_account_imap_info_destroy (GncImapInfo*);

    GList *gnc_account_imap_get_info_bayes (Account *acc);

    GList *gnc_account_imap_get_info (Account *acc, const char *category);

    gchar *gnc_account_get_map_entry (Account *acc, const char *head, const char *category);

    GncGUID *gnc_account_get_map_guid_entry (Account *acc, const char *head, const char *category);

    void gnc_account_delete_map_entry (Account *acc, char *head, char *category,
                                       char *match_string, gboolean empty);

    void gnc_account_delete_all_bayes_maps (Account *acc);

    void gnc_account_reset_convert_bayes_to_flat (void);

    void DxaccAccountSetCurrency (Account *account, gnc_commodity *currency);

    gnc_commodity * DxaccAccountGetCurrency (const Account *account);

    void dxaccAccountSetQuoteTZ (Account *account, const char *tz);
    const char * dxaccAccountGetQuoteTZ (const Account *account);
#define ACCOUNT_KVP     "kvp"
#define ACCOUNT_NAME_       "name"
#define ACCOUNT_CODE_       "code"
#define ACCOUNT_DESCRIPTION_    "desc"
#define ACCOUNT_COLOR_      "color"
#define ACCOUNT_FILTER_     "filter"
#define ACCOUNT_SORT_ORDER_ "sort-order"
#define ACCOUNT_SORT_REVERSED_ "sort-reversed"
#define ACCOUNT_NOTES_      "notes"
#define ACCOUNT_BALANCE_    "balance"
#define ACCOUNT_NOCLOSING_  "noclosing"
#define ACCOUNT_OPENING_BALANCE_ "opening-balance"
#define ACCOUNT_CLEARED_    "cleared"
#define ACCOUNT_RECONCILED_ "reconciled"
#define ACCOUNT_PRESENT_    "present"
#define ACCOUNT_FUTURE_MINIMUM_ "future-minimum"
#define ACCOUNT_TAX_RELATED "tax-related-p"
#define ACCOUNT_TYPE_       "account-type"
#define ACCOUNT_SCU     "smallest-commodity-unit"
#define ACCOUNT_NSCU        "non-standard-scu"
#define ACCOUNT_PARENT      "parent-account"

#define ACCOUNT_MATCH_ALL_TYPE  "account-match-all"

#ifdef __cplusplus
    } /* extern "C" */
#endif

#endif /* XACC_ACCOUNT_H */