durable_rules 2.0.10 → 2.0.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: '08354a5b9d64bb706031205f0710774dfe373110'
-  data.tar.gz: 32d5ec3373973b43b23510c30319215229080f9d
+  metadata.gz: 6dcf2ede6d2bd9909805f783b0bf914cd85c4c8e
+  data.tar.gz: 5d614d930ce359ac46d0ff33b76c64dc3004840e
 SHA512:
-  metadata.gz: 700351f9793a3bdc225208dbfcc85461c72f2640348f74831f616bc82bbc293fa7adc8da9377c62a4ea3152343cf3b0ccf94398436f50e61a013ee59890c26bd
-  data.tar.gz: a5d572adc4e81d3b79bc9f51bd889f95ff77e592c86ef614b4637838265dc3527a527e8996606098ba2b8e944a094f4936ed685f7eae945d0da3e40ff1dabf01
+  metadata.gz: a51d1872c5ac2696591a5aea0a75a84c5176a067e157ae69d8a9c506227910bc9111a75b90b2bf6299272b52c4d1d278ed46b7629ca9a3412256dd203d31899f
+  data.tar.gz: 9972206de9323de12674942bc4993d022fb0808f7be3559fa62ff468bb61e1ba87c25a4516e15025c8996701603e64cf1e2c0cb15aebc2839cb85289eff3ac30

data/src/rules/events.c

@@ -1449,7 +1449,7 @@ static unsigned int isNextMatch(ruleset *tree,
             }
         }
     }
-    
+
     if (currentAlpha->nextOffset) {
         unsigned int *nextHashset = &tree->nextPool[currentAlpha->nextOffset];
         for(unsigned int propertyIndex = 0; propertyIndex < jo->propertiesLength; ++propertyIndex) {
@@ -1532,8 +1532,8 @@ static unsigned int isArrayMatch(ruleset *tree,
                                            last - first + 1));
         }
 
-        if (arrayAlpha->nextListOffset) {
-            unsigned int *nextList = &tree->nextPool[arrayAlpha->nextListOffset];
+        if (arrayAlpha->arrayListOffset) {
+            unsigned int *nextList = &tree->nextPool[arrayAlpha->arrayListOffset];
             for (unsigned int entry = 0; nextList[entry] != 0; ++entry) {
                 node *listNode = &tree->nodePool[nextList[entry]];
                 jsonProperty *currentProperty;
@@ -1553,45 +1553,44 @@ static unsigned int isArrayMatch(ruleset *tree,
                     
                 }
             }
-        }
+        } 
 
-        if (!*propertyMatch) {
-            if (arrayAlpha->arrayListOffset) {
-                unsigned int *nextHashset = &tree->nextPool[arrayAlpha->arrayListOffset];
-                for(unsigned int propertyIndex = 0; propertyIndex < jo.propertiesLength; ++propertyIndex) {
-                    jsonProperty *currentProperty = &jo.properties[propertyIndex];
-                    for (unsigned int entry = currentProperty->hash & HASH_MASK; nextHashset[entry] != 0; entry = (entry + 1) % NEXT_BUCKET_LENGTH) {
-                        node *hashNode = &tree->nodePool[nextHashset[entry]]; 
-                        if (currentProperty->hash == hashNode->value.a.expression.left.value.id.propertyNameHash) {
-                            if (hashNode->value.a.expression.operator == OP_IALL || hashNode->value.a.expression.operator == OP_IANY) {
-                                CHECK_RESULT(isArrayMatch(tree,
-                                                          &jo,
-                                                          currentProperty, 
-                                                          &hashNode->value.a,
-                                                          propertyMatch));
-                            } else {
-                                CHECK_RESULT(isAlphaMatch(tree, 
-                                                          &hashNode->value.a,
-                                                          &jo, 
-                                                          propertyMatch));
-                            }
+        if (!*propertyMatch && arrayAlpha->arrayOffset) {
+            unsigned int *nextHashset = &tree->nextPool[arrayAlpha->arrayOffset];
+            for(unsigned int propertyIndex = 0; propertyIndex < jo.propertiesLength; ++propertyIndex) {
+                jsonProperty *currentProperty = &jo.properties[propertyIndex];
+                for (unsigned int entry = currentProperty->hash & HASH_MASK; nextHashset[entry] != 0; entry = (entry + 1) % NEXT_BUCKET_LENGTH) {
+                    node *hashNode = &tree->nodePool[nextHashset[entry]]; 
+                    if (currentProperty->hash == hashNode->value.a.expression.left.value.id.propertyNameHash) {
+                        if (hashNode->value.a.expression.operator == OP_IALL || hashNode->value.a.expression.operator == OP_IANY) {
+                            CHECK_RESULT(isArrayMatch(tree,
+                                                      &jo,
+                                                      currentProperty, 
+                                                      &hashNode->value.a,
+                                                      propertyMatch));
+                        } else {
+                            CHECK_RESULT(isAlphaMatch(tree, 
+                                                      &hashNode->value.a,
+                                                      &jo, 
+                                                      propertyMatch));
+                        }
 
-                            if (*propertyMatch && hashNode->value.a.nextOffset) {
-                                CHECK_RESULT(isNextMatch(tree,
-                                                         &jo,
-                                                         &hashNode->value.a,
-                                                         propertyMatch));
+                        if (*propertyMatch && (hashNode->value.a.nextOffset || hashNode->value.a.nextListOffset)) {
+                            CHECK_RESULT(isNextMatch(tree,
+                                                     &jo,
+                                                     &hashNode->value.a,
+                                                     propertyMatch));
 
-                            }
+                        }
 
-                            if (*propertyMatch && (hashNode->value.a.nextOffset || hashNode->value.a.nextListOffset)) {
-                                break;
-                            }  
-                        } 
-                    }
+                        if (*propertyMatch && (hashNode->value.a.nextOffset || hashNode->value.a.nextListOffset)) {
+                            break;
+                        }  
+                    } 
                 }
             }
         }
+        
 
         // OP_IANY, one element led a a valid path
         // OP_IALL, all elements led to a valid path

data/src/rules/rete.c

@@ -156,6 +156,7 @@ static unsigned int storeAlpha(ruleset *tree,
         return result;
     }
 
+    (*newNode)->value.a.arrayOffset = 0;
     (*newNode)->value.a.arrayListOffset = 0;
     (*newNode)->value.a.nextListOffset = 0;
     (*newNode)->value.a.betaListOffset = 0;
@@ -190,9 +191,9 @@ static unsigned int allocateNext(ruleset *tree,
     return RULES_OK;
 }
 
-static unsigned int ensureNextArrayHashset(ruleset *tree, node *newNode) {
-    if (!newNode->value.a.arrayListOffset) {
-        return allocateNext(tree, NEXT_BUCKET_LENGTH, &newNode->value.a.arrayListOffset);
+static unsigned int ensureArrayHashset(ruleset *tree, node *newNode) {
+    if (!newNode->value.a.arrayOffset) {
+        return allocateNext(tree, NEXT_BUCKET_LENGTH, &newNode->value.a.arrayOffset);
     }
 
     return RULES_OK;
@@ -206,6 +207,14 @@ static unsigned int ensureNextHashset(ruleset *tree, node *newNode) {
     return RULES_OK;
 }
 
+static unsigned int ensureArrayList(ruleset *tree, node *newNode) {
+    if (!newNode->value.a.arrayListOffset) {
+        return allocateNext(tree, NEXT_LIST_LENGTH, &newNode->value.a.arrayListOffset);
+    }
+
+    return RULES_OK;
+}
+
 static unsigned int ensureNextList(ruleset *tree, node *newNode) {
     if (!newNode->value.a.nextListOffset) {
         return allocateNext(tree, NEXT_LIST_LENGTH, &newNode->value.a.nextListOffset);
@@ -785,10 +794,19 @@ static unsigned int linkAlpha(ruleset *tree,
 
         parentBetaList[entry] = nextOffset;
     } else if (nextNode->value.a.expression.operator == OP_NEX) {
-        CHECK_RESULT(ensureNextList(tree, 
-                                    parentAlpha));
-        
-        unsigned int *parentNextList = &tree->nextPool[parentAlpha->value.a.nextListOffset];
+        unsigned int *parentNextList = NULL;
+        if ((parentAlpha->value.a.expression.operator == OP_IALL || parentAlpha->value.a.expression.operator == OP_IANY) && linkToArray) {
+            CHECK_RESULT(ensureArrayList(tree, 
+                                         parentAlpha));
+
+            parentNextList = &tree->nextPool[parentAlpha->value.a.arrayListOffset];
+        } else {
+            CHECK_RESULT(ensureNextList(tree, 
+                                        parentAlpha));
+
+            parentNextList = &tree->nextPool[parentAlpha->value.a.nextListOffset];
+        }
+
         unsigned int entry;
         for (entry = 0; parentNextList[entry] != 0; ++entry) {
             if (entry == NEXT_LIST_LENGTH) {
@@ -800,10 +818,10 @@ static unsigned int linkAlpha(ruleset *tree,
     } else {
         unsigned int *parentNext = NULL;
         if ((parentAlpha->value.a.expression.operator == OP_IALL || parentAlpha->value.a.expression.operator == OP_IANY) && linkToArray) {
-            CHECK_RESULT(ensureNextArrayHashset(tree, 
+            CHECK_RESULT(ensureArrayHashset(tree, 
                                                 parentAlpha));
 
-            parentNext = &tree->nextPool[parentAlpha->value.a.arrayListOffset];
+            parentNext = &tree->nextPool[parentAlpha->value.a.arrayOffset];
         } else {
             CHECK_RESULT(ensureNextHashset(tree, 
                                            parentAlpha));
@@ -1097,7 +1115,10 @@ static unsigned int createForwardAlpha(ruleset *tree,
     
     newAlpha->nameOffset = 0;
     newAlpha->type = NODE_ALPHA;
+    newAlpha->value.a.arrayOffset = 0;
     newAlpha->value.a.arrayListOffset = 0;
+    newAlpha->value.a.nextOffset = 0;
+    newAlpha->value.a.nextListOffset = 0;
     newAlpha->value.a.expression.left.type = JSON_MESSAGE_IDENTIFIER;
     newAlpha->value.a.expression.left.value.id.propertyNameOffset = 0;
     newAlpha->value.a.expression.left.value.id.propertyNameHash = HASH_FORWARD;
@@ -1280,7 +1301,7 @@ static unsigned int createAlpha(ruleset *tree,
                                          &first, 
                                          &last, 
                                          &type));
-        
+       
         CHECK_RESULT(createAlpha(tree, 
                                  first, 
                                  1,
@@ -1658,8 +1679,8 @@ static void printAlphaNode(ruleset *tree, node *alphaNode, int level, char *pref
     printSimpleExpression(tree, &alphaNode->value.a.expression, 1, NULL);
 
     printf("\n");
-    if (alphaNode->value.a.arrayListOffset) {
-        unsigned int *nextHashset = &tree->nextPool[alphaNode->value.a.arrayListOffset];
+    if (alphaNode->value.a.arrayOffset) {
+        unsigned int *nextHashset = &tree->nextPool[alphaNode->value.a.arrayOffset];
         for (unsigned int entry = 0; entry < NEXT_BUCKET_LENGTH; ++entry) { 
             if (nextHashset[entry]) {
                 printAlphaNode(tree, &tree->nodePool[nextHashset[entry]], level + 1, "Next Array ", nextHashset[entry]);  
@@ -1676,6 +1697,13 @@ static void printAlphaNode(ruleset *tree, node *alphaNode, int level, char *pref
         }  
     }
 
+    if (alphaNode->value.a.arrayListOffset) {
+        unsigned int *nextList = &tree->nextPool[alphaNode->value.a.arrayListOffset];
+        for (unsigned int entry = 0; nextList[entry] != 0; ++entry) {
+            printAlphaNode(tree, &tree->nodePool[nextList[entry]], level + 1, "Next Array List ", nextList[entry]);
+        }
+    }
+
     if (alphaNode->value.a.nextListOffset) {
         unsigned int *nextList = &tree->nextPool[alphaNode->value.a.nextListOffset];
         for (unsigned int entry = 0; nextList[entry] != 0; ++entry) {

data/src/rules/rete.h

@@ -87,6 +87,7 @@ typedef struct alpha {
     unsigned int betaListOffset;
     unsigned int nextListOffset;
     unsigned int arrayListOffset;
+    unsigned int arrayOffset;
     unsigned int nextOffset;
 } alpha;
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: durable_rules
 version: !ruby/object:Gem::Version
-  version: 2.0.10
+  version: 2.0.11
 platform: ruby
 authors:
 - Jesus Ruiz
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-10-06 00:00:00.000000000 Z
+date: 2019-10-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake