durable_rules 0.34.47 → 0.34.48

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8c244607aab331ef3e18e6251cd5b01a5dfb2a71
-  data.tar.gz: 0bec05ac51c6379c7b906d050622a78e534092ab
+  metadata.gz: 48d84abbe4090ab34d7cdc91409cf4d8051afce1
+  data.tar.gz: 196e6c8eb885f12d46a32deaaf6d6d0161e6ec44
 SHA512:
-  metadata.gz: a6b9c5cbe40df7dee845ad23682a13bfc730c444e3f3b1586778cd259d0d41f2a28bd4070b9ff0f873158055b8afd31483f6f70bc2ca0bb6036592a8b6964811
-  data.tar.gz: 7bffaa80fb9a37adc92c26e41238269bf8164f0044817002449ad93b1ace7f829d004b1a0e160cc52ff3331a610a02f1c955bb48913f6943118a029424f1d780
+  metadata.gz: 109df08236d6b157e1f631ea502960ae5205ecdeef2a7bb55769978bbd7b62f1b4988e5154b602f6a2ac125c2927956bf39e3bce48add692549d4fc58b7a6e5c
+  data.tar.gz: 8971e18c1d4b4a479e29712db7fa3fec15de5df1c511aa7bf705fcf6da0e10d1a5ecf9b0a705b15cd92bdb8501b31b66888702ba68980a82278ea3902cfa5f98

data/src/rules/events.c

@@ -1430,7 +1430,7 @@ static unsigned int handleMessage(ruleset *tree,
                             rulesBinding);
 }
 
-static unsigned int handleMessages(void *handle, 
+static unsigned int handleMessages(ruleset *tree, 
                                    unsigned char actionType,
                                    char *messages, 
                                    char **commands,
@@ -1464,7 +1464,7 @@ static unsigned int handleMessages(void *handle,
 
         lastTemp = *last;
         *last = '\0';
-        result = handleMessageCore(handle,
+        result = handleMessageCore(tree,
                                  NULL, 
                                  first, 
                                  &jo, 
@@ -1528,12 +1528,12 @@ static unsigned int handleState(ruleset *tree,
     return result;
 }
 
-static unsigned int handleTimers(void *handle, 
+static unsigned int handleTimers(ruleset *tree, 
                                  char **commands,
                                  unsigned int *commandCount,
                                  void **rulesBinding) {
     redisReply *reply;
-    unsigned int result = peekTimers(handle, rulesBinding, &reply);
+    unsigned int result = peekTimers(tree, rulesBinding, &reply);
     if (result != RULES_OK) {
         return result;
     }
@@ -1565,7 +1565,7 @@ static unsigned int handleTimers(void *handle,
 
         commands[*commandCount] = command;
         ++*commandCount;
-        result = handleMessage(handle, 
+        result = handleMessage(tree, 
                                NULL,
                                reply->element[i]->str + 2, 
                                action,
@@ -1582,14 +1582,14 @@ static unsigned int handleTimers(void *handle,
     return RULES_OK;
 }
 
-static unsigned int startHandleMessage(void *handle, 
+static unsigned int startHandleMessage(ruleset *tree, 
                                        char *message, 
                                        unsigned char actionType,
                                        void **rulesBinding,
                                        unsigned int *replyCount) {
     char *commands[MAX_COMMAND_COUNT];
     unsigned int commandCount = 0;
-    unsigned int result = handleMessage(handle, 
+    unsigned int result = handleMessage(tree, 
                                         NULL,
                                         message, 
                                         actionType, 
@@ -1609,13 +1609,13 @@ static unsigned int startHandleMessage(void *handle,
     return result;
 }
 
-static unsigned int executeHandleMessage(void *handle, 
+static unsigned int executeHandleMessage(ruleset *tree, 
                                          char *message, 
                                          unsigned char actionType) {
     char *commands[MAX_COMMAND_COUNT];
     unsigned int commandCount = 0;
     void *rulesBinding = NULL;
-    unsigned int result = handleMessage(handle, 
+    unsigned int result = handleMessage(tree, 
                                         NULL,
                                         message, 
                                         actionType, 
@@ -1635,14 +1635,14 @@ static unsigned int executeHandleMessage(void *handle,
     return result;
 }
 
-static unsigned int startHandleMessages(void *handle, 
+static unsigned int startHandleMessages(ruleset *tree, 
                                         char *messages, 
                                         unsigned char actionType,
                                         void **rulesBinding,
                                         unsigned int *replyCount) {
     char *commands[MAX_COMMAND_COUNT];
     unsigned int commandCount = 0;
-    unsigned int result = handleMessages(handle,
+    unsigned int result = handleMessages(tree,
                                          actionType,
                                          messages,
                                          commands,
@@ -1661,13 +1661,13 @@ static unsigned int startHandleMessages(void *handle,
     return result;
 }
 
-static unsigned int executeHandleMessages(void *handle, 
+static unsigned int executeHandleMessages(ruleset *tree, 
                                           char *messages, 
                                           unsigned char actionType) {
     char *commands[MAX_COMMAND_COUNT];
     unsigned int commandCount = 0;
     void *rulesBinding = NULL;
-    unsigned int result = handleMessages(handle,
+    unsigned int result = handleMessages(tree,
                                          actionType,
                                          messages,
                                          commands,
@@ -1695,85 +1695,127 @@ unsigned int complete(void *rulesBinding, unsigned int replyCount) {
     return RULES_OK;
 }
 
-unsigned int assertEvent(void *handle, char *message) {
-    return executeHandleMessage(handle, message, ACTION_ASSERT_EVENT);
+unsigned int assertEvent(unsigned int handle, char *message) {
+    ruleset *tree;
+    RESOLVE_HANDLE(handle, &tree);
+
+    return executeHandleMessage(tree, message, ACTION_ASSERT_EVENT);
 }
 
-unsigned int startAssertEvent(void *handle, 
+unsigned int startAssertEvent(unsigned int handle, 
                              char *message, 
                              void **rulesBinding, 
                              unsigned int *replyCount) {
-    return startHandleMessage(handle, message, ACTION_ASSERT_EVENT, rulesBinding, replyCount);
+    ruleset *tree;
+    RESOLVE_HANDLE(handle, &tree);
+
+    return startHandleMessage(tree, message, ACTION_ASSERT_EVENT, rulesBinding, replyCount);
 }
 
-unsigned int assertEvents(void *handle, 
+unsigned int assertEvents(unsigned int handle, 
                           char *messages) {
-    return executeHandleMessages(handle, messages, ACTION_ASSERT_EVENT);
+    ruleset *tree;
+    RESOLVE_HANDLE(handle, &tree);
+
+    return executeHandleMessages(tree, messages, ACTION_ASSERT_EVENT);
 }
 
-unsigned int startAssertEvents(void *handle, 
+unsigned int startAssertEvents(unsigned int handle, 
                               char *messages, 
                               void **rulesBinding, 
                               unsigned int *replyCount) {
-    return startHandleMessages(handle, messages, ACTION_ASSERT_EVENT, rulesBinding, replyCount);
+    ruleset *tree;
+    RESOLVE_HANDLE(handle, &tree);
+
+    return startHandleMessages(tree, messages, ACTION_ASSERT_EVENT, rulesBinding, replyCount);
 }
 
-unsigned int retractEvent(void *handle, char *message) {
-    return executeHandleMessage(handle, message, ACTION_REMOVE_EVENT);
+unsigned int retractEvent(unsigned int handle, char *message) {
+    ruleset *tree;
+    RESOLVE_HANDLE(handle, &tree);
+
+    return executeHandleMessage(tree, message, ACTION_REMOVE_EVENT);
 }
 
-unsigned int startAssertFact(void *handle, 
+unsigned int startAssertFact(unsigned int handle, 
                              char *message, 
                              void **rulesBinding, 
                              unsigned int *replyCount) {
-    return startHandleMessage(handle, message, ACTION_ASSERT_FACT, rulesBinding, replyCount);
+    ruleset *tree;
+    RESOLVE_HANDLE(handle, &tree);
+
+    return startHandleMessage(tree, message, ACTION_ASSERT_FACT, rulesBinding, replyCount);
 }
 
-unsigned int assertFact(void *handle, char *message) {
-    return executeHandleMessage(handle, message, ACTION_ASSERT_FACT);
+unsigned int assertFact(unsigned int handle, char *message) {
+    ruleset *tree;
+    RESOLVE_HANDLE(handle, &tree);
+
+    return executeHandleMessage(tree, message, ACTION_ASSERT_FACT);
 }
 
-unsigned int startAssertFacts(void *handle, 
+unsigned int startAssertFacts(unsigned int handle, 
                               char *messages, 
-                             void **rulesBinding, 
-                             unsigned int *replyCount) {
-    return startHandleMessages(handle, messages, ACTION_ASSERT_FACT, rulesBinding, replyCount);
+                              void **rulesBinding, 
+                              unsigned int *replyCount) {
+    ruleset *tree;
+    RESOLVE_HANDLE(handle, &tree);
+
+    return startHandleMessages(tree, messages, ACTION_ASSERT_FACT, rulesBinding, replyCount);
 }
 
-unsigned int assertFacts(void *handle, 
-                          char *messages) {
-    return executeHandleMessages(handle, messages, ACTION_ASSERT_FACT);
+unsigned int assertFacts(unsigned int handle, 
+                         char *messages) {
+    ruleset *tree;
+    RESOLVE_HANDLE(handle, &tree);
+
+    return executeHandleMessages(tree, messages, ACTION_ASSERT_FACT);
 }
 
-unsigned int retractFact(void *handle, char *message) {
-    return executeHandleMessage(handle, message, ACTION_REMOVE_FACT);
+unsigned int retractFact(unsigned int handle, char *message) {
+    ruleset *tree;
+    RESOLVE_HANDLE(handle, &tree);
+
+    return executeHandleMessage(tree, message, ACTION_REMOVE_FACT);
 }
 
-unsigned int startRetractFact(void *handle, 
+unsigned int startRetractFact(unsigned int handle, 
                              char *message, 
                              void **rulesBinding, 
                              unsigned int *replyCount) {
-    return startHandleMessage(handle, message, ACTION_REMOVE_FACT, rulesBinding, replyCount);
+    ruleset *tree;
+    RESOLVE_HANDLE(handle, &tree);
+
+    return startHandleMessage(tree, message, ACTION_REMOVE_FACT, rulesBinding, replyCount);
 }
 
-unsigned int retractFacts(void *handle, 
+unsigned int retractFacts(unsigned int handle, 
                           char *messages) {
-    return executeHandleMessages(handle, messages, ACTION_REMOVE_FACT);
+    ruleset *tree;
+    RESOLVE_HANDLE(handle, &tree);
+
+    return executeHandleMessages(tree, messages, ACTION_REMOVE_FACT);
 }
 
-unsigned int startRetractFacts(void *handle, 
+unsigned int startRetractFacts(unsigned int handle, 
                               char *messages, 
                               void **rulesBinding, 
                               unsigned int *replyCount) {
-    return startHandleMessages(handle, messages, ACTION_REMOVE_FACT, rulesBinding, replyCount);
+    ruleset *tree;
+    RESOLVE_HANDLE(handle, &tree);
+
+    return startHandleMessages(tree, messages, ACTION_REMOVE_FACT, rulesBinding, replyCount);
 }
 
-unsigned int assertState(void *handle, char *sid, char *state) {
+unsigned int assertState(unsigned int handle, char *sid, char *state) {
+    ruleset *tree;
+    RESOLVE_HANDLE(handle, &tree);
+
     char *commands[MAX_COMMAND_COUNT];
     unsigned int commandCount = 0;
     void *rulesBinding = NULL;
 
-    unsigned int result = handleState(handle, 
+    unsigned int result = handleState(tree, 
                                       state, 
                                       commands,
                                       &commandCount,
@@ -1791,11 +1833,14 @@ unsigned int assertState(void *handle, char *sid, char *state) {
     return result;
 }
 
-unsigned int assertTimers(void *handle) {
+unsigned int assertTimers(unsigned int handle) {
+    ruleset *tree;
+    RESOLVE_HANDLE(handle, &tree);
+
     char *commands[MAX_COMMAND_COUNT];
     unsigned int commandCount = 0;
     void *rulesBinding = NULL;
-    unsigned int result = handleTimers(handle, 
+    unsigned int result = handleTimers(tree, 
                                        commands,
                                        &commandCount,
                                        &rulesBinding);
@@ -1812,14 +1857,17 @@ unsigned int assertTimers(void *handle) {
     return RULES_OK;
 }
 
-unsigned int startAction(void *handle, 
+unsigned int startAction(unsigned int handle, 
                          char **state, 
                          char **messages, 
                          void **actionHandle,
                          void **actionBinding) {
+    ruleset *tree;
+    RESOLVE_HANDLE(handle, &tree);
+
     redisReply *reply;
     void *rulesBinding;
-    unsigned int result = peekAction(handle, &rulesBinding, &reply);
+    unsigned int result = peekAction(tree, &rulesBinding, &reply);
     if (result != RULES_OK) {
         return result;
     }
@@ -1838,15 +1886,18 @@ unsigned int startAction(void *handle,
     return RULES_OK;
 }
 
-unsigned int startUpdateState(void *handle, 
+unsigned int startUpdateState(unsigned int handle, 
                               void *actionHandle, 
                               char *state,
                               void **rulesBinding,
                               unsigned int *replyCount) {
+    ruleset *tree;
+    RESOLVE_HANDLE(handle, &tree);
+
     char *commands[MAX_COMMAND_COUNT];
     unsigned int result = RULES_OK;
     unsigned int commandCount = 0;
-    result = handleState(handle, 
+    result = handleState(tree, 
                          state,
                          commands,
                          &commandCount,
@@ -1862,9 +1913,12 @@ unsigned int startUpdateState(void *handle,
 
 }
 
-unsigned int completeAction(void *handle, 
+unsigned int completeAction(unsigned int handle, 
                             void *actionHandle, 
                             char *state) {
+    ruleset *tree;
+    RESOLVE_HANDLE(handle, &tree);
+
     char *commands[MAX_COMMAND_COUNT];
     unsigned int commandCount = 0;
     actionContext *context = (actionContext*)actionHandle;
@@ -1880,7 +1934,7 @@ unsigned int completeAction(void *handle,
     }
 
     ++commandCount;
-    result = handleState(handle, 
+    result = handleState(tree, 
                          state,
                          commands,
                          &commandCount,
@@ -1902,7 +1956,7 @@ unsigned int completeAction(void *handle,
     return RULES_OK;
 }
 
-unsigned int completeAndStartAction(void *handle, 
+unsigned int completeAndStartAction(unsigned int handle, 
                                     unsigned int expectedReplies,
                                     void *actionHandle, 
                                     char **messages) {
@@ -1959,19 +2013,22 @@ unsigned int completeAndStartAction(void *handle,
     return RULES_OK;
 }
 
-unsigned int abandonAction(void *handle, void *actionHandle) {
+unsigned int abandonAction(unsigned int handle, void *actionHandle) {
     freeReplyObject(((actionContext*)actionHandle)->reply);
     free(actionHandle);
     return RULES_OK;
 }
 
-unsigned int queueMessage(void *handle, unsigned int queueAction, char *sid, char *destination, char *message) {
+unsigned int queueMessage(unsigned int handle, unsigned int queueAction, char *sid, char *destination, char *message) {
+    ruleset *tree;
+    RESOLVE_HANDLE(handle, &tree);
+
     void *rulesBinding;
     if (!sid) {
         sid = "0";
     }
 
-    unsigned int result = resolveBinding(handle, sid, &rulesBinding);
+    unsigned int result = resolveBinding(tree, sid, &rulesBinding);
     if (result != RULES_OK) {
         return result;
     }
@@ -1979,13 +2036,16 @@ unsigned int queueMessage(void *handle, unsigned int queueAction, char *sid, cha
     return registerMessage(rulesBinding, queueAction, destination, message);
 }
 
-unsigned int startTimer(void *handle, char *sid, unsigned int duration, char manualReset, char *timer) {
+unsigned int startTimer(unsigned int handle, char *sid, unsigned int duration, char manualReset, char *timer) {
+    ruleset *tree;
+    RESOLVE_HANDLE(handle, &tree);
+
     void *rulesBinding;
     if (!sid) {
         sid = "0";
     }
     
-    unsigned int result = resolveBinding(handle, sid, &rulesBinding);
+    unsigned int result = resolveBinding(tree, sid, &rulesBinding);
     if (result != RULES_OK) {
         return result;
     }
@@ -1993,13 +2053,16 @@ unsigned int startTimer(void *handle, char *sid, unsigned int duration, char man
     return registerTimer(rulesBinding, duration, manualReset, timer);
 }
 
-unsigned int cancelTimer(void *handle, char *sid, char *timerName) {
+unsigned int cancelTimer(unsigned int handle, char *sid, char *timerName) {
+    ruleset *tree;
+    RESOLVE_HANDLE(handle, &tree);
+
     void *rulesBinding;
     if (!sid) {
         sid = "0";
     }
 
-    unsigned int result = resolveBinding(handle, sid, &rulesBinding);
+    unsigned int result = resolveBinding(tree, sid, &rulesBinding);
     if (result != RULES_OK) {
         return result;
     }
@@ -2007,13 +2070,16 @@ unsigned int cancelTimer(void *handle, char *sid, char *timerName) {
     return removeTimer(rulesBinding, timerName);
 }
 
-unsigned int renewActionLease(void *handle, char *sid) {
+unsigned int renewActionLease(unsigned int handle, char *sid) {
+    ruleset *tree;
+    RESOLVE_HANDLE(handle, &tree);
+
     void *rulesBinding;
     if (!sid) {
         sid = "0";
     }
 
-    unsigned int result = resolveBinding(handle, sid, &rulesBinding);
+    unsigned int result = resolveBinding(tree, sid, &rulesBinding);
     if (result != RULES_OK) {
         return result;
     }

data/src/rules/net.c

@@ -2395,12 +2395,14 @@ static unsigned int loadCommands(ruleset *tree, binding *rulesBinding) {
     return RULES_OK;
 }
 
-unsigned int bindRuleset(void *handle, 
+unsigned int bindRuleset(unsigned int handle, 
                          char *host, 
                          unsigned int port, 
                          char *password,
                          unsigned char db) {
-    ruleset *tree = (ruleset*)handle;
+    ruleset *tree;
+    RESOLVE_HANDLE(handle, &tree);
+    
     bindingsList *list;
     if (tree->bindingsList) {
         list = tree->bindingsList;

data/src/rules/rete.c

@@ -58,6 +58,10 @@ typedef struct all {
     unsigned short expressionsLength;
 } all;
 
+unsigned int firstEmptyEntry = 1;
+unsigned int lastEmptyEntry = MAX_HANDLES -1;
+char entriesInitialized = 0;
+
 static unsigned int validateAlgebra(char *rule);
 
 static unsigned int createBeta(ruleset *tree, 
@@ -1880,7 +1884,8 @@ static unsigned int createTree(ruleset *tree, char *rules) {
     return RULES_OK;
 }
 
-unsigned int createRuleset(void **handle, char *name, char *rules, unsigned int stateCaheSize) {
+unsigned int createRuleset(unsigned int *handle, char *name, char *rules, unsigned int stateCaheSize) {
+    INITIALIZE_ENTRIES;
 
 #ifdef _PRINT
     printf("%s\n", rules);
@@ -1967,15 +1972,17 @@ unsigned int createRuleset(void **handle, char *name, char *rules, unsigned int
     newNode->type = NODE_ALPHA;
     newNode->value.a.operator = OP_END;
 
-    *handle = tree;
-
     // will use random numbers for state stored event mids
     srand(time(NULL));
+
+    CREATE_HANDLE(tree, handle);
     return createTree(tree, rules);
 }
 
-unsigned int deleteRuleset(void *handle) {
-    ruleset *tree = (ruleset*)(handle);
+unsigned int deleteRuleset(unsigned int handle) {
+    ruleset *tree;
+    RESOLVE_HANDLE(handle, &tree);
+
     deleteBindingsList(tree);
     free(tree->nodePool);
     free(tree->nextPool);
@@ -1996,10 +2003,13 @@ unsigned int deleteRuleset(void *handle) {
     }
     free(tree->state);
     free(tree);
+    DELETE_HANDLE(handle);
     return RULES_OK;
 }
 
-unsigned int createClient(void **handle, char *name, unsigned int stateCaheSize) {
+unsigned int createClient(unsigned int *handle, char *name, unsigned int stateCaheSize) {
+    INITIALIZE_ENTRIES;
+
     ruleset *tree = malloc(sizeof(ruleset));
     if (!tree) {
         return ERR_OUT_OF_MEMORY;
@@ -2033,12 +2043,14 @@ unsigned int createClient(void **handle, char *name, unsigned int stateCaheSize)
         return result;
     }
 
-    *handle = tree;
+    CREATE_HANDLE(tree, handle);
     return RULES_OK;
 }
 
-unsigned int deleteClient(void *handle) {
-    ruleset *tree = (ruleset*)(handle);
+unsigned int deleteClient(unsigned int handle) {
+    ruleset *tree;
+    RESOLVE_HANDLE(handle, &tree);
+    
     deleteBindingsList(tree);
     free(tree->stringPool);
     free(tree->stateBuckets);
@@ -2054,6 +2066,7 @@ unsigned int deleteClient(void *handle) {
     }
     
     free(tree);
+    DELETE_HANDLE(handle);
     return RULES_OK;
 }
 

data/src/rules/rules.h

@@ -10,6 +10,8 @@
 #define ERR_RULE_BETA_LIMIT_EXCEEDED 8
 #define ERR_RULE_WITHOUT_QUALIFIER 9
 #define ERR_SETTING_NOT_FOUND 10
+#define ERR_INVALID_HANDLE 11
+#define ERR_HANDLE_LIMIT_EXCEEDED 12
 #define ERR_PARSE_VALUE 101
 #define ERR_PARSE_STRING 102
 #define ERR_PARSE_NUMBER 103
@@ -56,24 +58,71 @@
 #define QUEUE_ASSERT_EVENT 2
 #define QUEUE_RETRACT_FACT 3
 
+#define MAX_HANDLES 131072
+
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-unsigned int createRuleset(void **handle, 
+
+typedef struct handleEntry {
+    void *content;
+    unsigned int nextEmptyEntry;
+} handleEntry;
+
+handleEntry handleEntries[MAX_HANDLES];
+extern unsigned int firstEmptyEntry;
+extern unsigned int lastEmptyEntry;
+extern char entriesInitialized;
+
+#define INITIALIZE_ENTRIES do { \
+    if (!entriesInitialized) { \
+        for (unsigned int i = 0; i < lastEmptyEntry; ++i) { \
+            handleEntries[i].content = NULL; \
+            handleEntries[i].nextEmptyEntry = i + 1; \
+        } \
+        handleEntries[lastEmptyEntry].nextEmptyEntry = 0; \
+        entriesInitialized = 1; \
+    } \
+} while(0)
+
+#define RESOLVE_HANDLE(h, cRef) do { \
+    if (h < 1 || h > MAX_HANDLES - 1) return ERR_INVALID_HANDLE; \
+    if (!handleEntries[h].content) return ERR_INVALID_HANDLE; \
+    *cRef = handleEntries[h].content; \
+} while(0)
+
+#define CREATE_HANDLE(c, hRef) do { \
+    if (firstEmptyEntry == 0) return ERR_HANDLE_LIMIT_EXCEEDED; \
+    handleEntries[firstEmptyEntry].content = c; \
+    *hRef = firstEmptyEntry; \
+    firstEmptyEntry = handleEntries[firstEmptyEntry].nextEmptyEntry; \
+} while(0)
+
+#define DELETE_HANDLE(h) do { \
+    if (h < 1 || h > MAX_HANDLES - 1) return ERR_INVALID_HANDLE; \
+    if (!handleEntries[h].content) return ERR_INVALID_HANDLE; \
+    handleEntries[h].content = NULL; \
+    handleEntries[h].nextEmptyEntry = 0; \
+    handleEntries[lastEmptyEntry].nextEmptyEntry = h; \
+    lastEmptyEntry = h; \
+    if (!firstEmptyEntry) firstEmptyEntry = lastEmptyEntry; \
+} while(0)
+
+unsigned int createRuleset(unsigned int *handle, 
                            char *name, 
                            char *rules, 
                            unsigned int stateCaheSize);
 
-unsigned int deleteRuleset(void *handle);
+unsigned int deleteRuleset(unsigned int handle);
 
-unsigned int createClient(void **handle, 
+unsigned int createClient(unsigned int *handle, 
                           char *name,
                           unsigned int stateCaheSize);
 
-unsigned int deleteClient(void *handle);
+unsigned int deleteClient(unsigned int handle);
 
-unsigned int bindRuleset(void *handle, 
+unsigned int bindRuleset(unsigned int handle, 
                          char *host, 
                          unsigned int port, 
                          char *password,
@@ -82,111 +131,111 @@ unsigned int bindRuleset(void *handle,
 unsigned int complete(void *rulesBinding, 
                       unsigned int replyCount);
 
-unsigned int assertEvent(void *handle, 
+unsigned int assertEvent(unsigned int handle, 
                          char *message);
 
-unsigned int startAssertEvent(void *handle, 
+unsigned int startAssertEvent(unsigned int handle, 
                              char *message, 
                              void **rulesBinding, 
                              unsigned int *replyCount);
 
-unsigned int assertEvents(void *handle, 
+unsigned int assertEvents(unsigned int handle, 
                           char *messages);
 
-unsigned int startAssertEvents(void *handle, 
+unsigned int startAssertEvents(unsigned int handle, 
                               char *messages, 
                               void **rulesBinding, 
                               unsigned int *replyCount);
 
-unsigned int retractEvent(void *handle, 
+unsigned int retractEvent(unsigned int handle, 
                           char *message);
 
-unsigned int startAssertFact(void *handle, 
+unsigned int startAssertFact(unsigned int handle, 
                              char *message, 
                              void **rulesBinding, 
                              unsigned int *replyCount);
 
-unsigned int assertFact(void *handle, 
+unsigned int assertFact(unsigned int handle, 
                         char *message);
 
-unsigned int startAssertFacts(void *handle, 
+unsigned int startAssertFacts(unsigned int handle, 
                               char *messages, 
                               void **rulesBinding, 
                               unsigned int *replyCount);
 
-unsigned int assertFacts(void *handle, 
+unsigned int assertFacts(unsigned int handle, 
                          char *messages);
 
-unsigned int retractFact(void *handle, 
+unsigned int retractFact(unsigned int handle, 
                          char *message);
 
-unsigned int startRetractFact(void *handle, 
+unsigned int startRetractFact(unsigned int handle, 
                              char *message, 
                              void **rulesBinding, 
                              unsigned int *replyCount);
 
-unsigned int retractFacts(void *handle, 
+unsigned int retractFacts(unsigned int handle, 
                           char *messages);
 
-unsigned int startRetractFacts(void *handle, 
+unsigned int startRetractFacts(unsigned int handle, 
                               char *messages, 
                               void **rulesBinding, 
                               unsigned int *replyCount);
 
-unsigned int startUpdateState(void *handle, 
+unsigned int startUpdateState(unsigned int handle, 
                               void *actionHandle, 
                               char *state,
                               void **rulesBinding,
                               unsigned int *replyCount);
 
-unsigned int assertState(void *handle,
+unsigned int assertState(unsigned int handle,
                          char *sid, 
                          char *state);
 
-unsigned int startAction(void *handle, 
+unsigned int startAction(unsigned int handle, 
                          char **state, 
                          char **messages, 
                          void **actionHandle,
                          void **actionBinding);
 
-unsigned int completeAction(void *handle, 
+unsigned int completeAction(unsigned int handle, 
                             void *actionHandle, 
                             char *state);
 
-unsigned int completeAndStartAction(void *handle, 
+unsigned int completeAndStartAction(unsigned int handle, 
                                     unsigned int expectedReplies,
                                     void *actionHandle, 
                                     char **messages);
 
-unsigned int abandonAction(void *handle, 
+unsigned int abandonAction(unsigned int handle, 
                            void *actionHandle);
 
-unsigned int startTimer(void *handle, 
+unsigned int startTimer(unsigned int handle, 
                         char *sid, 
                         unsigned int duration, 
                         char manualReset,
                         char *timer);
 
-unsigned int cancelTimer(void *handle, 
+unsigned int cancelTimer(unsigned int handle, 
                          char *sid, 
                          char *timerName);
 
-unsigned int queueMessage(void *handle,
+unsigned int queueMessage(unsigned int handle,
                           unsigned int queueAction, 
                           char *sid, 
                           char *destination, 
                           char *message);
 
-unsigned int assertTimers(void *handle);
+unsigned int assertTimers(unsigned int handle);
 
-unsigned int getState(void *handle, 
+unsigned int getState(unsigned int handle, 
                       char *sid, 
                       char **state);
 
-unsigned int deleteState(void *handle, 
+unsigned int deleteState(unsigned int handle, 
                          char *sid);
 
-unsigned int renewActionLease(void *handle, 
+unsigned int renewActionLease(unsigned int handle, 
                               char *sid);
 
 #ifdef _WIN32

data/src/rules/state.c

@@ -503,19 +503,19 @@ static unsigned int resolveBindingAndEntry(ruleset *tree,
     return RULES_OK;
 }
 
-unsigned int resolveBinding(void *handle, 
+unsigned int resolveBinding(void *tree, 
                             char *sid, 
                             void **rulesBinding) {  
     stateEntry *entry = NULL;
-    return resolveBindingAndEntry(handle, sid, &entry, rulesBinding);
+    return resolveBindingAndEntry(tree, sid, &entry, rulesBinding);
 }
 
-unsigned int refreshState(void *handle, 
+unsigned int refreshState(void *tree, 
                           char *sid) {
     unsigned int result;
     stateEntry *entry = NULL;  
     void *rulesBinding;
-    result = resolveBindingAndEntry(handle, sid, &entry, &rulesBinding);
+    result = resolveBindingAndEntry(tree, sid, &entry, &rulesBinding);
     if (result != RULES_OK) {
         return result;
     }
@@ -585,13 +585,16 @@ unsigned int fetchStateProperty(void *tree,
     return RULES_OK;    
 }
 
-unsigned int getState(void *handle, char *sid, char **state) {
+unsigned int getState(unsigned int handle, char *sid, char **state) {
+    ruleset *tree;
+    RESOLVE_HANDLE(handle, &tree);
+
     void *rulesBinding = NULL;
     if (!sid) {
         sid = "0";
     }
 
-    unsigned int result = resolveBinding(handle, sid, &rulesBinding);
+    unsigned int result = resolveBinding(tree, sid, &rulesBinding);
     if (result != RULES_OK) {
       return result;
     }
@@ -599,9 +602,9 @@ unsigned int getState(void *handle, char *sid, char **state) {
     return getSession(rulesBinding, sid, state);
 }
 
-unsigned int getStateVersion(void *handle, char *sid, unsigned long *stateVersion) {
+unsigned int getStateVersion(void *tree, char *sid, unsigned long *stateVersion) {
     void *rulesBinding = NULL;
-    unsigned int result = resolveBinding(handle, sid, &rulesBinding);
+    unsigned int result = resolveBinding(tree, sid, &rulesBinding);
     if (result != RULES_OK) {
       return result;
     }
@@ -610,17 +613,20 @@ unsigned int getStateVersion(void *handle, char *sid, unsigned long *stateVersio
 }
 
 
-unsigned int deleteState(void *handle, char *sid) {
+unsigned int deleteState(unsigned int handle, char *sid) {
+    ruleset *tree;
+    RESOLVE_HANDLE(handle, &tree);
+
     if (!sid) {
         sid = "0";
     }
 
     void *rulesBinding = NULL;
-    unsigned int result = resolveBinding(handle, sid, &rulesBinding);
+    unsigned int result = resolveBinding(tree, sid, &rulesBinding);
     if (result != RULES_OK) {
       return result;
     }
 
     unsigned int sidHash = fnv1Hash32(sid, strlen(sid));
-    return deleteSession(handle, rulesBinding, sid, sidHash);
+    return deleteSession(tree, rulesBinding, sid, sidHash);
 }

data/src/rules/state.h

@@ -74,6 +74,6 @@ unsigned int fetchStateProperty(void *tree,
                                 char **state,
                                 jsonProperty **property);
 
-unsigned int getStateVersion(void *handle, 
+unsigned int getStateVersion(void *tree, 
                              char *sid, 
                              unsigned long *stateVersion);

data/src/rulesrb/rules.c

@@ -23,7 +23,7 @@ static VALUE rbCreateRuleset(VALUE self, VALUE name, VALUE rules, VALUE stateCac
 static VALUE rbDeleteRuleset(VALUE self, VALUE handle) {
     Check_Type(handle, T_FIXNUM);
 
-    unsigned int result = deleteRuleset((void *)FIX2LONG(handle));
+    unsigned int result = deleteRuleset(FIX2INT(handle));
     if (result != RULES_OK) {
         if (result == ERR_OUT_OF_MEMORY) {
             rb_raise(rb_eNoMemError, "Out of memory");
@@ -75,9 +75,9 @@ static VALUE rbBindRuleset(VALUE self, VALUE handle, VALUE host, VALUE port, VAL
 
     unsigned int result;
     if (TYPE(password) == T_STRING) {
-        result = bindRuleset((void *)FIX2LONG(handle), RSTRING_PTR(host), FIX2INT(port), RSTRING_PTR(password), FIX2INT(db));
+        result = bindRuleset(FIX2INT(handle), RSTRING_PTR(host), FIX2INT(port), RSTRING_PTR(password), FIX2INT(db));
     } else if (TYPE(password) == T_NIL) {
-        result = bindRuleset((void *)FIX2LONG(handle), RSTRING_PTR(host), FIX2INT(port), NULL, FIX2INT(db));
+        result = bindRuleset(FIX2INT(handle), RSTRING_PTR(host), FIX2INT(port), NULL, FIX2INT(db));
     } else {
         rb_raise(rb_eTypeError, "Wrong argument type for password");   
     }
@@ -115,7 +115,7 @@ static VALUE rbStartAssertEvent(VALUE self, VALUE handle, VALUE event) {
 
     unsigned int replyCount;
     void *rulesBinding = NULL;
-    unsigned int result = startAssertEvent((void *)FIX2LONG(handle), RSTRING_PTR(event), &rulesBinding, &replyCount);
+    unsigned int result = startAssertEvent(FIX2INT(handle), RSTRING_PTR(event), &rulesBinding, &replyCount);
     if (result == RULES_OK || result == ERR_EVENT_NOT_HANDLED) {
         VALUE output = rb_ary_new(); 
         rb_ary_push(output, INT2FIX(rulesBinding));
@@ -136,7 +136,7 @@ static VALUE rbAssertEvent(VALUE self, VALUE handle, VALUE event) {
     Check_Type(handle, T_FIXNUM);
     Check_Type(event, T_STRING);
 
-    unsigned int result = assertEvent((void *)FIX2LONG(handle), RSTRING_PTR(event));
+    unsigned int result = assertEvent(FIX2INT(handle), RSTRING_PTR(event));
     if (result == RULES_OK || result == ERR_EVENT_NOT_HANDLED || result == ERR_EVENT_OBSERVED) {
         return INT2FIX(result);    
     } else {
@@ -156,7 +156,7 @@ static VALUE rbQueueAssertEvent(VALUE self, VALUE handle, VALUE sid, VALUE desti
     Check_Type(destination, T_STRING);
     Check_Type(event, T_STRING);
 
-    unsigned int result = queueMessage((void *)FIX2LONG(handle), QUEUE_ASSERT_EVENT, RSTRING_PTR(sid), RSTRING_PTR(destination), RSTRING_PTR(event));
+    unsigned int result = queueMessage(FIX2INT(handle), QUEUE_ASSERT_EVENT, RSTRING_PTR(sid), RSTRING_PTR(destination), RSTRING_PTR(event));
     if (result != RULES_OK) {
         if (result == ERR_OUT_OF_MEMORY) {
             rb_raise(rb_eNoMemError, "Out of memory");
@@ -174,7 +174,7 @@ static VALUE rbStartAssertEvents(VALUE self, VALUE handle, VALUE events) {
 
     unsigned int replyCount;
     void *rulesBinding = NULL;
-    unsigned int result = startAssertEvents((void *)FIX2LONG(handle), RSTRING_PTR(events), &rulesBinding, &replyCount);
+    unsigned int result = startAssertEvents(FIX2INT(handle), RSTRING_PTR(events), &rulesBinding, &replyCount);
     if (result == RULES_OK || result == ERR_EVENT_NOT_HANDLED) {
         VALUE output = rb_ary_new(); 
         rb_ary_push(output, INT2FIX(rulesBinding));
@@ -195,7 +195,7 @@ static VALUE rbAssertEvents(VALUE self, VALUE handle, VALUE events) {
     Check_Type(handle, T_FIXNUM);
     Check_Type(events, T_STRING);
 
-    unsigned int result = assertEvents((void *)FIX2LONG(handle), RSTRING_PTR(events));
+    unsigned int result = assertEvents(FIX2INT(handle), RSTRING_PTR(events));
     if (result != RULES_OK) {
         if (result == ERR_OUT_OF_MEMORY) {
             rb_raise(rb_eNoMemError, "Out of memory");
@@ -211,7 +211,7 @@ static VALUE rbRetractEvent(VALUE self, VALUE handle, VALUE event) {
     Check_Type(handle, T_FIXNUM);
     Check_Type(event, T_STRING);
 
-    unsigned int result = retractEvent((void *)FIX2LONG(handle), RSTRING_PTR(event));
+    unsigned int result = retractEvent(FIX2INT(handle), RSTRING_PTR(event));
     if (result == RULES_OK || result == ERR_EVENT_NOT_HANDLED || result == ERR_EVENT_OBSERVED) {
         return INT2FIX(result);    
     } else {
@@ -231,7 +231,7 @@ static VALUE rbStartAssertFact(VALUE self, VALUE handle, VALUE fact) {
 
     unsigned int replyCount;
     void *rulesBinding = NULL;
-    unsigned int result = startAssertFact((void *)FIX2LONG(handle), RSTRING_PTR(fact), &rulesBinding, &replyCount);
+    unsigned int result = startAssertFact(FIX2INT(handle), RSTRING_PTR(fact), &rulesBinding, &replyCount);
     if (result == RULES_OK || result == ERR_EVENT_NOT_HANDLED) {
         VALUE output = rb_ary_new(); 
         rb_ary_push(output, INT2FIX(rulesBinding));
@@ -252,7 +252,7 @@ static VALUE rbAssertFact(VALUE self, VALUE handle, VALUE fact) {
     Check_Type(handle, T_FIXNUM);
     Check_Type(fact, T_STRING);
 
-    unsigned int result = assertFact((void *)FIX2LONG(handle), RSTRING_PTR(fact));
+    unsigned int result = assertFact(FIX2INT(handle), RSTRING_PTR(fact));
     if (result == RULES_OK || result == ERR_EVENT_NOT_HANDLED || result == ERR_EVENT_OBSERVED) {
         return INT2FIX(result);    
     } else {
@@ -272,7 +272,7 @@ static VALUE rbQueueAssertFact(VALUE self, VALUE handle, VALUE sid, VALUE destin
     Check_Type(destination, T_STRING);
     Check_Type(event, T_STRING);
 
-    unsigned int result = queueMessage((void *)FIX2LONG(handle), QUEUE_ASSERT_FACT, RSTRING_PTR(sid), RSTRING_PTR(destination), RSTRING_PTR(event));
+    unsigned int result = queueMessage(FIX2INT(handle), QUEUE_ASSERT_FACT, RSTRING_PTR(sid), RSTRING_PTR(destination), RSTRING_PTR(event));
     if (result != RULES_OK) {
         if (result == ERR_OUT_OF_MEMORY) {
             rb_raise(rb_eNoMemError, "Out of memory");
@@ -290,7 +290,7 @@ static VALUE rbStartAssertFacts(VALUE self, VALUE handle, VALUE facts) {
 
     unsigned int replyCount;
     void *rulesBinding = NULL;
-    unsigned int result = startAssertFacts((void *)FIX2LONG(handle), RSTRING_PTR(facts), &rulesBinding, &replyCount);
+    unsigned int result = startAssertFacts(FIX2INT(handle), RSTRING_PTR(facts), &rulesBinding, &replyCount);
     if (result == RULES_OK || result == ERR_EVENT_NOT_HANDLED) {
         VALUE output = rb_ary_new(); 
         rb_ary_push(output, INT2FIX(rulesBinding));
@@ -311,7 +311,7 @@ static VALUE rbAssertFacts(VALUE self, VALUE handle, VALUE facts) {
     Check_Type(handle, T_FIXNUM);
     Check_Type(facts, T_STRING);
 
-    unsigned int result = assertFacts((void *)FIX2LONG(handle), RSTRING_PTR(facts));
+    unsigned int result = assertFacts(FIX2INT(handle), RSTRING_PTR(facts));
     if (result != RULES_OK) {
         if (result == ERR_OUT_OF_MEMORY) {
             rb_raise(rb_eNoMemError, "Out of memory");
@@ -329,7 +329,7 @@ static VALUE rbStartRetractFact(VALUE self, VALUE handle, VALUE fact) {
 
     unsigned int replyCount;
     void *rulesBinding = NULL;
-    unsigned int result = startRetractFact((void *)FIX2LONG(handle), RSTRING_PTR(fact), &rulesBinding, &replyCount);
+    unsigned int result = startRetractFact(FIX2INT(handle), RSTRING_PTR(fact), &rulesBinding, &replyCount);
     if (result == RULES_OK || result == ERR_EVENT_NOT_HANDLED) {
         VALUE output = rb_ary_new(); 
         rb_ary_push(output, INT2FIX(rulesBinding));
@@ -350,7 +350,7 @@ static VALUE rbRetractFact(VALUE self, VALUE handle, VALUE fact) {
     Check_Type(handle, T_FIXNUM);
     Check_Type(fact, T_STRING);
 
-    unsigned int result = retractFact((void *)FIX2LONG(handle), RSTRING_PTR(fact));
+    unsigned int result = retractFact(FIX2INT(handle), RSTRING_PTR(fact));
     if (result == RULES_OK || result == ERR_EVENT_NOT_HANDLED || result == ERR_EVENT_OBSERVED) {
         return INT2FIX(result);    
     } else {
@@ -370,7 +370,7 @@ static VALUE rbQueueRetractFact(VALUE self, VALUE handle, VALUE sid, VALUE desti
     Check_Type(destination, T_STRING);
     Check_Type(event, T_STRING);
 
-    unsigned int result = queueMessage((void *)FIX2LONG(handle), QUEUE_RETRACT_FACT, RSTRING_PTR(sid), RSTRING_PTR(destination), RSTRING_PTR(event));
+    unsigned int result = queueMessage(FIX2INT(handle), QUEUE_RETRACT_FACT, RSTRING_PTR(sid), RSTRING_PTR(destination), RSTRING_PTR(event));
     if (result != RULES_OK) {
         if (result == ERR_OUT_OF_MEMORY) {
             rb_raise(rb_eNoMemError, "Out of memory");
@@ -388,7 +388,7 @@ static VALUE rbStartRetractFacts(VALUE self, VALUE handle, VALUE facts) {
 
     unsigned int replyCount;
     void *rulesBinding = NULL;
-    unsigned int result = startRetractFacts((void *)FIX2LONG(handle), RSTRING_PTR(facts), &rulesBinding, &replyCount);
+    unsigned int result = startRetractFacts(FIX2INT(handle), RSTRING_PTR(facts), &rulesBinding, &replyCount);
     if (result == RULES_OK || result == ERR_EVENT_NOT_HANDLED) {
         VALUE output = rb_ary_new(); 
         rb_ary_push(output, INT2FIX(rulesBinding));
@@ -409,7 +409,7 @@ static VALUE rbRetractFacts(VALUE self, VALUE handle, VALUE facts) {
     Check_Type(handle, T_FIXNUM);
     Check_Type(facts, T_STRING);
 
-    unsigned int result = retractFacts((void *)FIX2LONG(handle), RSTRING_PTR(facts));
+    unsigned int result = retractFacts(FIX2INT(handle), RSTRING_PTR(facts));
     if (result != RULES_OK) {
         if (result == ERR_OUT_OF_MEMORY) {
             rb_raise(rb_eNoMemError, "Out of memory");
@@ -426,7 +426,7 @@ static VALUE rbAssertState(VALUE self, VALUE handle, VALUE sid, VALUE state) {
     Check_Type(sid, T_STRING);
     Check_Type(state, T_STRING);
 
-    unsigned int result = assertState((void *)FIX2LONG(handle), RSTRING_PTR(sid), RSTRING_PTR(state));
+    unsigned int result = assertState(FIX2INT(handle), RSTRING_PTR(sid), RSTRING_PTR(state));
     if (result == RULES_OK || result == ERR_EVENT_NOT_HANDLED || result == ERR_EVENT_OBSERVED) {
         return INT2FIX(result);    
     } else {
@@ -447,7 +447,7 @@ static VALUE rbStartUpdateState(VALUE self, VALUE handle, VALUE actionHandle, VA
 
     unsigned int replyCount;
     void *rulesBinding = NULL;
-    unsigned int result = startUpdateState((void *)FIX2LONG(handle), (void *)FIX2LONG(actionHandle), RSTRING_PTR(state), &rulesBinding, &replyCount);
+    unsigned int result = startUpdateState(FIX2INT(handle), (void *)FIX2LONG(actionHandle), RSTRING_PTR(state), &rulesBinding, &replyCount);
     if (result == RULES_OK || result == ERR_EVENT_NOT_HANDLED) {
         VALUE output = rb_ary_new(); 
         rb_ary_push(output, INT2FIX(rulesBinding));
@@ -471,7 +471,7 @@ static VALUE rbStartAction(VALUE self, VALUE handle) {
     char *messages;
     void *actionHandle;
     void *actionBinding;
-    unsigned int result = startAction((void *)FIX2LONG(handle), &state, &messages, &actionHandle, &actionBinding);
+    unsigned int result = startAction(FIX2INT(handle), &state, &messages, &actionHandle, &actionBinding);
     if (result == ERR_NO_ACTION_AVAILABLE) {
         return Qnil;
     } else if (result != RULES_OK) {
@@ -495,7 +495,7 @@ static VALUE rbCompleteAction(VALUE self, VALUE handle, VALUE actionHandle, VALU
     Check_Type(actionHandle, T_FIXNUM);
     Check_Type(state, T_STRING);
 
-    unsigned int result = completeAction((void *)FIX2LONG(handle), (void *)FIX2LONG(actionHandle), RSTRING_PTR(state));
+    unsigned int result = completeAction(FIX2INT(handle), (void *)FIX2LONG(actionHandle), RSTRING_PTR(state));
     if (result != RULES_OK) {
         if (result == ERR_OUT_OF_MEMORY) {
             rb_raise(rb_eNoMemError, "Out of memory");
@@ -513,7 +513,7 @@ static VALUE rbCompleteAndStartAction(VALUE self, VALUE handle, VALUE expectedRe
     Check_Type(actionHandle, T_FIXNUM);
 
     char *messages;
-    unsigned int result = completeAndStartAction((void *)FIX2LONG(handle), FIX2LONG(expectedReplies), (void *)FIX2LONG(actionHandle), &messages);
+    unsigned int result = completeAndStartAction(FIX2INT(handle), FIX2LONG(expectedReplies), (void *)FIX2LONG(actionHandle), &messages);
     if (result == ERR_NO_ACTION_AVAILABLE) {
         return Qnil;
     } else if (result != RULES_OK) {
@@ -532,7 +532,7 @@ static VALUE rbAbandonAction(VALUE self, VALUE handle, VALUE actionHandle) {
     Check_Type(handle, T_FIXNUM);
     Check_Type(actionHandle, T_FIXNUM);
 
-    unsigned int result = abandonAction((void *)FIX2LONG(handle), (void *)FIX2LONG(actionHandle));
+    unsigned int result = abandonAction(FIX2INT(handle), (void *)FIX2LONG(actionHandle));
     if (result != RULES_OK) {
         if (result == ERR_OUT_OF_MEMORY) {
             rb_raise(rb_eNoMemError, "Out of memory");
@@ -551,7 +551,7 @@ static VALUE rbStartTimer(VALUE self, VALUE handle, VALUE sid, VALUE duration, V
     Check_Type(manualReset, T_FIXNUM);
     Check_Type(timer, T_STRING);    
 
-    unsigned int result = startTimer((void *)FIX2LONG(handle), RSTRING_PTR(sid), FIX2UINT(duration), FIX2SHORT(manualReset), RSTRING_PTR(timer));
+    unsigned int result = startTimer(FIX2INT(handle), RSTRING_PTR(sid), FIX2UINT(duration), FIX2SHORT(manualReset), RSTRING_PTR(timer));
     if (result != RULES_OK) {
         if (result == ERR_OUT_OF_MEMORY) {
             rb_raise(rb_eNoMemError, "Out of memory");
@@ -568,7 +568,7 @@ static VALUE rbCancelTimer(VALUE self, VALUE handle, VALUE sid, VALUE timerName)
     Check_Type(sid, T_STRING);
     Check_Type(timerName, T_STRING);    
 
-    unsigned int result = cancelTimer((void *)FIX2LONG(handle), RSTRING_PTR(sid), RSTRING_PTR(timerName));
+    unsigned int result = cancelTimer(FIX2INT(handle), RSTRING_PTR(sid), RSTRING_PTR(timerName));
     if (result != RULES_OK) {
         if (result == ERR_OUT_OF_MEMORY) {
             rb_raise(rb_eNoMemError, "Out of memory");
@@ -583,7 +583,7 @@ static VALUE rbCancelTimer(VALUE self, VALUE handle, VALUE sid, VALUE timerName)
 static VALUE rbAssertTimers(VALUE self, VALUE handle) {
     Check_Type(handle, T_FIXNUM);
 
-    unsigned int result = assertTimers((void *)FIX2LONG(handle));
+    unsigned int result = assertTimers(FIX2INT(handle));
     if (result == RULES_OK) {
         return INT2FIX(1);    
     } else if (result == ERR_NO_TIMERS_AVAILABLE) {
@@ -604,7 +604,7 @@ static VALUE rbGetState(VALUE self, VALUE handle, VALUE sid) {
     Check_Type(sid, T_STRING);
 
     char *state;
-    unsigned int result = getState((void *)FIX2LONG(handle), RSTRING_PTR(sid), &state);
+    unsigned int result = getState(FIX2INT(handle), RSTRING_PTR(sid), &state);
     if (result != RULES_OK) {
         if (result == ERR_OUT_OF_MEMORY) {
             rb_raise(rb_eNoMemError, "Out of memory");
@@ -622,7 +622,7 @@ static VALUE rbDeleteState(VALUE self, VALUE handle, VALUE sid) {
     Check_Type(handle, T_FIXNUM);
     Check_Type(sid, T_STRING);
 
-    unsigned int result = deleteState((void *)FIX2LONG(handle), RSTRING_PTR(sid));
+    unsigned int result = deleteState(FIX2INT(handle), RSTRING_PTR(sid));
     if (result != RULES_OK) {
         if (result == ERR_OUT_OF_MEMORY) {
             rb_raise(rb_eNoMemError, "Out of memory");
@@ -638,7 +638,7 @@ static VALUE rbRenewActionLease(VALUE self, VALUE handle, VALUE sid) {
     Check_Type(handle, T_FIXNUM);
     Check_Type(sid, T_STRING);
 
-    unsigned int result = renewActionLease((void *)FIX2LONG(handle), RSTRING_PTR(sid));
+    unsigned int result = renewActionLease(FIX2INT(handle), RSTRING_PTR(sid));
     if (result != RULES_OK) {
         if (result == ERR_OUT_OF_MEMORY) {
             rb_raise(rb_eNoMemError, "Out of memory");

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: durable_rules
 version: !ruby/object:Gem::Version
-  version: 0.34.47
+  version: 0.34.48
 platform: ruby
 authors:
 - Jesus Ruiz
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-02-18 00:00:00.000000000 Z
+date: 2018-02-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake