Object_Private

Private interfaces, not meant to be used by applications. More...

Files
file	qofobject-p.h
	the Core Object Registration/Lookup Private Interface

Data Structures
struct	QofBackend
struct	QofBook
	QofBook reference. More...
struct	QofBookTestFunctions

Functions
	QofBackend::QofBackend (const QofBackend &)=delete
	QofBackend::QofBackend (const QofBackend &&)=delete
virtual void	QofBackend::session_begin (QofSession *session, const char *new_uri, SessionOpenMode mode)=0
	Open the file or connect to the server.
virtual void	QofBackend::session_end ()=0
virtual void	QofBackend::load (QofBook *, QofBackendLoadType)=0
	Load the minimal set of application data needed for the application to be operable at initial startup.
virtual void	QofBackend::begin (QofInstance *)
	Called when the engine is about to make a change to a data structure.
virtual void	QofBackend::commit (QofInstance *)
	Commits the changes from the engine to the backend data storage.
virtual void	QofBackend::rollback (QofInstance *)
	Revert changes in the engine and unlock the backend.
virtual void	QofBackend::sync (QofBook *)=0
	Synchronizes the engine contents to the backend.
virtual void	QofBackend::safe_sync (QofBook *)=0
	Perform a sync in a way that prevents data loss on a DBI backend.
virtual void	QofBackend::export_coa (QofBook *)
	Extract the chart of accounts from the current database and create a new database with it.
void	QofBackend::set_error (QofBackendError err)
	Set the error value only if there isn't already an error already.
QofBackendError	QofBackend::get_error ()
	Retrieve the currently-stored error and clear it.
bool	QofBackend::check_error ()
	Report if there is an error.
void	QofBackend::set_message (std::string &&)
	Set a descriptive message that can be displayed to the user when there's an error.
const std::string &&	QofBackend::get_message ()
	Retrieve and clear the stored error message.
void	QofBackend::set_percentage (QofBePercentageFunc pctfn)
	Store and retrieve a backend-specific function for determining the progress in completing a long operation, for use with a progress meter.
QofBePercentageFunc	QofBackend::get_percentage ()
const std::string &	QofBackend::get_uri ()
	Retrieve the backend's storage URI.
static bool	QofBackend::register_backend (const char *, const char *)
	Class methods for dynamically loading the several backends and for freeing them at shutdown.
static void	QofBackend::release_backends ()

Variables
QofBePercentageFunc	QofBackend::m_percentage
std::string	QofBackend::m_fullpath
	Each backend resolves a fully-qualified file path.
QofInstance	QofBook::inst
gboolean	QofBook::session_dirty
time64	QofBook::dirty_time
QofBookDirtyCB	QofBook::dirty_cb
gpointer	QofBook::dirty_data
GHashTable *	QofBook::hash_of_collections
GHashTable *	QofBook::data_tables
GHashTable *	QofBook::data_table_finalizers
gboolean	QofBook::read_only
char	QofBook::book_open
gboolean	QofBook::shutting_down
gint32	QofBook::version
QofBackend *	QofBook::backend
gboolean	QofBook::cached_num_field_source
gboolean	QofBook::cached_num_field_source_isvalid
gint	QofBook::cached_num_days_autoreadonly
gboolean	QofBook::cached_num_days_autoreadonly_isvalid
gboolean(*	QofBookTestFunctions::get_session_dirty )(const QofBook *)
gboolean(*	QofBookTestFunctions::get_read_only )(const QofBook *)
QofBookDirtyCB(*	QofBookTestFunctions::get_dirty_cb )(const QofBook *)
void(*	QofBookTestFunctions::set_shutting_down )(QofBook *, gboolean)
gpointer(*	QofBookTestFunctions::get_dirty_data )(const QofBook *)
GHashTable *(*	QofBookTestFunctions::get_collections )(const QofBook *)
GHashTable *(*	QofBookTestFunctions::get_data_tables )(const QofBook *)
GHashTable *(*	QofBookTestFunctions::get_data_table_finalizers )(const QofBook *)
char(*	QofBookTestFunctions::get_book_open )(const QofBook *)
int(*	QofBookTestFunctions::get_version )(const QofBook *)

Backend_Private
Pseudo-object defining how the engine can interact with different back-ends (which may be SQL databases, or network interfaces to remote QOF servers. File-io is just one type of backend). The callbacks will be called at the appropriate times during a book session to allow the backend to store the data as needed.
enum	QofBackendLoadType { LOAD_TYPE_INITIAL_LOAD , LOAD_TYPE_LOAD_ALL }
using	GModuleVec = std::vector< GModule * >

Book_Private
QofBookTestFunctions *	_utest_qofbook_fill_functions (void)
void	qof_book_set_backend (QofBook *book, QofBackend *be)
gboolean	qof_book_register (void)
gchar *	qof_book_normalize_counter_format_internal (const gchar *p, const gchar *gint64_format, gchar **err_msg)
	Validate a counter format string with a given format specifier.
void	qof_book_print_dirty (const QofBook *book)
	This debugging function can be used to traverse the book structure and all subsidiary structures, printing out which structures have been marked dirty.

Class_Private
void	qof_class_init (void)
void	qof_class_shutdown (void)
QofSortFunc	qof_class_get_default_sort (QofIdTypeConst obj_name)

Entity_Private
void	qof_collection_insert_entity (QofCollection *, QofInstance *)
	Take entity, remove it from whatever collection its currently in, and place it in a new collection.
void	qof_collection_mark_clean (QofCollection *)
	reset value of dirty flag
void	qof_collection_mark_dirty (QofCollection *)
void	qof_collection_print_dirty (const QofCollection *col, gpointer dummy)

Objects_Private
void	qof_object_book_begin (QofBook *book)
	To be called from within the book.
void	qof_object_book_end (QofBook *book)
gboolean	qof_object_is_dirty (const QofBook *book)
void	qof_object_mark_clean (QofBook *book)
gboolean	qof_object_compliance (QofIdTypeConst type_name, gboolean warn)
	check an object can be created and supports iteration

Detailed Description

Private interfaces, not meant to be used by applications.

Typedef Documentation

GModuleVec

using GModuleVec = std::vector<GModule*>

Definition at line 169 of file qof-backend.hpp.

Enumeration Type Documentation

QofBackendLoadType

enum QofBackendLoadType

Definition at line 163 of file qof-backend.hpp.

{
    LOAD_TYPE_INITIAL_LOAD,
    LOAD_TYPE_LOAD_ALL
} QofBackendLoadType;

Function Documentation

_utest_qofbook_fill_functions()

QofBookTestFunctions * _utest_qofbook_fill_functions

(

void

)

Definition at line 1444 of file qofbook.cpp.

{
    QofBookTestFunctions *func = g_new (QofBookTestFunctions, 1);
 
    func->get_session_dirty = get_session_dirty;
    func->get_read_only = get_read_only;
    func->get_dirty_cb = get_dirty_cb;
    func->set_shutting_down = set_shutting_down;
    func->get_dirty_data = get_dirty_data;
    func->get_collections = get_collections;
    func->get_data_tables = get_data_tables;
    func->get_data_table_finalizers = get_data_table_finalizers;
    func->get_book_open = get_book_open;
    func->get_version = get_version;
    return func;
}

begin()

virtual void QofBackend::begin ( QofInstance *  )

inlinevirtual

Called when the engine is about to make a change to a data structure.

It could provide an advisory lock on data, but no backend does this.

Reimplemented in GncSqlBackend.

Definition at line 217 of file qof-backend.hpp.

{}

check_error()

bool QofBackend::check_error

(

)

Report if there is an error.

Definition at line 73 of file qof-backend.cpp.

{
    return m_last_err != ERR_BACKEND_NO_ERR;
}

commit()

void QofBackend::commit ( QofInstance *  instance )

virtual

Commits the changes from the engine to the backend data storage.

Reimplemented in GncSqlBackend, and GncXmlBackend.

Definition at line 49 of file qof-backend.cpp.

{
    if (qof_instance_is_dirty(instance))
        qof_instance_mark_clean(instance);
}

export_coa()

virtual void QofBackend::export_coa ( QofBook *  )

inlinevirtual

Extract the chart of accounts from the current database and create a new database with it.

Implemented only in the XML backend at present.

Reimplemented in GncXmlBackend.

Definition at line 250 of file qof-backend.hpp.

{}

get_error()

QofBackendError QofBackend::get_error

(

)

Retrieve the currently-stored error and clear it.

Definition at line 64 of file qof-backend.cpp.

{
    /* use 'stack-pop' semantics */
    auto err = m_last_err;
    m_last_err = ERR_BACKEND_NO_ERR;
    return err;
}

get_message()

const std::string && QofBackend::get_message

(

)

Retrieve and clear the stored error message.

Definition at line 85 of file qof-backend.cpp.

{
    return std::move(m_error_msg);
}

get_percentage()

QofBePercentageFunc QofBackend::get_percentage ( )

inline

Definition at line 271 of file qof-backend.hpp.

{ return m_percentage; }

get_uri()

const std::string & QofBackend::get_uri ( )

inline

Retrieve the backend's storage URI.

Definition at line 274 of file qof-backend.hpp.

{ return m_fullpath; }

load()

virtual void QofBackend::load ( QofBook *  , QofBackendLoadType    )

pure virtual

Load the minimal set of application data needed for the application to be operable at initial startup.

It is assumed that the application will perform a 'run_query()' to obtain any additional data that it needs. For file-based backends, it is acceptable for the backend to return all data at load time; for SQL-based backends, it is acceptable for the backend to return no data.

Thus, for example, the old GnuCash postgres backend returned the account tree, all currencies, and the pricedb, as these were needed at startup. It did not have to return any transactions whatsoever, as these were obtained at a later stage when a user opened a register, resulting in a query being sent to the backend. The current DBI backend on the other hand loads the entire database into memory.

(Its OK to send over entities at this point, but one should be careful of the network load; also, its possible that whatever is sent is not what the user wanted anyway, which is why its better to wait for the query).

Implemented in GncDbiBackend< Type >, GncSqlBackend, and GncXmlBackend.

qof_book_normalize_counter_format_internal()

gchar * qof_book_normalize_counter_format_internal	(	const gchar *	p,
		const gchar *	gint64_format,
		gchar **	err_msg
	)

Validate a counter format string with a given format specifier.

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 785 of file qofbook.cpp.

{
    const gchar *conv_start, *base, *tmp = nullptr;
    gchar *normalized_str = nullptr, *aux_str = nullptr;
 
    /* Validate a counter format. This is a very simple "parser" that
     * simply checks for a single gint64 conversion specification,
     * allowing all modifiers and flags that printf(3) specifies (except
     * for the * width and precision, which need an extra argument). */
    base = p;
 
    /* Skip a prefix of any character except % */
    while (*p)
    {
        /* Skip two adjacent percent marks, which are literal percent
         * marks */
        if (p[0] == '%' && p[1] == '%')
        {
            p += 2;
            continue;
        }
        /* Break on a single percent mark, which is the start of the
         * conversion specification */
        if (*p == '%')
            break;
        /* Skip all other characters */
        p++;
    }
 
    if (!*p)
    {
        if (err_msg)
            *err_msg = g_strdup("Format string ended without any conversion specification");
        return nullptr;
    }
 
    /* Store the start of the conversion for error messages */
    conv_start = p;
 
    /* Skip the % */
    p++;
 
    /* See whether we have already reached the correct format
     * specification (e.g. "li" on Unix, "I64i" on Windows). */
    tmp = strstr(p, gint64_format);
 
    if (!tmp)
    {
        if (err_msg)
            *err_msg = g_strdup_printf("Format string doesn't contain requested format specifier: %s", gint64_format);
        return nullptr;
    }
 
    /* Skip any number of flag characters */
    while (*p && (tmp != p) && strchr("#0- +'I", *p))
    {
        p++;
        tmp = strstr(p, gint64_format);
    }
 
    /* Skip any number of field width digits,
     * and precision specifier digits (including the leading dot) */
    while (*p && (tmp != p) && strchr("0123456789.", *p))
    {
        p++;
        tmp = strstr(p, gint64_format);
    }
 
    if (!*p)
    {
        if (err_msg)
            *err_msg = g_strdup_printf("Format string ended during the conversion specification. Conversion seen so far: %s", conv_start);
        return nullptr;
    }
 
    /* See if the format string starts with the correct format
     * specification. */
    tmp = strstr(p, gint64_format);
    if (tmp == nullptr)
    {
        if (err_msg)
            *err_msg = g_strdup_printf("Invalid length modifier and/or conversion specifier ('%.4s'), it should be: %s", p, gint64_format);
        return nullptr;
    }
    else if (tmp != p)
    {
        if (err_msg)
            *err_msg = g_strdup_printf("Garbage before length modifier and/or conversion specifier: '%*s'", (int)(tmp - p), p);
        return nullptr;
    }
 
    /* Copy the string we have so far and add normalized format specifier for long int */
    aux_str = g_strndup (base, p - base);
    normalized_str = g_strconcat (aux_str, PRIi64, nullptr);
    g_free (aux_str);
 
    /* Skip length modifier / conversion specifier */
    p += strlen(gint64_format);
    tmp = p;
 
    /* Skip a suffix of any character except % */
    while (*p)
    {
        /* Skip two adjacent percent marks, which are literal percent
         * marks */
        if (p[0] == '%' && p[1] == '%')
        {
            p += 2;
            continue;
        }
        /* Break on a single percent mark, which is the start of the
         * conversion specification */
        if (*p == '%')
        {
            if (err_msg)
                *err_msg = g_strdup_printf("Format string contains unescaped %% signs (or multiple conversion specifications) at '%s'", p);
            g_free (normalized_str);
            return nullptr;
        }
        /* Skip all other characters */
        p++;
    }
 
    /* Add the suffix to our normalized string */
    aux_str = normalized_str;
    normalized_str = g_strconcat (aux_str, tmp, nullptr);
    g_free (aux_str);
 
    /* If we end up here, the string was valid, so return no error
     * message */
    return normalized_str;
}

qof_book_print_dirty()

void qof_book_print_dirty

(

const QofBook *

book

)

This debugging function can be used to traverse the book structure and all subsidiary structures, printing out which structures have been marked dirty.

Definition at line 411 of file qofbook.cpp.

{
    if (qof_book_session_not_saved(book))
        PINFO("book is dirty.");
    qof_book_foreach_collection
    (book, (QofCollectionForeachCB)qof_collection_print_dirty, nullptr);
}

qof_book_register()

gboolean qof_book_register

(

void

)

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_set_backend()

void qof_book_set_backend	(	QofBook *	book,
		QofBackend *	be
	)

Definition at line 457 of file qofbook.cpp.

{
    if (!book) return;
    ENTER ("book=%p be=%p", book, be);
    book->backend = be;
    LEAVE (" ");
}

qof_class_get_default_sort()

QofSortFunc qof_class_get_default_sort

(

QofIdTypeConst

obj_name

)

Definition at line 75 of file qofclass.cpp.

{
    if (!obj_name) return NULL;
    return reinterpret_cast<QofSortFunc>(g_hash_table_lookup (sortTable,
                                  obj_name));
}

qof_class_init()

void qof_class_init

(

void

)

Definition at line 54 of file qofclass.cpp.

{
    if (initialized) return;
    initialized = TRUE;
 
    classTable = g_hash_table_new (g_str_hash, g_str_equal);
    sortTable = g_hash_table_new (g_str_hash, g_str_equal);
}

qof_class_shutdown()

void qof_class_shutdown

(

void

)

Definition at line 64 of file qofclass.cpp.

{
    if (!initialized) return;
    initialized = FALSE;
 
    g_hash_table_foreach_remove (classTable, clear_table, NULL);
    g_hash_table_destroy (classTable);
    g_hash_table_destroy (sortTable);
}

qof_collection_insert_entity()

void qof_collection_insert_entity	(	QofCollection *	col,
		QofInstance *	ent
	)

Take entity, remove it from whatever collection its currently in, and place it in a new collection.

To be used only for moving entity from one book to another.

Definition at line 95 of file qofid.cpp.

{
    const GncGUID *guid;
 
    if (!col || !ent) return;
    guid = qof_instance_get_guid(ent);
    if (guid_equal(guid, guid_null())) return;
    g_return_if_fail (col->e_type == ent->e_type);
    qof_collection_remove_entity (ent);
    g_hash_table_insert (col->hash_of_entities, (gpointer)guid, ent);
    qof_instance_set_collection(ent, col);
}

qof_collection_mark_clean()

void qof_collection_mark_clean

(

QofCollection *

col

)

reset value of dirty flag

Definition at line 238 of file qofid.cpp.

{
    if (col)
    {
        col->is_dirty = FALSE;
    }
}

qof_collection_mark_dirty()

void qof_collection_mark_dirty

(

QofCollection *

col

)

Definition at line 247 of file qofid.cpp.

{
    if (col)
    {
        col->is_dirty = TRUE;
    }
}

qof_collection_print_dirty()

void qof_collection_print_dirty	(	const QofCollection *	col,
		gpointer	dummy
	)

Definition at line 256 of file qofid.cpp.

{
    if (col->is_dirty)
        printf("%s collection is dirty.\n", col->e_type);
    qof_collection_foreach(col, (QofInstanceForeachCB)qof_instance_print_dirty, NULL);
}

qof_object_book_begin()

void qof_object_book_begin

(

QofBook *

book

)

To be called from within the book.

Definition at line 80 of file qofobject.cpp.

{
    GList *l;
 
    if (!book) return;
    ENTER (" ");
    for (l = object_modules; l; l = l->next)
    {
        QofObject *obj = static_cast<QofObject*>(l->data);
        if (obj->book_begin)
            obj->book_begin (book);
    }
 
    /* Remember this book for later */
    book_list = g_list_prepend (book_list, book);
    LEAVE (" ");
}

qof_object_book_end()

void qof_object_book_end

(

QofBook *

book

)

Definition at line 98 of file qofobject.cpp.

{
    GList *l;
 
    if (!book) return;
    ENTER (" ");
    for (l = object_modules; l; l = l->next)
    {
        QofObject *obj = static_cast<QofObject*>(l->data);
        if (obj->book_end)
            obj->book_end (book);
    }
 
    /* Remove it from the list */
    book_list = g_list_remove (book_list, book);
    LEAVE (" ");
}

qof_object_compliance()

gboolean qof_object_compliance	(	QofIdTypeConst	type_name,
		gboolean	warn
	)

check an object can be created and supports iteration

Parameters

type_name	object to check
warn	If called only once per operation, pass TRUE to log objects that fail the compliance check. To prevent repeated log messages when calling more than once, pass FALSE.

Returns

TRUE if object can be created and supports iteration, else FALSE.

Definition at line 167 of file qofobject.cpp.

{
    const QofObject *obj;
 
    obj = qof_object_lookup(type_name);
    if ((obj->create == nullptr) || (obj->foreach == nullptr))
    {
        if (warn)
        {
            PINFO (" Object type %s is not fully QOF compliant", obj->e_type);
        }
        return FALSE;
    }
    return TRUE;
}

qof_object_is_dirty()

gboolean qof_object_is_dirty

(

const QofBook *

book

)

Definition at line 117 of file qofobject.cpp.

{
    GList *l;
 
    if (!book) return FALSE;
    for (l = object_modules; l; l = l->next)
    {
        QofObject *obj = static_cast<QofObject*>(l->data);
        if (obj->is_dirty)
        {
            QofCollection *col;
            col = qof_book_get_collection (book, obj->e_type);
            if (obj->is_dirty (col)) return TRUE;
        }
    }
    return FALSE;
}

qof_object_mark_clean()

void qof_object_mark_clean

(

QofBook *

book

)

Definition at line 136 of file qofobject.cpp.

{
    GList *l;
 
    if (!book) return;
    for (l = object_modules; l; l = l->next)
    {
        QofObject *obj = static_cast<QofObject*>(l->data);
        if (obj->mark_clean)
        {
            QofCollection *col;
            col = qof_book_get_collection (book, obj->e_type);
            (obj->mark_clean) (col);
        }
    }
}

QofBackend()

QofBackend::QofBackend ( )

inline

Definition at line 177 of file qof-backend.hpp.

                 :
        m_percentage{nullptr}, m_fullpath{}, m_last_err{ERR_BACKEND_NO_ERR},
        m_error_msg{} {}

register_backend()

bool QofBackend::register_backend ( const char *  directory, const char *  module_name  )

static

Class methods for dynamically loading the several backends and for freeing them at shutdown.

Definition at line 91 of file qof-backend.cpp.

{
    if (!g_module_supported ())
    {
        PWARN("Modules not supported.");
        return false;
    }
 
    auto absdir = directory;
    auto pkgdir = gnc_path_get_pkglibdir ();
    if (!absdir || !g_path_is_absolute(absdir))
        absdir = pkgdir;
    auto fullpath = g_module_build_path (absdir, module_name);
/* Darwin modules can have either .so or .dylib for a suffix */
    if (!g_file_test (fullpath, G_FILE_TEST_EXISTS) &&
        g_strcmp0 (G_MODULE_SUFFIX, "so") == 0)
    {
        auto modname = g_strdup_printf ("lib%s.dylib", module_name);
        g_free (fullpath);
        fullpath = g_build_filename (absdir, modname, nullptr);
        g_free (modname);
    }
    auto backend = g_module_open (fullpath, G_MODULE_BIND_LAZY);
    g_free (fullpath);
    g_free (pkgdir);
    if (!backend)
    {
        PINFO ("%s: %s\n", PROJECT_NAME, g_module_error ());
        return false;
    }
    void (*module_init_func)(void);
    if (g_module_symbol (backend, "qof_backend_module_init",
                         reinterpret_cast<void**>(&module_init_func)))
        module_init_func ();
 
    g_module_make_resident (backend);
    c_be_registry.push_back(backend);
    return TRUE;
}

release_backends()

void QofBackend::release_backends ( )

static

Definition at line 132 of file qof-backend.cpp.

{
    for (auto backend : c_be_registry)
    {
        void (*module_finalize_func)(void);
        if (g_module_symbol(backend, "qof_backend_module_finalize",
                            reinterpret_cast<void**>(&module_finalize_func)))
            module_finalize_func();
    }
}

rollback()

virtual void QofBackend::rollback ( QofInstance *  )

inlinevirtual

Revert changes in the engine and unlock the backend.

Reimplemented in GncSqlBackend.

Definition at line 225 of file qof-backend.hpp.

{}

safe_sync()

virtual void QofBackend::safe_sync ( QofBook *  )

pure virtual

Perform a sync in a way that prevents data loss on a DBI backend.

Implemented in GncDbiBackend< Type >, GncDbiBackend< Type >, and GncXmlBackend.

session_begin()

virtual void QofBackend::session_begin ( QofSession *  session, const char *  new_uri, SessionOpenMode  mode  )

pure virtual

Open the file or connect to the server.

Parameters

session	The QofSession that will control the backend.
new_uri	The location of the data store that the backend will use.
mode	The session open mode. See qof_session_begin().

Implemented in GncDbiBackend< Type >, GncDbiBackend< Type >, and GncXmlBackend.

set_error()

void QofBackend::set_error

(

QofBackendError

err

)

Set the error value only if there isn't already an error already.

Definition at line 56 of file qof-backend.cpp.

{
    /* use stack-push semantics. Only the earliest error counts */
    if (m_last_err != ERR_BACKEND_NO_ERR) return;
    m_last_err = err;
}

set_message()

void QofBackend::set_message

(

std::string &&

msg

)

Set a descriptive message that can be displayed to the user when there's an error.

Definition at line 79 of file qof-backend.cpp.

{
    m_error_msg = msg;
}

set_percentage()

void QofBackend::set_percentage ( QofBePercentageFunc  pctfn )

inline

Store and retrieve a backend-specific function for determining the progress in completing a long operation, for use with a progress meter.

Definition at line 270 of file qof-backend.hpp.

{ m_percentage = pctfn; }

sync()

virtual void QofBackend::sync ( QofBook *  )

pure virtual

Synchronizes the engine contents to the backend.

This should done by using version numbers (hack alert – the engine does not currently contain version numbers). If the engine contents are newer than what is in the backend, the data is stored to the backend. If the engine contents are older, then the engine contents are updated.

Note that this sync operation is only meant to apply to the current contents of the engine. This routine is not intended to be used to fetch entity data from the backend.

File based backends tend to use sync as if it was called dump. Data is written out into the backend, overwriting the previous data. Database backends should implement a more intelligent solution.

Implemented in GncSqlBackend, and GncXmlBackend.

Variable Documentation

backend

QofBackend* QofBook::backend

Definition at line 113 of file qofbook-p.hpp.

book_open

char QofBook::book_open

Definition at line 97 of file qofbook-p.hpp.

cached_num_days_autoreadonly

gint QofBook::cached_num_days_autoreadonly

Definition at line 125 of file qofbook-p.hpp.

cached_num_days_autoreadonly_isvalid

gboolean QofBook::cached_num_days_autoreadonly_isvalid

Definition at line 127 of file qofbook-p.hpp.

cached_num_field_source

gboolean QofBook::cached_num_field_source

Definition at line 118 of file qofbook-p.hpp.

cached_num_field_source_isvalid

gboolean QofBook::cached_num_field_source_isvalid

Definition at line 120 of file qofbook-p.hpp.

data_table_finalizers

GHashTable* QofBook::data_table_finalizers

Definition at line 85 of file qofbook-p.hpp.

data_tables

GHashTable* QofBook::data_tables

Definition at line 82 of file qofbook-p.hpp.

dirty_cb

QofBookDirtyCB QofBook::dirty_cb

Definition at line 67 of file qofbook-p.hpp.

dirty_data

gpointer QofBook::dirty_data

Definition at line 71 of file qofbook-p.hpp.

dirty_time

time64 QofBook::dirty_time

Definition at line 62 of file qofbook-p.hpp.

get_book_open

char(* QofBookTestFunctions::get_book_open) (const QofBook *)

Definition at line 142 of file qofbook-p.hpp.

get_collections

GHashTable *(* QofBookTestFunctions::get_collections) (const QofBook *)

Definition at line 139 of file qofbook-p.hpp.

get_data_table_finalizers

GHashTable *(* QofBookTestFunctions::get_data_table_finalizers) (const QofBook *)

Definition at line 141 of file qofbook-p.hpp.

get_data_tables

GHashTable *(* QofBookTestFunctions::get_data_tables) (const QofBook *)

Definition at line 140 of file qofbook-p.hpp.

get_dirty_cb

QofBookDirtyCB(* QofBookTestFunctions::get_dirty_cb) (const QofBook *)

Definition at line 136 of file qofbook-p.hpp.

get_dirty_data

gpointer(* QofBookTestFunctions::get_dirty_data) (const QofBook *)

Definition at line 138 of file qofbook-p.hpp.

get_read_only

gboolean(* QofBookTestFunctions::get_read_only) (const QofBook *)

Definition at line 135 of file qofbook-p.hpp.

get_session_dirty

gboolean(* QofBookTestFunctions::get_session_dirty) (const QofBook *)

Definition at line 134 of file qofbook-p.hpp.

get_version

int(* QofBookTestFunctions::get_version) (const QofBook *)

Definition at line 143 of file qofbook-p.hpp.

hash_of_collections

GHashTable* QofBook::hash_of_collections

Definition at line 77 of file qofbook-p.hpp.

inst

QofInstance QofBook::inst

Definition at line 48 of file qofbook-p.hpp.

m_fullpath

std::string QofBackend::m_fullpath

protected

Each backend resolves a fully-qualified file path.

This holds the filepath and communicates it to the frontends.

Definition at line 286 of file qof-backend.hpp.

m_percentage

QofBePercentageFunc QofBackend::m_percentage

protected

Definition at line 282 of file qof-backend.hpp.

read_only

gboolean QofBook::read_only

Definition at line 91 of file qofbook-p.hpp.

session_dirty

gboolean QofBook::session_dirty

Definition at line 58 of file qofbook-p.hpp.

set_shutting_down

void(* QofBookTestFunctions::set_shutting_down) (QofBook *, gboolean)

Definition at line 137 of file qofbook-p.hpp.

shutting_down

gboolean QofBook::shutting_down

Definition at line 104 of file qofbook-p.hpp.

version

gint32 QofBook::version

Definition at line 107 of file qofbook-p.hpp.