void
kvp_frame_set_slot_path (KvpFrame *frame,
const KvpValue *new_value,
const char *first_key, ...)
{
va_list ap;
const char *key;
if (!frame) return;
g_return_if_fail (first_key && *first_key != '\0');
va_start (ap, first_key);
key = first_key;
while (TRUE)
{
KvpValue *value;
const char *next_key;
next_key = va_arg (ap, const char *);
if (!next_key)
{
kvp_frame_set_slot (frame, key, new_value);
break;
}
g_return_if_fail (*next_key != '\0');
value = kvp_frame_get_slot (frame, key);
if (!value)
{
KvpFrame *new_frame = kvp_frame_new ();
KvpValue *frame_value = kvp_value_new_frame (new_frame);
kvp_frame_set_slot_nc (frame, key, frame_value);
value = kvp_frame_get_slot (frame, key);
if (!value) break;
}
frame = kvp_value_get_frame (value);
if (!frame) break;
key = next_key;
}
va_end (ap);
}
KvpValue *
kvp_frame_get_slot_path (KvpFrame *frame,
const char *first_key, ...)
{
va_list ap;
KvpValue *value;
const char *key;
if (!frame || !first_key) return NULL;
va_start (ap, first_key);
key = first_key;
value = NULL;
while (TRUE)
{
value = kvp_frame_get_slot (frame, key);
if (!value) break;
key = va_arg (ap, const char *);
if (!key) break;
frame = kvp_value_get_frame (value);
if (!frame)
{
value = NULL;
break;
}
}
va_end (ap);
return value;
}
KvpValue *
kvp_frame_get_value(const KvpFrame *frame, const char *path)
{
char *key = NULL;
frame = get_trailer_or_null (frame, path, &key);
return kvp_frame_get_slot (frame, key);
}
Timespec
kvp_frame_get_timespec(const KvpFrame *frame, const char *path)
{
char *key = NULL;
frame = get_trailer_or_null (frame, path, &key);
return kvp_value_get_timespec(kvp_frame_get_slot (frame, key));
}
GncGUID *
kvp_frame_get_guid(const KvpFrame *frame, const char *path)
{
char *key = NULL;
frame = get_trailer_or_null (frame, path, &key);
return kvp_value_get_guid(kvp_frame_get_slot (frame, key));
}
/* Get pointer to last frame in path, or NULL if the path doesn't
* exist. The string stored in keypath will be hopelessly mangled .
*/
static inline const KvpFrame *
kvp_frame_get_frame_or_null_slash_trash (const KvpFrame *frame, char *key_path)
{
KvpValue *value;
char *key, *next;
if (!frame || !key_path) return NULL;
key = key_path;
key --;
while (key)
{
key ++;
while ('/' == *key)
{
key++;
}
if (0x0 == *key) break; /* trailing slash */
next = strchr (key, '/');
if (next) *next = 0x0;
value = kvp_frame_get_slot (frame, key);
if (!value) return NULL;
frame = kvp_value_get_frame (value);
if (!frame) return NULL;
key = next;
}
return frame;
}
void
kvp_frame_set_slot_path_gslist (KvpFrame *frame,
const KvpValue *new_value,
GSList *key_path)
{
if (!frame || !key_path) return;
while (TRUE)
{
const char *key = static_cast<char*>(key_path->data);
KvpValue *value;
if (!key)
return;
g_return_if_fail (*key != '\0');
key_path = key_path->next;
if (!key_path)
{
kvp_frame_set_slot (frame, key, new_value);
return;
}
value = kvp_frame_get_slot (frame, key);
if (!value)
{
KvpFrame *new_frame = kvp_frame_new ();
KvpValue *frame_value = kvp_value_new_frame (new_frame);
kvp_frame_set_slot_nc (frame, key, frame_value);
value = kvp_frame_get_slot (frame, key);
if (!value)
return;
}
frame = kvp_value_get_frame (value);
if (!frame)
return;
}
}
static inline gboolean
is_subsplit (Split *split)
{
KvpValue *kval;
/* generic stop-progress conditions */
if (!split) return FALSE;
g_return_val_if_fail (split->parent, FALSE);
/* If there are no sub-splits, then there's nothing to do. */
kval = kvp_frame_get_slot (split->inst.kvp_data, "lot-split");
if (!kval) return FALSE;
return TRUE;
}
Account *gnc_ofx_kvp_get_assoc_account(const Account* investment_account)
{
kvp_frame * acc_frame;
kvp_value * kvp_val;
Account *result = NULL;
g_assert(investment_account);
acc_frame = xaccAccountGetSlots(investment_account);
kvp_val = kvp_frame_get_slot(acc_frame, KEY_ASSOC_INCOME_ACCOUNT);
if (kvp_val != NULL)
{
result = xaccAccountLookup(kvp_value_get_guid(kvp_val),
gnc_account_get_book(investment_account));
}
return result;
}
static KvpFrame *
kvp_frame_add_value_nc(KvpFrame * frame, const char * path, KvpValue *value)
{
char *key = NULL;
KvpValue *oldvalue;
KvpFrame* orig_frame = frame;
frame = (KvpFrame *) get_trailer_or_null (frame, path, &key);
oldvalue = kvp_frame_get_slot (frame, key);
ENTER ("old frame=%s", kvp_frame_to_string(frame));
if (oldvalue)
{
/* If already a glist here, just append */
if (KVP_TYPE_GLIST == oldvalue->type)
{
GList * vlist = oldvalue->value.list;
vlist = g_list_append (vlist, value);
oldvalue->value.list = vlist;
}
else
/* If some other value, convert it to a glist */
{
KvpValue *klist;
GList *vlist = NULL;
vlist = g_list_append (vlist, oldvalue);
vlist = g_list_append (vlist, value);
klist = kvp_value_new_glist_nc (vlist);
kvp_frame_replace_slot_nc (frame, key, klist);
}
LEAVE ("new frame=%s", kvp_frame_to_string(frame));
return frame;
}
/* Hmm, if we are here, the path doesn't exist. We need to
* create the path, add the value to it. */
frame = orig_frame;
frame = kvp_frame_set_value_nc (frame, path, value);
LEAVE ("new frame=%s", kvp_frame_to_string(frame));
return frame;
}
/* Get the named frame, or create it if it doesn't exist.
* gcc -O3 should inline it. It performs no error checks,
* the caller is responsible of passing good keys and frames.
*/
static inline KvpFrame *
get_or_make (KvpFrame *fr, const char * key)
{
KvpFrame *next_frame;
KvpValue *value;
value = kvp_frame_get_slot (fr, key);
if (value)
{
next_frame = kvp_value_get_frame (value);
}
else
{
next_frame = kvp_frame_new ();
kvp_frame_set_slot_nc (fr, key,
kvp_value_new_frame_nc (next_frame));
}
return next_frame;
}
static void
kvp_frame_compare_helper(const char *key, KvpValue * val, gpointer data)
{
kvp_frame_cmp_status *status = (kvp_frame_cmp_status *) data;
if (status->compare == 0)
{
KvpFrame *other_frame = status->other_frame;
KvpValue *other_val = kvp_frame_get_slot(other_frame, key);
if (other_val)
{
status->compare = kvp_value_compare(val, other_val);
}
else
{
status->compare = 1;
}
}
}
KvpValue *
kvp_frame_get_slot_path_gslist (KvpFrame *frame,
const GSList *key_path)
{
if (!frame || !key_path) return NULL;
while (TRUE)
{
const char *key = static_cast<const char*>(key_path->data);
KvpValue *value;
if (!key) break;
value = kvp_frame_get_slot (frame, key);
if (!value) break;
key_path = key_path->next;
if (!key_path) return value;
frame = kvp_value_get_frame (value);
if (!frame) break;
}
return NULL;
}
