durable_rules 0.34.29 → 0.34.31

data/src/rules/json.c

@@ -395,7 +395,7 @@ static unsigned int getString(char *start, char **first, char **last) {
 static unsigned int getStringAndHash(char *start, char **first, char **last, unsigned int *hash) {
     unsigned char state = ST_STRING_SEEK;
     char delimiter = '\0';
-    unsigned int currentHash = 5381;
+    unsigned int currentHash = FNV_32_OFFSET_BASIS;
     while(start[0] != '\0') {
         switch (state) {
             case ST_STRING_SEEK:
@@ -417,11 +417,14 @@ static unsigned int getStringAndHash(char *start, char **first, char **last, uns
                     state = ST_STRING_ESC;  
                 }
 
-                currentHash = ((currentHash << 5) + currentHash) + (*start);
+                currentHash ^= (*start);
+                currentHash *= FNV_32_PRIME;
                 break;
             case ST_STRING_ESC:
                 state = ST_STRING_PARSE;
-                currentHash = ((currentHash << 5) + currentHash) + (*start);
+
+                currentHash ^= (*start);
+                currentHash *= FNV_32_PRIME;
                 break;
         }
 
@@ -430,3 +433,4 @@ static unsigned int getStringAndHash(char *start, char **first, char **last, uns
 
     return ERR_PARSE_STRING;
 }
+

data/src/rules/json.h

@@ -17,6 +17,9 @@
 #define JSON_REGEX 0x0C
 #define JSON_IREGEX 0x0D
 
+#define FNV_32_OFFSET_BASIS 0x811c9dc5
+#define FNV_32_PRIME 16777619
+
 unsigned int readNextName(char *start, char **first, char **last, unsigned int *hash);
 unsigned int readNextValue(char *start, char **first, char **last, unsigned char *type);
 unsigned int readNextArrayValue(char *start, char **first, char **last, unsigned char *type);

data/src/rules/net.c

@@ -686,7 +686,12 @@ static unsigned int loadAddMessageCommand(ruleset *tree, binding *rulesBinding)
     if (asprintf(&lua, 
 "local sid = ARGV[1]\n"
 "local assert_fact = tonumber(ARGV[2])\n"
-"local keys_count = tonumber(ARGV[3])\n"
+// when mark visited is set to 0, it means eval will be called immedately
+// with the same message. In that case, the function will avid setting
+// the visited bit (for events), storing the message and increasing the
+// mid count (for the case of auto generated mid)
+"local mark_visited = tonumber(ARGV[3])\n"
+"local keys_count = tonumber(ARGV[4])\n"
 "local events_hashset = \"%s!e!\" .. sid\n"
 "local facts_hashset = \"%s!f!\" .. sid\n"
 "local visited_hashset = \"%s!v!\" .. sid\n"
@@ -694,12 +699,14 @@ static unsigned int loadAddMessageCommand(ruleset *tree, binding *rulesBinding)
 "local message = {}\n"
 "local primary_message_keys = {}\n"
 "local input_keys = {}\n"
-"local save_message = function(current_key, message, events_key, messages_key)\n"
-"    redis.call(\"hsetnx\", messages_key, message[\"id\"], cmsgpack.pack(message))\n"
+"local save_message = function(current_key, message, events_key, messages_key, save_hashset)\n"
+"    if save_hashset == 1 then\n"
+"        redis.call(\"hsetnx\", messages_key, message[\"id\"], cmsgpack.pack(message))\n"
+"    end\n"
 "    local primary_key = primary_message_keys[current_key](message)\n"
 "    redis.call(\"lpush\", events_key .. \"!m!\" .. primary_key, message[\"id\"])\n"
 "end\n"
-"for index = 4 + keys_count, #ARGV, 3 do\n"
+"for index = 5 + keys_count, #ARGV, 3 do\n"
 "    if ARGV[index + 2] == \"1\" then\n"
 "        message[ARGV[index]] = ARGV[index + 1]\n"
 "    elseif ARGV[index + 2] == \"2\" or  ARGV[index + 2] == \"3\" then\n"
@@ -717,35 +724,41 @@ static unsigned int loadAddMessageCommand(ruleset *tree, binding *rulesBinding)
 "    end\n"
 "end\n"
 "local mid = message[\"id\"]\n"
-"if not mid then\n"
-"    mid = \"$m-\" .. redis.call(\"hincrby\", mid_count_hashset, sid, 1)\n"
+"if mid == \"\" then\n"
+"    if mark_visited == 0 then\n"
+"        mid = \"$m-\" .. redis.call(\"hget\", mid_count_hashset, sid) + 1\n"
+"    else\n"
+"        mid = \"$m-\" .. redis.call(\"hincrby\", mid_count_hashset, sid, 1)\n"
+"    end\n"
 "    message[\"id\"] = mid\n"
 "else\n"
-"    if redis.call(\"hsetnx\", visited_hashset, mid, 1) == 0 then\n"
-"        if assert_fact == 0 then\n"
-"            if not redis.call(\"hget\", events_hashset, mid) then\n"
-"                return %d\n"
-"            end\n"
-"        else\n"
-"            if not redis.call(\"hget\", facts_hashset, mid) then\n"
+"    if assert_fact == 1 then\n"
+"        if redis.call(\"hexists\", facts_hashset, mid) == 1 then\n"
+"            return %d\n"
+"        end\n"
+"    else\n"
+"        if mark_visited == 1 then\n"
+"            if redis.call(\"hsetnx\", visited_hashset, mid, 1) == 0 then\n"
 "                return %d\n"
 "            end\n"
+"        elseif redis.call(\"hexists\", visited_hashset, mid) == 1 then \n"
+"            return %d\n"
 "        end\n"
 "    end\n"
 "end\n"
-"for index = 4, 3 + keys_count, 1 do\n"
+"for index = 5, 4 + keys_count, 1 do\n"
 "    input_keys[ARGV[index]] = true\n"
 "end\n"
 "%sif assert_fact == 1 then\n"
 "    message[\"$f\"] = 1\n"
-"    for index = 4, 3 + keys_count, 1 do\n"
+"    for index = 5, 4 + keys_count, 1 do\n"
 "        local key = ARGV[index]\n"
-"        save_message(key, message, key .. \"!f!\" .. sid, facts_hashset)\n"
+"        save_message(key, message, key .. \"!f!\" .. sid, facts_hashset, mark_visited)\n"
 "    end\n"
 "else\n"
-"    for index = 4, 3 + keys_count, 1 do\n"
+"    for index = 5, 4 + keys_count, 1 do\n"
 "        local key = ARGV[index]\n"
-"        save_message(key, message, key .. \"!e!\" .. sid, events_hashset)\n"
+"        save_message(key, message, key .. \"!e!\" .. sid, events_hashset, mark_visited)\n"
 "    end\n"
 "end\n",
                 name,
@@ -754,6 +767,7 @@ static unsigned int loadAddMessageCommand(ruleset *tree, binding *rulesBinding)
                 name,
                 ERR_EVENT_OBSERVED,
                 ERR_EVENT_OBSERVED,
+                ERR_EVENT_OBSERVED,
                 addMessageLua)  == -1) {
         return ERR_OUT_OF_MEMORY;
     }
@@ -947,6 +961,7 @@ static unsigned int loadPeekActionCommand(ruleset *tree, binding *rulesBinding)
     if (asprintf(&lua, 
 "local facts_key = \"%s!f!\"\n"
 "local events_key = \"%s!e!\"\n"
+"local visited_key = \"%s!v!\"\n"
 "local action_key = \"%s!a\"\n"
 "local state_key = \"%s!s\"\n"
 "local timers_key = \"%s!t\"\n"
@@ -1040,7 +1055,7 @@ static unsigned int loadPeekActionCommand(ruleset *tree, binding *rulesBinding)
 "    if cancel then\n"
 "        for i = 1, #frame, 1 do\n"
 "            if type(frame[i]) == \"table\" then\n"
-"                redis.call(\"hsetnx\", events_hashset, frame[i][\"id\"], cmsgpack.pack(frame[i]))\n"
+"                redis.call(\"hdel\", visited_key .. sid, frame[i][\"id\"])\n"
 "                redis.call(\"zadd\", timers_key, max_score, \"p:\" .. cjson.encode(frame[i]))\n"
 "            end\n"
 "        end\n"
@@ -1211,6 +1226,7 @@ static unsigned int loadPeekActionCommand(ruleset *tree, binding *rulesBinding)
                 name,
                 name,
                 name,
+                name,
                 peekActionLua)  == -1) {
         return ERR_OUT_OF_MEMORY;
     }
@@ -2095,15 +2111,13 @@ static unsigned int loadEvalMessageCommand(ruleset *tree, binding *rulesBinding)
 "        message[\"id\"] = mid\n"
 "    end\n"
 "else\n"
-"    if redis.call(\"hsetnx\", visited_hashset, mid, 1) == 0 then\n"
-"        if assert_fact == 0 then\n"
-"            if message and redis.call(\"hexists\", events_hashset, mid) == 0 then\n"
-"                return %d\n"
-"            end\n"
-"        else\n"
-"            if message and redis.call(\"hexists\", facts_hashset, mid) == 0 then\n"
-"                return %d\n"
-"            end\n"
+"    if assert_fact == 1 then\n"
+"        if message and redis.call(\"hexists\", facts_hashset, mid) == 1 then\n"
+"            return %d\n"
+"        end\n"
+"    else\n"
+"        if message and redis.call(\"hsetnx\", visited_hashset, mid, 1) == 0 then\n"
+"            return %d\n"
 "        end\n"
 "    end\n"
 "end\n"
@@ -2354,12 +2368,12 @@ unsigned int formatEvalMessage(void *rulesBinding,
                                char *sid, 
                                char *mid,
                                char *message, 
-                               jsonProperty *allProperties,
-                               unsigned int propertiesLength,
+                               jsonObject *jo,
                                unsigned char actionType,
                                char **keys,
                                unsigned int keysLength,
                                char **command) {
+    unsigned int propertiesLength = jo->propertiesLength;
     if (actionType == ACTION_RETRACT_FACT || actionType == ACTION_RETRACT_EVENT) {
         propertiesLength = 0; 
     }
@@ -2404,16 +2418,16 @@ unsigned int formatEvalMessage(void *rulesBinding,
 
     unsigned int offset = 8 + keysLength;
     for (unsigned int i = 0; i < propertiesLength; ++i) {
-        argv[offset + i * 3] = allProperties[i].name;
-        argvl[offset + i * 3] = allProperties[i].nameLength;
-        argv[offset + i * 3 + 1] = message + allProperties[i].valueOffset;
-        if (allProperties[i].type == JSON_STRING) {
-            argvl[offset + i * 3 + 1] = allProperties[i].valueLength;
+        argv[offset + i * 3] = jo->properties[i].name;
+        argvl[offset + i * 3] = jo->properties[i].nameLength;
+        argv[offset + i * 3 + 1] = jo->properties[i].valueString;
+        if (jo->properties[i].type == JSON_STRING) {
+            argvl[offset + i * 3 + 1] = jo->properties[i].valueLength;
         } else {
-            argvl[offset + i * 3 + 1] = allProperties[i].valueLength + 1;
+            argvl[offset + i * 3 + 1] = jo->properties[i].valueLength + 1;
         }
 
-        switch(allProperties[i].type) {
+        switch(jo->properties[i].type) {
             case JSON_STRING:
                 argv[offset + i * 3 + 2] = "1";
                 break;
@@ -2446,22 +2460,23 @@ unsigned int formatEvalMessage(void *rulesBinding,
 unsigned int formatStoreMessage(void *rulesBinding, 
                                 char *sid, 
                                 char *message, 
-                                jsonProperty *allProperties,
-                                unsigned int propertiesLength,
+                                jsonObject *jo,
                                 unsigned char storeFact,
+                                unsigned char markVisited,
                                 char **keys,
                                 unsigned int keysLength,
                                 char **command) {
+    unsigned int propertiesLength = jo->propertiesLength;
     binding *bindingContext = (binding*)rulesBinding;
     char keysLengthString[5];
 #ifdef _WIN32
     sprintf_s(keysLengthString, sizeof(char) * 5, "%d", keysLength);
-    char **argv = (char **)_alloca(sizeof(char*)*(6 + keysLength + propertiesLength * 3));
-    size_t *argvl = (size_t *)_alloca(sizeof(size_t)*(6 + keysLength + propertiesLength * 3));
+    char **argv = (char **)_alloca(sizeof(char*)*(7 + keysLength + propertiesLength * 3));
+    size_t *argvl = (size_t *)_alloca(sizeof(size_t)*(7 + keysLength + propertiesLength * 3));
 #else
     snprintf(keysLengthString, sizeof(char) * 5, "%d", keysLength);
-    char *argv[6 + keysLength + propertiesLength * 3];
-    size_t argvl[6 + keysLength + propertiesLength * 3];
+    char *argv[7 + keysLength + propertiesLength * 3];
+    size_t argvl[7 + keysLength + propertiesLength * 3];
 #endif
 
     argv[0] = "evalsha";
@@ -2474,26 +2489,28 @@ unsigned int formatStoreMessage(void *rulesBinding,
     argvl[3] = strlen(sid);
     argv[4] = storeFact ? "1" : "0";
     argvl[4] = 1;
-    argv[5] = keysLengthString;
-    argvl[5] = strlen(keysLengthString);
+    argv[5] = markVisited ? "1" : "0";
+    argvl[5] = 1;
+    argv[6] = keysLengthString;
+    argvl[6] = strlen(keysLengthString);
 
     for (unsigned int i = 0; i < keysLength; ++i) {
-        argv[6 + i] = keys[i];
-        argvl[6 + i] = strlen(keys[i]);
+        argv[7 + i] = keys[i];
+        argvl[7 + i] = strlen(keys[i]);
     }
 
-    unsigned int offset = 6 + keysLength;
+    unsigned int offset = 7 + keysLength;
     for (unsigned int i = 0; i < propertiesLength; ++i) {
-        argv[offset +  i * 3] = allProperties[i].name;
-        argvl[offset + i * 3] = allProperties[i].nameLength;
-        argv[offset + i * 3 + 1] = message + allProperties[i].valueOffset;
-        if (allProperties[i].type == JSON_STRING) {
-            argvl[offset + i * 3 + 1] = allProperties[i].valueLength;
+        argv[offset +  i * 3] = jo->properties[i].name;
+        argvl[offset + i * 3] = jo->properties[i].nameLength;
+        argv[offset + i * 3 + 1] = jo->properties[i].valueString;
+        if (jo->properties[i].type == JSON_STRING) {
+            argvl[offset + i * 3 + 1] = jo->properties[i].valueLength;
         } else {
-            argvl[offset + i * 3 + 1] = allProperties[i].valueLength + 1;
+            argvl[offset + i * 3 + 1] = jo->properties[i].valueLength + 1;
         }
 
-        switch(allProperties[i].type) {
+        switch(jo->properties[i].type) {
             case JSON_STRING:
                 argv[offset + i * 3 + 2] = "1";
                 break;

data/src/rules/net.h

@@ -54,8 +54,7 @@ unsigned int formatEvalMessage(void *rulesBinding,
                                char *sid, 
                                char *mid,
                                char *message, 
-                               jsonProperty *allProperties,
-                               unsigned int propertiesLength,
+                               jsonObject *jo,
                                unsigned char actionType,
                                char **keys,
                                unsigned int keysLength,
@@ -64,9 +63,9 @@ unsigned int formatEvalMessage(void *rulesBinding,
 unsigned int formatStoreMessage(void *rulesBinding, 
                                 char *sid, 
                                 char *message, 
-                                jsonProperty *allProperties,
-                                unsigned int propertiesLength,
+                                jsonObject *jo,
                                 unsigned char storeFact,
+                                unsigned char markVisited,
                                 char **keys,
                                 unsigned int keysLength,
                                 char **command);

data/src/rules/rete.c

@@ -8,34 +8,32 @@
 #include "json.h"
 #include "regex.h"
 
-#define HASH_ALL 193486302 // all
-#define HASH_ANY 193486381 // any
-#define HASH_PRI 193502832 // pri
-#define HASH_COUNT 255678574 // count
-#define HASH_SPAN 2090731639 // span
-#define HASH_CAP 193488121 // cap
-#define HASH_BY 5863264 // by
-#define HASH_LT 193419881 // $lt
-#define HASH_LTE 2087888878 // $lte
-#define HASH_GT 193419716 // $gt
-#define HASH_GTE 2087883433 // $gte
-#define HASH_EQ 193419647 // $eq
-#define HASH_NEQ 2087890573 // $neq
-#define HASH_MT 193419914 // $mt
-#define HASH_IMT 2087885395 // $imt
-#define HASH_EX 193419654 // $ex
-#define HASH_NEX 2087890580 // $nex
-#define HASH_OR 193419978 // $or
-#define HASH_AND 2087876700 // $and
-#define HASH_S 5861212 // $s
-#define HASH_NAME 2090536006 // name 
-#define HASH_ADD 2087876370 // $add
-#define HASH_SUB 2087896531 // $sub
-#define HASH_MUL 2087890007 // $mul
-#define HASH_DIV 2087879820 // $div
-#define HASH_L 5861205 // $l
-#define HASH_R 5861211 //$r
-#define HASH_FORWARD 1810358942 // $forward
+#define HASH_ALL 321211332 // all
+#define HASH_ANY 740945997 // any
+#define HASH_PRI 1450887882 // pri
+#define HASH_COUNT 967958004 // count
+#define HASH_CAP 41178555 // cap
+#define HASH_LT 542787579 // $lt
+#define HASH_LTE 2350824890 // $lte
+#define HASH_GT 507407960 // $gt
+#define HASH_GTE 3645344263 // $gte
+#define HASH_EQ 256037865 // $eq
+#define HASH_NEQ 2488026869 // $neq
+#define HASH_MT 576092554 // $mt
+#define HASH_IMT 1472564215 // $imt
+#define HASH_EX 373481198 // $ex
+#define HASH_NEX 2605470202 // $nex
+#define HASH_OR 340911698 // $or
+#define HASH_AND 3746487396 // $and
+#define HASH_S 1186729920 // $s
+#define HASH_NAME 2369371622 // name 
+#define HASH_ADD 4081054038 // $add
+#define HASH_SUB 1040718071 // $sub
+#define HASH_MUL 304370403 // $mul
+#define HASH_DIV 130502 // $div
+#define HASH_L 1706836109 // $l
+#define HASH_R 1203507539 //$r
+#define HASH_FORWARD 739185624 // $forward
 
 typedef struct path {
     unsigned char operator;
@@ -746,26 +744,15 @@ static unsigned int validateRuleset(char *rules) {
             return countResult;
         }
 
-        unsigned int spanResult = validateSetting(HASH_SPAN, first, JSON_INT);
-        if (spanResult != PARSE_OK && spanResult != ERR_SETTING_NOT_FOUND) {
-            return spanResult;
-        }
-
         unsigned int capResult = validateSetting(HASH_CAP, first, JSON_INT);
         if (capResult != PARSE_OK && capResult != ERR_SETTING_NOT_FOUND) {
             return capResult;
         }
 
-        if ((spanResult == PARSE_OK && (countResult == PARSE_OK || capResult == PARSE_OK)) ||
-            (countResult == PARSE_OK && capResult == PARSE_OK)) {
+        if (countResult == PARSE_OK && capResult == PARSE_OK) {
             return ERR_UNEXPECTED_NAME;
         }
 
-        result = validateSetting(HASH_BY, first, JSON_STRING);
-        if (result != PARSE_OK && result != ERR_SETTING_NOT_FOUND) {
-            return result;
-        }
-
         result = validateSetting(HASH_PRI, first, JSON_INT);
         if (result != PARSE_OK && result != ERR_SETTING_NOT_FOUND) {
             return result;
@@ -783,7 +770,7 @@ static unsigned int validateRuleset(char *rules) {
                 if (result != RULES_OK && result != PARSE_END) {
                     return result;
                 }
-            } else if (hash != HASH_COUNT && hash != HASH_PRI && hash != HASH_SPAN && hash != HASH_CAP && hash != HASH_BY) {
+            } else if (hash != HASH_COUNT && hash != HASH_PRI && hash != HASH_CAP) {
                 return ERR_UNEXPECTED_NAME;
             }
 
@@ -1289,7 +1276,7 @@ static unsigned int createBetaConnector(ruleset *tree,
 
             if (operator == OP_ALL || operator == OP_ANY || operator == OP_NOT) {
                 nameLength = nameLength - 4;
-                hash = djbHash(first, nameLength);
+                hash = fnv1Hash32(first, nameLength);
             }
         }        
         
@@ -1694,7 +1681,6 @@ static unsigned int createTree(ruleset *tree, char *rules) {
         ruleAction->value.c.cap = 0;
         getSetting(HASH_PRI, first, &ruleAction->value.c.priority);
         getSetting(HASH_COUNT, first, &ruleAction->value.c.count);
-        getSetting(HASH_SPAN, first, &ruleAction->value.c.span);
         getSetting(HASH_CAP, first, &ruleAction->value.c.cap);
         if (!ruleAction->value.c.count && !ruleAction->value.c.span && !ruleAction->value.c.cap) {
             ruleAction->value.c.count = 1;

data/src/rules/state.c

@@ -6,15 +6,13 @@
 #include "json.h"
 #include "net.h"
 
-unsigned int djbHash(char *str, unsigned int len) {
-   unsigned int hash = 5381;
-   unsigned int i = 0;
-
-   for(i = 0; i < len; str++, i++) {
-      hash = ((hash << 5) + hash) + (*str);
-   }
-
-   return hash;
+unsigned int fnv1Hash32(char *str, unsigned int len) {
+    unsigned int hash = FNV_32_OFFSET_BASIS;
+    for(unsigned int i = 0; i < len; str++, i++) {
+        hash ^= (*str);
+        hash *= FNV_32_PRIME;
+    }
+    return hash;
 }
 
 static unsigned int evictEntry(ruleset *tree) {
@@ -43,7 +41,7 @@ static unsigned int evictEntry(ruleset *tree) {
                 current->sidHash = 0;
                 current->bindingIndex = 0;
                 current->lastRefresh = 0;
-                current->propertiesLength = 0;
+                current->jo.propertiesLength = 0;
                 found = 1;
             }
         }
@@ -164,15 +162,70 @@ static stateEntry *getEntry(ruleset *tree, char *sid, unsigned int sidHash) {
     return NULL;
 }
 
+static unsigned int fixupIds(jsonObject *jo) {
+    jsonProperty *property;
+    // id and sid are coerced to strings
+    // to avoid unnecessary conversions
+    if (jo->sidIndex != UNDEFINED_INDEX && jo->properties[jo->sidIndex].type != JSON_NIL) {
+        //coerce value to string
+        property = &jo->properties[jo->sidIndex];
+        if (property->type == JSON_DOUBLE || property->type == JSON_INT) {
+            ++property->valueLength;
+        }
+
+        property->type = JSON_STRING;
+    } else {
+        property = &jo->properties[jo->propertiesLength];
+        jo->sidIndex = jo->propertiesLength;
+        ++jo->propertiesLength;
+        if (jo->propertiesLength == MAX_OBJECT_PROPERTIES) {
+            return ERR_EVENT_MAX_PROPERTIES;
+        }
+
+        strncpy(jo->sidBuffer, "0", 1);
+        property->hash = HASH_SID;
+        property->isMaterial = 1;
+        property->valueString = jo->sidBuffer;
+        property->valueLength = 1;
+        strncpy(property->name, "sid", 3);
+        property->nameLength = 3;
+        property->type = JSON_STRING;
+    } 
+
+    if (jo->idIndex != UNDEFINED_INDEX && jo->properties[jo->idIndex].type != JSON_NIL) {
+        //coerce value to string
+        property = &jo->properties[jo->idIndex];
+        if (property->type == JSON_DOUBLE || property->type == JSON_INT) {
+            ++property->valueLength;
+        }
+
+        property->type = JSON_STRING;
+    } else {
+        property = &jo->properties[jo->propertiesLength];
+        jo->idIndex = jo->propertiesLength;
+        ++jo->propertiesLength;
+        if (jo->propertiesLength == MAX_OBJECT_PROPERTIES) {
+            return ERR_EVENT_MAX_PROPERTIES;
+        }
+
+        jo->idBuffer[0] = 0;
+        property->hash = HASH_ID;
+        property->isMaterial = 1;
+        property->valueString = jo->idBuffer;
+        property->valueLength = 0;
+        strncpy(property->name, "id", 2);
+        property->nameLength = 2;
+        property->type = JSON_STRING;
+    }
+
+    return RULES_OK;
+}
+
 unsigned int constructObject(char *root,
                              char *parentName, 
                              char *object,
-                             char createHashtable,
-                             unsigned int maxProperties,
-                             jsonProperty *properties, 
-                             unsigned int *propertiesLength, 
-                             unsigned int *midIndex, 
-                             unsigned int *sidIndex,
+                             char layout,
+                             jsonObject *jo,
                              char **next) {
     char *firstName;
     char *lastName;
@@ -180,7 +233,16 @@ unsigned int constructObject(char *root,
     char *last;
     unsigned char type;
     unsigned int hash;
-    int parentNameLength = (parentName ? strlen(parentName): 0);
+    int parentNameLength;
+    if (parentName) {
+        parentNameLength = strlen(parentName);
+    } else {
+        parentNameLength = 0;
+        jo->idIndex = UNDEFINED_INDEX;
+        jo->sidIndex = UNDEFINED_INDEX;
+        jo->propertiesLength = 0;
+    }
+
     object = (object ? object : root);
     unsigned int result = readNextName(object, &firstName, &lastName, &hash);
     while (result == PARSE_OK) {
@@ -191,35 +253,40 @@ unsigned int constructObject(char *root,
 
         jsonProperty *property = NULL;
         if (type != JSON_OBJECT) {
-            if (!createHashtable) {
-                property = &properties[*propertiesLength];
-                if (hash == HASH_ID) {
-                    *midIndex = *propertiesLength;
-                } else if (hash == HASH_SID) {
-                    *sidIndex = *propertiesLength;
-                }
-            } else {
-                unsigned int candidate = hash % maxProperties;
-                while (properties[candidate].type != 0) {
-                    candidate = (candidate + 1) % maxProperties;
-                }
-
-                if (hash == HASH_ID) {
-                    *midIndex = candidate;
-                } else if (hash == HASH_SID) {
-                    *sidIndex = candidate;
+            switch (layout) {
+                case JSON_OBJECT_SEQUENCED:
+                    property = &jo->properties[jo->propertiesLength];
+                    if (hash == HASH_ID) {
+                        jo->idIndex = jo->propertiesLength;
+                    } else if (hash == HASH_SID) {
+                        jo->sidIndex = jo->propertiesLength;
+                    }
+                    break;
+                case JSON_OBJECT_HASHED: 
+                {
+                    unsigned int candidate = hash % MAX_OBJECT_PROPERTIES;
+                    while (jo->properties[candidate].type != 0) {
+                        candidate = (candidate + 1) % MAX_OBJECT_PROPERTIES;
+                    }
+
+                    if (hash == HASH_ID) {
+                        jo->idIndex = candidate;
+                    } else if (hash == HASH_SID) {
+                        jo->sidIndex = candidate;
+                    }
+
+                    property = &jo->properties[candidate];
                 }
-
-                property = &properties[candidate];
-            } 
-
-            *propertiesLength = *propertiesLength + 1;
-            if (*propertiesLength == maxProperties) {
+                break;
+            }
+            
+            ++jo->propertiesLength;
+            if (jo->propertiesLength == MAX_OBJECT_PROPERTIES) {
                 return ERR_EVENT_MAX_PROPERTIES;
             }
 
             property->isMaterial = 0;
-            property->valueOffset = first - root;
+            property->valueString = first;
             property->valueLength = last - first;
             property->type = type;
         }
@@ -244,15 +311,11 @@ unsigned int constructObject(char *root,
                 strncpy(newParent, firstName, nameLength);
                 newParent[nameLength] = '\0';
                 result = constructObject(root,
-                                       newParent, 
-                                       first, 
-                                       createHashtable, 
-                                       maxProperties, 
-                                       properties, 
-                                       propertiesLength, 
-                                       midIndex, 
-                                       sidIndex, 
-                                       next);
+                                         newParent, 
+                                         first, 
+                                         layout, 
+                                         jo,
+                                         next);
                 if (result != RULES_OK) {
                     return result;
                 }
@@ -269,7 +332,7 @@ unsigned int constructObject(char *root,
                 property->name[parentNameLength] = '.';
                 strncpy(&property->name[parentNameLength + 1], firstName, nameLength);
                 property->nameLength = fullNameLength;
-                property->hash = djbHash(property->name, fullNameLength);
+                property->hash = fnv1Hash32(property->name, fullNameLength);
             } else {
 #ifdef _WIN32
                 char *fullName = (char *)_alloca(sizeof(char)*(fullNameLength + 1));
@@ -281,15 +344,11 @@ unsigned int constructObject(char *root,
                 strncpy(&fullName[parentNameLength + 1], firstName, nameLength);
                 fullName[fullNameLength] = '\0';
                 result = constructObject(root,
-                                       fullName, 
-                                       first, 
-                                       createHashtable, 
-                                       maxProperties, 
-                                       properties, 
-                                       propertiesLength, 
-                                       midIndex, 
-                                       sidIndex, 
-                                       next);
+                                         fullName, 
+                                         first, 
+                                         layout, 
+                                         jo, 
+                                         next);
                 if (result != RULES_OK) {
                     return result;
                 }
@@ -300,15 +359,20 @@ unsigned int constructObject(char *root,
         result = readNextName(last, &firstName, &lastName, &hash);
     }
  
+    if (!parentName) {
+        int idResult = fixupIds(jo);
+        if (idResult != RULES_OK) {
+            return idResult;
+        }
+    }
+
     return (result == PARSE_END ? RULES_OK: result);
 }
 
 void rehydrateProperty(jsonProperty *property, char *state) {
-    // ID and SID are treated as strings regardless of type
-    // to avoid unnecessary conversions
-    if (!property->isMaterial && property->hash != HASH_ID && property->hash != HASH_SID) {
+    if (!property->isMaterial) {
         unsigned short propertyLength = property->valueLength + 1;
-        char *propertyFirst = state + property->valueOffset;
+        char *propertyFirst = property->valueString;
         unsigned char propertyType = property->type;
         unsigned char b = 0;
         char temp;
@@ -343,7 +407,7 @@ static unsigned int resolveBindingAndEntry(ruleset *tree,
                                           char *sid, 
                                           stateEntry **entry,
                                           void **rulesBinding) {   
-    unsigned int sidHash = djbHash(sid, strlen(sid));
+    unsigned int sidHash = fnv1Hash32(sid, strlen(sid));
     if (!ensureEntry(tree, sid, sidHash, entry)) {
         unsigned int result = getBindingIndex(tree, sidHash, &(*entry)->bindingIndex);
         if (result != RULES_OK) {
@@ -386,20 +450,14 @@ unsigned int refreshState(void *handle,
         return result;
     }
 
-    memset(entry->properties, 0, MAX_STATE_PROPERTIES * sizeof(jsonProperty));
-    entry->propertiesLength = 0;
+    memset(entry->jo.properties, 0, MAX_OBJECT_PROPERTIES * sizeof(jsonProperty));
+    entry->jo.propertiesLength = 0;
     char *next;
-    unsigned int midIndex = UNDEFINED_INDEX;
-    unsigned int sidIndex = UNDEFINED_INDEX;
     result =  constructObject(entry->state,
                              NULL, 
                              NULL, 
-                             1, 
-                             MAX_STATE_PROPERTIES, 
-                             entry->properties, 
-                             &entry->propertiesLength, 
-                             &midIndex, 
-                             &sidIndex, 
+                             JSON_OBJECT_HASHED, 
+                             &entry->jo, 
                              &next);
     if (result != RULES_OK) {
         return result;
@@ -416,7 +474,7 @@ unsigned int fetchStateProperty(void *tree,
                                 unsigned char ignoreStaleState,
                                 char **state,
                                 jsonProperty **property) {
-    unsigned int sidHash = djbHash(sid, strlen(sid));
+    unsigned int sidHash = fnv1Hash32(sid, strlen(sid));
     stateEntry *entry = getEntry(tree, sid, sidHash);
     if (entry == NULL || entry->lastRefresh == 0) {
         return ERR_STATE_NOT_LOADED;
@@ -426,11 +484,11 @@ unsigned int fetchStateProperty(void *tree,
         return ERR_STALE_STATE;
     }
 
-    unsigned int propertyIndex = propertyHash % MAX_STATE_PROPERTIES;
-    jsonProperty *result = &entry->properties[propertyIndex];
+    unsigned int propertyIndex = propertyHash % MAX_OBJECT_PROPERTIES;
+    jsonProperty *result = &entry->jo.properties[propertyIndex];
     while (result->type != 0 && result->hash != propertyHash) {
-        propertyIndex = (propertyIndex + 1) % MAX_STATE_PROPERTIES;  
-        result = &entry->properties[propertyIndex];   
+        propertyIndex = (propertyIndex + 1) % MAX_OBJECT_PROPERTIES;  
+        result = &entry->jo.properties[propertyIndex];   
     }
 
     if (!result->type) {