r3 library is included, route registration still doesn't work because of some reference issue, TODO: do a better implementation

speedy/Makefile

@@ -1,6 +1,6 @@
 CXX=clang++
 CFLAGS=-std=c++11 -Wall
-LDFLAGS=-luv -lhttp_parser
+LDFLAGS=-luv -lhttp_parser -lr3
 INC=-I../
 SOURCES=$(wildcard *.cpp)
 EXECUTABLE=test.out

speedy/README.md

@@ -21,5 +21,11 @@ make install
 * https://github.com/c9s/r3
 
 ```
-brew install r3 (OSX)
+./autogen.sh
+./configure
+make
+sudo make install
 ```
+
+## NOTE
+r3_include.h is custom r3 header file because of compilation problem related to redefinition of bool

speedy/r3_include.h

@@ -0,0 +1,228 @@
+/*
+ * r3.h
+ * Copyright (C) 2014 c9s <yoanlin93@gmail.com>
+ *
+ * Distributed under terms of the MIT license.
+ */
+#ifndef R3_NODE_H
+#define R3_NODE_H
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <pcre.h>
+#include <stdbool.h>
+#include <r3/str_array.h>
+#include <r3/r3_str.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct _edge;
+struct _node;
+struct _route;
+typedef struct _edge edge;
+typedef struct _node node;
+typedef struct _route route;
+
+struct _node {
+    edge  ** edges;
+    // edge  ** edge_table;
+
+    // edges are mostly less than 255
+    unsigned char    compare_type; // compare_type: pcre, opcode, string
+    unsigned char    edge_len;
+    unsigned char    endpoint; // endpoint, should be zero for non-endpoint nodes
+    unsigned char    ov_cnt; // capture vector array size for pcre
+
+    // almost less than 255
+    unsigned char      edge_cap;
+    unsigned char      route_len;
+    unsigned char      route_cap;
+    // <-- here comes a char[1] struct padding for alignment since we have 4 char above.
+
+
+    /** compile-time variables here.... **/
+
+    /* the combined regexp pattern string from pattern_tokens */
+    pcre * pcre_pattern;
+    pcre_extra * pcre_extra;
+
+    route ** routes;
+
+    char * combined_pattern;
+
+    /**
+     * the pointer of route data
+     */
+    void * data;
+};
+
+#define r3_node_edge_pattern(node,i) node->edges[i]->pattern
+#define r3_node_edge_pattern_len(node,i) node->edges[i]->pattern_len
+
+struct _edge {
+    char * pattern; // 8 bytes
+    node * child; // 8 bytes
+    unsigned char  pattern_len; // 1 byte
+    unsigned char  opcode:4; // 4 bit
+    unsigned char  has_slug:1; // 1 bit
+};
+
+struct _route {
+    char * path;
+    int    path_len;
+
+    int    request_method; // can be (GET || POST)
+
+    char * host; // required host name
+    int    host_len;
+
+    void * data;
+
+    char * remote_addr_pattern;
+    int    remote_addr_pattern_len;
+};
+
+typedef struct {
+    str_array * vars;
+    const char * path; // current path to dispatch
+    int    path_len; // the length of the current path
+    int    request_method;  // current request method
+
+    void * data; // route ptr
+
+    char * host; // the request host
+    int    host_len;
+
+    char * remote_addr;
+    int    remote_addr_len;
+} match_entry;
+
+
+
+
+
+
+
+
+node * r3_tree_create(int cap);
+
+node * r3_node_create();
+
+void r3_tree_free(node * tree);
+
+edge * r3_node_connectl(node * n, const char * pat, int len, int strdup, node *child);
+
+#define r3_node_connect(n, pat, child) r3_node_connectl(n, pat, strlen(pat), 0, child)
+
+edge * r3_node_find_edge(const node * n, const char * pat, int pat_len);
+
+void r3_node_append_edge(node *n, edge *child);
+
+
+edge * r3_node_find_common_prefix(node *n, const char *path, int path_len, int *prefix_len, char **errstr);
+
+node * r3_tree_insert_pathl(node *tree, const char *path, int path_len, void * data);
+
+#define r3_tree_insert_pathl(tree, path, path_len, data) r3_tree_insert_pathl_ex(tree, path, path_len, NULL , data, NULL)
+
+
+
+route * r3_tree_insert_routel(node *tree, int method, const char *path, int path_len, void *data);
+
+route * r3_tree_insert_routel_ex(node *tree, int method, const char *path, int path_len, void *data, char **errstr);
+
+#define r3_tree_insert_routel(n, method, path, path_len, data) r3_tree_insert_routel_ex(n, method, path, path_len, data, NULL)
+
+#define r3_tree_insert_path(n,p,d) r3_tree_insert_pathl_ex(n,p,strlen(p), NULL, d, NULL)
+
+#define r3_tree_insert_route(n,method,path,data) r3_tree_insert_routel(n, method, path, strlen(path), data)
+
+
+/**
+ * The private API to insert a path
+ */
+node * r3_tree_insert_pathl_ex(node *tree, const char *path, int path_len, route * route, void * data, char ** errstr);
+
+void r3_tree_dump(const node * n, int level);
+
+
+edge * r3_node_find_edge_str(const node * n, const char * str, int str_len);
+
+
+int r3_tree_compile(node *n, char** errstr);
+
+int r3_tree_compile_patterns(node * n, char** errstr);
+
+node * r3_tree_matchl(const node * n, const char * path, int path_len, match_entry * entry);
+
+#define r3_tree_match(n,p,e)  r3_tree_matchl(n,p, strlen(p), e)
+
+// node * r3_tree_match_entry(node * n, match_entry * entry);
+#define r3_tree_match_entry(n, entry) r3_tree_matchl(n, entry->path, entry->path_len, entry)
+
+bool r3_node_has_slug_edges(const node *n);
+
+edge * r3_edge_createl(const char * pattern, int pattern_len, node * child);
+
+node * r3_edge_branch(edge *e, int dl);
+
+void r3_edge_free(edge * edge);
+
+
+
+
+
+route * r3_route_create(const char * path);
+
+route * r3_route_createl(const char * path, int path_len);
+
+
+void r3_node_append_route(node * n, route * route);
+
+void r3_route_free(route * route);
+
+int r3_route_cmp(const route *r1, const match_entry *r2);
+
+route * r3_tree_match_route(const node *n, match_entry * entry);
+
+#define r3_route_create(p) r3_route_createl(p, strlen(p))
+
+
+#define METHOD_GET 2
+#define METHOD_POST 2<<1
+#define METHOD_PUT 2<<2
+#define METHOD_DELETE 2<<3
+#define METHOD_PATCH 2<<4
+#define METHOD_HEAD 2<<5
+#define METHOD_OPTIONS 2<<6
+
+
+
+int r3_pattern_to_opcode(const char * pattern, int pattern_len);
+
+enum { NODE_COMPARE_STR, NODE_COMPARE_PCRE, NODE_COMPARE_OPCODE };
+
+enum { OP_EXPECT_MORE_DIGITS = 1, OP_EXPECT_MORE_WORDS, OP_EXPECT_NOSLASH, OP_EXPECT_NODASH, OP_EXPECT_MORE_ALPHA };
+
+
+
+match_entry * match_entry_createl(const char * path, int path_len);
+
+#define match_entry_create(path) match_entry_createl(path,strlen(path))
+
+void match_entry_free(match_entry * entry);
+
+
+
+
+#ifdef __cplusplus
+}
+#endif
+
+
+
+
+#endif /* !R3_NODE_H */

speedy/speedy.hpp

@@ -1,8 +1,11 @@
 #ifndef MEMGRAPH_SPEEDY_HPP
 #define MEMGRAPH_SPEEDY_HPP
 
+#include <vector>
+
 #include "io/uv/uv.hpp"
 #include "http/http.hpp"
+#include "r3_include.h"
 
 namespace speedy
 {
@@ -12,11 +15,11 @@ class Speedy
 private:
     http::HttpServer server;
     http::Ipv4 ip;
+    node *n;
 public:
     Speedy(uv::UvLoop& loop, const http::Ipv4& ip);
-    void get(const std::string path, http::request_cb_t callback); 
+    void get(const std::string &path, http::request_cb_t callback); 
     void listen();
-    ~Speedy();
 };
 
 }

speedy/speedy.inl

@@ -8,25 +8,39 @@ namespace speedy
 
 Speedy::Speedy(uv::UvLoop& loop, const http::Ipv4& ip) : server(loop), ip(ip)
 {
+    n = r3_tree_create(100);
 }
 
-void Speedy::get(const std::string path, http::request_cb_t callback)
+void Speedy::get(const std::string &path, http::request_cb_t callback)
 {
+    // this->callbacks.push_back(callback);
+    // r3_tree_insert_pathl(n, path.c_str(), path.size(), &callbacks[callbacks.size() - 1]);
+    r3_tree_insert_pathl(n, path.c_str(), path.size(), &callback);
+    // r3_tree_insert_pathl(n, path.c_str(), path.size(), &callbacks.back());
 }
 
 void Speedy::listen()
 {
-    server.listen(ip, [](http::Request& req, http::Response& res) {
-        res.send(req.url);
+    char *errstr = NULL;
+    int err = r3_tree_compile(n, &errstr);
+    if (err) {
+        std::cout << "R3 compile error" << std::endl;
+    }
+
+    server.listen(ip, [this](http::Request& req, http::Response& res) {
+        auto url = req.url;
+        node *n = r3_tree_matchl(this->n, url.c_str(), url.size(), NULL);
+        if (n) {
+            auto callback = *reinterpret_cast<http::request_cb_t*>(n->data);
+             callback(req, res);
+        } else {
+            res.send("Not found");
+        }
     });
 
     std::cout << "Server is UP" << std::endl;
 }
 
-Speedy::~Speedy()
-{
-}
-
 }
 
 #endif

speedy/test.cpp

@@ -2,12 +2,31 @@
 
 #include "speedy.hpp"
 
+// TODO: still doesn't work
+// debug the whole thing
+void test(http::request_cb_t callback, speedy::Speedy &app) {
+    app.get("/test", callback); 
+}
+
+auto foo = [](http::Request& req, http::Response& res) {
+    res.send("foo");
+};
+
 int main(void)
 {
     uv::UvLoop loop;
     http::Ipv4 ip("0.0.0.0", 3400);
 
     speedy::Speedy app(loop, ip);
+    app.get("/foo", foo);
+    app.get("/bar", [](http::Request& req, http::Response& res) {
+        res.send("bar");
+    });
+    auto cb = [](http::Request& req, http::Response& res) {
+        res.send("test");
+    };
+    test(http::request_cb_t(cb), app);
+
     app.listen();
 
     loop.run(uv::UvLoop::Mode::Default);