/* implement COLLECTION_MODE_COPY if set */
static cp_avlnode *create_avlnode(cp_avltree *tree, void *key, void *value)
{
cp_avlnode *node = NULL;
if (tree->mode & COLLECTION_MODE_COPY)
{
void *k = tree->key_copy ? (*tree->key_copy)(key) : key;
if (k)
{
void *v = tree->value_copy ? (*tree->value_copy)(value) : value;
if (v)
node = cp_avlnode_create(k, v, tree->mempool);
}
}
else
node = cp_avlnode_create(key, value, tree->mempool);
if (node && (tree->mode & COLLECTION_MODE_MULTIPLE_VALUES))
{
cp_vector *m = cp_vector_create(1);
if (m == NULL)
{
cp_avltree_destroy_node(tree, node);
return NULL;
}
cp_vector_add_element(m, node->value);
node->value = m;
}
return node;
}
int main()
{
int i, n;
char *a = "AaAa";
char *b = "BbBb";
char *c = "CcCc";
char *p;
cp_vector *v = cp_vector_create(1);
for (i = 0; i < 30; i++)
{
char buf[0x20];
sprintf(buf, "%s %d", a, i);
cp_vector_add_element(v, strdup(buf));
sprintf(buf, "%s %d", b, i);
cp_vector_add_element(v, strdup(buf));
sprintf(buf, "%s %d", c, i);
cp_vector_add_element(v, strdup(buf));
}
n = cp_vector_size(v);
for (i = 0; i < n; i++)
{
p = cp_vector_element_at(v, i);
printf("%d: %s\n", i, p);
}
cp_vector_destroy_custom(v, free);
return 0;
}
globals* globals_alloc() {
globals *g = malloc(sizeof(globals));
assert(g);
g->sorts = cp_trie_create_trie(COLLECTION_MODE_DEEP, 0, free);
assert(g->sorts);
g->sorts_N = 0;
g->ops = cp_multimap_create_by_option(COLLECTION_MODE_DEEP|COLLECTION_MODE_COPY|COLLECTION_MODE_MULTIPLE_VALUES ,
op_s_key, op_cmp, op_dup, free);
assert(g->ops);
g->ops_N = 0;
g->op_names = cp_vector_create(1); //size in multiples of sizeof(void*)
assert(g->op_names);
g->terms = cp_multimap_create_by_option(COLLECTION_MODE_DEEP|COLLECTION_MODE_COPY|COLLECTION_MODE_MULTIPLE_VALUES ,
op_s_key, op_cmp, op_dup, free); /* TODO: CHANGE TO REFLECT THE TARGET SORT OF THE TERM ONLY */
g->f = stdout;
return g;
}
cp_pooled_thread_scheduler *cp_pooled_thread_scheduler_create(cp_thread_pool *pool)
{
cp_pooled_thread_scheduler *scheduler =
calloc(1, sizeof(cp_pooled_thread_scheduler));
if (scheduler == NULL)
cp_fatal(CP_MEMORY_ALLOCATION_FAILURE, "can\'t allocate thread manager");
scheduler->pool = pool;
scheduler->client_list = cp_vector_create(20);
#ifdef CP_HAS_SRANDOM
srandom(time(NULL));
#else
srand(time(NULL));
#endif
return scheduler;
}
int cp_db_connection_execute_statement_args(cp_db_connection *connection,
cp_db_statement *statement,
cp_result_set **results, ...)
{
if (connection->data_source->act->execute_statement)
{
int i;
int rc;
va_list argp;
int p_int;
long p_long;
#ifdef CP_HAS_LONG_LONG
long long p_longlong;
#else
__int64 p_longlong;
#endif /* CP_HAS_LONG_LONG */
double p_double;
cp_timestampz p_timestamp;
cp_string p_str;
cp_vector *tmp = NULL;
void *ptr;
int *lengths = NULL;
void **prm = NULL;
if (statement->prm_count)
{
prm = calloc(statement->prm_count, sizeof(void *));
lengths = calloc(statement->prm_count, sizeof(int));
}
va_start(argp, results);
for (i = 0; i < statement->prm_count; i++)
{
tmp = cp_vector_create(statement->prm_count);
switch (statement->types[i])
{
case CP_FIELD_TYPE_CHAR:
case CP_FIELD_TYPE_VARCHAR:
prm[i] = va_arg(argp, char *);
lengths[i] = strlen(prm[i]);
break;
case CP_FIELD_TYPE_BLOB:
ptr = malloc(sizeof(int));
p_str = va_arg(argp, cp_string);
memcpy(ptr, &p_str, sizeof(cp_string));
prm[i] = ptr;
lengths[i] = p_str.len;
break;
case CP_FIELD_TYPE_BOOLEAN:
case CP_FIELD_TYPE_SHORT:
case CP_FIELD_TYPE_INT:
ptr = malloc(sizeof(int));
p_int = va_arg(argp, int);
memcpy(ptr, &p_int, sizeof(int));
cp_vector_add_element(tmp, ptr);
prm[i] = ptr;
lengths[i] = sizeof(int);
break;
case CP_FIELD_TYPE_LONG:
ptr = malloc(sizeof(long));
p_long = va_arg(argp, long);
memcpy(ptr, &p_long, sizeof(long));
cp_vector_add_element(tmp, ptr);
prm[i] = ptr;
lengths[i] = sizeof(long);
break;
case CP_FIELD_TYPE_LONG_LONG:
#ifdef CP_HAS_LONG_LONG
ptr = malloc(sizeof(long long));
p_longlong = va_arg(argp, long long);
memcpy(ptr, &p_longlong, sizeof(long long));
lengths[i] = sizeof(long long);
#else
ptr = malloc(sizeof(__int64));
p_longlong = va_arg(argp, __int64);
memcpy(ptr, &p_longlong, sizeof(__int64));
lengths[i] = sizeof(__int64);
#endif /* CP_HAS_LONG_LONG */
cp_vector_add_element(tmp, ptr);
prm[i] = ptr;
break;
case CP_FIELD_TYPE_FLOAT:
case CP_FIELD_TYPE_DOUBLE:
ptr = malloc(sizeof(double));
p_double = va_arg(argp, double);
memcpy(ptr, &p_double, sizeof(double));
cp_vector_add_element(tmp, ptr);
prm[i] = ptr;
lengths[i] = sizeof(double);
break;
case CP_FIELD_TYPE_DATE:
case CP_FIELD_TYPE_TIME:
case CP_FIELD_TYPE_TIMESTAMP:
ptr = malloc(sizeof(cp_timestampz));
p_timestamp = va_arg(argp, cp_timestampz);
memcpy(ptr, &p_timestamp, sizeof(cp_timestampz));
cp_vector_add_element(tmp, ptr);
prm[i] = ptr;
break;
}
}
rc = (*connection->data_source->act->execute_statement)(connection,
statement,
results,
lengths,
prm);
va_end(argp);
if (statement->prm_count)
{
free(prm);
free(lengths);
}
if (prm) free(prm);
if (tmp)
cp_vector_destroy_custom(tmp, (cp_destructor_fn) free);
return rc;
}
