durable_rules 0.34.57 → 2.00.001

data/src/rules/state.h

@@ -1,34 +1,77 @@
 
+#include <time.h> 
+
 #define HASH_ID 926444256
 #define HASH_SID 3593476751
 #define UNDEFINED_INDEX 0xFFFFFFFF
-#define MAX_NAME_LENGTH 256
 #define SID_BUFFER_LENGTH 2
 #define ID_BUFFER_LENGTH 22
-#define UNDEFINED_HASH_OFFSET 0xFFFFFFFF
 
-#define JSON_OBJECT_SEQUENCED 1
-#define JSON_OBJECT_HASHED 2
+#define MESSAGE_TYPE_EVENT 0
+#define MESSAGE_TYPE_FACT 1
+
+#define UNDEFINED_HASH_OFFSET 0
+#define MAX_OBJECT_PROPERTIES 32
+#define MAX_MESSAGE_FRAMES 16
+#define MAX_MESSAGE_INDEX_LENGTH 512
+#define MAX_LEFT_FRAME_INDEX_LENGTH 512
+#define MAX_RIGHT_FRAME_INDEX_LENGTH 512
+#define MAX_LOCATION_INDEX_LENGTH 16
+
+#define LEFT_FRAME 0
+#define RIGHT_FRAME 1
+#define A_FRAME 2
+#define B_FRAME 3
+#define ACTION_FRAME 4
+
+#define STATE_LEASE_TIME 30 
+
+#define MESSAGE_NODE(state, offset) &((messageNode *)state->messagePool.content)[offset]
+
+#define RIGHT_FRAME_NODE(state, index, offset) &((rightFrameNode *)state->betaState[index].rightFramePool.content)[offset]
+
+#define LEFT_FRAME_NODE(state, index, offset) &((leftFrameNode *)state->betaState[index].leftFramePool.content)[offset]
+
+#define A_FRAME_NODE(state, index, offset) &((leftFrameNode *)state->connectorState[index].aFramePool.content)[offset]
+
+#define B_FRAME_NODE(state, index, offset) &((leftFrameNode *)state->connectorState[index].bFramePool.content)[offset]
 
-#define MAX_OBJECT_PROPERTIES 128
+#define ACTION_FRAME_NODE(state, index, offset) &((leftFrameNode *)state->actionState[index].resultPool.content)[offset]
+
+#define RESULT_FRAME(actionNode, offset) &((leftFrameNode *)actionNode->resultPool.content)[offset];
+
+#define STATE_NODE(tree, offset) &((stateNode *)((ruleset *)tree)->statePool.content)[offset]
+
+#define LOCATION_NODE(message, offset) &((locationNode *)message->locationPool.content)[offset]
+
+
+// defined in rete.h
+struct node;
+
+typedef struct pool {
+    void *content;
+    unsigned int freeOffset;
+    unsigned int contentLength;
+    unsigned int count;
+} pool;
 
 typedef struct jsonProperty {
     unsigned int hash;
     unsigned char type;
-    unsigned char isMaterial;
-    char *valueString;
+    unsigned short valueOffset;
     unsigned short valueLength;
-    char name[MAX_NAME_LENGTH];
-    unsigned short nameLength;
     union {
         long i; 
         double d; 
         unsigned char b; 
+        char *s;
     } value;
 } jsonProperty;
 
 typedef struct jsonObject {
+    char *content;
     jsonProperty properties[MAX_OBJECT_PROPERTIES];
+    unsigned short propertyIndex[MAX_OBJECT_PROPERTIES];
     unsigned char propertiesLength; 
     unsigned int idIndex; 
     unsigned int sidIndex;
@@ -36,28 +79,120 @@ typedef struct jsonObject {
     char idBuffer[ID_BUFFER_LENGTH];
 } jsonObject;
 
-typedef struct stateEntry {
-    unsigned int nextHashOffset;
-    unsigned int nextLruOffset;
-    unsigned int prevLruOffset;
-    unsigned int sidHash;
-    unsigned int bindingIndex;
-    unsigned int lastRefresh;
-    char *state;
-    char *sid;
+typedef struct frameLocation {
+    unsigned char frameType;
+    unsigned int nodeIndex;
+    unsigned int frameOffset;
+} frameLocation;
+
+typedef struct locationNode {
+    unsigned int prevOffset;
+    unsigned int nextOffset;
+    unsigned int hash;
+    frameLocation location;
+    unsigned char isActive;
+} locationNode;
+
+typedef struct messageNode {
+    unsigned int prevOffset;
+    unsigned int nextOffset;
+    unsigned int hash;
+    unsigned char isActive;
+    unsigned char messageType;
+    pool locationPool;
+    unsigned int locationIndex[MAX_LOCATION_INDEX_LENGTH * 2];
     jsonObject jo;
-} stateEntry;
+} messageNode;
+
+typedef struct messageFrame {
+    unsigned int hash;
+    unsigned int nameOffset;
+    unsigned int messageNodeOffset;
+} messageFrame;
+
+typedef struct leftFrameNode {
+    unsigned int prevOffset;
+    unsigned int nextOffset;
+    unsigned int nameOffset;
+    unsigned int hash;
+    unsigned char isActive;
+    unsigned char isDispatching;
+    unsigned short messageCount;
+    unsigned short reverseIndex[MAX_MESSAGE_FRAMES];
+    messageFrame messages[MAX_MESSAGE_FRAMES];
+} leftFrameNode;
+
+typedef struct rightFrameNode {
+    unsigned int prevOffset;
+    unsigned int nextOffset;
+    unsigned int hash;
+    unsigned char isActive;
+    unsigned int messageOffset;
+} rightFrameNode;
+
+typedef struct actionStateNode {
+    struct node *reteNode;
+    pool resultPool;
+    unsigned int resultIndex[2];
+} actionStateNode;
+
+typedef struct connectorStateNode {
+    struct node *reteNode;
+    pool aFramePool;
+    unsigned int aFrameIndex[2];
+    pool bFramePool;
+    unsigned int bFrameIndex[2];
+} connectorStateNode;
+
+typedef struct betaStateNode {
+    struct node *reteNode;
+    pool leftFramePool;
+    unsigned int leftFrameIndex[MAX_LEFT_FRAME_INDEX_LENGTH * 2];
+    pool rightFramePool;
+    unsigned int rightFrameIndex[MAX_RIGHT_FRAME_INDEX_LENGTH * 2];
+} betaStateNode;
+
+typedef struct actionContext {
+    unsigned int actionStateIndex;
+    unsigned int resultCount;
+    unsigned int resultFrameOffset;
+    char *messages;
+    char *stateFact;
+} actionContext;
+
+typedef struct stateNode {
+    char *sid;
+    time_t lockExpireTime;
+    unsigned int offset;
+    unsigned int prevOffset;
+    unsigned int nextOffset;
+    unsigned int factOffset;
+    unsigned int hash;
+    unsigned char isActive;
+    pool messagePool;
+    unsigned int messageIndex[MAX_MESSAGE_INDEX_LENGTH * 2];
+    betaStateNode *betaState;
+    actionStateNode *actionState; 
+    connectorStateNode *connectorState;
+    actionContext context;
+} stateNode;
+
 
 unsigned int fnv1Hash32(char *str, unsigned int len);
 
-void rehydrateProperty(jsonProperty *property, char *state);
+unsigned int getObjectProperty(jsonObject *jo, 
+                               unsigned int hash, 
+                               jsonProperty **property);
 
-unsigned int refreshState(void *tree, char *sid);
+unsigned int setObjectProperty(jsonObject *jo, 
+                               unsigned int hash, 
+                               unsigned char type, 
+                               unsigned short valueOffset, 
+                               unsigned short valueLength);
 
 unsigned int constructObject(char *root,
                              char *parentName, 
                              char *object,
-                             char layout,
                              char generateId,
                              jsonObject *jo,
                              char **next);
@@ -66,14 +201,153 @@ unsigned int resolveBinding(void *tree,
                             char *sid, 
                             void **rulesBinding);
 
-unsigned int fetchStateProperty(void *tree,
-                                char *sid, 
-                                unsigned int propertyHash, 
-                                unsigned int maxTime, 
-                                unsigned char ignoreStaleState,
-                                char **state,
-                                jsonProperty **property);
 
-unsigned int getStateVersion(void *tree, 
+unsigned int getHash(char *sid, char *key);
+
+unsigned int initStatePool(void *tree);
+
+unsigned int addFrameLocation(stateNode *state,
+                              frameLocation location,
+                              unsigned int messageNodeOffset);
+
+unsigned int deleteFrameLocation(stateNode *state,
+                                 unsigned int messageNodeOffset,
+                                 frameLocation location);
+
+
+unsigned int deleteMessageFromFrame(unsigned int messageNodeOffset, 
+                                    leftFrameNode *frame);
+
+unsigned int getMessageFromFrame(stateNode *state,
+                                 messageFrame *messages,
+                                 unsigned int hash,
+                                 jsonObject **message);
+
+unsigned int setMessageInFrame(leftFrameNode *node,
+                               unsigned int nameOffset,
+                               unsigned int hash, 
+                               unsigned int messageNodeOffset);
+
+unsigned int getLastLeftFrame(stateNode *state,
+                              unsigned int index, 
+                              unsigned int hash,
+                              frameLocation *location,
+                              leftFrameNode **node);
+
+unsigned int setLeftFrame(stateNode *state,
+                          unsigned int hash, 
+                          frameLocation location);
+
+
+unsigned int deleteLeftFrame(stateNode *state,
+                             frameLocation location);
+
+unsigned int createLeftFrame(stateNode *state,
+                             struct node *reteNode,
+                             leftFrameNode *oldNode,                        
+                             leftFrameNode **newNode,
+                             frameLocation *newLocation);
+
+unsigned int getLastConnectorFrame(stateNode *state,
+                                   unsigned int frameType,
+                                   unsigned int index, 
+                                   unsigned int *valueOffset,
+                                   leftFrameNode **node);
+
+unsigned int setConnectorFrame(stateNode *state, 
+                               unsigned int frameType,
+                               frameLocation location);
+
+
+unsigned int deleteConnectorFrame(stateNode *state,
+                                  unsigned int frameType,
+                                  frameLocation location);
+
+unsigned int createConnectorFrame(stateNode *state,
+                                  unsigned int frameType,
+                                  struct node *reteNode,
+                                  leftFrameNode *oldNode,                        
+                                  leftFrameNode **newNode,
+                                  frameLocation *newLocation);
+
+unsigned int getLastRightFrame(stateNode *state,
+                           unsigned int index, 
+                           unsigned int hash,
+                           rightFrameNode **node);
+
+unsigned int setRightFrame(stateNode *state,
+                           unsigned int hash, 
+                           frameLocation location);
+
+unsigned int deleteRightFrame(stateNode *state,
+                              frameLocation location);
+
+unsigned int createRightFrame(stateNode *state,
+                              struct node *reteNode,
+                              rightFrameNode **node,
+                              frameLocation *location);
+
+unsigned int getActionFrame(stateNode *state,
+                            frameLocation resultLocation,
+                            leftFrameNode **resultNode);
+
+unsigned int setActionFrame(stateNode *state, 
+                            frameLocation location);
+
+
+unsigned int deleteActionFrame(stateNode *state,
+                               frameLocation location);
+
+unsigned int deleteDispatchingActionFrame(stateNode *state,
+                                          frameLocation location);
+
+unsigned int createActionFrame(stateNode *state,
+                               struct node *reteNode,
+                               leftFrameNode *oldNode,                        
+                               leftFrameNode **newNode,
+                               frameLocation *newLocation);
+
+unsigned int deleteMessage(stateNode *state,
+                           unsigned int messageNodeOffset);
+
+unsigned int getMessage(stateNode *state,
+                        char *mid,
+                        unsigned int *valueOffset);
+
+unsigned int storeMessage(stateNode *state,
+                          char *mid,
+                          jsonObject *message,
+                          unsigned char messageType,
+                          unsigned int *valueOffset);
+
+unsigned int ensureStateNode(void *tree, 
                              char *sid, 
-                             unsigned long *stateVersion);
+                             unsigned char *isNew,
+                             stateNode **state);
+
+unsigned int serializeResult(void *tree, 
+                             stateNode *state, 
+                             actionStateNode *actionNode, 
+                             unsigned int count,
+                             char **result);
+
+unsigned int serializeState(stateNode *state, 
+                            char **stateFact);
+
+unsigned int getNextResultInState(void *tree, 
+                                  stateNode *state,
+                                  unsigned int *actionStateIndex,
+                                  unsigned int *resultCount,
+                                  unsigned int *resultFrameOffset, 
+                                  actionStateNode **resultAction);
+
+unsigned int getNextResult(void *tree, 
+                           time_t currentTime,
+                           stateNode **resultState, 
+                           unsigned int *actionStateIndex,
+                           unsigned int *resultCount,
+                           unsigned int *resultFrameOffset, 
+                           actionStateNode **resultAction);
+
+
+

data/src/rulesrb/extconf.rb

@@ -4,7 +4,6 @@ RbConfig::MAKEFILE_CONFIG['CC'] = ENV['CC'] if ENV['CC']
 
 rules_include = File.join(File.dirname(__FILE__), %w{.. .. src rules})
 rules_lib = File.join(File.dirname(__FILE__), %w{.. .. src rules})
-hiredis_lib = File.join(File.dirname(__FILE__), %w{.. .. deps hiredis})
 
 RbConfig::CONFIG['configure_args'] =~ /with-make-prog\=(\w+)/
 make_program = $1 || ENV['make']
@@ -17,12 +16,6 @@ else
   'make'
 end
 
-# Make sure hiredis is built...
-Dir.chdir(hiredis_lib) do
-  success = system("#{make_program} static")
-  raise "Building hiredis failed" if !success
-end
-
 # Make sure rules is built...
 Dir.chdir(rules_lib) do
   success = system("#{make_program} static")
@@ -31,7 +24,7 @@ end
 
 # Statically link to hiredis (mkmf can't do this for us)
 $CFLAGS << " -I#{rules_lib} "
-$LDFLAGS << " -L#{rules_lib} -L#{hiredis_lib} -lrules -lhiredis"
+$LDFLAGS << " -L#{rules_lib} -lrules"
 
 have_func("rb_thread_fd_select")
 create_makefile('src/rulesrb/rules')

data/src/rulesrb/rules.c

@@ -3,12 +3,12 @@
 
 VALUE rulesModule = Qnil;
 
-static VALUE rbCreateRuleset(VALUE self, VALUE name, VALUE rules, VALUE stateCacheSize) {
+static VALUE rbCreateRuleset(VALUE self, VALUE name, VALUE rules) {
     Check_Type(name, T_STRING);
     Check_Type(rules, T_STRING);
 
-    void *output = NULL;
-    unsigned int result = createRuleset(&output, RSTRING_PTR(name), RSTRING_PTR(rules), FIX2INT(stateCacheSize));
+    unsigned int output = 0;
+    unsigned int result = createRuleset(&output, RSTRING_PTR(name), RSTRING_PTR(rules));
     if (result != RULES_OK) {
         if (result == ERR_OUT_OF_MEMORY) {
             rb_raise(rb_eNoMemError, "Out of memory");
@@ -35,110 +35,17 @@ static VALUE rbDeleteRuleset(VALUE self, VALUE handle) {
     return Qnil;
 }
 
-static VALUE rbCreateClient(VALUE self, VALUE name, VALUE stateCacheSize) {
-    Check_Type(name, T_STRING);
-    Check_Type(stateCacheSize, T_FIXNUM);
-
-    void *output = NULL;
-    unsigned int result = createClient(&output, RSTRING_PTR(name), FIX2INT(stateCacheSize));
-    if (result != RULES_OK) {
-        if (result == ERR_OUT_OF_MEMORY) {
-            rb_raise(rb_eNoMemError, "Out of memory");
-        } else { 
-            rb_raise(rb_eException, "Could not create client, error code: %d", result);
-        }
-    }
-
-    return INT2FIX(output);
-}
-
-static VALUE rbDeleteClient(VALUE self, VALUE handle) {
-    Check_Type(handle, T_FIXNUM);
-
-    unsigned int result = deleteClient((void *)FIX2LONG(handle));
-    if (result != RULES_OK) {
-        if (result == ERR_OUT_OF_MEMORY) {
-            rb_raise(rb_eNoMemError, "Out of memory");
-        } else { 
-            rb_raise(rb_eException, "Could not delete client, error code: %d", result);
-        }
-    }
-
-    return Qnil;
-}
-
-static VALUE rbBindRuleset(VALUE self, VALUE handle, VALUE host, VALUE port, VALUE password, VALUE db) {
-    Check_Type(handle, T_FIXNUM);
-    Check_Type(host, T_STRING);
-    Check_Type(port, T_FIXNUM);
-    Check_Type(db, T_FIXNUM);
-
-    unsigned int result;
-    if (TYPE(password) == T_STRING) {
-        result = bindRuleset(FIX2INT(handle), RSTRING_PTR(host), FIX2INT(port), RSTRING_PTR(password), FIX2INT(db));
-    } else if (TYPE(password) == T_NIL) {
-        result = bindRuleset(FIX2INT(handle), RSTRING_PTR(host), FIX2INT(port), NULL, FIX2INT(db));
-    } else {
-        rb_raise(rb_eTypeError, "Wrong argument type for password");   
-    }
-
-    if (result != RULES_OK) {
-        if (result == ERR_OUT_OF_MEMORY) {
-            rb_raise(rb_eNoMemError, "Out of memory");
-        } else { 
-            rb_raise(rb_eException, "Could not create connection, error code: %d", result);
-        }
-    }
-
-    return Qnil;
-}
-
-static VALUE rbComplete(VALUE self, VALUE rulesBinding, VALUE replyCount) {
-    Check_Type(rulesBinding, T_FIXNUM);
-    Check_Type(replyCount, T_FIXNUM);
-    
-    unsigned int result = complete((void *)FIX2LONG(rulesBinding), FIX2LONG(replyCount));
-    if (result != RULES_OK) {
-        if (result == ERR_OUT_OF_MEMORY) {
-            rb_raise(rb_eNoMemError, "Out of memory");
-        } else { 
-            rb_raise(rb_eException, "Could not complete action, error code: %d", result);
-        }
-    }
-
-    return Qnil;
-}
-
-static VALUE rbStartAssertEvent(VALUE self, VALUE handle, VALUE event) {
-    Check_Type(handle, T_FIXNUM);
-    Check_Type(event, T_STRING);
-
-    unsigned int replyCount;
-    void *rulesBinding = NULL;
-    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));
-        rb_ary_push(output, INT2FIX(replyCount));
-        return output;  
-    } else {
-        if (result == ERR_OUT_OF_MEMORY) {
-            rb_raise(rb_eNoMemError, "Out of memory");
-        } else { 
-            rb_raise(rb_eException, "Could not assert event, error code: %d", result);
-        }
-    }
-
-    return Qnil;
-}
-
 static VALUE rbAssertEvent(VALUE self, VALUE handle, VALUE event) {
     Check_Type(handle, T_FIXNUM);
     Check_Type(event, T_STRING);
 
-    unsigned int result = assertEvent(FIX2INT(handle), RSTRING_PTR(event));
+    unsigned int stateOffset;
+    unsigned int result = assertEvent(FIX2INT(handle), RSTRING_PTR(event), &stateOffset);
     if (result == RULES_OK || result == ERR_EVENT_NOT_HANDLED || result == ERR_EVENT_OBSERVED) {
-        return INT2FIX(result);    
+        VALUE output = rb_ary_new(); 
+        rb_ary_push(output, INT2FIX(result));
+        rb_ary_push(output, INT2FIX(stateOffset));
+        return output; 
     } else {
         if (result == ERR_OUT_OF_MEMORY) {
             rb_raise(rb_eNoMemError, "Out of memory");
@@ -150,100 +57,23 @@ static VALUE rbAssertEvent(VALUE self, VALUE handle, VALUE event) {
     return Qnil;
 }
 
-static VALUE rbQueueAssertEvent(VALUE self, VALUE handle, VALUE sid, VALUE destination, VALUE event) {
-    Check_Type(handle, T_FIXNUM);
-    Check_Type(sid, T_STRING);
-    Check_Type(destination, T_STRING);
-    Check_Type(event, T_STRING);
-
-    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");
-        } else { 
-            rb_raise(rb_eException, "Could not queue assert event, error code: %d", result);
-        }
-    }
-
-    return Qnil;
-}
-
-static VALUE rbStartAssertEvents(VALUE self, VALUE handle, VALUE events) {
-    Check_Type(handle, T_FIXNUM);
-    Check_Type(events, T_STRING);
-
-    unsigned int replyCount;
-    void *rulesBinding = NULL;
-    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));
-        rb_ary_push(output, INT2FIX(replyCount));
-        return output;  
-    } else {
-        if (result == ERR_OUT_OF_MEMORY) {
-            rb_raise(rb_eNoMemError, "Out of memory");
-        } else { 
-            rb_raise(rb_eException, "Could not assert events, error code: %d", result);
-        }
-    }
-
-    return Qnil;
-}
 
 static VALUE rbAssertEvents(VALUE self, VALUE handle, VALUE events) {
     Check_Type(handle, T_FIXNUM);
     Check_Type(events, T_STRING);
 
-    unsigned int result = assertEvents(FIX2INT(handle), RSTRING_PTR(events));
+    unsigned int stateOffset;
+    unsigned int result = assertEvents(FIX2INT(handle), RSTRING_PTR(events), &stateOffset);
     if (result == RULES_OK || result == ERR_EVENT_NOT_HANDLED || result == ERR_EVENT_OBSERVED) {
-        return INT2FIX(result);    
-    } else {
-        if (result == ERR_OUT_OF_MEMORY) {
-            rb_raise(rb_eNoMemError, "Out of memory");
-        } else { 
-            rb_raise(rb_eException, "Could not assert events, error code: %d", result);
-        }
-    }
-
-    return Qnil;
-}
-
-static VALUE rbRetractEvent(VALUE self, VALUE handle, VALUE event) {
-    Check_Type(handle, T_FIXNUM);
-    Check_Type(event, T_STRING);
-
-    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 {
-        if (result == ERR_OUT_OF_MEMORY) {
-            rb_raise(rb_eNoMemError, "Out of memory");
-        } else { 
-            rb_raise(rb_eException, "Could not retract event, error code: %d", result);
-        }
-    }
-
-    return Qnil;
-}
-
-static VALUE rbStartAssertFact(VALUE self, VALUE handle, VALUE fact) {
-    Check_Type(handle, T_FIXNUM);
-    Check_Type(fact, T_STRING);
-
-    unsigned int replyCount;
-    void *rulesBinding = NULL;
-    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));
-        rb_ary_push(output, INT2FIX(replyCount));
-        return output;  
+        rb_ary_push(output, INT2FIX(result));
+        rb_ary_push(output, INT2FIX(stateOffset));
+        return output; 
     } else {
         if (result == ERR_OUT_OF_MEMORY) {
             rb_raise(rb_eNoMemError, "Out of memory");
         } else { 
-            rb_raise(rb_eException, "Could not assert fact, error code: %d", result);
+            rb_raise(rb_eException, "Could not assert events, error code: %d", result);
         }
     }
 
@@ -254,55 +84,18 @@ static VALUE rbAssertFact(VALUE self, VALUE handle, VALUE fact) {
     Check_Type(handle, T_FIXNUM);
     Check_Type(fact, T_STRING);
 
-    unsigned int result = assertFact(FIX2INT(handle), RSTRING_PTR(fact));
+    unsigned int stateOffset;
+    unsigned int result = assertFact(FIX2INT(handle), RSTRING_PTR(fact), &stateOffset);
     if (result == RULES_OK || result == ERR_EVENT_NOT_HANDLED || result == ERR_EVENT_OBSERVED) {
-        return INT2FIX(result);    
-    } else {
-        if (result == ERR_OUT_OF_MEMORY) {
-            rb_raise(rb_eNoMemError, "Out of memory");
-        } else { 
-            rb_raise(rb_eException, "Could not assert fact, error code: %d", result);
-        }
-    }
-
-    return Qnil;
-}
-
-static VALUE rbQueueAssertFact(VALUE self, VALUE handle, VALUE sid, VALUE destination, VALUE event) {
-    Check_Type(handle, T_FIXNUM);
-    Check_Type(sid, T_STRING);
-    Check_Type(destination, T_STRING);
-    Check_Type(event, T_STRING);
-
-    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");
-        } else { 
-            rb_raise(rb_eException, "Could not queue assert fact, error code: %d", result);
-        }
-    }
-
-    return Qnil;
-}
-
-static VALUE rbStartAssertFacts(VALUE self, VALUE handle, VALUE facts) {
-    Check_Type(handle, T_FIXNUM);
-    Check_Type(facts, T_STRING);
-
-    unsigned int replyCount;
-    void *rulesBinding = NULL;
-    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));
-        rb_ary_push(output, INT2FIX(replyCount));
-        return output;  
+        rb_ary_push(output, INT2FIX(result));
+        rb_ary_push(output, INT2FIX(stateOffset));
+        return output; 
     } else {
         if (result == ERR_OUT_OF_MEMORY) {
             rb_raise(rb_eNoMemError, "Out of memory");
         } else { 
-            rb_raise(rb_eException, "Could not assert facts, error code: %d", result);
+            rb_raise(rb_eException, "Could not assert fact, error code: %d", result);
         }
     }
 
@@ -313,37 +106,18 @@ static VALUE rbAssertFacts(VALUE self, VALUE handle, VALUE facts) {
     Check_Type(handle, T_FIXNUM);
     Check_Type(facts, T_STRING);
 
-    unsigned int result = assertFacts(FIX2INT(handle), RSTRING_PTR(facts));
+    unsigned int stateOffset;
+    unsigned int result = assertFacts(FIX2INT(handle), RSTRING_PTR(facts), &stateOffset);
     if (result == RULES_OK || result == ERR_EVENT_NOT_HANDLED || result == ERR_EVENT_OBSERVED) {
-        return INT2FIX(result);    
-    } else {
-        if (result == ERR_OUT_OF_MEMORY) {
-            rb_raise(rb_eNoMemError, "Out of memory");
-        } else { 
-            rb_raise(rb_eException, "Could not assert facts, error code: %d", result);
-        }
-    }
-
-    return Qnil;
-}
-
-static VALUE rbStartRetractFact(VALUE self, VALUE handle, VALUE fact) {
-    Check_Type(handle, T_FIXNUM);
-    Check_Type(fact, T_STRING);
-
-    unsigned int replyCount;
-    void *rulesBinding = NULL;
-    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));
-        rb_ary_push(output, INT2FIX(replyCount));
-        return output;  
+        rb_ary_push(output, INT2FIX(result));
+        rb_ary_push(output, INT2FIX(stateOffset));
+        return output; 
     } else {
         if (result == ERR_OUT_OF_MEMORY) {
             rb_raise(rb_eNoMemError, "Out of memory");
         } else { 
-            rb_raise(rb_eException, "Could not retract fact, error code: %d", result);
+            rb_raise(rb_eException, "Could not assert facts, error code: %d", result);
         }
     }
 
@@ -354,9 +128,13 @@ static VALUE rbRetractFact(VALUE self, VALUE handle, VALUE fact) {
     Check_Type(handle, T_FIXNUM);
     Check_Type(fact, T_STRING);
 
-    unsigned int result = retractFact(FIX2INT(handle), RSTRING_PTR(fact));
+    unsigned int stateOffset;
+    unsigned int result = retractFact(FIX2INT(handle), RSTRING_PTR(fact), &stateOffset);
     if (result == RULES_OK || result == ERR_EVENT_NOT_HANDLED || result == ERR_EVENT_OBSERVED) {
-        return INT2FIX(result);    
+        VALUE output = rb_ary_new(); 
+        rb_ary_push(output, INT2FIX(result));
+        rb_ary_push(output, INT2FIX(stateOffset));
+        return output; 
     } else {
         if (result == ERR_OUT_OF_MEMORY) {
             rb_raise(rb_eNoMemError, "Out of memory");
@@ -368,36 +146,17 @@ static VALUE rbRetractFact(VALUE self, VALUE handle, VALUE fact) {
     return Qnil;
 }
 
-static VALUE rbQueueRetractFact(VALUE self, VALUE handle, VALUE sid, VALUE destination, VALUE event) {
-    Check_Type(handle, T_FIXNUM);
-    Check_Type(sid, T_STRING);
-    Check_Type(destination, T_STRING);
-    Check_Type(event, T_STRING);
-
-    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");
-        } else { 
-            rb_raise(rb_eException, "Could not queue retract fact, error code: %d", result);
-        }
-    }
-
-    return Qnil;
-}
-
-static VALUE rbStartRetractFacts(VALUE self, VALUE handle, VALUE facts) {
+static VALUE rbRetractFacts(VALUE self, VALUE handle, VALUE facts) {
     Check_Type(handle, T_FIXNUM);
     Check_Type(facts, T_STRING);
 
-    unsigned int replyCount;
-    void *rulesBinding = NULL;
-    unsigned int result = startRetractFacts(FIX2INT(handle), RSTRING_PTR(facts), &rulesBinding, &replyCount);
-    if (result == RULES_OK || result == ERR_EVENT_NOT_HANDLED) {
+    unsigned int stateOffset;
+    unsigned int result = retractFacts(FIX2INT(handle), RSTRING_PTR(facts), &stateOffset);
+    if (result == RULES_OK || result == ERR_EVENT_NOT_HANDLED || result == ERR_EVENT_OBSERVED) {
         VALUE output = rb_ary_new(); 
-        rb_ary_push(output, INT2FIX(rulesBinding));
-        rb_ary_push(output, INT2FIX(replyCount));
-        return output;  
+        rb_ary_push(output, INT2FIX(result));
+        rb_ary_push(output, INT2FIX(stateOffset));
+        return output; 
     } else {
         if (result == ERR_OUT_OF_MEMORY) {
             rb_raise(rb_eNoMemError, "Out of memory");
@@ -409,30 +168,14 @@ static VALUE rbStartRetractFacts(VALUE self, VALUE handle, VALUE facts) {
     return Qnil;
 }
 
-static VALUE rbRetractFacts(VALUE self, VALUE handle, VALUE facts) {
+static VALUE rbUpdateState(VALUE self, VALUE handle, VALUE state) {
     Check_Type(handle, T_FIXNUM);
-    Check_Type(facts, T_STRING);
-
-    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");
-        } else { 
-            rb_raise(rb_eException, "Could not retract facts, error code: %d", result);
-        }
-    }
-
-    return Qnil;
-}
-
-static VALUE rbAssertState(VALUE self, VALUE handle, VALUE sid, VALUE state) {
-    Check_Type(handle, T_FIXNUM);
-    Check_Type(sid, T_STRING);
     Check_Type(state, T_STRING);
 
-    unsigned int result = assertState(FIX2INT(handle), RSTRING_PTR(sid), RSTRING_PTR(state));
+    unsigned int stateOffset;
+    unsigned int result = updateState(FIX2INT(handle), RSTRING_PTR(state), &stateOffset);
     if (result == RULES_OK || result == ERR_EVENT_NOT_HANDLED || result == ERR_EVENT_OBSERVED) {
-        return INT2FIX(result);    
+        return INT2FIX(stateOffset);    
     } else {
         if (result == ERR_OUT_OF_MEMORY) {
             rb_raise(rb_eNoMemError, "Out of memory");
@@ -444,38 +187,13 @@ static VALUE rbAssertState(VALUE self, VALUE handle, VALUE sid, VALUE state) {
     return Qnil;
 }
 
-static VALUE rbStartUpdateState(VALUE self, VALUE handle, VALUE actionHandle, VALUE state) {
-    Check_Type(handle, T_FIXNUM);
-    Check_Type(actionHandle, T_FIXNUM);
-    Check_Type(state, T_STRING);
-
-    unsigned int replyCount;
-    void *rulesBinding = NULL;
-    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));
-        rb_ary_push(output, INT2FIX(replyCount));
-        return output;  
-    } else {
-        if (result == ERR_OUT_OF_MEMORY) {
-            rb_raise(rb_eNoMemError, "Out of memory");
-        } else { 
-            rb_raise(rb_eException, "Could not start update state, error code: %d", result);
-        }
-    }
-
-    return Qnil;
-}
-
 static VALUE rbStartAction(VALUE self, VALUE handle) {
     Check_Type(handle, T_FIXNUM);
 
     char *state;
     char *messages;
-    void *actionHandle;
-    void *actionBinding;
-    unsigned int result = startAction(FIX2INT(handle), &state, &messages, &actionHandle, &actionBinding);
+    unsigned int stateOffset;
+    unsigned int result = startAction(FIX2INT(handle), &state, &messages, &stateOffset);
     if (result == ERR_NO_ACTION_AVAILABLE) {
         return Qnil;
     } else if (result != RULES_OK) {
@@ -489,35 +207,39 @@ static VALUE rbStartAction(VALUE self, VALUE handle) {
     VALUE output = rb_ary_new(); 
     rb_ary_push(output, rb_str_new2(state));
     rb_ary_push(output, rb_str_new2(messages));
-    rb_ary_push(output, INT2FIX(actionHandle));
-    rb_ary_push(output, INT2FIX(actionBinding));
+    rb_ary_push(output, INT2FIX(stateOffset));
     return output;
 }
 
-static VALUE rbCompleteAction(VALUE self, VALUE handle, VALUE actionHandle, VALUE state) {
+static VALUE rbStartActionForState(VALUE self, VALUE handle, VALUE stateOffset) {
     Check_Type(handle, T_FIXNUM);
-    Check_Type(actionHandle, T_FIXNUM);
-    Check_Type(state, T_STRING);
+    Check_Type(stateOffset, T_FIXNUM);
 
-    unsigned int result = completeAction(FIX2INT(handle), (void *)FIX2LONG(actionHandle), RSTRING_PTR(state));
-    if (result != RULES_OK) {
+    char *state;
+    char *messages;
+    unsigned int result = startActionForState(FIX2INT(handle), FIX2INT(stateOffset), &state, &messages);
+    if (result == ERR_NO_ACTION_AVAILABLE) {
+        return Qnil;
+    } else if (result != RULES_OK) {
         if (result == ERR_OUT_OF_MEMORY) {
             rb_raise(rb_eNoMemError, "Out of memory");
         } else { 
-            rb_raise(rb_eException, "Could not complete action, error code: %d", result);
+            rb_raise(rb_eException, "Could not start action, error code: %d", result);
         }
     }
 
-    return Qnil;
+    VALUE output = rb_ary_new(); 
+    rb_ary_push(output, rb_str_new2(state));
+    rb_ary_push(output, rb_str_new2(messages));
+    return output;
 }
 
-static VALUE rbCompleteAndStartAction(VALUE self, VALUE handle, VALUE expectedReplies, VALUE actionHandle) {
+static VALUE rbCompleteAndStartAction(VALUE self, VALUE handle, VALUE stateOffset) {
     Check_Type(handle, T_FIXNUM);
-    Check_Type(expectedReplies, T_FIXNUM);
-    Check_Type(actionHandle, T_FIXNUM);
+    Check_Type(stateOffset, T_FIXNUM);
 
     char *messages;
-    unsigned int result = completeAndStartAction(FIX2INT(handle), FIX2LONG(expectedReplies), (void *)FIX2LONG(actionHandle), &messages);
+    unsigned int result = completeAndStartAction(FIX2INT(handle), FIX2INT(stateOffset), &messages);
     if (result == ERR_NO_ACTION_AVAILABLE) {
         return Qnil;
     } else if (result != RULES_OK) {
@@ -531,12 +253,11 @@ static VALUE rbCompleteAndStartAction(VALUE self, VALUE handle, VALUE expectedRe
     return rb_str_new2(messages);
 }
 
-
-static VALUE rbAbandonAction(VALUE self, VALUE handle, VALUE actionHandle) {
+static VALUE rbAbandonAction(VALUE self, VALUE handle, VALUE stateOffset) {
     Check_Type(handle, T_FIXNUM);
-    Check_Type(actionHandle, T_FIXNUM);
+    Check_Type(stateOffset, T_FIXNUM);
 
-    unsigned int result = abandonAction(FIX2INT(handle), (void *)FIX2LONG(actionHandle));
+    unsigned int result = abandonAction(FIX2INT(handle), FIX2INT(stateOffset));
     if (result != RULES_OK) {
         if (result == ERR_OUT_OF_MEMORY) {
             rb_raise(rb_eNoMemError, "Out of memory");
@@ -588,11 +309,7 @@ static VALUE rbAssertTimers(VALUE self, VALUE handle) {
     Check_Type(handle, T_FIXNUM);
 
     unsigned int result = assertTimers(FIX2INT(handle));
-    if (result == RULES_OK) {
-        return INT2FIX(1);    
-    } else if (result == ERR_NO_TIMERS_AVAILABLE) {
-        return INT2FIX(0);    
-    } else {
+    if (result != RULES_OK) {
         if (result == ERR_OUT_OF_MEMORY) {
             rb_raise(rb_eNoMemError, "Out of memory");
         } else { 
@@ -656,33 +373,18 @@ static VALUE rbRenewActionLease(VALUE self, VALUE handle, VALUE sid) {
 
 void Init_rules() {
     rulesModule = rb_define_module("Rules");
-    rb_define_singleton_method(rulesModule, "create_ruleset", rbCreateRuleset, 3);
+    rb_define_singleton_method(rulesModule, "create_ruleset", rbCreateRuleset, 2);
     rb_define_singleton_method(rulesModule, "delete_ruleset", rbDeleteRuleset, 1);
-    rb_define_singleton_method(rulesModule, "create_client", rbCreateClient, 2);
-    rb_define_singleton_method(rulesModule, "delete_client", rbDeleteClient, 1);
-    rb_define_singleton_method(rulesModule, "bind_ruleset", rbBindRuleset, 5);
-    rb_define_singleton_method(rulesModule, "complete", rbComplete, 2);
     rb_define_singleton_method(rulesModule, "assert_event", rbAssertEvent, 2);
-    rb_define_singleton_method(rulesModule, "queue_assert_event", rbQueueAssertEvent, 4);
-    rb_define_singleton_method(rulesModule, "start_assert_event", rbStartAssertEvent, 2);
     rb_define_singleton_method(rulesModule, "assert_events", rbAssertEvents, 2);
-    rb_define_singleton_method(rulesModule, "start_assert_events", rbStartAssertEvents, 2);
-    rb_define_singleton_method(rulesModule, "retract_event", rbRetractEvent, 2);
-    rb_define_singleton_method(rulesModule, "start_assert_fact", rbStartAssertFact, 2);
     rb_define_singleton_method(rulesModule, "assert_fact", rbAssertFact, 2);
-    rb_define_singleton_method(rulesModule, "queue_assert_fact", rbQueueAssertFact, 4);
-    rb_define_singleton_method(rulesModule, "start_assert_facts", rbStartAssertFacts, 2);
     rb_define_singleton_method(rulesModule, "assert_facts", rbAssertFacts, 2);
-    rb_define_singleton_method(rulesModule, "start_retract_fact", rbStartRetractFact, 2);
     rb_define_singleton_method(rulesModule, "retract_fact", rbRetractFact, 2);
-    rb_define_singleton_method(rulesModule, "queue_retract_fact", rbQueueRetractFact, 4);
-    rb_define_singleton_method(rulesModule, "start_retract_facts", rbStartRetractFacts, 2);
     rb_define_singleton_method(rulesModule, "retract_facts", rbRetractFacts, 2);
-    rb_define_singleton_method(rulesModule, "assert_state", rbAssertState, 3);
-    rb_define_singleton_method(rulesModule, "start_update_state", rbStartUpdateState, 3);
+    rb_define_singleton_method(rulesModule, "update_state", rbUpdateState, 2);
     rb_define_singleton_method(rulesModule, "start_action", rbStartAction, 1);
-    rb_define_singleton_method(rulesModule, "complete_action", rbCompleteAction, 3);
-    rb_define_singleton_method(rulesModule, "complete_and_start_action", rbCompleteAndStartAction, 3);
+    rb_define_singleton_method(rulesModule, "start_action_for_state", rbStartActionForState, 2);
+    rb_define_singleton_method(rulesModule, "complete_and_start_action", rbCompleteAndStartAction, 2);
     rb_define_singleton_method(rulesModule, "abandon_action", rbAbandonAction, 2);
     rb_define_singleton_method(rulesModule, "start_timer", rbStartTimer, 5);
     rb_define_singleton_method(rulesModule, "cancel_timer", rbCancelTimer, 3);