bitmapper 0.1.1 → 0.1.2

data/ext/bitmapper/bit_mapper_wrap.c

@@ -29,7 +29,8 @@ void allocate_map(Bitmapper* map, int index_len){
   map->bkt_size = pow(10, 10 - index_len);
   map->bkt_count = size;
   map->index_len = index_len;
-  map->white_list_char = NULL;
+  map->filter_enabled = 0;
+  map->filter_status = bit_bucket_create(size);
   sprintf(map->fill_str, "%%llu%%0%illu\n",10-index_len);
 }
 
@@ -46,19 +47,29 @@ void free_map(Bitmapper* map){
       map->bkts[i] = NULL;
     }
   }
-  if(map->white_list_char != NULL) free(map->white_list_char);
+  if(map->filter_status != NULL) bit_bucket_free(map->filter_status);
   if(map->bkts != NULL) free(map->bkts);
 }
 
-void set_white_list_char(Bitmapper* map, char c){
-  if(map->white_list_char !=NULL) free(map->white_list_char);
-  map->white_list_char = (char*)malloc(sizeof(char));
-  map->white_list_char[0] = c;
+void enable_filter(Bitmapper* map){
+  map->filter_enabled = 1;
 }
 
-void clear_white_list_char(Bitmapper* map){
-  if(map->white_list_char !=NULL) free(map->white_list_char);
-  map->white_list_char = NULL;
+void disable_filter(Bitmapper* map){
+  map->filter_enabled = 0;
+}
+
+int set_in_filter(Bitmapper* map, unsigned long long int number){
+  map->filter_enabled = 1;
+  return bit_bucket_set_bit(map->filter_status, number);
+}
+
+int status_for_filter(Bitmapper* map, unsigned long long int number){
+  return bit_bucket_get_bit(map->filter_status, number);
+}
+
+int clear_in_filter(Bitmapper* map, unsigned long long int number){
+  return bit_bucket_clear_bit(map->filter_status, number);
 }
 
 /*
@@ -73,6 +84,7 @@ BitBucket* create_bucket_for(BitBucket* bkt, unsigned long long int size){
 
 /*
   Adds the given number to the bucket reperesented by the given index
+  if filter is enabled and the index is set in filter_status
   @param Bitmapper* the mapepr object to use
   @param unsigned long long int the offset to be added(if the offset is greater
   than bucket size it is rejected)
@@ -80,6 +92,7 @@ BitBucket* create_bucket_for(BitBucket* bkt, unsigned long long int size){
  */
 int add_num_in_bkt(Bitmapper* map,unsigned long long int offset, unsigned long long int bkt_index){
   if(bkt_index > map->bkt_count) return 1;
+  if(map->filter_enabled == 1 && status_for_filter(map, bkt_index) == 0) return 0; /* ignore silently */
   if((map->bkts[bkt_index]) == NULL)
     map->bkts[bkt_index] = (BitBucket*)create_bucket_for(map->bkts[bkt_index], map->bkt_size);
   if(bit_bucket_set_bit(map->bkts[bkt_index], offset) != 0){
@@ -112,6 +125,7 @@ int add_num(Bitmapper* map,unsigned long long int full_num){
 */
 int remove_num_in_bkt(Bitmapper* map,unsigned long long int offset, unsigned long long int bkt_index){
   if(bkt_index > map->bkt_count) return 1;
+  if(map->filter_enabled == 1 && status_for_filter(map, bkt_index) == 0) return 0; /* ignore silently */
   if(map->bkts[bkt_index] == NULL)
     return 0;
   if(bit_bucket_clear_bit(map->bkts[bkt_index], offset) != 0){
@@ -177,10 +191,7 @@ int add_numbers_in_file(Bitmapper* map,FILE *in){
   sprintf(scan_str, "%%%is%%%is\n",map->index_len, 10-map->index_len);
   while(fgets(msisdn, 15, in)!=NULL){
     sscanf(msisdn,scan_str, index, rest_num);
-    if(map->white_list_char !=NULL && strncmp(index, map->white_list_char, 1) != 0){
-    }else{
-      add_num_in_bkt(map, atoll(rest_num), atoll(index) );
-    }
+    add_num_in_bkt(map, atoll(rest_num), atoll(index) );
   }
 }
 

data/ext/bitmapper/bit_mapper_wrap.h

@@ -12,16 +12,21 @@ typedef struct Bitmapper{
   unsigned long long int bkt_size;   /* size of each bucket in bits */
   /* the format specifier used to dump number to file from buckets */
   int index_len;
-  char *white_list_char;
   char fill_str[20];
+  int filter_enabled;
+  BitBucket* filter_status;
 } Bitmapper;
 
 Bitmapper* create_map();
 void allocate_map(Bitmapper*, int);
 void free_map(Bitmapper*);
 BitBucket* create_bucket_for(BitBucket*, unsigned long long int);
-void set_white_list_char(Bitmapper*, char);
-void clear_white_list_char(Bitmapper*);
+
+void enable_filter(Bitmapper*);
+void disable_filter(Bitmapper*);
+int set_for_filter(Bitmapper* , unsigned long long int);
+int status_for_filter(Bitmapper*, unsigned long long int );
+int clear_in_filter(Bitmapper*, unsigned long long int);
 
 int add_num_in_bkt(Bitmapper* ,unsigned long long int, unsigned long long int);
 int add_num(Bitmapper* ,unsigned long long int);

data/ext/bitmapper/bitmapper.c

@@ -192,26 +192,47 @@ VALUE bm_num_status(VALUE self, VALUE num){
   return (VALUE)Qfalse;
 }
 
+VALUE bm_enable_filter(VALUE self){
+  Bitmapper* map;
+  Data_Get_Struct(self, Bitmapper, map);
+  enable_filter(map);
+  return self;
+}
 
-VALUE bm_set_filter(VALUE self, VALUE vCh){
-  int status;
-  char ch;
+VALUE bm_disable_filter(VALUE self){
+  Bitmapper* map;
+  Data_Get_Struct(self, Bitmapper, map);
+  disable_filter(map);
+  return self;
+}
+
+VALUE bm_set_filters(VALUE self, VALUE val){
+  int i;
   Bitmapper* map;
+  VALUE tmp;
 
+  if(TYPE(val) != T_ARRAY) rb_raise(rb_eRuntimeError, "Should be of type Array");
   Data_Get_Struct(self, Bitmapper, map);
-  vCh = rb_funcall(vCh, rb_intern("to_s"), 0); /* hack */
-  ch = NUM2CHR(vCh);
-  set_white_list_char(map, ch);
+  for(i=0; i< RARRAY_LEN(val); i++){
+    tmp = RARRAY_PTR(val)[i];
+    tmp = rb_funcall(tmp, rb_intern("to_s"), 0); /* hack */
+    set_in_filter(map, bm_to_ll(tmp));
+  }
   return (VALUE)Qtrue;
 }
 
-VALUE bm_clear_filter(VALUE self){
-  int status;
-  VALUE return_val;
+VALUE bm_clear_filters(VALUE self, VALUE val){
+  int i;
   Bitmapper* map;
+  VALUE tmp;
 
+  if(TYPE(val) != T_ARRAY) rb_raise(rb_eRuntimeError, "Should be of type Array");
   Data_Get_Struct(self, Bitmapper, map);
-  clear_white_list_char(map);
+  for(i=0; i< RARRAY_LEN(val); i++){
+    tmp = RARRAY_PTR(val)[i];
+    tmp = rb_funcall(tmp, rb_intern("to_s"), 0); /* hack */
+    clear_in_filter(map, bm_to_ll(tmp));
+  }
   return (VALUE)Qtrue;
 }
 
@@ -224,8 +245,12 @@ void Init_bitmapper(){
   rb_define_method(rb_cBitmapper, "add", bm_add_from_file, 1);
   rb_define_method(rb_cBitmapper, "remove", bm_remove_from_file, 1);
   rb_define_method(rb_cBitmapper, "dump_to", bm_dump_to_file, 1);
-  rb_define_method(rb_cBitmapper, "set_filter", bm_set_filter, 1);
-  rb_define_method(rb_cBitmapper, "clear_filter", bm_clear_filter, 0);
+
+  rb_define_method(rb_cBitmapper, "enable_filter", bm_enable_filter, 0);
+  rb_define_method(rb_cBitmapper, "disable_filter", bm_disable_filter, 0);
+  rb_define_method(rb_cBitmapper, "set_filters", bm_set_filters, 1);
+  rb_define_method(rb_cBitmapper, "clear_filters", bm_clear_filters, 1);
+
   rb_define_method(rb_cBitmapper, "load_from_str", bm_load_str_to_bkt, 2);
   rb_define_method(rb_cBitmapper, "dump_to_str", bm_dump_bkt_str, 2);
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bitmapper
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-07-05 00:00:00.000000000 Z
+date: 2012-07-16 00:00:00.000000000 Z
 dependencies: []
 description: A fast, in-memory, bit map filter!
 email: gouthamvel@gmail.com