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

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
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. More...
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. More...
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 More...

Detailed Description

Private interfaces, not meant to be used by applications.

Function Documentation

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 773 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_collection_insert_entity()

void qof_collection_insert_entity	(	QofCollection *	,
		QofInstance *
	)

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_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;
}