int grok_pattern_add(const grok_t *grok, const char *name, size_t name_len,
const char *regexp, size_t regexp_len) {
TCTREE *patterns = grok->patterns;
grok_log(grok, LOG_PATTERNS, "Adding new pattern '%.*s' => '%.*s'",
name_len, name, regexp_len, regexp);
tctreeput(patterns, name, name_len, regexp, regexp_len);
return GROK_OK;
}
void main () {
uint32_t key = 123;
const char *val = "abcdefkrnglrg";
// Make a new tree
TCTREE *tree = tctreenew();
// Put an integer key
tctreeput(tree, &key, sizeof(key), val, strlen(val));
// Put a different key
key = 122;
tctreeput(tree, &key, sizeof(key), val, strlen(val));
// Put the same key twice
tctreeput(tree, &key, sizeof(key), val, strlen(val));
// Put the same key but keep the old value
tctreeputkeep(tree, &key, sizeof(key), val, strlen(val));
// Get back a value
int size;
void *newVal = tctreeget(tree, &key, sizeof(key), &size);
printf("Got value %s\n", newVal);
// Create an iterator
tctreeiterinit(tree);
// Walk the tree
tctreeiternext(tree, &size);
tctreeiternext(tree, &size);
tctreeiternext(tree, &size);
// Clear the tree
tctreeclear(tree);
// Put one value back in the tree to make sure it's freed on delete
tctreeput(tree, &key, sizeof(key), val, strlen(val));
// Delete the tree
tctreedel(tree);
// Make a list
TCLIST *list = tclistnew();
// Push a few times
tclistpush(list, &key, sizeof(key));
key += 1;
tclistpush(list, &key, sizeof(key));
key += 1;
tclistpush(list, &key, sizeof(key));
// Overwrite an existing element
tclistover(list, 1, &key, sizeof(key));
// Get a value
tclistval(list, 2, &size);
// Remove some values
newVal = tclistremove(list, 2, &size);
free(newVal);
newVal = tclistremove(list, 0, &size);
free(newVal);
// Free the whole list
tclistdel(list);
}
void grok_capture_add(grok_t *grok, const grok_capture *gct, int only_renamed) {
grok_log(grok, LOG_CAPTURE,
"Adding pattern '%s' as capture %d (pcrenum %d)",
gct->name, gct->id, gct->pcre_capture_number);
if (only_renamed && strstr(gct->name, ":") == NULL) {
return;
}
/* Primary key is id */
tctreeput(grok->captures_by_id, &(gct->id), sizeof(gct->id),
gct, sizeof(grok_capture));
/* Tokyo Cabinet doesn't seem to support 'secondary indexes' like BDB does,
* so let's manually update all the other 'captures_by_*' trees */
int unused_size;
tctreeput(grok->captures_by_capture_number, &(gct->pcre_capture_number),
sizeof(gct->pcre_capture_number), gct, sizeof(grok_capture));
int i, listsize;
/* TCTREE doesn't permit dups, so let's make the structure a tree of arrays,
* keyed on a string. */
/* captures_by_name */
TCLIST *by_name_list;
by_name_list = (TCLIST *) tctreeget(grok->captures_by_name,
(const char *)gct->name,
gct->name_len, &unused_size);
if (by_name_list == NULL) {
by_name_list = tclistnew();
}
/* delete a capture with the same capture id so we can replace it*/
listsize = tclistnum(by_name_list);
for (i = 0; i < listsize; i++) {
grok_capture *list_gct;
list_gct = (grok_capture *)tclistval(by_name_list, i, &unused_size);
if (list_gct->id == gct->id) {
tclistremove(by_name_list, i, &unused_size);
break;
}
}
tclistpush(by_name_list, gct, sizeof(grok_capture));
tctreeput(grok->captures_by_name, gct->name, gct->name_len,
by_name_list, sizeof(TCLIST));
/* end captures_by_name */
/* captures_by_subname */
TCLIST *by_subname_list;
by_subname_list = (TCLIST *) tctreeget(grok->captures_by_subname,
(const char *)gct->subname,
gct->subname_len, &unused_size);
if (by_subname_list == NULL) {
by_subname_list = tclistnew();
}
/* delete a capture with the same capture id so we can replace it*/
listsize = tclistnum(by_subname_list);
for (i = 0; i < listsize; i++) {
grok_capture *list_gct;
list_gct = (grok_capture *)tclistval(by_subname_list, i, &unused_size);
if (list_gct->id == gct->id) {
tclistremove(by_subname_list, i, &unused_size);
break;
}
}
tclistpush(by_subname_list, gct, sizeof(grok_capture));
tctreeput(grok->captures_by_subname, gct->subname, gct->subname_len,
by_subname_list, sizeof(TCLIST));
/* end captures_by_subname */
}
