QOF: qsf-xml.h File Reference

QOF 0.7.5

- Main Page
- Related Pages
- Modules
- Data Structures
- Files

- File List
- Globals

Data Structures | Macros | Typedefs | Enumerations | Functions
qsf-xml.h File Reference

Private QSF header - not for use by applications. More...

`#include <stdio.h>`
`#include <stdlib.h>`
`#include <regex.h>`
`#include <time.h>`
`#include "qof.h"`
`#include <libintl.h>`

Go to the source code of this file.

## Data Structures
struct | QsfObject_s
| Holds a description of the QofObject. More...
struct | QsfMetadata_s
| QSF Parameters. More...
struct | QsfValidates_s
| Validation metadata. More...
struct | QsfNodeIterate
| One iterator, two typedefs. More...

## Macros
#define | _(String) dgettext (GETTEXT_PACKAGE, String)
#define | QSF_QOF_VERSION QOF_OBJECT_VERSION
#define | QSF_XSD_TIME QOF_UTC_DATE_FORMAT
#define | QSF_XML_BOOLEAN_TEST "true"
#define | QSF_OBJECT_SCHEMA "qsf-object.xsd.xml"
#define | QSF_MAP_SCHEMA "qsf-map.xsd.xml"
QSF Object XML
#define | QSF_ROOT_TAG "qof-qsf"
#define | QSF_DEFAULT_NS "http://qof.sourceforge.net/"
#define | QSF_DATE_LENGTH MAX_DATE_LENGTH
#define | QSF_BOOK_TAG "book"
#define | QSF_BOOK_GUID "book-guid"
#define | QSF_BOOK_COUNT "count"
#define | QSF_OBJECT_TAG "object"
#define | QSF_OBJECT_TYPE "type"
#define | QSF_OBJECT_COUNT "count"
#define | QSF_XML_VERSION "1.0"
Representing KVP as XML
<kvp type="kvp" path="/from-sched-xaction" value="guid">c858b9a3235723b55bc1179f0e8c1322</kvp> A kvp type KVP parameter located at $path containing a GUID $value. The relevance of type="kvp" won't be evident in GnuCash, they all use "kvp". A non-GnuCash example helps: <kvp type="pilot_addr_kvp" path="/user/name" value="guid">c858b9a3235723b55bc1179f0e8c1322</kvp> A pilot_addr_kvp type KVP parameter located at /user/name containing a guid value.
#define | QSF_OBJECT_KVP "path"
#define | QSF_OBJECT_VALUE "value"
QSF Map XML
#define | MAP_ROOT_TAG "qsf-map"
#define | MAP_DEFINITION_TAG "definition"
#define | MAP_DEFINE_TAG "define"
#define | MAP_ITERATE_ATTR "foreach"
#define | MAP_DEFAULT_TAG "default"
#define | MAP_OBJECT_TAG "object"
#define | MAP_CALCULATE_TAG "calculate"
#define | MAP_QOF_VERSION "qof_version"
#define | MAP_NAME_ATTR "name"
#define | MAP_TYPE_ATTR "type"
#define | MAP_VALUE_ATTR "value"
#define | MAP_OBJECT_ATTR "object"
#define | MAP_E_TYPE "e_type"
#define | MAP_ENUM_TYPE "enum"
#define | QSF_BOOLEAN_DEFAULT "boolean"
| A specific boolean default for this map.
#define | QSF_CONDITIONAL "if"
#define | QSF_CONDITIONAL_SET "set"
#define | QSF_CONDITIONAL_ELSE "else"
#define | QSF_OPTION "option"
#define | QSF_FORMATTING_OPTION "format"

## Typedefs
typedef struct QsfObject_s | QsfObject
| Holds a description of the QofObject. More...
typedef struct QsfMetadata_s | QsfParam
| QSF Parameters. More...
typedef struct QsfValidates_s | QsfValidator
| Validation metadata. More...

## Enumerations
enum | QsfType { QSF_UNDEF = 0, IS_QSF_MAP, IS_QSF_OBJ, HAVE_QSF_MAP, OUR_QSF_OBJ }
enum | QsfStatus { QSF_NO_OBJECT = 0, QSF_DEFINED_OBJECT, QSF_REGISTERED_OBJECT, QSF_CALCULATED_OBJECT, QSF_INVALID_OBJECT }
| Status of various object during mapping. More...

## Functions
gint | qsf_compare_tag_strings (const xmlChar *node_name, gchar *tag_name)
| shorthand function More...
gint | qsf_strings_equal (const xmlChar *node_name, gchar *tag_name)
| shorthand function More...
gint | qsf_is_element (xmlNodePtr a, xmlNsPtr ns, gchar *c)
| shorthand function More...
gint | qsf_check_tag (QsfParam *params, gchar *qof_type)
| shorthand function More...
void | qsf_object_validation_handler (xmlNodePtr child, xmlNsPtr ns, QsfValidator *valid)
| Checks all incoming objects for QOF registration. More...
gboolean | qsf_is_valid (const gchar *schema_dir, const gchar *schema_filename, xmlDocPtr doc)
| Compares an xmlDoc in memory against the schema file. More...
GList ** | qsf_map_prepare_list (GList **maps)
| Prepare the default list of maps. More...
void | qsf_book_node_handler (xmlNodePtr child, xmlNsPtr qsf_ns, QsfParam *params)
| Book and book-guid node handler. More...
KvpValue * | string_to_kvp_value (const gchar *content, KvpValueType type)
| Convert a string value into KvpValue. More...
void | qsf_valid_foreach (xmlNodePtr parent, QsfValidCB cb, struct QsfNodeIterate *qsfiter, QsfValidator *valid)
void | qsf_node_foreach (xmlNodePtr parent, QsfNodeCB cb, struct QsfNodeIterate *qsfiter, QsfParam *params)
xmlDocPtr | qsf_object_convert (xmlDocPtr mapDoc, xmlNodePtr qsf_root, QsfParam *params)
| Convert between QSF objects. More...
void | qsf_object_node_handler (xmlNodePtr child, xmlNsPtr qsf_ns, QsfParam *params)

## Why two sets of functions and typedefs?
These functions are in pairs, one to use in an existing session and one to use when deciding which backend should be selected for a new session. When there is an existing QofSession, the qsf_param context will be available, so set error codes in the backend. Use the *_be functions. When just determining the type of file, qsf_param is not necessary and no backend is available (it has not been selected yet). Use the twin function. e.g. in ::qsf_file_type()
typedef void(* | QsfNodeCB) (xmlNodePtr, xmlNsPtr, QsfParam *)
| map and qsf object callback More...
typedef void(* | QsfValidCB) (xmlNodePtr, xmlNsPtr, QsfValidator *)
| validator callback More...
gboolean | is_qsf_object_be (QsfParam *params)
| Validate a QSF file and identify a suitable QSF map. More...
gboolean | is_qsf_object (const gchar *path)
| Validate a QSF file and identify a suitable QSF map. More...
gboolean | is_our_qsf_object_be (QsfParam *params)
| Validate a QSF file and determine type. More...
gboolean | is_our_qsf_object (const gchar *path)
| Validate a QSF file. More...
gboolean | is_qsf_map_be (QsfParam *params)
| Validate a QSF map file. More...
gboolean | is_qsf_map (const gchar *path)
| Validate a QSF map file. More...
gboolean | is_qsf_object_with_map_be (gchar *map_path, QsfParam *params)
| Validate a QSF file and a selected QSF map. More...
gboolean | is_qsf_object_with_map (const gchar *path, gchar *map_file)
| Validate a QSF file and a selected QSF map. More...

## Detailed Description

Private QSF header - not for use by applications.

Author
  Copyright (C) 2004-2005 Neil Williams linux.nosp@m.@cod.nosp@m.ehelp.nosp@m..co..nosp@m.uk

Definition in file qsf-xml.h.

## Macro Definition Documentation

#define MAP_CALCULATE_TAG "calculate"

One calculation for every parameter that needs to be set.

QSF follows the same rule as qof_book_merge. Only if a getter and a setter function are defined for a parameter is it available to QSF. If a QofAccessFunc and QofSetterFunc are both defined for any QofObject parameter, that parameter MUST be calculated in any map that defines that object.

Definition at line 251 of file qsf-xml.h.

#define MAP_DEFAULT_TAG "default"

User editable defaults for data not available within the available QSF objects.

Some defaults will relate to how to format descriptive dates, whether discount should be considered, which account to use for certain QSF data from applications that do not use accounts.

Some defaults are pre-defined and cannot be over-written:

- qsf_time_now
- qsf_time_string

Attributes (All are mandatory):

name The text name for this default. Certain pre-defined defaults exist but user- or map-defined defaults can have any unique text name. Spaces are NOT allowed, use undersccores instead. The value of name must not duplicate any existing default, define, object or parameter unless the special type, enum, is used.

type QOF_TYPE - must be one of the recognised QOF data types for the qof_version in use or the special type, enum.

value Text representation of the required value. For numeric, use the format [0-9]?/[0-9]?

Attention
  Using boolean defaults

A boolean default is not output in the QSF directly, instead the value is used in the calculations to modify certain values. If the boolean default is set to true, the if statement containing the boolean name will be evaluated. If the boolean default is set to false, the corresponding else will be evaluted. Make sure your calculations contain an appropriate else statement so that the boolean value can be adjusted without invalidating the map!

QSF deals with partial QofBooks - each object is fully described but the book does not have to contain any specific object types or have any particular structure. To merge partial books into usual QofBook data sources, the map must deal with entities that need to be referenced in the target QofBook but which simply do not exist in the QofBook used to generate the QSF. e.g. pilot-link knows nothing of Accounts yet when QSF creates a gncInvoice from qof-datebook, gncInvoice needs to know the GUID of certain accounts in the target QofBook. This is handled in the map by specifying the name of the account as a default for that map. When imported, the QSF QofBackend looks up the object required using the name of the parameter to obtain the parameter type. This is the only situation where QSF converts between QOF data types. A string description of the required object is converted to the GUID for that specific entity. The map cannot contain the GUID as it is generic and used by multiple users.

Attention
  Using enumerators
  - enum types are the only defaults that are allowed to use the same name value more than once.
  - enum types are used to increase the readability of a QSF map.
  - The enum name acts to group the enum values together - in a similar fashion to radio buttons in HTML forms.
  - enum types are used only where the QOF object itself uses an enum type.

e.g. the tax_included enum type allows maps to use the full name of the enum value GNC_TAXINCLUDED_YES, instead of the cryptic digit value, 1.

Definition at line 229 of file qsf-xml.h.

#define MAP_DEFINE_TAG "define"

defines each object supported by this QSF map

Attributes: e_type Copied directly from the QofObject definition. Content: The full QofObject description for the defined QOF object.

Definition at line 154 of file qsf-xml.h.

#define MAP_DEFINITION_TAG "definition"

Second level container for defined objects

Attributes: qof_version - Taken from the QOF_OBJECT_VERSION macro in QOF. At the time of QSF development, QOF_OBJECT_VERSION is defined as 3. All QSF maps and QSF objects must use the same qof_version which in turn must match the QOF_OBJECT_VERSION for the QOF library in use by the calling process.

No text content allowed.

Definition at line 147 of file qsf-xml.h.

#define MAP_E_TYPE "e_type"

Validates the objects defined in the map

The e_type will be used to match incoming QSF objects with the relevant QSF map. The value of the e_type must be the value of the e_type for that object in the originating QOF application. The define tag must contain the value of the description of the same object in the same originating QOF application.

Definition at line 303 of file qsf-xml.h.

#define MAP_ENUM_TYPE "enum"

Todo:
  enum is an attempt to make enumerator values descriptive in the maps and QSF (possibly). Not working yet.

Definition at line 307 of file qsf-xml.h.

#define MAP_ITERATE_ATTR "foreach"

Dictate which object type is the basis for iteration in a hierarchical object set.

Definition at line 158 of file qsf-xml.h.

#define MAP_NAME_ATTR "name"

The name of the default setting.

Use this name to refer to the value of this default in the map calculations.

Make sure that the type of this default matches the type of the parameter being set by the parent calculation!

Definition at line 270 of file qsf-xml.h.

#define MAP_OBJECT_ATTR "object"

The object to use to provide the data being set using the map.

Definition at line 293 of file qsf-xml.h.

#define MAP_OBJECT_TAG "object"

Contains all the calculations to make one object from others.

Note that creating an object for the import application can involve using data from more than one QSF object, as well as defaults and lookups in the import application itself. Conditionals, simple arithmetic and date/time formatting options are also available.

Definition at line 240 of file qsf-xml.h.

#define MAP_QOF_VERSION "qof_version"

This is the QOF_OBJECT_VERSION from QOF.

QSF maps may need to be updated if QOF itself is upgraded. This setting is coded into QOF and maps for one version cannot necessarily be used by other versions. At the first release of QSF, QOF_OBJECT_VERSION = 3.

Definition at line 260 of file qsf-xml.h.

#define MAP_ROOT_TAG "qsf-map"

Top level root tag for QSF Maps

Definition at line 136 of file qsf-xml.h.

#define MAP_TYPE_ATTR "type"

QSF will NOT convert between QOF types.

QSF will allow a conditional to use a parameter of one type to determine the value from a parameter of another type, but the final value assigned MUST be of the same type as the parent calculation.

Definition at line 279 of file qsf-xml.h.

#define MAP_VALUE_ATTR "value"

The value of the tag, used in defaults and calculations.

The value of a default is a string representation of the value to be inserted into the calculation where the default is used.

The value of a calculation is the name of the parameter that will be set by that calculation.

Definition at line 289 of file qsf-xml.h.

#define QSF_BOOK_COUNT "count"

Sequential counter of each book in this file

Definition at line 99 of file qsf-xml.h.

#define QSF_BOOK_GUID "book-guid"

QOF GUID tag for the QofBook described by this QSF object file

Definition at line 97 of file qsf-xml.h.

#define QSF_BOOK_TAG "book"

First level child: book tag - the QofBook.

Definition at line 94 of file qsf-xml.h.

#define QSF_CONDITIONAL "if"

child of calculate.

Conditionals can reference objects as if within the original application. In operation, the map is overlaid across both sets of defined objects, an import object in the source application and an output object for the destination object. The current import and output QSF objects are therefore always available to the map. Conditionals can reference parameter as well as object values.

Definition at line 322 of file qsf-xml.h.

#define QSF_CONDITIONAL_ELSE "else"

Alternative

if(){} else{} is also supported. Nesting of conditionals causes problems for validating the final map against any sensible XML Schema and a map that does not validate will be rejected. When editing conditionals in a QSF map, ALWAYS validate the map using xmllint. If necessary, define a variable at the foot of the definitions block, using a similar syntax to a default, then use that variable in another conditional

variable name="my_rate" type="numeric" value="0/1"

The syntax for xmllint is:

xmllint –schema <schema file> <qsf-file>

Use the qsf-object.xsd.xml schema for objects and qsf-map.xsd.xml for map files.

e.g. xmllint –schema qsf-object.xsd.xml –noout qof-qsf.xml

Definition at line 358 of file qsf-xml.h.

#define QSF_CONDITIONAL_SET "set"

Assignment statement

Map assignments can use the native values within the output object. The output object must support setting the relevant parameter using the value exactly as given in the map because the relevant set() function will be called using this value. This may reduce the readability of the map but the relevant application could also be modified to support a more readable set function.

Definition at line 334 of file qsf-xml.h.

#define QSF_DATE_LENGTH MAX_DATE_LENGTH

Max length of QSF_XSD_TIME.

MAX_DATE_LENGTH itself is defined in qof-time.h

Definition at line 91 of file qsf-xml.h.

#define QSF_DEFAULT_NS "http://qof.sourceforge.net/"

Default namespace for QSF root tag

The map namespace is not included as maps are not currently written out by QOF.

Definition at line 87 of file qsf-xml.h.

#define QSF_FORMATTING_OPTION "format"

How to format dates/times

When the QSF map uses a date/time value as a string, the formatting can be adjusted to personal preference. format will only be evaluated if the calculated parameter is a QOF_TYPE_STRING - any format attributes on other data types will be ignored.

Definition at line 376 of file qsf-xml.h.

#define QSF_MAP_SCHEMA "qsf-map.xsd.xml"

Name of the QSF Map Schema.

Definition at line 423 of file qsf-xml.h.

#define QSF_OBJECT_COUNT "count"

Sequential counter for each QSF object in this file

Definition at line 105 of file qsf-xml.h.

#define QSF_OBJECT_KVP "path"

The path to this KVP value in the entity frame.

Definition at line 127 of file qsf-xml.h.

#define QSF_OBJECT_SCHEMA "qsf-object.xsd.xml"

Name of the QSF Object Schema.

Definition at line 420 of file qsf-xml.h.

#define QSF_OBJECT_TAG "object"

Second level child: object tag

Definition at line 101 of file qsf-xml.h.

#define QSF_OBJECT_TYPE "type"

QSF parameter name for object type specifiers

Definition at line 103 of file qsf-xml.h.

#define QSF_OBJECT_VALUE "value"

The KVP Value.

Definition at line 129 of file qsf-xml.h.

#define QSF_OPTION "option"

enum operator

Not implemented yet - may need to change once work starts. Theoretically, option will specify when an enumerator value is in use - it is quite possible that it will be unnecessary.

Definition at line 366 of file qsf-xml.h.

#define QSF_QOF_VERSION QOF_OBJECT_VERSION

QOF Version check.

Make sure the same version of QOF is in use in both applications.

Definition at line 70 of file qsf-xml.h.

#define QSF_ROOT_TAG "qof-qsf"

The top level root tag

Definition at line 81 of file qsf-xml.h.

#define QSF_XML_BOOLEAN_TEST "true"

needs to be lowercase for XML validation

Definition at line 417 of file qsf-xml.h.

#define QSF_XML_VERSION "1.0"

The current XML version.

Definition at line 107 of file qsf-xml.h.

#define QSF_XSD_TIME QOF_UTC_DATE_FORMAT

xsd:dateTime format in coordinated universal time, UTC.

You can reproduce the string from the GNU/Linux command line using the date utility:

date -u +Y-m-dTH:M:SZ

2004-12-12T23:39:11Z

The datestring must be timezone independent and include all specified fields.

Remember to use gmtime() NOT localtime()!. From the command line, use the -u switch with the date command: date -u

To generate a timestamp based on a real time, use the qsf_time_now and qsf_time_string defaults.

qsf_time_now : Format: QOF_TYPE_DATE. The current time taken from the moment the default is read into a QSF object at runtime.

qsf_time_string : Format: QOF_TYPE_STRING. The current timestamp taken from the moment the default is read into a QSF object at runtime. This form is used when the output parameter needs a formatted date string, not an actual date object. The format is determined by the optional format attribute of the set tag which takes the same operators as the GNU C Library for strftime() and output may therefore be dependent on the locale of the calling process - take care. Default value is F, used when qsf_time_string is set without the format attribute.

Both defaults use UTC.

Definition at line 414 of file qsf-xml.h.

## Typedef Documentation

typedef void(* QsfNodeCB) (xmlNodePtr, xmlNsPtr, QsfParam *)

map and qsf object callback

This callback cannot do both the map and the validation tasks because validation sometimes needs to be done without qsf_params.

e.g. when selecting which backend should be used for a particular data source where two or more backends share the same access_method.

Definition at line 677 of file qsf-xml.h.

typedef struct QsfObject_s QsfObject

Holds a description of the QofObject.

Used when converting QOF objects from another application. The incoming, unknown, objects need to be stored prior to conversion. This allows many-to-many conversions where an invoice can receive data from an incoming expense AND datebook and use data from an incoming contacts object to lookup the customer for the invoice.

typedef struct QsfMetadata_s QsfParam

QSF Parameters.

This struct is a catch-all for all parameters required for various stages of the process. There are lots of elements here that will finally be removed.

typedef struct QsfValidates_s QsfValidator

Validation metadata.

The validation is a separate parse with separate data. This is used to determine which backend should load the data.

typedef void(* QsfValidCB) (xmlNodePtr, xmlNsPtr, QsfValidator *)

validator callback

Todo:
  The need for separate metadata means a separate callback typedef is needed for the validator, but this should be fixed to only need one.

Definition at line 684 of file qsf-xml.h.

## Enumeration Type Documentation

enum QsfStatus

Status of various object during mapping.

When handling a map, the incoming QSF objects are not registered with this instance of QOF - they originate from another QOF user. Each object in a map needs to be defined. If the object is registered, the map is checked to locate a calculation that can be used to generate this object. If the object is not registered, the incoming QSF is checked to ensure it provides the object data for the calculation. If anything goes wrong, QSF_INVALID_OBJECT is used.

Maps can be unidirectional or bidirectional so QOF registration is used to determine which calculations should be used and which should be ignored.

All QSF_REGISTERED_OBJECT types need a calculation - if any types remain tagged as QSF_REGISTERED_OBJECT when the map validation is complete, the validation must fail. The only acceptable end values for QsfStatus are QSF_DEFINED_OBJECT, QSF_CALCULATED_OBJECT or QSF_INVALID_OBJECT.

Enumerator
QSF_NO_OBJECT | Init value.
QSF_DEFINED_OBJECT | The object is unregistered but defined. Objects of this type must exist in the incoming QSF and must provide data for the calculation of registered objects.
QSF_REGISTERED_OBJECT | Temporary value. The object is registered and defined - a calculation is needed but has not been found, yet.
QSF_CALCULATED_OBJECT | The object is registered, defined and can be calculated.
QSF_INVALID_OBJECT | Oops value.

Definition at line 446 of file qsf-xml.h.

467 {

enum QsfType

Enumerator
QSF_UNDEF | Initial undefined value.
IS_QSF_MAP | A QSF map
IS_QSF_OBJ | A QSF object without a map - it may or may not need one.
HAVE_QSF_MAP | A QSF object with the map it needs.
OUR_QSF_OBJ | A QSF object that can be loaded without a map.

Definition at line 41 of file qsf-xml.h.

42 {
44 QSF_UNDEF = 0,
46 IS_QSF_MAP,
48 IS_QSF_OBJ,
50 HAVE_QSF_MAP,
52 OUR_QSF_OBJ,
53 } QsfType;
HAVE_QSF_MAP
Definition: qsf-xml.h:50
OUR_QSF_OBJ
Definition: qsf-xml.h:52
IS_QSF_MAP
Definition: qsf-xml.h:46
IS_QSF_OBJ
Definition: qsf-xml.h:48
QsfType
QsfType
Definition: qsf-xml.h:41
QSF_UNDEF
Definition: qsf-xml.h:44

## Function Documentation

gboolean is_our_qsf_object | ( | const gchar * | path | ) |

Validate a QSF file.

Parameters

  path | Absolute or relative path to the file to be validated

The file is validated against the QSF object schema, qsf-object.xsd.xml and each object described in the file is checked to see if it is registered with QOF within the QOF environment of the calling process.

Files that pass the test can be imported into the QOF application without the need for a QSF map.

Returns
  TRUE if the file validates and all objects pass, otherwise FALSE.

Definition at line 180 of file qsf-xml.c.

181 {
182 xmlDocPtr doc;
183 struct QsfNodeIterate qsfiter;
184 xmlNodePtr object_root;
185 QsfValidator valid;
186 gint table_count;
187
188 g_return_val_if_fail ((path != NULL), FALSE);
189 doc = xmlParseFile (path);
190 if (doc == NULL)
191 {
192 return FALSE;
193 }
194 if (TRUE != qsf_is_valid (QSF_SCHEMA_DIR, QSF_OBJECT_SCHEMA, doc))
195 {
196 PINFO (" validation failed %s %s %s", QSF_SCHEMA_DIR,
197 QSF_OBJECT_SCHEMA, path);
198 return FALSE;
199 }
200 object_root = xmlDocGetRootElement (doc);
201 /* check that all objects in the file are already registered in QOF */
202 valid.object_table = g_hash_table_new (g_str_hash, g_str_equal);
203 valid.qof_registered_count = 0;
204 valid.valid_object_count = 0;
205 qsfiter.ns = object_root->ns;
206 qsf_valid_foreach (object_root, qsf_object_validation_handler,
207 &qsfiter, &valid);
208 table_count = g_hash_table_size (valid.object_table);
209 g_hash_table_destroy (valid.object_table);
210 xmlFreeDoc (doc);
211 if (table_count == valid.qof_registered_count)
212 {
213 return TRUE;
214 }
215 return FALSE;
216 }
qsf_object_validation_handler
void qsf_object_validation_handler(xmlNodePtr child, xmlNsPtr ns, QsfValidator *valid)
Checks all incoming objects for QOF registration.
Definition: qsf-xml.c:134
PINFO
#define PINFO(format, args...)
Definition: qoflog.h:199
QsfValidates_s
Validation metadata.
Definition: qsf-xml.h:558
qsf_valid_foreach
void qsf_valid_foreach(xmlNodePtr parent, QsfValidCB cb, struct QsfNodeIterate *qsfiter, QsfValidator *valid)
Definition: qsf-xml.c:102
qsf_is_valid
gboolean qsf_is_valid(const gchar *schema_dir, const gchar *schema_filename, xmlDocPtr doc)
Compares an xmlDoc in memory against the schema file.
Definition: qsf-xml.c:75
QsfNodeIterate
One iterator, two typedefs.
Definition: qsf-xml.h:689
QsfValidates_s::qof_registered_count
gint qof_registered_count
Definition: qsf-xml.h:578
QsfValidates_s::valid_object_count
gint valid_object_count
Definition: qsf-xml.h:572
QSF_OBJECT_SCHEMA
#define QSF_OBJECT_SCHEMA
Definition: qsf-xml.h:420
QsfValidates_s::object_table
GHashTable * object_table
Definition: qsf-xml.h:565

gboolean is_our_qsf_object_be | ( | QsfParam * | params | ) |

Validate a QSF file and determine type.

Parameters

  params | Pointer to qsf_param context

The file is validated against the QSF object schema, qsf-object.xsd.xml and each object described in the file is checked to see if it is registered with QOF within the QOF environment of the calling process.

Files that pass the test can be imported into the QOF appliction without the need for a QSF map.

Returns
  TRUE if the file validates and all objects pass, otherwise FALSE.

Definition at line 243 of file qsf-xml.c.

244 {
245 xmlDocPtr doc;
246 struct QsfNodeIterate qsfiter;
247 xmlNodePtr object_root;
248 QsfValidator valid;
249 gint table_count;
250
251 g_return_val_if_fail ((params != NULL), FALSE);
252 if (params->filepath == NULL)
253 {
254 qof_error_set_be (params->be, qof_error_register
255 (_("The QSF XML file '%s' could not be found."), TRUE));
256 return FALSE;
257 }
258 if (params->file_type != QSF_UNDEF)
259 {
260 return FALSE;
261 }
262 doc = xmlParseFile (params->filepath);
263 if (doc == NULL)
264 {
265 qof_error_set_be (params->be, qof_error_register
266 (_("There was an error parsing the file '%s'."), TRUE));
267 return FALSE;
268 }
269 if (TRUE != qsf_is_valid (QSF_SCHEMA_DIR, QSF_OBJECT_SCHEMA, doc))
270 {
271 qof_error_set_be (params->be, qof_error_register
272 (_("Invalid QSF Object file! The QSF object file '%s' "
273 " failed to validate against the QSF object schema. "
274 "The XML structure of the file is either not well-formed "
275 "or the file contains illegal data."), TRUE));
276 xmlFreeDoc (doc);
277 return FALSE;
278 }
279 params->file_type = IS_QSF_OBJ;
280 object_root = xmlDocGetRootElement (doc);
281 xmlFreeDoc (doc);
282 valid.object_table = g_hash_table_new (g_str_hash, g_str_equal);
283 valid.qof_registered_count = 0;
284 qsfiter.ns = object_root->ns;
285 qsf_valid_foreach (object_root, qsf_object_validation_handler,
286 &qsfiter, &valid);
287 table_count = g_hash_table_size (valid.object_table);
288 if (table_count == valid.qof_registered_count)
289 {
290 g_hash_table_destroy (valid.object_table);
291 return TRUE;
292 }
293 g_hash_table_destroy (valid.object_table);
294 qof_error_set_be (params->be, params->err_nomap);
295 return FALSE;
296 }
qof_error_register
QofErrorId qof_error_register(const gchar *err_message, gboolean use_file)
Generate and register a new error.
Definition: qoferror.c:91
qsf_object_validation_handler
void qsf_object_validation_handler(xmlNodePtr child, xmlNsPtr ns, QsfValidator *valid)
Checks all incoming objects for QOF registration.
Definition: qsf-xml.c:134
QsfValidates_s
Validation metadata.
Definition: qsf-xml.h:558
qsf_valid_foreach
void qsf_valid_foreach(xmlNodePtr parent, QsfValidCB cb, struct QsfNodeIterate *qsfiter, QsfValidator *valid)
Definition: qsf-xml.c:102
QsfMetadata_s::file_type
QsfType file_type
Definition: qsf-xml.h:472
qsf_is_valid
gboolean qsf_is_valid(const gchar *schema_dir, const gchar *schema_filename, xmlDocPtr doc)
Compares an xmlDoc in memory against the schema file.
Definition: qsf-xml.c:75
QsfMetadata_s::be
QofBackend * be
Definition: qsf-xml.h:519
QsfNodeIterate
One iterator, two typedefs.
Definition: qsf-xml.h:689
QsfValidates_s::qof_registered_count
gint qof_registered_count
Definition: qsf-xml.h:578
IS_QSF_OBJ
Definition: qsf-xml.h:48
QSF_OBJECT_SCHEMA
#define QSF_OBJECT_SCHEMA
Definition: qsf-xml.h:420
QsfMetadata_s::filepath
gchar * filepath
Definition: qsf-xml.h:533
QsfValidates_s::object_table
GHashTable * object_table
Definition: qsf-xml.h:565
QSF_UNDEF
Definition: qsf-xml.h:44

gboolean is_qsf_map | ( | const gchar * | path | ) |

Validate a QSF map file.

Parameters

  path | Absolute or relative path to the file to be validated

These functions are in pairs. When called from within a QofSession, the qsf_param context will be available. When just determining the type of file, qsf_param is not necessary. Use the *_be functions from within the QofBackend and the corresponding function in other code.

The file is validated aginst the QSF map schema, qsf-map.xsd.xsml. This function is called by is_qsf_object. If called directly, the map file is validated and closed, no data is retrieved. QSF maps do not contain user data but are used to import QSF object files from other applications.

Returns
  TRUE if the map validates, otherwise FALSE.

Definition at line 372 of file qsf-xml-map.c.

373 {
374 xmlDocPtr doc;
375 struct QsfNodeIterate qsfiter;
376 QsfValidator valid;
377 xmlNodePtr map_root;
378 xmlNsPtr map_ns;
379
380 g_return_val_if_fail ((path != NULL), FALSE);
381 if (path == NULL)
382 {
383 return FALSE;
384 }
385 doc = xmlParseFile (path);
386 if (doc == NULL)
387 {
388 return FALSE;
389 }
390 if (TRUE != qsf_is_valid (QSF_SCHEMA_DIR, QSF_MAP_SCHEMA, doc))
391 {
392 return FALSE;
393 }
394 map_root = xmlDocGetRootElement (doc);
395 map_ns = map_root->ns;
396 qsfiter.ns = map_ns;
397 valid.error_state = QOF_SUCCESS;
398 valid.map_table = g_hash_table_new (g_str_hash, g_str_equal);
399 qsf_valid_foreach (map_root, qsf_map_validation_handler,
400 &qsfiter, &valid);
401 if (valid.error_state != QOF_SUCCESS)
402 {
403 g_hash_table_destroy (valid.map_table);
404 return FALSE;
405 }
406 g_hash_table_destroy (valid.map_table);
407 return TRUE;
408 }
QsfValidates_s
Validation metadata.
Definition: qsf-xml.h:558
qsf_valid_foreach
void qsf_valid_foreach(xmlNodePtr parent, QsfValidCB cb, struct QsfNodeIterate *qsfiter, QsfValidator *valid)
Definition: qsf-xml.c:102
qsf_is_valid
gboolean qsf_is_valid(const gchar *schema_dir, const gchar *schema_filename, xmlDocPtr doc)
Compares an xmlDoc in memory against the schema file.
Definition: qsf-xml.c:75
QsfNodeIterate
One iterator, two typedefs.
Definition: qsf-xml.h:689
QOF_SUCCESS
#define QOF_SUCCESS
Definition: qoferror.h:124
QSF_MAP_SCHEMA
#define QSF_MAP_SCHEMA
Definition: qsf-xml.h:423

gboolean is_qsf_map_be | ( | QsfParam * | params | ) |

Validate a QSF map file.

Parameters

  params | Pointer to qsf_param context

The file is validated aginst the QSF map schema, qsf-map.xsd.xsml. This function is called by is_qsf_object. If called directly, the map file is validated and closed with a QofBackend error. QSF maps do not contain user data and are used to import QSF object files.

Returns
  TRUE if the map validates, otherwise FALSE.

Definition at line 320 of file qsf-xml-map.c.

321 {
322 xmlDocPtr doc;
323 struct QsfNodeIterate qsfiter;
324 QsfValidator valid;
325 xmlNodePtr map_root;
326 xmlNsPtr map_ns;
327 gchar *path;
328
329 g_return_val_if_fail ((params != NULL), FALSE);
330 path = g_strdup (params->filepath);
331 if (path == NULL)
332 {
333 qof_error_set_be (params->be, qof_error_register
334 (_("The QSF XML file '%s' could not be found."), TRUE));
335 return FALSE;
336 }
337 doc = xmlParseFile (path);
338 if (doc == NULL)
339 {
340 qof_error_set_be (params->be, qof_error_register
341 (_("There was an error parsing the file '%s'."), TRUE));
342 return FALSE;
343 }
344 if (TRUE != qsf_is_valid (QSF_SCHEMA_DIR, QSF_MAP_SCHEMA, doc))
345 {
346 qof_error_set_be (params->be,
347 qof_error_register (
348 _("Invalid QSF Map file! The QSF map file "
349 "failed to validate against the QSF map schema. "
350 "The XML structure of the file is either not well-formed "
351 "or the file contains illegal data."), FALSE));
352 return FALSE;
353 }
354 map_root = xmlDocGetRootElement (doc);
355 map_ns = map_root->ns;
356 qsfiter.ns = map_ns;
357 valid.object_table = g_hash_table_new (g_str_hash, g_str_equal);
358 valid.map_table = g_hash_table_new (g_str_hash, g_str_equal);
359 valid.error_state = QOF_SUCCESS;
360 qsf_valid_foreach (map_root, qsf_map_validation_handler,
361 &qsfiter, &valid);
362 if (valid.error_state != QOF_SUCCESS)
363 {
364 g_hash_table_destroy (valid.object_table);
365 return FALSE;
366 }
367 g_hash_table_destroy (valid.object_table);
368 return TRUE;
369 }
qof_error_register
QofErrorId qof_error_register(const gchar *err_message, gboolean use_file)
Generate and register a new error.
Definition: qoferror.c:91
QsfValidates_s
Validation metadata.
Definition: qsf-xml.h:558
qsf_valid_foreach
void qsf_valid_foreach(xmlNodePtr parent, QsfValidCB cb, struct QsfNodeIterate *qsfiter, QsfValidator *valid)
Definition: qsf-xml.c:102
qsf_is_valid
gboolean qsf_is_valid(const gchar *schema_dir, const gchar *schema_filename, xmlDocPtr doc)
Compares an xmlDoc in memory against the schema file.
Definition: qsf-xml.c:75
QsfMetadata_s::be
QofBackend * be
Definition: qsf-xml.h:519
QsfNodeIterate
One iterator, two typedefs.
Definition: qsf-xml.h:689
QOF_SUCCESS
#define QOF_SUCCESS
Definition: qoferror.h:124
QsfMetadata_s::filepath
gchar * filepath
Definition: qsf-xml.h:533
QSF_MAP_SCHEMA
#define QSF_MAP_SCHEMA
Definition: qsf-xml.h:423

gboolean is_qsf_object | ( | const gchar * | path | ) |

Validate a QSF file and identify a suitable QSF map.

Parameters

  path | Absolute or relative path to the file to be validated.

These functions are in pairs. When called from within a QofSession, the qsf_param context will be available. When just determining the type of file, qsf_param is not necessary. Use the *_be functions from within the QofBackend and the corresponding function in other code.

The file is validated against the QSF object schema, qsf-object.xsd.xml and each object described in the file is checked to find out if a suitable QSF map exists. Map files are accepted if all objects described in the QSF object file are defined in the QSF map.

Returns
  TRUE if the file validates and a QSF map can be found, otherwise FALSE.

Definition at line 219 of file qsf-xml.c.

220 {
221 xmlDocPtr doc;
222
223 g_return_val_if_fail ((path != NULL), FALSE);
224 if (path == NULL)
225 {
226 return FALSE;
227 }
228 doc = xmlParseFile (path);
229 if (doc == NULL)
230 {
231 return FALSE;
232 }
233 if (TRUE != qsf_is_valid (QSF_SCHEMA_DIR, QSF_OBJECT_SCHEMA, doc))
234 {
235 return FALSE;
236 }
237 /* Note cannot test against a map here, so if the file is valid QSF,
238 accept it and work out the details later. */
239 return TRUE;
240 }
qsf_is_valid
gboolean qsf_is_valid(const gchar *schema_dir, const gchar *schema_filename, xmlDocPtr doc)
Compares an xmlDoc in memory against the schema file.
Definition: qsf-xml.c:75
QSF_OBJECT_SCHEMA
#define QSF_OBJECT_SCHEMA
Definition: qsf-xml.h:420

gboolean is_qsf_object_be | ( | QsfParam * | params | ) |

Validate a QSF file and identify a suitable QSF map.

Parameters

  params | Pointer to qsf_param context

These functions are in pairs. When called from within a QofSession, the qsf_param context will be available. When just determining the type of file, qsf_param is not necessary. Use the *_be functions from within the QofBackend and the corresponding function in other code.

The file is validated against the QSF object schema, qsf-object.xsd.xml and each object described in the file is checked to find out if a suitable QSF map exists. Map files are accepted if all objects described in the QSF object file are defined in the QSF map.

Returns
  TRUE if the file validates and a QSF map can be found, otherwise FALSE.

Definition at line 299 of file qsf-xml.c.

300 {
301 gboolean result;
302 xmlDocPtr doc;
303 GList *maps;
304 gchar *path;
305
306 g_return_val_if_fail ((params != NULL), FALSE);
307 path = g_strdup (params->filepath);
308 if (path == NULL)
309 {
310 qof_error_set_be (params->be, qof_error_register
311 (_("The QSF XML file '%s' could not be found."), TRUE));
312 return FALSE;
313 }
314 /* skip validation if is_our_qsf_object has already been called. */
315 /* if (ERR_QSF_INVALID_OBJ == qof_backend_get_error (params->be))
316 {
317 return FALSE;
318 }*/
319 if (params->file_type == QSF_UNDEF)
320 {
321 doc = xmlParseFile (path);
322 if (doc == NULL)
323 {
324 qof_error_set_be (params->be, qof_error_register
325 (_("There was an error parsing the file '%s'."), TRUE));
326 return FALSE;
327 }
328 if (TRUE != qsf_is_valid (QSF_SCHEMA_DIR, QSF_OBJECT_SCHEMA, doc))
329 {
330 qof_error_set_be (params->be, qof_error_register
331 (_("Invalid QSF Object file! The QSF object file '%s' "
332 " failed to validate against the QSF object schema. "
333 "The XML structure of the file is either not well-formed "
334 "or the file contains illegal data."), TRUE));
335 return FALSE;
336 }
337 }
338 result = FALSE;
339 /* retrieve list of maps from config frame. */
340 for (maps = params->map_files; maps; maps = maps->next)
341 {
342 QofErrorId err;
343 result = is_qsf_object_with_map_be (maps->data, params);
344 err = qof_error_check_be (params->be);
345 if ((err == QOF_SUCCESS) && result)
346 {
347 params->map_path = maps->data;
348 PINFO ("map chosen = %s", params->map_path);
349 break;
350 }
351 }
352 return result;
353 }
qof_error_register
QofErrorId qof_error_register(const gchar *err_message, gboolean use_file)
Generate and register a new error.
Definition: qoferror.c:91
PINFO
#define PINFO(format, args...)
Definition: qoflog.h:199
QsfMetadata_s::file_type
QsfType file_type
Definition: qsf-xml.h:472
qsf_is_valid
gboolean qsf_is_valid(const gchar *schema_dir, const gchar *schema_filename, xmlDocPtr doc)
Compares an xmlDoc in memory against the schema file.
Definition: qsf-xml.c:75
QofErrorId
gint32 QofErrorId
The ID of this error.
Definition: qofbackend.h:54
QsfMetadata_s::be
QofBackend * be
Definition: qsf-xml.h:519
qof_error_check_be
QofErrorId qof_error_check_be(QofBackend *be)
Check for errors.
Definition: qoferror.c:234
QsfMetadata_s::map_path
gchar * map_path
Definition: qsf-xml.h:535
QOF_SUCCESS
#define QOF_SUCCESS
Definition: qoferror.h:124
is_qsf_object_with_map_be
gboolean is_qsf_object_with_map_be(gchar *map_path, QsfParam *params)
Validate a QSF file and a selected QSF map.
Definition: qsf-xml-map.c:240
QsfMetadata_s::map_files
GList * map_files
Definition: qsf-xml.h:545
QSF_OBJECT_SCHEMA
#define QSF_OBJECT_SCHEMA
Definition: qsf-xml.h:420
QsfMetadata_s::filepath
gchar * filepath
Definition: qsf-xml.h:533
QSF_UNDEF
Definition: qsf-xml.h:44

gboolean is_qsf_object_with_map | ( | const gchar * | path,
|  | gchar * | map_file
| ) |  |

Validate a QSF file and a selected QSF map.

Parameters

  path | Absolute or relative path to the selected QSF object file
  map_file | Name of the QSF map file, located in QSF_SCHEMA_DIR.

The file is validated against the QSF object schema, qsf-object.xsd.xml and each object described in the file is checked to find out if the supplied QSF map is suitable. Map files are accepted if all objects described in the QSF object file are defined in the QSF map.

Returns
  TRUE if the file validates and the supplied QSF map is usable, otherwise FALSE.

Definition at line 290 of file qsf-xml-map.c.

291 {
292 xmlDocPtr doc, map_doc;
293 QofErrorId result;
294 gchar *map_path;
295
296 map_path = g_strdup_printf ("%s/%s", QSF_SCHEMA_DIR, map_file);
297 if (path == NULL)
298 {
299 return FALSE;
300 }
301 doc = xmlParseFile (path);
302 if (doc == NULL)
303 {
304 return FALSE;
305 }
306 if (TRUE != qsf_is_valid (QSF_SCHEMA_DIR, QSF_OBJECT_SCHEMA, doc))
307 {
308 return FALSE;
309 }
310 if (map_path == NULL)
311 {
312 return FALSE;
313 }
314 map_doc = xmlParseFile (map_path);
315 result = check_qsf_object_with_map_internal (map_doc, doc);
316 return (result == QOF_SUCCESS) ? TRUE : FALSE;
317 }
qsf_is_valid
gboolean qsf_is_valid(const gchar *schema_dir, const gchar *schema_filename, xmlDocPtr doc)
Compares an xmlDoc in memory against the schema file.
Definition: qsf-xml.c:75
QofErrorId
gint32 QofErrorId
The ID of this error.
Definition: qofbackend.h:54
QOF_SUCCESS
#define QOF_SUCCESS
Definition: qoferror.h:124
QSF_OBJECT_SCHEMA
#define QSF_OBJECT_SCHEMA
Definition: qsf-xml.h:420

gboolean is_qsf_object_with_map_be | ( | gchar * | map_path,
|  | QsfParam * | params
| ) |  |

Validate a QSF file and a selected QSF map.

Parameters

  map_path | Absolute or relative path to the selected QSF map file
  params | Pointer to qsf_param context

The file is validated against the QSF object schema, qsf-object.xsd.xml and each object described in the file is checked to find out if the supplied QSF map is suitable. Map files are accepted if all objects described in the QSF object file are defined in the QSF map.

This backend twin also sets QofErrorId codes.

Returns
  TRUE if the file validates and the supplied QSF map is usable, otherwise FALSE.

Definition at line 240 of file qsf-xml-map.c.

241 {
242 xmlDocPtr doc, map_doc;
243 QofErrorId result;
244 gchar *path, *map_path;
245
246 g_return_val_if_fail ((params != NULL), FALSE);
247 path = g_strdup (params->filepath);
248 map_path = g_strdup_printf ("%s/%s", QSF_SCHEMA_DIR, map_file);
249 PINFO (" checking map file '%s'", map_path);
250 if (path == NULL)
251 {
252 qof_error_set_be (params->be, qof_error_register
253 (_("The QSF XML file '%s' could not be found."), TRUE));
254 return FALSE;
255 }
256 doc = xmlParseFile (path);
257 if (doc == NULL)
258 {
259 qof_error_set_be (params->be, qof_error_register
260 (_("There was an error parsing the file '%s'."), TRUE));
261 return FALSE;
262 }
263 if (TRUE != qsf_is_valid (QSF_SCHEMA_DIR, QSF_OBJECT_SCHEMA, doc))
264 {
265 qof_error_set_be (params->be, qof_error_register
266 (_("Invalid QSF Object file! The QSF object file '%s' "
267 " failed to validate against the QSF object schema. "
268 "The XML structure of the file is either not well-formed "
269 "or the file contains illegal data."), TRUE));
270 return FALSE;
271 }
272 if (map_path == NULL)
273 {
274 qof_error_set_be (params->be, qof_error_register
275 (_("The QSF map file '%s' could not be found."), TRUE));
276 return FALSE;
277 }
278 map_doc = xmlParseFile (map_path);
279 if (map_doc == NULL)
280 {
281 qof_error_set_be (params->be, qof_error_register
282 (_("There was an error parsing the file '%s'."), TRUE));
283 return FALSE;
284 }
285 result = check_qsf_object_with_map_internal (map_doc, doc);
286 return (result == QOF_SUCCESS) ? TRUE : FALSE;
287 }
qof_error_register
QofErrorId qof_error_register(const gchar *err_message, gboolean use_file)
Generate and register a new error.
Definition: qoferror.c:91
PINFO
#define PINFO(format, args...)
Definition: qoflog.h:199
qsf_is_valid
gboolean qsf_is_valid(const gchar *schema_dir, const gchar *schema_filename, xmlDocPtr doc)
Compares an xmlDoc in memory against the schema file.
Definition: qsf-xml.c:75
QofErrorId
gint32 QofErrorId
The ID of this error.
Definition: qofbackend.h:54
QsfMetadata_s::be
QofBackend * be
Definition: qsf-xml.h:519
QOF_SUCCESS
#define QOF_SUCCESS
Definition: qoferror.h:124
QSF_OBJECT_SCHEMA
#define QSF_OBJECT_SCHEMA
Definition: qsf-xml.h:420
QsfMetadata_s::filepath
gchar * filepath
Definition: qsf-xml.h:533

void qsf_book_node_handler | ( | xmlNodePtr | child,
|  | xmlNsPtr | qsf_ns,
|  | QsfParam * | params
| ) |  |

Book and book-guid node handler.

Reads the book count="" attribute (currently only 1 QofBook is supported per QSF object file). Sets the book-guid as the GUID of the current QofBackend QofBook in qsf_param. Calls the next handler, qsf_object_node_handler, with the child of the book tag.

Definition at line 424 of file qsf-xml.c.

425 {
426 gchar *book_count_s, *tail;
427 gint book_count;
428 xmlNodePtr child_node;
429 struct QsfNodeIterate qsfiter;
430 gchar *buffer;
431 GUID book_guid;
432
433 g_return_if_fail (child);
434 g_return_if_fail (params);
435 ENTER (" child=%s", child->name);
436 if (qsf_is_element (child, ns, QSF_BOOK_TAG))
437 {
438 book_count_s =
439 (gchar *) xmlGetProp (child, BAD_CAST QSF_BOOK_COUNT);
440 if (book_count_s)
441 {
442 book_count = (gint) strtol (book_count_s, &tail, 0);
443 /* More than one book not currently supported. */
444 g_free (book_count_s);
445 g_return_if_fail (book_count == 1);
446 }
447 qsfiter.ns = ns;
448 child_node = child->children->next;
449 if (qsf_is_element (child_node, ns, QSF_BOOK_GUID))
450 {
451 DEBUG (" trying to set book GUID");
452 buffer = BAD_CAST xmlNodeGetContent (child_node);
453 g_return_if_fail (TRUE == string_to_guid (buffer, &book_guid));
454 qof_entity_set_guid ((QofEntity *) params->book, &book_guid);
455 xmlNewChild (params->output_node, params->qsf_ns,
456 BAD_CAST QSF_BOOK_GUID, BAD_CAST buffer);
457 xmlFree (buffer);
458 }
459 qsf_node_foreach (child, qsf_object_node_handler, &qsfiter, params);
460 }
461 LEAVE (" ");
462 }
QsfMetadata_s::qsf_ns
xmlNsPtr qsf_ns
Definition: qsf-xml.h:507
QofEntity_s
Definition: qofid.h:147
string_to_guid
gboolean string_to_guid(const gchar *string, GUID *guid)
QSF_BOOK_COUNT
#define QSF_BOOK_COUNT
Definition: qsf-xml.h:99
LEAVE
#define LEAVE(format, args...)
Definition: qoflog.h:227
QsfNodeIterate
One iterator, two typedefs.
Definition: qsf-xml.h:689
QSF_BOOK_TAG
#define QSF_BOOK_TAG
Definition: qsf-xml.h:94
qsf_node_foreach
void qsf_node_foreach(xmlNodePtr parent, QsfNodeCB cb, struct QsfNodeIterate *qsfiter, QsfParam *params)
Definition: qsf-xml.c:116
DEBUG
#define DEBUG(format, args...)
Definition: qoflog.h:208
QsfMetadata_s::book
QofBook * book
Definition: qsf-xml.h:529
_GUID
Definition: guid.h:53
qsf_is_element
gint qsf_is_element(xmlNodePtr a, xmlNsPtr ns, gchar *c)
shorthand function
Definition: qsf-xml.c:55
QsfMetadata_s::output_node
xmlNodePtr output_node
Definition: qsf-xml.h:499
qof_entity_set_guid
void qof_entity_set_guid(QofEntity *ent, const GUID *guid)
Definition: qofid.c:92
ENTER
#define ENTER(format, args...)
Definition: qoflog.h:217
qsf_object_node_handler
void qsf_object_node_handler(xmlNodePtr child, xmlNsPtr qsf_ns, QsfParam *params)
Definition: qsf-xml.c:385
QSF_BOOK_GUID
#define QSF_BOOK_GUID
Definition: qsf-xml.h:97

gint qsf_check_tag | ( | QsfParam * | params,
|  | gchar * | qof_type
| ) |  |

shorthand function

This may look repetitive but each one is used separately as well as in a block.

Definition at line 69 of file qsf-xml.c.

70 {
71 return qsf_is_element (params->child_node, params->qsf_ns, qof_type);
72 }
QsfMetadata_s::qsf_ns
xmlNsPtr qsf_ns
Definition: qsf-xml.h:507
QsfMetadata_s::child_node
xmlNodePtr child_node
Definition: qsf-xml.h:493
qsf_is_element
gint qsf_is_element(xmlNodePtr a, xmlNsPtr ns, gchar *c)
shorthand function
Definition: qsf-xml.c:55

gint qsf_compare_tag_strings | ( | const xmlChar * | node_name,
|  | gchar * | tag_name
| ) |  |

shorthand function

This may look repetitive but each one is used separately as well as in a block.

Definition at line 39 of file qsf-xml.c.

40 {
41 return xmlStrcmp (node_name, (const xmlChar *) tag_name);
42 }

gint qsf_is_element | ( | xmlNodePtr | a,
|  | xmlNsPtr | ns,
|  | gchar * | c
| ) |  |

shorthand function

This may look repetitive but each one is used separately as well as in a block.

Definition at line 55 of file qsf-xml.c.

56 {
57 g_return_val_if_fail (a != NULL, 0);
58 g_return_val_if_fail (ns != NULL, 0);
59 g_return_val_if_fail (c != NULL, 0);
60 if ((a->ns == ns) && (a->type == XML_ELEMENT_NODE) &&
61 qsf_strings_equal (a->name, c))
62 {
63 return 1;
64 }
65 return 0;
66 }
qsf_strings_equal
gint qsf_strings_equal(const xmlChar *node_name, gchar *tag_name)
shorthand function
Definition: qsf-xml.c:45

gboolean qsf_is_valid | ( | const gchar * | schema_dir,
|  | const gchar * | schema_filename,
|  | xmlDocPtr | doc
| ) |  |

Compares an xmlDoc in memory against the schema file.

Parameters

  schema_dir | set at compile time to $prefix/share/qsf/
  schema_filename | Either the QSF Object Schema or the QSF Map Schema.
  doc | The xmlDoc read from the file using libxml2.

Ensure that you call the right schema_filename for the doc in question!

Incorrect validation will result in output to the terminal window.

Returns
  TRUE if the doc validates against the assigned schema, otherwise FALSE.

Definition at line 75 of file qsf-xml.c.

77 {
78 xmlSchemaParserCtxtPtr qsf_schema_file;
79 xmlSchemaPtr qsf_schema;
80 xmlSchemaValidCtxtPtr qsf_context;
81 gchar *schema_path;
82 gint result;
83
84 g_return_val_if_fail (doc || schema_filename, FALSE);
85 schema_path = g_strdup_printf ("%s/%s", schema_dir, schema_filename);
86 qsf_schema_file = xmlSchemaNewParserCtxt (schema_path);
87 qsf_schema = xmlSchemaParse (qsf_schema_file);
88 qsf_context = xmlSchemaNewValidCtxt (qsf_schema);
89 result = xmlSchemaValidateDoc (qsf_context, doc);
90 xmlSchemaFreeParserCtxt (qsf_schema_file);
91 xmlSchemaFreeValidCtxt (qsf_context);
92 xmlSchemaFree (qsf_schema);
93 g_free (schema_path);
94 if (result == 0)
95 {
96 return TRUE;
97 }
98 return FALSE;
99 }

GList** qsf_map_prepare_list | ( | GList ** | maps | ) |

Prepare the default list of maps.

Prepend the default maps to the supplied GList.

The GList remains the property of the caller.

Todo:
  Automate this once map support is stable

Definition at line 167 of file qsf-backend.c.

168 {
169 /* Add new map filenames here. */
171 *maps = g_list_prepend (*maps, "pilot-qsf-GnuCashInvoice.xml");
172 *maps = g_list_prepend (*maps, "pilot-qsf-gncCustomer.xml");
173 return maps;
174 }

void qsf_node_foreach | ( | xmlNodePtr | parent,
|  | QsfNodeCB | cb,
|  | struct QsfNodeIterate * | qsfiter,
|  | QsfParam * | params
| ) |  |

Iterate over the children of the parent node.

Only iterates over the immediate children of the parent - this function is not recursive.

Definition at line 116 of file qsf-xml.c.

118 {
119 xmlNodePtr cur_node;
120
121 if (!parent)
122 return;
123 g_return_if_fail (params);
124 g_return_if_fail (qsfiter->ns);
125 qsfiter->fcn = &cb;
126 for (cur_node = parent->children; cur_node != NULL;
127 cur_node = cur_node->next)
128 {
129 cb (cur_node, qsfiter->ns, params);
130 }
131 }

xmlDocPtr qsf_object_convert | ( | xmlDocPtr | mapDoc,
|  | xmlNodePtr | qsf_root,
|  | QsfParam * | params
| ) |  |

Convert between QSF objects.

This is the main workhorse of the conversion between QSF objects using maps.

Parameters

  mapDoc | The map document, parsed by libxml2.
  qsf_root | The top node of the QSF object to be converted using the map.
  params | The QSF backend parameters.

Each calculation in the map is performed over the child nodes of the object tree. A new xmlDoc is created and this is made available to QOF to be loaded into the book.

Definition at line 954 of file qsf-xml-map.c.

956 {
957 /* mapDoc : map document. qsf_root: incoming QSF root node. */
958 struct QsfNodeIterate qsfiter;
959 xmlDocPtr output_doc;
960 xmlNode *cur_node;
961 xmlNode *map_root, *output_root;
962
963 g_return_val_if_fail ((mapDoc && qsf_root && params), NULL);
964 ENTER (" root=%s", qsf_root->name);
965 /* prepare the intermediary document */
966 qsfiter.ns = params->qsf_ns;
967 output_doc = xmlNewDoc (BAD_CAST QSF_XML_VERSION);
968 output_root = xmlNewNode (NULL, BAD_CAST QSF_ROOT_TAG);
969 xmlDocSetRootElement (output_doc, output_root);
970 xmlSetNs (output_root, params->qsf_ns);
971 params->output_node = xmlNewChild (output_root, params->qsf_ns,
972 BAD_CAST QSF_BOOK_TAG, NULL);
973 xmlNewProp (params->output_node, BAD_CAST QSF_BOOK_COUNT,
974 BAD_CAST "1");
975 /* parse the incoming QSF */
976 qsf_book_node_handler (qsf_root->children->next, params->qsf_ns,
977 params);
978 /* parse the map and calculate the values */
979 map_root = xmlDocGetRootElement (mapDoc);
980 params->foreach_limit = 0;
981 qsfiter.ns = params->map_ns;
982 /* sets qof_foreach iterator, defines and defaults. */
983 qsf_node_foreach (map_root, qsf_map_top_node_handler, &qsfiter, params);
984 /* identify the entities of iterator type. */
985 qsfiter.ns = params->qsf_ns;
986 qsf_node_foreach (qsf_root->children->next, iterator_cb, &qsfiter,
987 params);
988 PINFO (" counted %d records", params->foreach_limit);
989 params->count = 0;
990 for (cur_node = map_root->children; cur_node != NULL;
991 cur_node = cur_node->next)
992 {
993 params->convert_node = cur_node;
994 if (qsf_is_element (cur_node, params->map_ns, MAP_OBJECT_TAG))
995 {
996 gint i;
997
998 params->lister = NULL;
999 PINFO (" found an object tag. starting calculation");
1000 /* cur_node describes the target object */
1001 if (!qof_class_is_registered (BAD_CAST
1002 xmlGetProp (cur_node, MAP_TYPE_ATTR)))
1003 {
1004 continue;
1005 }
1006 qsf_add_object_tag (params, params->count);
1007 params->count++;
1008 qsfiter.ns = params->map_ns;
1009 PINFO (" params->foreach_limit=%d", params->foreach_limit);
1010 for (i = -1; i < params->foreach_limit; i++)
1011 {
1012 qsf_node_foreach (cur_node, qsf_map_object_handler,
1013 &qsfiter, params);
1014 params->qsf_object_list =
1015 g_list_next (params->qsf_object_list);
1016 params->count++;
1017 }
1018 }
1019 }
1020 params->file_type = OUR_QSF_OBJ;
1021 /* use for debugging */
1022 xmlSaveFormatFileEnc ("-", output_doc, "UTF-8", 1);
1023 LEAVE (" ");
1024 return output_doc;
1025 }
QsfMetadata_s::qsf_ns
xmlNsPtr qsf_ns
Definition: qsf-xml.h:507
PINFO
#define PINFO(format, args...)
Definition: qoflog.h:199
qof_class_is_registered
gboolean qof_class_is_registered(QofIdTypeConst obj_name)
Definition: qofclass.c:132
QSF_ROOT_TAG
#define QSF_ROOT_TAG
Definition: qsf-xml.h:81
QsfMetadata_s::count
gint count
Definition: qsf-xml.h:476
QsfMetadata_s::file_type
QsfType file_type
Definition: qsf-xml.h:472
MAP_TYPE_ATTR
#define MAP_TYPE_ATTR
Definition: qsf-xml.h:279
OUR_QSF_OBJ
Definition: qsf-xml.h:52
QsfMetadata_s::foreach_limit
gint foreach_limit
Definition: qsf-xml.h:515
QSF_BOOK_COUNT
#define QSF_BOOK_COUNT
Definition: qsf-xml.h:99
LEAVE
#define LEAVE(format, args...)
Definition: qoflog.h:227
QsfNodeIterate
One iterator, two typedefs.
Definition: qsf-xml.h:689
QSF_BOOK_TAG
#define QSF_BOOK_TAG
Definition: qsf-xml.h:94
QsfMetadata_s::qsf_object_list
GList * qsf_object_list
Definition: qsf-xml.h:478
QsfMetadata_s::convert_node
xmlNodePtr convert_node
Definition: qsf-xml.h:495
qsf_node_foreach
void qsf_node_foreach(xmlNodePtr parent, QsfNodeCB cb, struct QsfNodeIterate *qsfiter, QsfParam *params)
Definition: qsf-xml.c:116
QsfMetadata_s::lister
xmlNodePtr lister
Definition: qsf-xml.h:505
qsf_is_element
gint qsf_is_element(xmlNodePtr a, xmlNsPtr ns, gchar *c)
shorthand function
Definition: qsf-xml.c:55
QsfMetadata_s::output_node
xmlNodePtr output_node
Definition: qsf-xml.h:499
qsf_book_node_handler
void qsf_book_node_handler(xmlNodePtr child, xmlNsPtr qsf_ns, QsfParam *params)
Book and book-guid node handler.
Definition: qsf-xml.c:424
MAP_OBJECT_TAG
#define MAP_OBJECT_TAG
Definition: qsf-xml.h:240
ENTER
#define ENTER(format, args...)
Definition: qoflog.h:217
QSF_XML_VERSION
#define QSF_XML_VERSION
Definition: qsf-xml.h:107

void qsf_object_node_handler | ( | xmlNodePtr | child,
|  | xmlNsPtr | qsf_ns,
|  | QsfParam * | params
| ) |  |

Despite the name, this function handles the QSF object book tag AND the object tags.

Used to parse object and map files.

Definition at line 385 of file qsf-xml.c.

387 {
388 struct QsfNodeIterate qsfiter;
389 QsfObject *object_set;
390 gchar *tail, *object_count_s;
391 gint64 c;
392
393 g_return_if_fail (child != NULL);
394 g_return_if_fail (qsf_ns != NULL);
395 params->qsf_ns = qsf_ns;
396 if (qsf_is_element (child, qsf_ns, QSF_OBJECT_TAG))
397 {
398 params->qsf_parameter_hash = NULL;
399 c = 0;
400 object_set = g_new (QsfObject, 1);
401 params->object_set = object_set;
402 object_set->object_count = 0;
403 object_set->parameters =
404 g_hash_table_new (g_str_hash, g_str_equal);
405 object_set->object_type = ((gchar *) xmlGetProp (child,
406 BAD_CAST QSF_OBJECT_TYPE));
407 object_count_s = ((gchar *) xmlGetProp (child,
408 BAD_CAST QSF_OBJECT_COUNT));
409 if (object_count_s)
410 {
411 c = (gint64) strtol (object_count_s, &tail, 0);
412 object_set->object_count = (gint) c;
413 g_free (object_count_s);
414 }
415 params->qsf_object_list =
416 g_list_prepend (params->qsf_object_list, object_set);
417 qsfiter.ns = qsf_ns;
418 params->qsf_parameter_hash = object_set->parameters;
419 qsf_node_foreach (child, qsf_parameter_handler, &qsfiter, params);
420 }
421 }
QsfMetadata_s::qsf_ns
xmlNsPtr qsf_ns
Definition: qsf-xml.h:507
QSF_OBJECT_COUNT
#define QSF_OBJECT_COUNT
Definition: qsf-xml.h:105
QSF_OBJECT_TAG
#define QSF_OBJECT_TAG
Definition: qsf-xml.h:101
QSF_OBJECT_TYPE
#define QSF_OBJECT_TYPE
Definition: qsf-xml.h:103
QsfNodeIterate
One iterator, two typedefs.
Definition: qsf-xml.h:689
QsfMetadata_s::qsf_object_list
GList * qsf_object_list
Definition: qsf-xml.h:478
qsf_node_foreach
void qsf_node_foreach(xmlNodePtr parent, QsfNodeCB cb, struct QsfNodeIterate *qsfiter, QsfParam *params)
Definition: qsf-xml.c:116
QsfMetadata_s::qsf_parameter_hash
GHashTable * qsf_parameter_hash
Definition: qsf-xml.h:484
qsf_is_element
gint qsf_is_element(xmlNodePtr a, xmlNsPtr ns, gchar *c)
shorthand function
Definition: qsf-xml.c:55
QsfObject_s
Holds a description of the QofObject.
Definition: qsf-xml.h:63
QsfMetadata_s::object_set
QsfObject * object_set
Definition: qsf-xml.h:474

void qsf_object_validation_handler | ( | xmlNodePtr | child,
|  | xmlNsPtr | ns,
|  | QsfValidator * | valid
| ) |  |

Checks all incoming objects for QOF registration.

Sums all existing objects in the QSF and counts the number of those objects that are also registered with QOF in the host application.

Definition at line 134 of file qsf-xml.c.

136 {
137 xmlNodePtr cur_node;
138 xmlChar *object_declaration;
139 guint count;
140 QsfStatus type;
141 gboolean is_registered;
142
143 count = 0;
144 type = QSF_NO_OBJECT;
145 is_registered = FALSE;
146 for (cur_node = child->children; cur_node != NULL;
147 cur_node = cur_node->next)
148 {
149 if (qsf_is_element (cur_node, ns, QSF_OBJECT_TAG))
150 {
151 object_declaration =
152 xmlGetProp (cur_node, BAD_CAST QSF_OBJECT_TYPE);
153 is_registered = qof_class_is_registered (object_declaration);
154 if (is_registered)
155 {
156 type = QSF_REGISTERED_OBJECT;
157 }
158 else
159 {
160 type = QSF_DEFINED_OBJECT;
161 }
162 xmlFree (object_declaration);
163 count = g_hash_table_size (valid->object_table);
164 g_hash_table_insert (valid->object_table, object_declaration,
165 GINT_TO_POINTER (type));
166 /* if insert was successful - i.e. object is unique so far */
167 if (g_hash_table_size (valid->object_table) > count)
168 {
169 valid->valid_object_count++;
170 if (is_registered)
171 {
172 valid->qof_registered_count++;
173 }
174 }
175 }
176 }
177 }
QSF_NO_OBJECT
Definition: qsf-xml.h:449
QSF_REGISTERED_OBJECT
Definition: qsf-xml.h:456
qof_class_is_registered
gboolean qof_class_is_registered(QofIdTypeConst obj_name)
Definition: qofclass.c:132
QSF_DEFINED_OBJECT
Definition: qsf-xml.h:453
QSF_OBJECT_TAG
#define QSF_OBJECT_TAG
Definition: qsf-xml.h:101
QSF_OBJECT_TYPE
#define QSF_OBJECT_TYPE
Definition: qsf-xml.h:103
QsfValidates_s::qof_registered_count
gint qof_registered_count
Definition: qsf-xml.h:578
QsfStatus
QsfStatus
Status of various object during mapping.
Definition: qsf-xml.h:446
QsfValidates_s::valid_object_count
gint valid_object_count
Definition: qsf-xml.h:572
qsf_is_element
gint qsf_is_element(xmlNodePtr a, xmlNsPtr ns, gchar *c)
shorthand function
Definition: qsf-xml.c:55
QsfValidates_s::object_table
GHashTable * object_table
Definition: qsf-xml.h:565

gint qsf_strings_equal | ( | const xmlChar * | node_name,
|  | gchar * | tag_name
| ) |  |

shorthand function

This may look repetitive but each one is used separately as well as in a block.

Definition at line 45 of file qsf-xml.c.

46 {
47 if (0 == qsf_compare_tag_strings (node_name, tag_name))
48 {
49 return 1;
50 }
51 return 0;
52 }
qsf_compare_tag_strings
gint qsf_compare_tag_strings(const xmlChar *node_name, gchar *tag_name)
shorthand function
Definition: qsf-xml.c:39

void qsf_valid_foreach | ( | xmlNodePtr | parent,
|  | QsfValidCB | cb,
|  | struct QsfNodeIterate * | qsfiter,
|  | QsfValidator * | valid
| ) |  |

Validate the children of the parent node.

Note
  Slightly different to qsf_node_foreach because the validation can be run without qsf_param being initialized.

Definition at line 102 of file qsf-xml.c.

104 {
105 xmlNodePtr cur_node;
106
107 qsfiter->v_fcn = &cb;
108 for (cur_node = parent->children; cur_node != NULL;
109 cur_node = cur_node->next)
110 {
111 cb (cur_node, qsfiter->ns, valid);
112 }
113 }

KvpValue* string_to_kvp_value | ( | const gchar * | content,
|  | KvpValueType | type
| ) |  |

Convert a string value into KvpValue.

Partner to kvp_value_to_string. Given the type of KvpValue required, attempts to convert the string into that type of value.

Parameters

  content | A string representation of the value, ideally as output by kvp_value_to_string.
  type | KvpValueType of the intended KvpValue

Returns
  KvpValue* or NULL on failure.

Todo:
  reconcile the duplication with the QSF version

Definition at line 1223 of file qsf-backend.c.

1224 {
1225 gchar *tail;
1226 gint64 cm_i64;
1227 gdouble cm_double;
1228 QofNumeric cm_numeric;
1229 GUID *cm_guid;
1230 #ifndef QOF_DISABLE_DEPRECATED
1231 struct tm kvp_time;
1232 time_t kvp_time_t;
1233 Timespec cm_date;
1234 #endif
1235
1236 switch (type)
1237 {
1238 case KVP_TYPE_GINT64:
1239 {
1240 errno = 0;
1241 cm_i64 = strtoll (content, &tail, 0);
1242 if (errno == 0)
1243 {
1244 return kvp_value_new_gint64 (cm_i64);
1245 }
1246 break;
1247 }
1248 case KVP_TYPE_DOUBLE:
1249 {
1250 errno = 0;
1251 cm_double = strtod (content, &tail);
1252 if (errno == 0)
1253 return kvp_value_new_double (cm_double);
1254 break;
1255 }
1256 case KVP_TYPE_NUMERIC:
1257 {
1258 qof_numeric_from_string (content, &cm_numeric);
1259 return kvp_value_new_numeric (cm_numeric);
1260 break;
1261 }
1262 case KVP_TYPE_STRING:
1263 {
1264 return kvp_value_new_string (content);
1265 break;
1266 }
1267 case KVP_TYPE_GUID:
1268 {
1269 cm_guid = g_new0 (GUID, 1);
1270 if (TRUE == string_to_guid (content, cm_guid))
1271 return kvp_value_new_guid (cm_guid);
1272 break;
1273 }
1274 case KVP_TYPE_TIME :
1275 {
1276 QofDate *qd;
1277 QofTime *qt;
1278 KvpValue *retval;
1279
1280 qd = qof_date_parse (content, QOF_DATE_FORMAT_UTC);
1281 if(qd)
1282 {
1283 qt = qof_date_to_qtime (qd);
1284 retval = kvp_value_new_time (qt);
1285 qof_date_free (qd);
1286 qof_time_free (qt);
1287 return retval;
1288 }
1289 else
1290 PERR (" failed to parse date");
1291 }
1292 #ifndef QOF_DISABLE_DEPRECATED
1293 case KVP_TYPE_TIMESPEC:
1294 {
1295 strptime (content, QSF_XSD_TIME, &kvp_time);
1296 kvp_time_t = mktime (&kvp_time);
1297 timespecFromTime_t (&cm_date, kvp_time_t);
1298 return kvp_value_new_timespec (cm_date);
1299 break;
1300 }
1301 #endif
1302 case KVP_TYPE_BOOLEAN :
1303 {
1304 gboolean val;
1305 val = qof_util_bool_to_int (content);
1306 return kvp_value_new_boolean (val);
1307 }
1308 case KVP_TYPE_BINARY:
1309 // return kvp_value_new_binary(value->value.binary.data,
1310 // value->value.binary.datasize);
1311 break;
1312 case KVP_TYPE_GLIST:
1313 // return kvp_value_new_glist(value->value.list);
1314 break;
1315 case KVP_TYPE_FRAME:
1316 // return kvp_value_new_frame(value->value.frame);
1317 break;
1318 }
1319 return NULL;
1320 }
KVP_TYPE_TIMESPEC
Definition: kvpframe.h:121
QOF_DATE_FORMAT_UTC
#define QOF_DATE_FORMAT_UTC
QOF UTC format, xsd:date compatible. QOF_UTC_DATE_FORMAT "%Y-%m-%dT%H:%M:%SZ".
Definition: qofdate.h:277
PERR
#define PERR(format, args...)
Definition: qoflog.h:183
qof_date_free
void qof_date_free(QofDate *date)
Definition: qofdate.c:608
string_to_guid
gboolean string_to_guid(const gchar *string, GUID *guid)
KVP_TYPE_GUID
Unique identifier.
Definition: kvpframe.h:118
timespec64
Definition: qoftime.h:97
kvp_value_new_boolean
KvpValue * kvp_value_new_boolean(gboolean value)
Definition: kvpframe.c:1226
KVP_TYPE_GLIST
Definition: kvpframe.h:132
KVP_TYPE_FRAME
Definition: kvpframe.h:134
qof_util_bool_to_int
gint qof_util_bool_to_int(const gchar *val)
Definition: qofutil.c:249
qof_date_to_qtime
QofTime * qof_date_to_qtime(const QofDate *qd)
Definition: qofdate.c:892
QofDate_s
Full range replacement for struct tm.
Definition: qofdate.h:138
KVP_TYPE_NUMERIC
128bit denominator/numerator maths.
Definition: kvpframe.h:106
qof_date_parse
QofDate * qof_date_parse(const gchar *str, QofDateFormat df)
Convert a timestamp to a QofTime.
Definition: qofdate.c:525
KvpValue
struct _KvpValue KvpValue
Definition: kvpframe.h:78
kvp_value_new_timespec
KvpValue * kvp_value_new_timespec(Timespec timespec)
Definition: deprecated.c:1482
timespecFromTime_t
void timespecFromTime_t(Timespec *ts, time_t t)
Definition: deprecated.c:304
qof_numeric_from_string
gboolean qof_numeric_from_string(const gchar *str, QofNumeric *n)
Definition: qofnumeric.c:1121
qof_time_free
void qof_time_free(QofTime *qt)
Free a QofTime when no longer required.
Definition: qoftime.c:56
KVP_TYPE_GINT64
64bit integer
Definition: kvpframe.h:94
_QofNumeric
Definition: qofnumeric.h:52
_GUID
Definition: guid.h:53
QSF_XSD_TIME
#define QSF_XSD_TIME
Definition: qsf-xml.h:414
QofTime
struct QofTime64 QofTime
Use a 64-bit signed int QofTime.
Definition: qoftime.h:120
KVP_TYPE_BOOLEAN
Simple boolean type.
Definition: kvpframe.h:140
KVP_TYPE_BINARY
Definition: kvpframe.h:130
KVP_TYPE_STRING
standard C string
Definition: kvpframe.h:112
KVP_TYPE_DOUBLE
standard C double type
Definition: kvpframe.h:100
KVP_TYPE_TIME
64bit time/date handling.
Definition: kvpframe.h:128