Book

A QOF Book is a dataset. More...

Files
file	qofbook.h
	Encapsulate all the information about a dataset.

Data Structures
struct	QofBookClass

Macros
#define	__KVP_VALUE
#define	QOF_TYPE_BOOK   (qof_book_get_type ())
#define	QOF_BOOK(o)   (G_TYPE_CHECK_INSTANCE_CAST ((o), QOF_TYPE_BOOK, QofBook))
#define	QOF_BOOK_CLASS(k)   (G_TYPE_CHECK_CLASS_CAST((k), QOF_TYPE_BOOK, QofBookClass))
#define	QOF_IS_BOOK(o)   (G_TYPE_CHECK_INSTANCE_TYPE ((o), QOF_TYPE_BOOK))
#define	QOF_IS_BOOK_CLASS(k)   (G_TYPE_CHECK_CLASS_TYPE ((k), QOF_TYPE_BOOK))
#define	QOF_BOOK_GET_CLASS(o)   (G_TYPE_INSTANCE_GET_CLASS ((o), QOF_TYPE_BOOK, QofBookClass))
#define	QOF_BOOK_RETURN_ENTITY(book, guid, e_type, c_type)
	Encapsulates all the information about a dataset manipulated by QOF. More...
#define	qof_book_get_guid(X)   qof_entity_get_guid (QOF_INSTANCE(X))
	deprecated

Typedefs
typedef void(*	QofBookDirtyCB) (QofBook *, gboolean dirty, gpointer user_data)
typedef void(*	GncOptionSave) (GncOptionDB *, QofBook *, gboolean)
typedef void(*	GncOptionLoad) (GncOptionDB *, QofBook *)
typedef GList	QofBookList
	GList of QofBook.
typedef void(*	QofBookFinalCB) (QofBook *, gpointer key, gpointer user_data)
typedef void(*	QofCollectionForeachCB) (QofCollection *, gpointer user_data)
	Invoke the indicated callback on each collection in the book. More...

Functions
GType	qof_book_get_type (void)
gboolean	qof_book_register (void)
	Register the book object with the QOF object system. More...
QofBook *	qof_book_new (void)
	Allocate, initialise and return a new QofBook. More...
void	qof_book_destroy (QofBook *book)
	End any editing sessions associated with book, and free all memory associated with it. More...
void	qof_book_mark_closed (QofBook *book)
	Close a book to editing. More...
gboolean	qof_book_is_open (const QofBook *book)
void	qof_book_swap_books_readonly (QofBook *book, QofBook *other)
QofCollection *	qof_book_get_collection (const QofBook *, QofIdType)
	Return The table of entities of the given type. More...
void	qof_book_foreach_collection (const QofBook *, QofCollectionForeachCB, gpointer)
void	qof_book_set_data (QofBook *book, const gchar *key, gpointer data)
	The qof_book_set_data() allows arbitrary pointers to structs to be stored in QofBook. More...
void	qof_book_set_data_fin (QofBook *book, const gchar *key, gpointer data, QofBookFinalCB)
	Same as qof_book_set_data(), except that the callback will be called when the book is destroyed. More...
gpointer	qof_book_get_data (const QofBook *book, const gchar *key)
	Retrieves arbitrary pointers to structs stored by qof_book_set_data. More...
gboolean	qof_book_is_readonly (const QofBook *book)
	Return whether the book is read only. More...
void	qof_book_mark_readonly (QofBook *book)
	Mark the book as read only. More...
gboolean	qof_book_empty (const QofBook *book)
	Check if the book has had anything loaded into it. More...
gboolean	qof_book_use_trading_accounts (const QofBook *book)
	Returns flag indicating whether this book uses trading accounts.
void	qof_book_reset_num_days_autoreadonly_cache (QofBook *book)
gboolean	qof_book_uses_autoreadonly (const QofBook *book)
	Returns TRUE if the auto-read-only feature should be used, otherwise FALSE. More...
gint	qof_book_get_num_days_autoreadonly (const QofBook *book)
	Returns the number of days for auto-read-only transactions. More...
GDate *	qof_book_get_autoreadonly_gdate (const QofBook *book)
	Returns the GDate that is the threshold for auto-read-only. More...
void	qof_book_set_default_invoice_report (QofBook *book, const gchar *guid, const gchar *name)
	Save the Invoice Report name / guid to be used as the default for printing Invoices.
gchar *	qof_book_get_default_invoice_report_guid (const QofBook *book)
	Get the guid of the Invoice Report to be used as the default for printing Invoices.
gchar *	qof_book_get_default_invoice_report_name (const QofBook *book)
	Get the name of the Invoice Report to be used as the default for printing Invoices.
gdouble	qof_book_get_default_invoice_report_timeout (const QofBook *book)
	Get the length of time available to change the used Invoice Report when printing Invoices.
gboolean	qof_book_use_split_action_for_num_field (const QofBook *book)
	Returns TRUE if this book uses split action field as the 'Num' field, FALSE if it uses transaction number field.
gboolean	qof_book_shutting_down (const QofBook *book)
	Is the book shutting down?
gboolean	qof_book_session_not_saved (const QofBook *book)
	qof_book_not_saved() returns the value of the session_dirty flag, set when changes to any object in the book are committed (qof_backend->commit_edit has been called) and the backend hasn't yet written out the changes. More...
void	qof_book_mark_session_saved (QofBook *book)
	The qof_book_mark_saved() routine marks the book as having been saved (to a file, to a database). More...
void	qof_book_mark_session_dirty (QofBook *book)
	The qof_book_mark_dirty() routine marks the book as having been modified. More...
time64	qof_book_get_session_dirty_time (const QofBook *book)
	Retrieve the earliest modification time on the book. More...
void	qof_book_set_dirty_cb (QofBook *book, QofBookDirtyCB cb, gpointer user_data)
	Set the function to call when a book transitions from clean to dirty, or vice versa.
gint64	qof_book_get_counter (QofBook *book, const char *counter_name)
	This will get the named counter for this book. More...
gchar *	qof_book_increment_and_format_counter (QofBook *book, const char *counter_name)
	This will increment the named counter for this book and format it. More...
gchar *	qof_book_normalize_counter_format (const gchar *format, gchar **err_msg)
	Validate a counter format string. More...
char *	qof_book_get_counter_format (const QofBook *book, const char *counter_name)
	Get the format string to use for the named counter. More...
const char *	qof_book_get_string_option (const QofBook *book, const char *opt_name)
void	qof_book_set_string_option (QofBook *book, const char *opt_name, const char *opt_val)
const GncGUID *	qof_book_get_guid_option (QofBook *book, GSList *path)
void	qof_book_option_frame_delete (QofBook *book, const char *opt_name)
GHashTable *	qof_book_get_features (QofBook *book)
	Access functions for reading and setting the used-features on this book.
void	qof_book_unset_feature (QofBook *book, const gchar *key)
void	qof_book_set_feature (QofBook *book, const gchar *key, const gchar *descr)
void	qof_book_begin_edit (QofBook *book)
void	qof_book_commit_edit (QofBook *book)
void	qof_book_save_options (QofBook *book, GncOptionSave save_cb, GncOptionDB *odb, gboolean clear)
	Save a GncOptionsDB back to the book's KVP. More...
void	qof_book_set_option (QofBook *book, KvpValue *value, GSList *path)
	Save a single option value. More...
KvpValue *	qof_book_get_option (QofBook *book, GSList *path)
	Read a single option value. More...
void	qof_book_options_delete (QofBook *book, GSList *path)
	Delete the options. More...

Detailed Description

A QOF Book is a dataset.

It provides a single handle through which all the various collections of entities can be found. In particular, given only the type of the entity, the collection can be found.

Books also provide the 'natural' place to working with a storage backend, as a book can encapsulate everything held in storage.

Macro Definition Documentation

QOF_BOOK_RETURN_ENTITY

#define QOF_BOOK_RETURN_ENTITY	(		book,
			guid,
			e_type,
			c_type
	)

Value:

{   \
  QofInstance *val = NULL;                                  \
  if ((guid != NULL) && (book != NULL)) {                   \
    const QofCollection *col;                               \
    col = qof_book_get_collection (book, e_type);           \
    val = qof_collection_lookup_entity (col, guid);         \
  }                                                         \
  return (c_type *) val;                                    \
}

Encapsulates all the information about a dataset manipulated by QOF.

This is the top-most structure used for anchoring data. This macro looks up an entity by GncGUID and returns a pointer to the entity by ending with a "return" statement. Hence, this macro can only be used as the last statement in the definition of a function, but not somewhere inline in the code.

Definition at line 101 of file qofbook.h.

Typedef Documentation

QofCollectionForeachCB

typedef void(* QofCollectionForeachCB) (QofCollection *, gpointer user_data)

Invoke the indicated callback on each collection in the book.

Definition at line 157 of file qofbook.h.

Function Documentation

qof_book_destroy()

void qof_book_destroy

(

QofBook *

book

)

End any editing sessions associated with book, and free all memory associated with it.

Definition at line 331 of file qofbook.cpp.

{
    GHashTable* cols;

    if (!book || !book->hash_of_collections) return;
    ENTER ("book=%p", book);

    book->shutting_down = TRUE;
    qof_event_force (&book->inst, QOF_EVENT_DESTROY, nullptr);

    /* Call the list of finalizers, let them do their thing.
     * Do this before tearing into the rest of the book.
     */
    g_hash_table_foreach (book->data_table_finalizers, book_final, book);

    /* Lots hold a variety of pointers that need to still exist while
     * cleaning them up so run its book_end before the rest.
     */
    auto lots{qof_book_get_collection(book, GNC_ID_LOT)};
    qof_collection_foreach(lots, destroy_lot, nullptr);
    qof_object_book_end (book);

    g_hash_table_destroy (book->data_table_finalizers);
    book->data_table_finalizers = nullptr;
    g_hash_table_destroy (book->data_tables);
    book->data_tables = nullptr;

    /* qof_instance_release (&book->inst); */

    /* Note: we need to save this hashtable until after we remove ourself
     * from it, otherwise we'll crash in our dispose() function when we
     * DO remove ourself from the collection but the collection had already
     * been destroyed.
     */
    cols = book->hash_of_collections;
    g_object_unref (book);
    g_hash_table_destroy (cols);

    LEAVE ("book=%p", book);
}

qof_book_empty()

gboolean qof_book_empty

(

const QofBook *

book

)

Check if the book has had anything loaded into it.

Definition at line 511 of file qofbook.cpp.

{
    if (!book) return TRUE;
    auto root_acct_col = qof_book_get_collection (book, GNC_ID_ROOT_ACCOUNT);
    return qof_collection_get_data(root_acct_col) == nullptr;
}

qof_book_get_autoreadonly_gdate()

GDate* qof_book_get_autoreadonly_gdate

(

const QofBook *

book

)

Returns the GDate that is the threshold for auto-read-only.

Any txn with posted-date lesser than this date should be considered read-only.

If the auto-read-only feature is not used (qof_book_uses_autoreadonly() returns FALSE), NULL is returned here.

The returned object was allocated newly; the caller must g_date_free() the object afterwards.

Definition at line 1006 of file qofbook.cpp.

{
    gint num_days;
    GDate* result = nullptr;

    g_assert(book);
    num_days = qof_book_get_num_days_autoreadonly(book);
    if (num_days > 0)
    {
        result = gnc_g_date_new_today();
        g_date_subtract_days(result, num_days);
    }
    return result;
}

qof_book_get_collection()

QofCollection* qof_book_get_collection	(	const QofBook *	,
		QofIdType
	)

Return The table of entities of the given type.

When an object's constructor calls qof_instance_init(), a reference to the object is stored in the book. The book stores all the references to initialized instances, sorted by type. This function returns a collection of the references for the specified type.

If the collection doesn't yet exist for the indicated type, it is created. Thus, this routine is guaranteed to return a non-NULL value. (Unless the system malloc failed (out of memory) in which case what happens??).

Definition at line 521 of file qofbook.cpp.

{
    QofCollection *col;

    if (!book || !entity_type) return nullptr;

    col = static_cast<QofCollection*>(g_hash_table_lookup (book->hash_of_collections, entity_type));
    if (!col)
    {
        col = qof_collection_new (entity_type);
        g_hash_table_insert(
            book->hash_of_collections,
            (gpointer)qof_string_cache_insert(entity_type), col);
    }
    return col;
}

qof_book_get_counter()

gint64 qof_book_get_counter	(	QofBook *	book,
		const char *	counter_name
	)

This will get the named counter for this book.

The return value is -1 on error or the current value of the counter.

Definition at line 592 of file qofbook.cpp.

{
    KvpFrame *kvp;
    KvpValue *value;

    if (!book)
    {
        PWARN ("No book!!!");
        return -1;
    }

    if (!counter_name || *counter_name == '\0')
    {
        PWARN ("Invalid counter name.");
        return -1;
    }

    /* Use the KVP in the book */
    kvp = qof_instance_get_slots (QOF_INSTANCE (book));

    if (!kvp)
    {
        PWARN ("Book has no KVP_Frame");
        return -1;
    }

    value = kvp->get_slot({"counters", counter_name});
    if (value)
    {
        auto int_value{value->get<int64_t>()};
        /* Might be a double because of
         * https://bugs.gnucash.org/show_bug.cgi?id=798930
         */
        if (!int_value)
            int_value = static_cast<int64_t>(value->get<double>());
        return int_value;
    }
    else
    {
        /* New counter */
        return 0;
    }
}

qof_book_get_counter_format()

char* qof_book_get_counter_format	(	const QofBook *	book,
		const char *	counter_name
	)

Get the format string to use for the named counter.

The return value is NULL on error or the format string of the counter. The returned string should be freed by the caller.

Definition at line 698 of file qofbook.cpp.

{
    KvpFrame *kvp;
    const char *user_format = nullptr;
    gchar *norm_format = nullptr;
    KvpValue *value;
    gchar *error = nullptr;

    if (!book)
    {
        PWARN ("No book!!!");
        return nullptr;
    }

    if (!counter_name || *counter_name == '\0')
    {
        PWARN ("Invalid counter name.");
        return nullptr;
    }

    /* Get the KVP from the current book */
    kvp = qof_instance_get_slots (QOF_INSTANCE (book));

    if (!kvp)
    {
        PWARN ("Book has no KVP_Frame");
        return nullptr;
    }

    /* Get the format string */
    value = kvp->get_slot({"counter_formats", counter_name});
    if (value)
    {
        user_format = value->get<const char*>();
        norm_format = qof_book_normalize_counter_format(user_format, &error);
        if (!norm_format)
        {
            PWARN("Invalid counter format string. Format string: '%s' Counter: '%s' Error: '%s')", user_format, counter_name, error);
            /* Invalid format string */
            user_format = nullptr;
            g_free(error);
        }
    }

    /* If no (valid) format string was found, use the default format
     * string */
    if (!norm_format)
    {
        /* Use the default format */
        norm_format = g_strdup ("%.6" PRIi64);
    }
    return norm_format;
}

qof_book_get_data()

gpointer qof_book_get_data	(	const QofBook *	book,
		const gchar *	key
	)

Retrieves arbitrary pointers to structs stored by qof_book_set_data.

qof_book_get_num_days_autoreadonly()

gint qof_book_get_num_days_autoreadonly

(

const QofBook *

book

)

Returns the number of days for auto-read-only transactions.

If zero, the auto-read-only feature should be disabled (and qof_book_uses_autoreadonly() returns FALSE).

Definition at line 986 of file qofbook.cpp.

{
    g_assert(book);

    if (!book->cached_num_days_autoreadonly_isvalid)
    {
        double tmp;

        // No cached value? Then do the expensive KVP lookup
        qof_instance_get (QOF_INSTANCE (book),
              PARAM_NAME_NUM_AUTOREAD_ONLY, &tmp,
              nullptr);

        const_cast<QofBook*>(book)->cached_num_days_autoreadonly = tmp;
        const_cast<QofBook*>(book)->cached_num_days_autoreadonly_isvalid = TRUE;
    }
    // Value is cached now. Use the cheap variable returning.
    return (gint) book->cached_num_days_autoreadonly;
}

qof_book_get_option()

KvpValue* qof_book_get_option	(	QofBook *	book,
		GSList *	path
	)

Read a single option value.

Used from Scheme, the KvpValue<–>SCM translation is handled by the functions in kvp-scm.c and automated by SWIG. The starting element is set as KVP_OPTION_PATH in qofbookslots.h.

Parameters

book	The book.
path	A GSList of keys which form a path under KVP_OPTION_PATH.

Definition at line 1392 of file qofbook.cpp.

{
    KvpFrame *root = qof_instance_get_slots(QOF_INSTANCE (book));
    return root->get_slot(gslist_to_option_path(path));
}

qof_book_get_session_dirty_time()

time64 qof_book_get_session_dirty_time

(

const QofBook *

book

)

Retrieve the earliest modification time on the book.

Definition at line 420 of file qofbook.cpp.

{
    return book->dirty_time;
}

qof_book_increment_and_format_counter()

gchar* qof_book_increment_and_format_counter	(	QofBook *	book,
		const char *	counter_name
	)

This will increment the named counter for this book and format it.

The return value is NULL on error or the formatted (new) value of the counter. The caller should free the result with g_gree.

Definition at line 637 of file qofbook.cpp.

{
    KvpFrame *kvp;
    KvpValue *value;
    gint64 counter;
    gchar* format;
    gchar* result;

    if (!book)
    {
        PWARN ("No book!!!");
        return nullptr;
    }

    if (!counter_name || *counter_name == '\0')
    {
        PWARN ("Invalid counter name.");
        return nullptr;
    }

    /* Get the current counter value from the KVP in the book. */
    counter = qof_book_get_counter(book, counter_name);

    /* Check if an error occurred */
    if (counter < 0)
        return nullptr;

    /* Increment the counter */
    counter++;

    /* Get the KVP from the current book */
    kvp = qof_instance_get_slots (QOF_INSTANCE (book));

    if (!kvp)
    {
        PWARN ("Book has no KVP_Frame");
        return nullptr;
    }

    /* Save off the new counter */
    qof_book_begin_edit(book);
    value = new KvpValue(counter);
    delete kvp->set_path({"counters", counter_name}, value);
    qof_instance_set_dirty (QOF_INSTANCE (book));
    qof_book_commit_edit(book);

    format = qof_book_get_counter_format(book, counter_name);

    if (!format)
    {
        PWARN("Cannot get format for counter");
        return nullptr;
    }

    /* Generate a string version of the counter */
    result = g_strdup_printf(format, counter);
    g_free (format);
    return result;
}

qof_book_is_readonly()

gboolean qof_book_is_readonly

(

const QofBook *

book

)

Return whether the book is read only.

Definition at line 497 of file qofbook.cpp.

{
    g_return_val_if_fail( book != nullptr, TRUE );
    return book->read_only;
}

qof_book_mark_closed()

void qof_book_mark_closed

(

QofBook *

book

)

Close a book to editing.

It is up to the application to check this flag, and once marked closed, books cannot be marked as open.

Definition at line 570 of file qofbook.cpp.

{
    if (!book)
    {
        return;
    }
    book->book_open = 'n';
}

qof_book_mark_readonly()

void qof_book_mark_readonly

(

QofBook *

book

)

Mark the book as read only.

Definition at line 504 of file qofbook.cpp.

{
    g_return_if_fail( book != nullptr );
    book->read_only = TRUE;
}

qof_book_mark_session_dirty()

void qof_book_mark_session_dirty

(

QofBook *

book

)

The qof_book_mark_dirty() routine marks the book as having been modified.

It can be used by frontend when the used has made a change at the book level.

Definition at line 397 of file qofbook.cpp.

{
    if (!book) return;
    if (!book->session_dirty)
    {
        /* Set the session dirty upfront, because the callback will check. */
        book->session_dirty = TRUE;
        book->dirty_time = gnc_time (nullptr);
        if (book->dirty_cb)
            book->dirty_cb(book, TRUE, book->dirty_data);
    }
}

qof_book_mark_session_saved()

void qof_book_mark_session_saved

(

QofBook *

book

)

The qof_book_mark_saved() routine marks the book as having been saved (to a file, to a database).

Used by backends to mark the notsaved flag as FALSE just after loading. Can also be used by the frontend when the used has said to abandon any changes.

Definition at line 383 of file qofbook.cpp.

{
    if (!book) return;

    book->dirty_time = 0;
    if (book->session_dirty)
    {
        /* Set the session clean upfront, because the callback will check. */
        book->session_dirty = FALSE;
        if (book->dirty_cb)
            book->dirty_cb(book, FALSE, book->dirty_data);
    }
}

qof_book_new()

QofBook* qof_book_new

(

void

)

Allocate, initialise and return a new QofBook.

Books contain references to all of the top-level object containers.

Definition at line 290 of file qofbook.cpp.

{
    QofBook *book;

    ENTER (" ");
    book = static_cast<QofBook*>(g_object_new(QOF_TYPE_BOOK, nullptr));
    qof_object_book_begin (book);

    qof_event_gen (&book->inst, QOF_EVENT_CREATE, nullptr);
    LEAVE ("book=%p", book);
    return book;
}

qof_book_normalize_counter_format()

gchar* qof_book_normalize_counter_format	(	const gchar *	format,
		gchar **	err_msg
	)

Validate a counter format string.

If valid, returns a normalized format string, that is whatever long int specifier was used will be replaced with the value of the posix "PRIx64" macro. If not valid returns NULL and optionally set an error message is a non-null err_msg parameter was passed. The caller should free the returned format string and error message with g_free.

Definition at line 753 of file qofbook.cpp.

{
    const gchar *valid_formats [] = {
            G_GINT64_FORMAT,
            "lli",
            "I64i",
            PRIi64,
            "li",
            nullptr,
    };
    int i = 0;
    gchar *normalized_spec = nullptr;

    while (valid_formats[i])
    {

        if (err_msg && *err_msg)
        {
            g_free (*err_msg);
            *err_msg = nullptr;
        }

        normalized_spec = qof_book_normalize_counter_format_internal(p, valid_formats[i], err_msg);
        if (normalized_spec)
            return normalized_spec;  /* Found a valid format specifier, return */
        i++;
    }

    return nullptr;
}

qof_book_options_delete()

void qof_book_options_delete	(	QofBook *	book,
		GSList *	path
	)

Delete the options.

Primarily used from Scheme to clear out the options before saving a new set.

Parameters

book	The book.
list	A GList of keys which from a path under KVP_OPTION_PATH. If GList is Null, the whole option is deleted.

Definition at line 1399 of file qofbook.cpp.

{
    KvpFrame *root = qof_instance_get_slots(QOF_INSTANCE (book));
    if (path != nullptr)
    {
        Path path_v {str_KVP_OPTION_PATH};
        Path tmp_path;
        for (auto item = path; item != nullptr; item = g_slist_next(item))
            tmp_path.push_back(static_cast<const char*>(item->data));
        delete root->set_path(gslist_to_option_path(path), nullptr);
    }
    else
        delete root->set_path({str_KVP_OPTION_PATH}, nullptr);
}

qof_book_register()

gboolean qof_book_register

(

void

)

Register the book object with the QOF object system.

Definition at line 1415 of file qofbook.cpp.

{
    static QofParam params[] =
    {
        { QOF_PARAM_GUID, QOF_TYPE_GUID, (QofAccessFunc)qof_entity_get_guid, nullptr },
        { QOF_PARAM_KVP,  QOF_TYPE_KVP,  (QofAccessFunc)qof_instance_get_slots, nullptr },
        { nullptr },
    };

    qof_class_register (QOF_ID_BOOK, nullptr, params);

    return TRUE;
}

qof_book_save_options()

void qof_book_save_options	(	QofBook *	book,
		GncOptionSave	save_cb,
		GncOptionDB *	odb,
		gboolean	clear
	)

Save a GncOptionsDB back to the book's KVP.

Parameters

book	The book.
save_cb	A callback function that does the saving.
odb	The GncOptionsDB to save from.
clear	Should the GncOptionsDB be emptied after the save?

Definition at line 1340 of file qofbook.cpp.

{
    /* Wrap this in begin/commit so that it commits only once instead of doing
     * so for every option. Qof_book_set_option will take care of dirtying the
     * book.
     */
    qof_book_begin_edit (book);
    save_cb (odb, book, clear);
    qof_book_commit_edit (book);
}

qof_book_session_not_saved()

gboolean qof_book_session_not_saved

(

const QofBook *

book

)

qof_book_not_saved() returns the value of the session_dirty flag, set when changes to any object in the book are committed (qof_backend->commit_edit has been called) and the backend hasn't yet written out the changes.

(Note that SQL backends write commits out immediately; file backends don't, and use the flag to control an autosave timer.)

Definition at line 375 of file qofbook.cpp.

{
    if (!book) return FALSE;
    return !qof_book_empty(book) && book->session_dirty;

}

qof_book_set_data()

void qof_book_set_data	(	QofBook *	book,
		const gchar *	key,
		gpointer	data
	)

The qof_book_set_data() allows arbitrary pointers to structs to be stored in QofBook.

This is the "preferred" method for extending QofBook to hold new data types. This is also the ideal location to store other arbitrary runtime data that the application may need.

qof_book_set_data_fin()

void qof_book_set_data_fin	(	QofBook *	book,
		const gchar *	key,
		gpointer	data,
		QofBookFinalCB
	)

Same as qof_book_set_data(), except that the callback will be called when the book is destroyed.

The argument to the callback will be the book followed by the data pointer.

qof_book_set_option()

void qof_book_set_option	(	QofBook *	book,
		KvpValue *	value,
		GSList *	path
	)

Save a single option value.

Used from Scheme, the KvpValue<–>SCM translation is handled by the functions in kvp-scm.c and automated by SWIG. The starting element is set as KVP_OPTION_PATH in qofbookslots.h.

Parameters

book	The book.
value	The KvpValue to store.
path	A GSList of keys which form a path under KVP_OPTION_PATH.

Definition at line 1379 of file qofbook.cpp.

{
    KvpFrame *root = qof_instance_get_slots (QOF_INSTANCE (book));
    qof_book_begin_edit (book);
    delete root->set_path(gslist_to_option_path(path), value);
    qof_instance_set_dirty (QOF_INSTANCE (book));
    qof_book_commit_edit (book);

    // Also, mark any cached value as invalid
    book->cached_num_field_source_isvalid = FALSE;
}

qof_book_uses_autoreadonly()

gboolean qof_book_uses_autoreadonly

(

const QofBook *

book

)

Returns TRUE if the auto-read-only feature should be used, otherwise FALSE.

This is just a wrapper on qof_book_get_num_days_autoreadonly() == 0.

Definition at line 974 of file qofbook.cpp.

{
    g_assert(book);
    return (qof_book_get_num_days_autoreadonly(book) != 0);
}