Addresses #1031

Added invalidate_callback function to the OMTcursors.
Added tests for invalidate callback functions.

git-svn-id: file:///svn/tokudb@5203 c7de825b-a66e-492c-adef-691d508d4ae1

newbrt/omt.c

@@ -49,6 +49,8 @@ struct omt {
 
 struct omt_cursor {
     OMT omt;   // The omt this cursor is associated with.  NULL if not present.
+    void (*invalidate)(OMTCURSOR, void*);
+    void *invalidate_extra;
     u_int32_t index; // This is the state for the initial implementation
     OMTCURSOR next,prev; // circular linked list of all OMTCURSORs associated with omt.
 };
@@ -76,6 +78,8 @@ int toku_omt_cursor_create (OMTCURSOR *omtcp) {
     if (c==NULL) return errno;
     c->omt = NULL;
     c->next = c->prev = NULL;
+    c->invalidate = NULL;
+    c->invalidate_extra = NULL;
     *omtcp = c;
     return 0;
 }
@@ -84,8 +88,14 @@ OMT toku_omt_cursor_get_omt(OMTCURSOR c) {
     return c->omt;
 }
 
+void toku_omt_cursor_set_invalidate_callback(OMTCURSOR c, void (*f)(OMTCURSOR,void*), void* extra) {
+    c->invalidate = f;
+    c->invalidate_extra = extra;
+}
+
 void toku_omt_cursor_invalidate (OMTCURSOR c) {
     if (c==NULL || c->omt==NULL) return;
+    if (c->invalidate) c->invalidate(c, c->invalidate_extra);
     if (c->next == c) {
 	// It's the last one.
 	c->omt->associated = NULL;

newbrt/omt.h

@@ -453,7 +453,16 @@ int toku_omt_cursor_prev (OMTCURSOR c, OMTVALUE *v);
 void toku_omt_cursor_invalidate (OMTCURSOR c);
 // Effect: Invalidate c.  (This does not mean that c is destroyed or
 // that its memory is freed.)
-
+// If c is valid, the invalidate callback function (if any) will be called
+// before invalidating c.
+
+void toku_omt_cursor_set_invalidate_callback(OMTCURSOR c, void (*f)(OMTCURSOR,void*), void* extra);
+// Effect:
+//  Saves function 'f' to be called whenever the cursor is invalidated.
+//  'extra' is passed as an additional parameter to f.
+// Requires:
+//  The lifetime of the 'extra' parameter must continue at least till the cursor
+//  is destroyed.
 
 #endif  /* #ifndef OMT_H */
 

newbrt/tests/omt-test.c

@@ -843,11 +843,96 @@ void test_find(enum create_type create_choice, enum close_when_done close) {
     test_close(close);
 }
 
+void invalidate_callback_null(OMTCURSOR c, void *extra) {
+    assert(c && !extra);
+}
+
+void invalidate_callback_inc(OMTCURSOR c, void *extra) {
+    assert(c);
+    int *num = extra;
+    (*num)++;
+}
+
+void test_invalidate(enum create_type create_choice, BOOL set_callback, BOOL invalidate_callback) {
+    init_identity_values(random_seed, 100);
+    test_create_from_sorted_array(create_choice, KEEP_WHEN_DONE);
+
+    OMTCURSOR c;
+    int invalidate_count = 0;
+        
+    int r = toku_omt_cursor_create(&c);
+    if (set_callback || invalidate_callback) {
+        toku_omt_cursor_set_invalidate_callback(c, invalidate_callback_inc, &invalidate_count);
+    } 
+    if (invalidate_callback) {
+        toku_omt_cursor_set_invalidate_callback(c, invalidate_callback_null, NULL);
+    }
+    OMTVALUE val;
+    r = toku_omt_fetch(omt, 0, &val, c); CKERR(r);
+    assert(toku_omt_cursor_is_valid(c));
+    assert(invalidate_count==0);
+    r = toku_omt_cursor_prev(c, &val); CKERR2(r, EINVAL);
+    assert(!toku_omt_cursor_is_valid(c));
+    if (set_callback && !invalidate_callback) assert(invalidate_count==1);
+    else                                      assert(invalidate_count==0);
+    r = toku_omt_cursor_prev(c, &val); CKERR2(r, EINVAL);
+    assert(!toku_omt_cursor_is_valid(c));
+    if (set_callback && !invalidate_callback) assert(invalidate_count==1);
+    else                                      assert(invalidate_count==0);
+
+    r = toku_omt_fetch(omt, toku_omt_size(omt)-1, &val, c); CKERR(r);
+    assert(toku_omt_cursor_is_valid(c));
+    if (set_callback && !invalidate_callback) assert(invalidate_count==1);
+    else                                      assert(invalidate_count==0);
+
+    r = toku_omt_cursor_prev(c, &val); CKERR(r);
+    assert(toku_omt_cursor_is_valid(c));
+    if (set_callback && !invalidate_callback) assert(invalidate_count==1);
+    else                                      assert(invalidate_count==0);
+    r = toku_omt_cursor_next(c, &val); CKERR(r);
+    assert(toku_omt_cursor_is_valid(c));
+    if (set_callback && !invalidate_callback) assert(invalidate_count==1);
+    else                                      assert(invalidate_count==0);
+    r = toku_omt_cursor_next(c, &val); CKERR2(r, EINVAL);
+    assert(!toku_omt_cursor_is_valid(c));
+    if (set_callback && !invalidate_callback) assert(invalidate_count==2);
+    else                                      assert(invalidate_count==0);
+
+    r = toku_omt_fetch(omt, toku_omt_size(omt)-1, &val, c); CKERR(r);
+    assert(toku_omt_cursor_is_valid(c));
+    if (set_callback && !invalidate_callback) assert(invalidate_count==2);
+    else                                      assert(invalidate_count==0);
+
+    test_close(CLOSE_WHEN_DONE);
+    assert(!toku_omt_cursor_is_valid(c));
+    if (set_callback && !invalidate_callback) assert(invalidate_count==3);
+    else                                      assert(invalidate_count==0);
+
+    init_identity_values(random_seed, 100);
+    test_create_from_sorted_array(create_choice, KEEP_WHEN_DONE);
+    r = toku_omt_fetch(omt, toku_omt_size(omt)-1, &val, c); CKERR(r);
+    assert(toku_omt_cursor_is_valid(c));
+    if (set_callback && !invalidate_callback) assert(invalidate_count==3);
+    else                                      assert(invalidate_count==0);
+
+    toku_omt_cursor_destroy(&c);
+    if (set_callback && !invalidate_callback) assert(invalidate_count==4);
+    else                                      assert(invalidate_count==0);
+
+    test_close(CLOSE_WHEN_DONE);
+    if (set_callback && !invalidate_callback) assert(invalidate_count==4);
+    else                                      assert(invalidate_count==0);
+}
+
 void runtests_create_choice(enum create_type create_choice) {
     test_create_array(create_choice, TEST_SORTED);
     test_create_array(create_choice, TEST_RANDOM);
     test_create_array(create_choice, TEST_IDENTITY);
     test_find(        create_choice, CLOSE_WHEN_DONE);
+    test_invalidate(  create_choice, FALSE, FALSE);
+    test_invalidate(  create_choice, FALSE, TRUE);
+    test_invalidate(  create_choice, TRUE,  FALSE);
+    test_invalidate(  create_choice, TRUE,  TRUE);
 }
 
 int main(int argc, const char *argv[]) {