r3/src/node.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>

// Jemalloc memory management
#include <jemalloc/jemalloc.h>

// PCRE
#include <pcre.h>

// Judy array
#include <Judy.h>

#include "str.h"
#include "node.h"
#include "token.h"

struct _rnode {
    redge ** children;
    int      children_len;
    int      children_cap;

    /* the combined regexp pattern string from pattern_tokens */
    char * combined_pattern;
    int    combined_pattern_len;

    int endpoint;
};

struct _redge {
    char * pattern;
    int    pattern_len;
    bool   is_slug;
    rnode * child;
};

// String value as the index http://judy.sourceforge.net/doc/JudySL_3x.htm



/**
 * Create a rnode object
 */
rnode * rnode_create(int cap) {
    rnode * n = (rnode*) malloc( sizeof(rnode) );

    n->children = (redge**) malloc( sizeof(redge*) * 10 );
    n->children_len = 0;
    n->children_cap = 10;
    n->endpoint = 0;
    n->combined_pattern = NULL;
    // n->edge_patterns = token_array_create(10);
    return n;
}

void rnode_free(rnode * tree) {
    for (int i = 0 ; i < tree->children_len ; i++ ) {
        redge_free(tree->children[ i ]);
    }
    free(tree->children);
    // token_array_free(tree->edge_patterns);
    free(tree);
    tree = NULL;
}



/* parent node, edge pattern, child */
bool rnode_add_child(rnode * n, char * pat , rnode *child) {
    // find the same sub-pattern, if it does not exist, create one

    redge * e;

    e = rnode_find_edge(n, pat);
    if (e) {
        return FALSE;
    }

    e = redge_create( pat, strlen(pat), child);
    rnode_append_edge(n, e);
    // token_array_append(n->edge_patterns, pat);
    // assert( token_array_len(n->edge_patterns) == n->children_len );
    return TRUE;
}



void rnode_append_edge(rnode *n, redge *e) {
    if (n->children_len >= n->children_cap) {
        n->children_cap *= 2;
        n->children = realloc(n->children, sizeof(redge) * n->children_cap);
    }
    n->children[ n->children_len++ ] = e;
}


redge * rnode_find_edge(rnode * n, char * pat) {
    redge * e;
    for (int i = 0 ; i < n->children_len ; i++ ) {
        e = n->children[i];
        if ( strcmp(e->pattern, pat) == 0 ) {
            return e;
        }
    }
    return NULL;
}



/**
 * This function combines ['/foo', '/bar', '/{slug}'] into (/foo)|(/bar)|/([^/]+)}
 *
 */
void rnode_combine_patterns(rnode * n) {
    char * cpat;
    char * p;

    cpat = malloc(128);
    if (cpat==NULL)
        return;

    p = cpat;

    redge *e = NULL;
    for ( int i = 0 ; i < n->children_len ; i++ ) {
        e = n->children[i];
        strncat(p++,"(", 1);
        strncat(p, e->pattern, e->pattern_len);

        p += e->pattern_len;

        strncat(p++,")", 1);

        if ( i + 1 < n->children_len ) {
            strncat(p++,"|",1);
        }
    }
    n->combined_pattern = cpat;
    n->combined_pattern_len = p - cpat;
}


rnode * rnode_lookup(rnode * tree, char * path, int path_len) {
    token_array * tokens = split_route_pattern(path, path_len);

    rnode * n = tree;
    redge * e = NULL;
    for ( int i = 0 ; i < tokens->len ; i++ ) {
        e = rnode_find_edge(n, token_array_fetch(tokens, i) );
        if (!e) {
            return NULL;
        }
        n = e->child;
    }
    if (n->endpoint) {
        return n;
    }
    return NULL;
}




rnode * rnode_insert_tokens(rnode * tree, token_array * tokens) {
    rnode * n = tree;
    redge * e = NULL;
    for ( int i = 0 ; i < tokens->len ; i++ ) {
        e = rnode_find_edge(n, token_array_fetch(tokens, i) );
        if (e) {
            n = e->child;
            continue;
        }
        // insert node
        rnode * child = rnode_create(3);
        rnode_add_child(n, strdup(token_array_fetch(tokens,i)) , child);
        n = child;
    }
    n->endpoint++;
    return n;
}

rnode * rnode_insert_route(rnode *tree, char *route)
{
    return rnode_insert_routel(tree, route, strlen(route) );
}

rnode * rnode_insert_routel(rnode *tree, char *route, int route_len)
{
    token_array * t = split_route_pattern(route, strlen(route));
    return rnode_insert_tokens(tree, t);
}

void rnode_dump(rnode * n, int level) {
    if ( n->children_len ) {
        print_indent(level);
        printf("*\n");
        for ( int i = 0 ; i < n->children_len ; i++ ) {
            redge * e = n->children[i];
            print_indent(level + 1);
            printf("+ \"%s\"\n", e->pattern);
            rnode_dump( e->child, level + 1);
        }
    }
}

redge * redge_create(char * pattern, int pattern_len, rnode * child) {
    redge * edge = (redge*) malloc( sizeof(redge) );
    edge->pattern = pattern;
    edge->pattern_len = pattern_len;
    edge->child = child;
    edge->is_slug = 0;
    return edge;
}

void redge_free(redge * e) {
    free(e->pattern);
    if ( e->child ) {
        rnode_free(e->child);
    }
}