kvpframe.h

Go to the documentation of this file.

/********************************************************************\
 * kvpframe.h -- Implements a key-value frame system                *
 *                                                                  *
 * 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 KVP_FRAME_H
#define KVP_FRAME_H

#include "qofnumeric.h"
#include "guid.h"
#include "qoftime.h"
#include "qofutil.h"

#define QOF_MOD_KVP "qof-kvp"

typedef struct _KvpFrame KvpFrame;

typedef struct _KvpValue KvpValue;

typedef enum
{
    KVP_TYPE_GINT64 = 1,
    KVP_TYPE_DOUBLE,
    KVP_TYPE_NUMERIC,
    KVP_TYPE_STRING,
    KVP_TYPE_GUID,
#ifndef QOF_DISABLE_DEPRECATED

    KVP_TYPE_TIMESPEC,
#endif

    KVP_TYPE_TIME,
    KVP_TYPE_BINARY,
    KVP_TYPE_GLIST,
    KVP_TYPE_FRAME,
    KVP_TYPE_BOOLEAN
} KvpValueType;

KvpFrame *
kvp_frame_new (void);

void 
kvp_frame_delete (KvpFrame * frame);

KvpFrame *
kvp_frame_copy (const KvpFrame * frame);

gboolean 
kvp_frame_is_empty (KvpFrame * frame);

void 
kvp_frame_set_gint64 (KvpFrame * frame, const gchar * path, gint64 ival);

void 
kvp_frame_set_double (KvpFrame * frame, const gchar * path, gdouble dval);

void 
kvp_frame_set_numeric (KvpFrame * frame, const gchar * path,
                        QofNumeric nval);

void 
kvp_frame_set_string (KvpFrame * frame, const gchar * path,
                       const gchar *str);

void 
kvp_frame_set_guid (KvpFrame * frame, const gchar * path,
                     const GUID * guid);

void
kvp_frame_set_time (KvpFrame * frame, const gchar *path, QofTime *qt);

void
kvp_frame_set_boolean (KvpFrame * frame, const gchar * path, gboolean val);

void 
kvp_frame_set_frame (KvpFrame * frame, const gchar * path,
                      KvpFrame * chld);

void kvp_frame_set_frame_nc (KvpFrame * frame, const gchar * path,
                             KvpFrame * chld);

KvpFrame *
kvp_frame_set_value (KvpFrame * frame, const gchar * path, 
                    const KvpValue * value);

KvpFrame *
kvp_frame_set_value_nc (KvpFrame * frame, const gchar * path, KvpValue * value);

KvpValue *
kvp_frame_replace_value_nc (KvpFrame * frame, const gchar * slot,
                              KvpValue * new_value);
void 
kvp_frame_add_gint64 (KvpFrame * frame, const gchar * path, gint64 ival);

void 
kvp_frame_add_double (KvpFrame * frame, const gchar * path, gdouble dval);

void 
kvp_frame_add_numeric (KvpFrame * frame, const gchar * path,
                        QofNumeric nval);

void
kvp_frame_add_time (KvpFrame * frame, const gchar *path, QofTime *qt);

void kvp_frame_add_string (KvpFrame * frame, const gchar * path,
                           const gchar * str);

void
kvp_frame_add_boolean (KvpFrame * frame, const gchar * path, gboolean val);

void kvp_frame_add_guid (KvpFrame * frame, const gchar * path,
                         const GUID * guid);

void kvp_frame_add_frame (KvpFrame * frame, const gchar * path,
                          KvpFrame * chld);
void kvp_frame_add_frame_nc (KvpFrame * frame, const gchar * path,
                             KvpFrame * chld);

KvpFrame *
kvp_frame_add_value (KvpFrame * frame, const gchar * path,
                       KvpValue * value);

/* \brief Add the value directly to the glist bag

 If not all frame components of the path exist, they are created.
 If there was another item previously stored at that path, then the
 path is converted to a bag, and the old value, along with the new
 value, is added to the bag. This routine returns the pointer to the
 last frame (the actual frame to which the value was added), or NULL
 if there was an error of any sort (typically, a parse error in the path).
*/
KvpFrame *
kvp_frame_add_value_nc (KvpFrame * frame, const gchar * path,
                          KvpValue * value);


gint64 
kvp_frame_get_gint64 (const KvpFrame * frame, const gchar * path);
gdouble 
kvp_frame_get_double (const KvpFrame * frame, const gchar * path);
QofNumeric 
kvp_frame_get_numeric (const KvpFrame * frame, const gchar * path);
gchar *
kvp_frame_get_string (const KvpFrame * frame, const gchar * path);
GUID *
kvp_frame_get_guid (const KvpFrame * frame, const gchar * path);
gpointer 
kvp_frame_get_binary (const KvpFrame * frame, const gchar * path,
                    guint64 * size_return);

gboolean
kvp_frame_get_boolean (const KvpFrame * frame, const gchar * path);

QofTime *
kvp_frame_get_time (const KvpFrame * frame, const gchar *path);

KvpValue *kvp_frame_get_value (const KvpFrame * frame, const gchar * path);

KvpFrame *kvp_frame_get_frame (const KvpFrame * frame, const gchar * path);

KvpFrame *
kvp_frame_get_frame_path (KvpFrame * frame, const gchar *, ...);

KvpFrame *
kvp_frame_get_frame_gslist (KvpFrame * frame, GSList * key_path);

KvpFrame *kvp_frame_get_frame_slash (KvpFrame * frame, const gchar * path);

KvpValue *
kvp_frame_replace_slot_nc (KvpFrame * frame, const gchar * slot,
                         KvpValue * new_value);


void kvp_frame_set_slot (KvpFrame * frame,
                         const gchar * key, const KvpValue * value);
void kvp_frame_set_slot_nc (KvpFrame * frame,
                            const gchar * key, KvpValue * value);

void kvp_frame_set_slot_path (KvpFrame * frame,
                              const KvpValue * value,
                              const gchar * first_key, ...);

void kvp_frame_set_slot_path_gslist (KvpFrame * frame,
                                     const KvpValue * value,
                                     GSList * key_path);

KvpValue *kvp_frame_get_slot (const KvpFrame * frame, const gchar * key);

KvpValue *kvp_frame_get_slot_path (KvpFrame * frame,
                                   const gchar * first_key, ...);

KvpValue *kvp_frame_get_slot_path_gslist (KvpFrame * frame,
                                          GSList * key_path);

gint kvp_glist_compare (const GList * list1, const GList * list2);

GList *kvp_glist_copy (const GList * list);

void kvp_glist_delete (GList * list);


KvpValue *kvp_value_new_gint64 (gint64 value);
KvpValue *kvp_value_new_double (double value);

KvpValue *kvp_value_new_numeric (QofNumeric value);
KvpValue *kvp_value_new_string (const gchar * value);
KvpValue *kvp_value_new_guid (const GUID * guid);
KvpValue *kvp_value_new_time (QofTime *value);
KvpValue *kvp_value_new_boolean (gboolean value);

KvpValue *kvp_value_new_binary (const void *data, guint64 datasize);
KvpValue *kvp_value_new_frame (const KvpFrame * value);

KvpValue *kvp_value_new_glist (const GList * value);

KvpValue *kvp_value_new_binary_nc (void *data, guint64 datasize);

KvpValue *kvp_value_new_glist_nc (GList * lst);

KvpValue *kvp_value_new_frame_nc (KvpFrame * value);

void kvp_value_delete (KvpValue * value);

KvpValue *kvp_value_copy (const KvpValue * value);

KvpFrame *kvp_value_replace_frame_nc (KvpValue * value, KvpFrame * newframe);

GList *kvp_value_replace_glist_nc (KvpValue * value, GList * newlist);

KvpValueType kvp_value_get_type (const KvpValue * value);

gint64 kvp_value_get_gint64 (const KvpValue * value);
gdouble kvp_value_get_double (const KvpValue * value);
QofNumeric kvp_value_get_numeric (const KvpValue * value);

gchar *
kvp_value_get_string (const KvpValue * value);

GUID *
kvp_value_get_guid (const KvpValue * value);

gpointer
kvp_value_get_binary (const KvpValue * value, guint64 * size_return);

GList *
kvp_value_get_glist (const KvpValue * value);

KvpFrame *
kvp_value_get_frame (const KvpValue * value);


gboolean
kvp_value_get_boolean (const KvpValue * value);

QofTime*
kvp_value_get_time (const KvpValue * value);

gint 
kvp_value_compare (const KvpValue * va, const KvpValue * vb);

gchar *
kvp_value_to_bare_string (const KvpValue * val);

gchar *
kvp_value_to_string (const KvpValue * val);

gboolean 
kvp_value_binary_append (KvpValue * v, gpointer data, guint64 size);

typedef void (*KvpValueForeachCB) (const gchar *key, KvpValue * value, gpointer data);

void 
kvp_frame_for_each_slot (KvpFrame * f, KvpValueForeachCB, gpointer data);

#endif

---