durable_rules 2.0.9 → 2.0.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: cfa1e57dda8143326832f1c3fda960c12f1c86b5
-  data.tar.gz: f448dd2fe6abcbb32f56f33e33f3048e4ab0fb10
+  metadata.gz: '08354a5b9d64bb706031205f0710774dfe373110'
+  data.tar.gz: 32d5ec3373973b43b23510c30319215229080f9d
 SHA512:
-  metadata.gz: 7d58e95f7a9364dc84a1296c6db45fcefbabcf4c54e01c904e2d41722a482ae4d384ebaaaa1b9ff3f9a91c4396fb26c8126ac3be3a1c7c1041bc682156ab3d01
-  data.tar.gz: ee9107a906fe6e38519d43805a7a790406d6e677aba8a4074a27c6fd4d98bb92b07960296f3a22d76f59247861b4c5d387082eac2f2997711af9ba45c191fb01
+  metadata.gz: 700351f9793a3bdc225208dbfcc85461c72f2640348f74831f616bc82bbc293fa7adc8da9377c62a4ea3152343cf3b0ccf94398436f50e61a013ee59890c26bd
+  data.tar.gz: a5d572adc4e81d3b79bc9f51bd889f95ff77e592c86ef614b4637838265dc3527a527e8996606098ba2b8e944a094f4936ed685f7eae945d0da3e40ff1dabf01

data/src/rules/events.c

@@ -156,8 +156,8 @@ static unsigned int reduceBool(unsigned char left,
     return RULES_OK;
 }
 
-static unsigned int reduceInt(long left, 
-                              long right, 
+static unsigned int reduceInt(long long left, 
+                              long long right, 
                               unsigned char op,
                               jsonProperty *targetProperty) {
     switch(op) {
@@ -354,10 +354,10 @@ static unsigned int reduceProperties(unsigned char operator,
             {
 #ifdef _WIN32
                 char *leftString = (char *)_alloca(sizeof(char)*(MAX_INT_LENGTH + 1));
-                sprintf_s(leftString, sizeof(char)*(MAX_INT_LENGTH + 1), "%ld", leftProperty->value.i);
+                sprintf_s(leftString, sizeof(char)*(MAX_INT_LENGTH + 1), "%lld", leftProperty->value.i);
 #else
                 char leftString[MAX_INT_LENGTH + 1];
-                snprintf(leftString, sizeof(char)*(MAX_INT_LENGTH + 1), "%ld", leftProperty->value.i);
+                snprintf(leftString, sizeof(char)*(MAX_INT_LENGTH + 1), "%lld", leftProperty->value.i);
 #endif         
                 return reduceString(leftString,
                                     leftProperty->valueLength,
@@ -403,10 +403,10 @@ static unsigned int reduceProperties(unsigned char operator,
             {
 #ifdef _WIN32
                 char *rightString = (char *)_alloca(sizeof(char)*(MAX_INT_LENGTH + 1));
-                sprintf_s(rightString, sizeof(char)*(MAX_INT_LENGTH + 1), "%ld", rightProperty->value.i);
+                sprintf_s(rightString, sizeof(char)*(MAX_INT_LENGTH + 1), "%lld", rightProperty->value.i);
 #else
                 char rightString[MAX_INT_LENGTH + 1];
-                snprintf(rightString, sizeof(char)*(MAX_INT_LENGTH + 1), "%ld", rightProperty->value.i);
+                snprintf(rightString, sizeof(char)*(MAX_INT_LENGTH + 1), "%lld", rightProperty->value.i);
 #endif         
                 return reduceString(leftProperty->value.s,
                                     leftProperty->valueLength,
@@ -617,10 +617,10 @@ static unsigned int getFrameHashForExpression(ruleset *tree,
         {
 #ifdef _WIN32
             char *string = (char *)_alloca(sizeof(char)*(MAX_INT_LENGTH + 1));
-            sprintf_s(string, sizeof(char)*(MAX_INT_LENGTH + 1), "%ld", property->value.i);
+            sprintf_s(string, sizeof(char)*(MAX_INT_LENGTH + 1), "%lld", property->value.i);
 #else
             char string[MAX_INT_LENGTH + 1];
-            snprintf(string, sizeof(char)*(MAX_INT_LENGTH + 1), "%ld", property->value.i);
+            snprintf(string, sizeof(char)*(MAX_INT_LENGTH + 1), "%lld", property->value.i);
 #endif   
             *hash = fnv1Hash32(string, strlen(string));
             break;
@@ -716,7 +716,6 @@ static unsigned int isAlphaMatch(ruleset *tree,
                                  alpha *currentAlpha,
                                  jsonObject *messageObject,
                                  unsigned char *propertyMatch) {
-
     *propertyMatch = 0;
     if (currentAlpha->expression.operator == OP_EX) {
         *propertyMatch = 1;
@@ -1444,47 +1443,49 @@ static unsigned int isNextMatch(ruleset *tree,
                 }    
 
                 if (*propertyMatch) {
-                    break;
+                    return RULES_OK;
                 }
                 
             }
         }
     }
-
+    
     if (currentAlpha->nextOffset) {
         unsigned int *nextHashset = &tree->nextPool[currentAlpha->nextOffset];
         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 (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));
-                }
+                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 || hashNode->value.a.nextListOffset)) {
-                    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) {
-                    break;
-                }   
+                    if (*propertyMatch) {
+                        break;
+                    }   
+                }
             }
         }
     }   
-    
+
     return RULES_OK;
 }
 
@@ -1493,6 +1494,7 @@ static unsigned int isArrayMatch(ruleset *tree,
                                  jsonProperty *currentProperty,
                                  alpha *arrayAlpha,
                                  unsigned char *propertyMatch) {
+    
     unsigned int result = RULES_OK;
     if (currentProperty->type != JSON_ARRAY) {
         return RULES_OK;
@@ -1553,42 +1555,44 @@ static unsigned int isArrayMatch(ruleset *tree,
             }
         }
 
-        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) {
+            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 && hashNode->value.a.nextOffset) {
-                            CHECK_RESULT(isNextMatch(tree,
-                                                     &jo,
-                                                     &hashNode->value.a,
-                                                     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)) {
-                            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
         if ((arrayAlpha->expression.operator == OP_IALL && !*propertyMatch) ||
@@ -1988,7 +1992,7 @@ unsigned int retractFacts(unsigned int handle,
     ruleset *tree;
     RESOLVE_HANDLE(handle, &tree);
 
-    return handleMessages(tree, ACTION_ASSERT_EVENT, messages, stateOffset);
+    return handleMessages(tree, ACTION_RETRACT_FACT, messages, stateOffset);
 }
 
 unsigned int updateState(unsigned int handle, 

data/src/rules/state.c

@@ -1397,7 +1397,7 @@ unsigned int setObjectProperty(jsonObject *jo,
         case JSON_INT:
             temp = first[property->valueLength];
             first[property->valueLength] = '\0';
-            property->value.i = atol(first);
+            property->value.i = atoll(first);
             first[property->valueLength] = temp;
             break;
         case JSON_DOUBLE:

data/src/rules/state.h

@@ -67,7 +67,7 @@ typedef struct jsonProperty {
     unsigned short valueOffset;
     unsigned short valueLength;
     union {
-        long i; 
+        long long i; 
         double d; 
         unsigned char b; 
         char *s;

metadata

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