static int
table_static_update(struct table *table)
{
struct table *t;
void *p = NULL;
/* no config ? ok */
if (table->t_config[0] == '\0')
goto ok;
t = table_create("static", table->t_name, "update", table->t_config);
if (!table_config(t))
goto err;
/* replace former table, frees t */
while (dict_poproot(&table->t_dict, NULL, (void **)&p))
free(p);
dict_merge(&table->t_dict, &t->t_dict);
table_destroy(t);
ok:
log_info("info: Table \"%s\" successfully updated", table->t_name);
return 1;
err:
table_destroy(t);
log_info("info: Failed to update table \"%s\"", table->t_name);
return 0;
}
/*************************************************************************
* dict_union: merges contents of 2 dictionaries into
* a third
*
* dict1 - pointer to dictionary 1
* dict2 - pointer to dictionary 2
*
* Returns: dictionary pointer
* NULL - failed to merge
* non-NULL - pointer to new dictionary
*
* Notes: entries of the same string have their counts
* added and their flags ORed together.
*************************************************************************/
DICTIONARY *dict_union( const DICTIONARY *dict1 , const DICTIONARY *dict2 )
{
DICTIONARY *dict = NULL;
STRING_ENTRY *se, *se2;
long initial_string_count, initial_hash_chains, max_chain_length;
long i, string_index;
/***********
** Initialize the new dictionary.
***********/
if ( dict1==NULL || dict2==NULL )
goto err_exit;
if ((dict=(DICTIONARY *)malloc(sizeof(DICTIONARY))) == NULL)
goto err_exit;
initial_string_count = dict1->string_max;
initial_hash_chains = dict1->table_size;
max_chain_length = dict1->allowable_chain_length;
dict = dict_create( 4,
initial_string_count,
initial_hash_chains,
max_chain_length );
/***********
** Copy the entries from dict1 into the new dictionary.
***********/
for ( i = 0 ; i < dict1->entry_count ; i++ ) {
se = (STRING_ENTRY*)&dict1->string_table[i];
if ( se->count > 0 ) {
se2 = dict_insert(
dict,
dict1->string_array+se->string_offset,
se->count,
se->flags,
NULL,
&string_index );
if ( se2 == NULL )
goto err_exit;
} /* endif */
} /* endfor */
/* Merge the entries from dict2 into the new dictionary. */
if ( dict_merge(dict,dict2,FALSE) == FALSE )
goto err_exit;
/* Success. Return a pointer to the new dictionary. */
return( dict );
/* Failure. Ignominiously erase our tracks and return NULL. */
err_exit:
dict_destroy( dict );
return NULL;
}
void service_app_sync(DictionaryIterator* iter) {
pthread_mutex_lock(&g_mxAppSyncList);
struct AppSyncList* pAS = g_pAppSyncList;
while (pAS) {
uint32_t size = pAS->s->buffer_size;
dict_merge(&(pAS->s->current_iter), &size, iter, true, pAS->s->callback.value_changed, pAS->s->callback.context);
pAS = pAS->next;
}
pthread_mutex_unlock(&g_mxAppSyncList);
}
TA_RetCode TA_DictMerge( TA_Dict *dest, const TA_Dict *src )
{
const TA_PrivDictInfo *srcDict;
TA_PrivDictInfo *destDict;
srcDict = (const TA_PrivDictInfo *)src;
destDict = (TA_PrivDictInfo *)dest;
if( !srcDict || !destDict )
return TA_BAD_PARAM;
/* Make sure both dictionary are of the same type. */
#define DICT_TYPE_MASK (TA_DICT_KEY_ONE_STRING|TA_DICT_KEY_TWO_STRING|TA_DICT_KEY_INTEGER)
if( (srcDict->flags&DICT_TYPE_MASK) != (destDict->flags&DICT_TYPE_MASK) )
return TA_DICT_TYPE_MISMATCH;
dict_init( &theDict->d, DICTCOUNT_T_MAX, compareFunction_I );
dict_merge( &destDict->d, &srcDict->d );
TO BE COMPLETED
}
AppMessageResult app_sync_set(struct AppSync *s,
const Tuplet * const keys_and_values_to_update,
const uint8_t count) {
// update state on this side
uint32_t in_size = dict_calc_buffer_size_from_tuplets(keys_and_values_to_update, count);
uint8_t* buffer = (uint8_t*) malloc(in_size);
DictionaryIterator iter;
if (dict_serialize_tuplets_to_buffer_with_iter(&iter, keys_and_values_to_update, count, buffer, &in_size) != DICT_OK)
return APP_MSG_BUFFER_OVERFLOW;
uint32_t size = s->buffer_size;
dict_merge(&(s->current_iter), &size, &iter, true, s->callback.value_changed, s->callback.context);
free(buffer);
// prepare data & send
DictionaryIterator* iter_out;
app_message_outbox_begin(&iter_out);
uint32_t out_size = iter_out->end - (void*)iter_out->dictionary;
if (dict_serialize_tuplets_to_buffer_with_iter(iter_out, keys_and_values_to_update, count, (uint8_t*)iter_out->dictionary, &out_size) != DICT_OK)
return APP_MSG_BUFFER_OVERFLOW;
return app_message_outbox_send();
}
int main(void)
{
input_t in;
dict_t darray[10];
dict_t *d = &darray[0];
dnode_t *dn;
size_t i;
char *tok1, *tok2, *val;
const char *key;
char *help =
"a <key> <val> add value to dictionary\n"
"d <key> delete value from dictionary\n"
"l <key> lookup value in dictionary\n"
"( <key> lookup lower bound\n"
") <key> lookup upper bound\n"
"< <key> lookup strict lower bound\n"
"> <key> lookup strict upper bound\n"
"# <num> switch to alternate dictionary (0-9)\n"
"j <num> <num> merge two dictionaries\n"
"f free the whole dictionary\n"
"k allow duplicate keys\n"
"c show number of entries\n"
"t dump whole dictionary in sort order\n"
"m make dictionary out of sorted items\n"
"p turn prompt on\n"
"s switch to non-functioning allocator\n"
"q quit";
for (i = 0; i < sizeof darray / sizeof *darray; i++)
dict_init(&darray[i], DICTCOUNT_T_MAX, comparef);
for (;;) {
if (prompt)
putchar('>');
fflush(stdout);
if (!fgets(in, sizeof(input_t), stdin))
break;
switch(in[0]) {
case '?':
puts(help);
break;
case 'a':
if (tokenize(in+1, &tok1, &tok2, (char **) 0) != 2) {
puts("what?");
break;
}
key = dupstring(tok1);
val = dupstring(tok2);
if (!key || !val) {
puts("out of memory");
free((void *) key);
free(val);
}
if (!dict_alloc_insert(d, key, val)) {
puts("dict_alloc_insert failed");
free((void *) key);
free(val);
break;
}
break;
case 'd':
if (tokenize(in+1, &tok1, (char **) 0) != 1) {
puts("what?");
break;
}
dn = dict_lookup(d, tok1);
if (!dn) {
puts("dict_lookup failed");
break;
}
val = (char *) dnode_get(dn);
key = (char *) dnode_getkey(dn);
dict_delete_free(d, dn);
free(val);
free((void *) key);
break;
case 'f':
dict_free_nodes(d);
break;
case 'l':
case '(':
case ')':
case '<':
case '>':
if (tokenize(in+1, &tok1, (char **) 0) != 1) {
puts("what?");
break;
}
dn = 0;
switch (in[0]) {
case 'l':
dn = dict_lookup(d, tok1);
break;
case '(':
dn = dict_lower_bound(d, tok1);
break;
case ')':
dn = dict_upper_bound(d, tok1);
break;
case '<':
dn = dict_strict_lower_bound(d, tok1);
break;
case '>':
dn = dict_strict_upper_bound(d, tok1);
break;
}
if (!dn) {
puts("lookup failed");
break;
}
val = (char *) dnode_get(dn);
puts(val);
break;
case 'm':
construct(d);
break;
case 'k':
dict_allow_dupes(d);
break;
case 'c':
printf("%lu\n", (unsigned long) dict_count(d));
break;
case 't':
for (dn = dict_first(d); dn; dn = dict_next(d, dn)) {
printf("%s\t%s\n", (char *) dnode_getkey(dn),
(char *) dnode_get(dn));
}
break;
case 'q':
exit(0);
break;
case '\0':
break;
case 'p':
prompt = 1;
break;
case 's':
dict_set_allocator(d, new_node, del_node, NULL);
break;
case '#':
if (tokenize(in+1, &tok1, (char **) 0) != 1) {
puts("what?");
break;
} else {
int dictnum = atoi(tok1);
if (dictnum < 0 || dictnum > 9) {
puts("invalid number");
break;
}
d = &darray[dictnum];
}
break;
case 'j':
if (tokenize(in+1, &tok1, &tok2, (char **) 0) != 2) {
puts("what?");
break;
} else {
int dict1 = atoi(tok1), dict2 = atoi(tok2);
if (dict1 < 0 || dict1 > 9 || dict2 < 0 || dict2 > 9) {
puts("invalid number");
break;
}
dict_merge(&darray[dict1], &darray[dict2]);
}
break;
default:
putchar('?');
putchar('\n');
break;
}
}
return 0;
}
