bitmapper 0.0.1

data/ext/bitmapper/bit_bucket.c

@@ -0,0 +1,143 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "bit_bucket.h"
+
+void _bit_bucket_set_bit_to(BitBucket* ptr,unsigned long long int byte_part, int bit_part, unsigned val){
+  val = (val == 0) ? 0 : 1;
+  switch(bit_part){
+  case 0: ptr->bucket[byte_part].f0 = val;break;
+  case 1: ptr->bucket[byte_part].f1 = val;break;
+  case 2: ptr->bucket[byte_part].f2 = val;break;
+  case 3: ptr->bucket[byte_part].f3 = val;break;
+  case 4: ptr->bucket[byte_part].f4 = val;break;
+  case 5: ptr->bucket[byte_part].f5 = val;break;
+  case 6: ptr->bucket[byte_part].f6 = val;break;
+  case 7: ptr->bucket[byte_part].f7 = val;break;
+  };
+}
+
+/*
+  sets the of given bit location to 1
+  @param BitBucket* pointer to the bit bucket to use, users
+  responsablity to ensure pointer is valid
+  @param num the bit location
+*/
+int bit_bucket_set_bit(BitBucket* ptr,unsigned long long int num){
+  unsigned long long int byte_part=num/8, bit_part=num%8;
+  if(num > ptr->size) return 1;
+  _bit_bucket_set_bit_to(ptr, byte_part, bit_part, 1);
+  return 0;
+}
+
+/*
+  clears the state of given bit location to 0
+  @param BitBucket* pointer to the bit bucket to use, users
+  responsablity to ensure pointer is valid
+  @param num the bit location
+*/
+int bit_bucket_clear_bit(BitBucket* ptr,unsigned long long int num){
+  unsigned long long int byte_part=num/8, bit_part=num%8;
+  if(num > ptr->size) return 1;
+  _bit_bucket_set_bit_to(ptr, byte_part, bit_part, 0);
+  return 0;
+}
+
+/*
+  returns the current state of given bit location
+  @param BitBucket* pointer to the bit bucket to use, users
+  responsablity to ensure pointer is valid
+  @param num the bit location
+*/
+int bit_bucket_get_bit(BitBucket* ptr,unsigned long long int num){
+  unsigned long long int byte_part=num/8, bit_part=num%8;
+  if(num > ptr->size) return 2;
+  switch(bit_part){
+  case 0: return ptr->bucket[byte_part].f0;
+  case 1: return ptr->bucket[byte_part].f1;
+  case 2: return ptr->bucket[byte_part].f2;
+  case 3: return ptr->bucket[byte_part].f3;
+  case 4: return ptr->bucket[byte_part].f4;
+  case 5: return ptr->bucket[byte_part].f5;
+  case 6: return ptr->bucket[byte_part].f6;
+  case 7: return ptr->bucket[byte_part].f7;
+  };
+}
+
+/*
+  Resets the given BitBucket*
+  @param BitBucket* pointer to the bit bucket to use, users
+  responsablity to ensure pointer is valid
+*/
+void bit_bucket_reset(BitBucket *ptr){
+  unsigned long long int count = ptr->size/8+1, i;
+  for(i=0;i<count;i++){
+    ptr->bucket[i] = (ByteBits){0,0,0,0,0,0,0,0};
+  }
+}
+
+/*
+  Creates BitBucket with the given size and allocates the requried
+  memory. A reset on all bits is done after creating the memory.
+  @param long long size Number of bits you want to allocate.
+*/
+BitBucket* bit_bucket_create(unsigned long long int size){
+  unsigned long long int count = size/8 + 1;
+  BitBucket *ptr = (BitBucket*)malloc(sizeof(BitBucket));
+  ptr->size = size;
+  ptr->bucket = (ByteBits*)malloc(count*sizeof(ByteBits));
+  bit_bucket_reset(ptr);
+  return ptr;
+}
+
+/*
+  gives the size of the BitBucket in bytes
+  @param BitBucket* pointer to the bit bucket to use, users
+  responsablity to ensure pointer is valid
+*/
+unsigned long long int bit_bucket_size(BitBucket *ptr){
+  return ptr->size/8+1;
+}
+
+/*
+  gives the string representation of BitBucket
+  @param BitBucket* pointer to the bit bucket to use, users
+  responsablity to ensure pointer is valid
+*/
+void bit_bucket_string(BitBucket *ptr, unsigned char* raw){
+  unsigned long long int count = ptr->size/8+1, i;
+  if(ptr == NULL){
+    puts("######### ERROR: ptr is returning null");
+  }
+  memcpy(raw,ptr->bucket, count);
+}
+
+/*
+  Copies 1 Byte of given string to BitBucket* memory at given position
+  @param BitBucket* pointer to the bit bucket to use, users
+  responsablity to ensure pointer is valid
+  @param char* pointer to location where the 1 Byte is located
+  @pos unsigned long long int the offset byte location in BitBucket to be modified
+*/
+int bit_bucket_load_byte(BitBucket* ptr,char *buf, unsigned long long int pos){
+  unsigned long long int count = ptr->size/8+1, i;
+  if(ptr == NULL){
+    printf("####### ERROR: ptr is returning null");
+    return 2;
+  }
+  if(count < pos) return 2;
+  memcpy(ptr->bucket+pos, buf, 1);
+  return 1;
+}
+
+/*
+  Frees all the memory allocated by bit_bucket_create
+  Should be called before dereferencing BitBucket pointer
+  returned by bit_bucket_create
+  @param BitBucket* the pointer to be cleared
+*/
+void bit_bucket_free(BitBucket *ptr){
+  free(ptr->bucket);
+  free(ptr);
+}

data/ext/bitmapper/bit_bucket.h

@@ -0,0 +1,37 @@
+#ifndef BIT_BUCKET
+#define BIT_BUCKET
+
+/*
+  this is the bitfield which takes 1 byte(8-bits) of space in memory
+*/
+typedef struct ByteBits{
+  unsigned char  f0:1;
+  unsigned char  f1:1;
+  unsigned char  f2:1;
+  unsigned char  f3:1;
+  unsigned char  f4:1;
+  unsigned char  f5:1;
+  unsigned char  f6:1;
+  unsigned char  f7:1;
+} ByteBits;
+
+/*
+  wrapper for sequence of ByteBits number of Bytebits will be
+  given_size(in bits)/8 + 1
+*/
+typedef struct BitBucket{
+  ByteBits *bucket;
+  unsigned long long int size;         /* size in bits as given */
+} BitBucket;
+
+void _bit_bucket_set_bit_to(BitBucket* ptr,unsigned long long int byte_part, int bit_part, unsigned val);
+int bit_bucket_set_bit(BitBucket* ptr,unsigned long long int num);
+int bit_bucket_clear_bit(BitBucket* ptr,unsigned long long int num);
+int bit_bucket_get_bit(BitBucket* ptr,unsigned long long int num);
+void bit_bucket_reset(BitBucket *ptr);
+BitBucket* bit_bucket_create(unsigned long long int size);
+unsigned long long int bit_bucket_size(BitBucket *ptr);
+void bit_bucket_string(BitBucket *ptr, unsigned char* raw);
+int bit_bucket_load_byte(BitBucket* ptr,char *buf, unsigned long long int pos);
+void bit_bucket_free(BitBucket *ptr);
+#endif /* BIT_BUCKET */

data/ext/bitmapper/bit_mapper_wrap.c

@@ -0,0 +1,349 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+
+#include "bit_mapper_wrap.h"
+/* #include "bit_bucket.c" */
+
+/*
+   Creates empty Bitmapper*. Without BitBucket pointers.
+*/
+Bitmapper* create_map(){
+  Bitmapper* map;
+  map =  (Bitmapper*)malloc(sizeof(Bitmapper));
+  return map;
+}
+
+/*
+  Buckets are not allocated space a this point. They will be created
+  on the fly.
+  @param int Number of digits from left(Most Significant Digits) to be used
+  for indexing 10^(10-index) will be the size of the bucket in bits.
+*/
+void allocate_map(Bitmapper* map, int index_len){
+  unsigned long long int size = pow(10, index_len),i;
+  map->bkts = (BitBucket**)malloc(size*sizeof(BitBucket*));
+  for(i=0;i<size; i++){
+    map->bkts[i] = NULL;
+  }
+  map->bkt_size = pow(10, 10 - index_len);
+  map->bkt_count = size;
+  map->index_len = index_len;
+  sprintf(map->fill_str, "%%llu%%0%illu\n",10-index_len);
+}
+
+/*
+  Clears the memory allocated by create_map and create_bucket_for(if available)
+  @param Bitmapper* the Bitmapper* object to clear, only the buckets in
+  the bitmap obj and the buckets pointer will be freed
+*/
+void free_map(Bitmapper* map){
+  unsigned long long int i;
+  for(i=0;i<map->bkt_count; i++){
+    if((map->bkts[i])!=NULL) bit_bucket_free(map->bkts[i]);
+  }
+  free(map->bkts);
+  free(map);
+}
+
+/*
+  Creates a Bitbucket with the given size and returns the pointer
+  @param BitBucket* the pointer to the bucket
+  @param unsigned long long int the size of bucket in bits
+ */
+BitBucket* create_bucket_for(BitBucket* bkt, unsigned long long int size){
+  bkt = bit_bucket_create(size);
+  return bkt;
+}
+
+/*
+  Adds the given number to the bucket reperesented by the given index
+  @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)
+  @param unsigned long long int the index of the bucket that will hold the number
+ */
+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->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){
+    puts("out of range");
+    return 1;/* ERROR out of range */
+  }
+  return 0;
+}
+
+/*
+  Wrapper for add_num_in_bkt, splits the given number into index and
+  bit location
+  @param Bitmapper* the mapepr object to use
+  @param unsigned long long int the number
+ */
+int add_num(Bitmapper* map,unsigned long long int full_num){
+  unsigned long long int offset, bkt_index, div;
+  div = pow(10, 10-map->index_len);
+  bkt_index = full_num / div;
+  offset = full_num % div;
+  return add_num_in_bkt(map, offset, bkt_index);
+}
+
+/*
+  Removes the given number from the bucket reperesented by the given index
+  @param Bitmapper* the mapepr object to use
+  @param unsigned long long int the offset to be Removed(if the offset is greater
+  than bucket size it is rejected)
+  @param unsigned long long int the index of the bucket that would be hold the number
+*/
+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->bkts[bkt_index] == NULL)
+    return 0;
+  if(bit_bucket_clear_bit(map->bkts[bkt_index], offset) != 0){
+    puts("out of range");
+    return 1;/* ERROR out of range */
+  }
+  return 0;
+}
+
+/*
+  Wrapper for remove_num_in_bkt, splits the given number into index and
+  bit location
+  @param Bitmapper* the mapepr object to use
+  @param unsigned long long int the number
+*/
+int remove_num(Bitmapper* map,unsigned long long int full_num){
+  unsigned long long int offset, bkt_index, div;
+  div = pow(10, 10-map->index_len);
+  bkt_index = full_num / div;
+  offset = full_num % div;
+  return remove_num_in_bkt(map, offset, bkt_index);
+}
+
+/*
+  returns the status of the given bit offset in the bucket reperesented by the given index
+  @param Bitmapper* the mapepr object to use
+  @param unsigned long long int the offset to be checked(if the number is greater
+  than bucket size it is rejected)
+  @param unsigned long long int the index of the bucket that would be hold the number
+*/
+int status_num_in_bkt(Bitmapper* map,unsigned long long int offset, unsigned long long int bkt_index){
+  if(bkt_index > map->bkt_count) return 2;
+  if(map->bkts[bkt_index] == NULL)
+    return 0;
+  return bit_bucket_get_bit(map->bkts[bkt_index], offset);
+}
+
+/*
+  Wrapper for status_num_in_bkt, splits the given number into index and
+  bit location
+  @param Bitmapper* the mapepr object to use
+  @param unsigned long long int the number
+*/
+int status_num(Bitmapper* map,unsigned long long int full_num){
+  unsigned long long int offset, bkt_index, div;
+  div = pow(10, 10-map->index_len);
+  bkt_index = full_num / div;
+  offset = full_num % div;
+  return status_num_in_bkt(map, offset, bkt_index);
+}
+
+/*
+  A wrapper method which take a file and loads all the numbers in that
+  file into Bitmapper*. Works with DOS & unix files.
+  @param Bitmapper* the mapepr object to use
+  @param FILE* the file pointer to the opened file
+
+  TODO: check for validity of number
+ */
+int add_numbers_in_file(Bitmapper* map,FILE *in){
+  char scan_str[20];
+  char msisdn[15], index[map->index_len], rest_num[10-map->index_len];
+  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);
+    add_num_in_bkt(map, atoll(rest_num), atoll(index) );
+  }
+}
+
+/*
+  A wrapper method which take a file and removes all the numbers in that
+  file from Bitmapper* if the number exist. Works with DOS & unix files.
+  @param Bitmapper* the mapepr object to use
+  @param FILE* the file pointer to the opened file
+
+  TODO: check for validity of number
+ */
+int remove_numbers_in_file(Bitmapper* map,FILE *del){
+  char scan_str[20];
+  char msisdn[15], index[map->index_len], rest_num[10-map->index_len];
+  sprintf(scan_str, "%%%is%%%is\n",map->index_len, 10-map->index_len);
+  while(fgets(msisdn, 15, del)!=NULL){
+    sscanf(msisdn,scan_str, index, rest_num);
+    remove_num_in_bkt(map, atoll(rest_num), atoll(index) );
+  }
+}
+
+/*
+  Dumps the number in bucket(if available) into the given file
+  @param Bitmapper* the mapepr object to use
+  @param FILE* the file pointer to the opened file
+  @param unsigned long long int index to the bucket to consider
+ */
+int dump_bucket_to_file(Bitmapper* map, FILE* fp, unsigned long long int bkt_index){
+  unsigned long long int i;
+  unsigned num;
+  if(map->bkt_count<=bkt_index) return 1;
+
+  if(map->bkts[bkt_index] == NULL)
+    return 2;
+  for(i=0;i<map->bkt_size;i++){
+    num = bit_bucket_get_bit(map->bkts[bkt_index], i);
+    if(num==1){
+      fprintf(fp, map->fill_str, bkt_index, i);
+    }
+  }
+  return 0;
+}
+
+/*
+  Dumps all numbers set in Bitmapper* in into the given file
+  @param Bitmapper* the mapepr object to use
+  @param FILE* the file pointer to the opened file
+  @param unsigned long long int the length of index
+ */
+int dump_all_to_file(Bitmapper* map, FILE* fp){
+  unsigned long long int i;
+  for(i=0;i<map->bkt_count;i++){
+    dump_bucket_to_file(map, fp, i);
+  }
+  return 0;
+}
+
+/*
+  Dumps the bucket's(if available) bit values into the given file
+  @param Bitmapper* the mapepr object to use
+  @param FILE* the file pointer to the opened file
+  @param unsigned long long int index to the bucket to consider
+
+  TODO: If the bucket doesn't exist, dump empty string equal to the
+  size of the bucket
+ */
+int dump_bucket_str_to_file(Bitmapper* map, FILE* fp,unsigned long long int bkt_index){
+  unsigned char* raw = (unsigned char*)malloc(map->bkt_size/8+1);
+  BitBucket* tmp;
+  if(map->bkts[bkt_index] == NULL)
+    tmp = bit_bucket_create(map->bkt_size);
+  else
+    tmp = map->bkts[bkt_index];
+  bit_bucket_string(tmp, raw);
+  fwrite(raw, 1, bit_bucket_size(tmp), fp);
+
+  if(map->bkts[bkt_index] == NULL)
+    bit_bucket_free(tmp);
+  free(raw);
+  return 0;
+}
+
+/*
+  Dumps all bucket's bit values into the given file
+  @param Bitmapper* the mapepr object to use
+  @param FILE* the file pointer to the opened file
+  @param unsigned long long int the length of index
+ */
+int dump_all_str_to_file(Bitmapper* map, FILE* fp){
+  unsigned long long int i;
+  for(i=0;i<map->bkt_count;i++){
+    dump_bucket_str_to_file(map, fp, i);
+  }
+  return 0;
+}
+
+/*
+  Loads binary string from file to given bitmap bucket. Creates
+  bucket if it doesn't exist
+  @param Bitmapper* the mapepr object to use
+  @param FILE* the file pointer to the opened file
+  @param unsigned long long int the index of bucket to load
+ */
+int load_str_file_to_bucket(Bitmapper* map, FILE* fp,unsigned long long int bkt_index){
+  unsigned long long int size,i;
+  char buf[1];
+  if(map->bkts[bkt_index] == NULL){
+    puts("creating bucket");
+    map->bkts[bkt_index] = (BitBucket*)create_bucket_for(map->bkts[bkt_index], map->bkt_size);
+  }
+
+  size = bit_bucket_size(map->bkts[bkt_index]);
+  for(i=0;i<size;i++){
+    fread(buf, 1, 1, fp);
+    if(buf == NULL) break;
+    bit_bucket_load_byte(map->bkts[bkt_index], buf, i);
+  }
+  return 0;
+}
+
+/*
+  Loads binary string from file to given bitmap-> Creates
+  bucket if it doesn't exist.
+  * The load is one-one bit maping.
+  * bits exceding Bitmapper* size(buckets count * size of each bucket
+  in bits) will be ignored
+  * the size of the bucket reperesented in file string must be equal
+  to the size of bucket in Bitmapper*.
+  @param Bitmapper* the mapepr object to use
+  @param FILE* the file pointer to the opened file
+  @param unsigned long long int the index of bucket to load
+ */
+int load_str_file(Bitmapper* map, FILE* fp){
+  unsigned long long int size, i, bkt_no;
+  char buf[1];
+  for(bkt_no = 0;bkt_no < map->bkt_count; bkt_no++){
+    if(map->bkts[bkt_no] == NULL){
+      // TODO
+      puts("creating bucket");
+      map->bkts[bkt_no] = (BitBucket*)create_bucket_for(map->bkts[bkt_no], map->bkt_size);
+    }
+    size = bit_bucket_size(map->bkts[bkt_no]);
+    for(i=0;i<size;i++){
+      fread(buf, 1, 1, fp);
+      if(buf == NULL) return 0;
+      bit_bucket_load_byte(map->bkts[bkt_no], buf, i);
+    }
+    return 0;
+  }
+}
+
+void test(){
+  int index_len = 6;
+  FILE *in, *out, *del, *str_out, *str_in;
+  Bitmapper* map = create_map();
+  allocate_map(map, index_len);
+  in = fopen("/tmp/ncpr/out.txt","r");
+  add_numbers_in_file(map, in);
+  /* in = fopen("test/data/1-add.txt","r"); */
+  /* del = fopen("test/data/1-del.txt","r"); */
+  out = fopen("/tmp/ncpr/out2.txt","w");
+  /* str_out = fopen("/tmp/ncpr/str_out.txt","w"); */
+  /* add_numbers_in_file(map, in, index_len); */
+  /* //   remove_numbers_in_file(map, del); */
+  /* /\* dump_all_str_to_file( map, str_out); *\/ */
+  /* dump_bucket_str_to_file(map, str_out,  934793); */
+  /* fclose(str_out); */
+  /* str_in = fopen("/tmp/ncpr/str_out.txt","r"); */
+  /* load_str_file_to_bucket(map, str_in,  934793); */
+  /* puts("dumping to file"); */
+  dump_all_to_file(map, out);
+
+
+  fclose(in);
+  /* fclose(del); */
+  fclose(out);
+  /* fclose(str_in); */
+  free_map(map);
+}
+
+void main(){
+  test();
+}

data/ext/bitmapper/bit_mapper_wrap.h

@@ -0,0 +1,39 @@
+#include "bit_bucket.h"
+
+#ifndef BIT_MAPPER_WRAP
+#define BIT_MAPPER_WRAP
+
+/*
+  Bitmapper Object holds the buckets pointer and other info
+*/
+typedef struct Bitmapper{
+  BitBucket** bkts;         /* pointer to list of pointers(count=bkt_count) */
+  unsigned long long int bkt_count;  /* number of buckets in 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 fill_str[20];
+} Bitmapper;
+
+Bitmapper* create_map();
+void allocate_map(Bitmapper*, int);
+void free_map(Bitmapper*);
+BitBucket* create_bucket_for(BitBucket*, 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);
+int remove_num_in_bkt(Bitmapper* ,unsigned long long int, unsigned long long int);
+int remove_num(Bitmapper* ,unsigned long long int);
+int status_num_in_bkt(Bitmapper* ,unsigned long long int, unsigned long long int);
+int status_num(Bitmapper* ,unsigned long long int);
+
+int add_numbers_in_file(Bitmapper* ,FILE*);
+int remove_numbers_in_file(Bitmapper* ,FILE* );
+int dump_bucket_to_file(Bitmapper*, FILE* , unsigned long long int);
+int dump_all_to_file(Bitmapper* , FILE* );
+
+int dump_bucket_str_to_file(Bitmapper* , FILE* ,unsigned long long int );
+int dump_all_str_to_file(Bitmapper* , FILE*);
+int load_str_file_to_bucket(Bitmapper* , FILE* ,unsigned long long int);
+int load_str_file(Bitmapper* , FILE*);
+
+#endif  /* BIT_MAPPER_WRAP */

data/ext/bitmapper/bitmapper.c

@@ -0,0 +1,198 @@
+#include "ruby.h"
+#include "bit_mapper_wrap.h"
+
+static VALUE rb_cBitmapper;
+static ID index_len;
+
+VALUE bm_init(VALUE self, VALUE len){
+  Bitmapper* map;
+  Data_Get_Struct(self, Bitmapper, map);
+  allocate_map(map, FIX2INT(len));
+  rb_iv_set(self, "@index_len", len);
+  return self;
+}
+
+/*
+   TODO: check if void* to Bitmapper* is a safe cast
+ */
+void bm_free(void *p){
+  free_map((Bitmapper*)p);
+}
+
+VALUE bm_alloc(VALUE self){
+  Bitmapper* map;
+  map = create_map();
+  return Data_Wrap_Struct(self, 0, bm_free, map);
+}
+
+/*
+   Generates current index and assign it to @indexes variable
+ */
+VALUE bm_referesh_indexes(VALUE self){
+  Bitmapper* map;
+  ID id_push;
+  VALUE arr;
+  FILE *fp;
+  unsigned long long int i;
+  arr = rb_ary_new();
+  id_push = rb_intern("push");
+  Data_Get_Struct(self, Bitmapper, map);
+
+  rb_funcall(arr, rb_intern("clear"), 0);
+  for(i=0;i<map->bkt_count;i++)
+    if(map->bkts[i] != NULL)
+      rb_funcall(arr, id_push, 1, LL2NUM(i));
+
+  rb_iv_set(self, "@indexes", arr);
+  return self;
+}
+
+/*
+   Call to refresh indexs in @indexes
+   and return the value
+ */
+VALUE bm_get_indexes(VALUE self){
+  bm_referesh_indexes(self);
+  return rb_iv_get(self, "@indexes");
+}
+
+VALUE bm_add_from_file(VALUE self, VALUE file_str){
+  Bitmapper* map;
+  FILE *fp;
+  Data_Get_Struct(self, Bitmapper, map);
+  fp = fopen(RSTRING_PTR(StringValue(file_str)), "r");
+  if(fp == NULL) rb_raise(rb_eIOError, "file counld not be opened");
+  add_numbers_in_file(map, fp);
+  fclose(fp);
+  return self;
+}
+
+VALUE bm_remove_from_file(VALUE self, VALUE file_str){
+  Bitmapper* map;
+  FILE *fp;
+  Data_Get_Struct(self, Bitmapper, map);
+  fp = fopen(RSTRING_PTR(StringValue(file_str)), "r");
+  if(fp == NULL) rb_raise(rb_eIOError, "file counld not be opened");
+  remove_numbers_in_file(map, fp);
+  fclose(fp);
+  return self;
+}
+
+VALUE bm_dump_to_file(VALUE self, VALUE file_str){
+  Bitmapper* map;
+  FILE *fp;
+  Data_Get_Struct(self, Bitmapper, map);
+  fp = fopen(RSTRING_PTR(StringValue(file_str)), "w");
+  if(fp == NULL) rb_raise(rb_eIOError, "file counld not be opened");
+  dump_all_to_file(map, fp);
+  fclose(fp);
+  return self;
+}
+
+VALUE bm_load_str_to_bkt(VALUE self, VALUE file_str, VALUE index){
+  Bitmapper* map;
+  FILE *fp;
+  Data_Get_Struct(self, Bitmapper, map);
+  fp = fopen(RSTRING_PTR(StringValue(file_str)), "r");
+  if(fp == NULL) rb_raise(rb_eIOError, "file counld not be opened");
+  load_str_file_to_bucket(map, fp, NUM2LL(index));
+  fclose(fp);
+  return self;
+}
+
+VALUE bm_dump_bkt_str(VALUE self, VALUE file_str, VALUE index){
+  Bitmapper* map;
+  FILE *fp;
+  Data_Get_Struct(self, Bitmapper, map);
+  fp = fopen(RSTRING_PTR(StringValue(file_str)), "w");
+  if(fp == NULL) rb_raise(rb_eIOError, "file counld not be opened");
+  dump_bucket_str_to_file(map, fp, NUM2LL(index));
+  fclose(fp);
+  return self;
+}
+
+/*
+   helper method, works as to_i for various datatypes
+ */
+unsigned long long int bm_to_ll(VALUE num){
+  VALUE tmp;
+  switch(TYPE(num)){
+  case T_STRING:
+    tmp = rb_funcall(num, rb_intern("to_i"), 0); /* hack */
+    return NUM2LL(tmp);
+  case T_FIXNUM:
+  case T_BIGNUM:
+    return NUM2LL(num);
+  }
+  return 0;
+}
+
+/*
+  adds the given number to bitmapper
+*/
+VALUE bm_set(VALUE self, VALUE num){
+  int status;
+  Bitmapper* map;
+
+  Data_Get_Struct(self, Bitmapper, map);
+  status = add_num(map, bm_to_ll(num));
+  if(status==0)
+    return (VALUE)Qtrue;
+  else
+    rb_raise(rb_eTypeError, "not valid number");
+  return (VALUE)Qfalse;
+}
+
+/*
+  removes the given number from bitmapper
+*/
+VALUE bm_clear(VALUE self, VALUE num){
+  int status;
+  Bitmapper* map;
+
+  Data_Get_Struct(self, Bitmapper, map);
+  status = remove_num(map, bm_to_ll(num));
+  if(status==0)
+    return (VALUE)Qtrue;
+  else
+    rb_raise(rb_eTypeError, "not valid number");
+  return (VALUE)Qfalse;
+}
+
+/*
+  returns true if the provided number is present in bitmap or returns
+  false
+*/
+VALUE bm_num_status(VALUE self, VALUE num){
+  int status;
+  VALUE return_val;
+  Bitmapper* map;
+
+  Data_Get_Struct(self, Bitmapper, map);
+  status = status_num(map, bm_to_ll(num));
+  if(status==1)
+    return (VALUE)Qtrue;
+  else if(status == 0)
+    return (VALUE)Qfalse;
+  else
+    rb_raise(rb_eTypeError, "not valid number");
+  return (VALUE)Qfalse;
+
+}
+
+void Init_bitmapper(){
+  rb_cBitmapper = rb_define_class("Bitmapper", rb_cObject);
+  rb_define_alloc_func(rb_cBitmapper, bm_alloc);
+  rb_define_method(rb_cBitmapper, "initialize", bm_init, 1);
+  rb_define_method(rb_cBitmapper, "get_indexes", bm_get_indexes, 0);
+  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, "load_from_str", bm_load_str_to_bkt, 2);
+  rb_define_method(rb_cBitmapper, "dump_to_str", bm_dump_bkt_str, 2);
+
+  rb_define_method(rb_cBitmapper, "status?", bm_num_status, 1);
+  rb_define_method(rb_cBitmapper, "set", bm_set, 1);
+  rb_define_method(rb_cBitmapper, "clear", bm_clear, 1);
+
+}

data/ext/bitmapper/extconf.rb

@@ -0,0 +1,11 @@
+# Loads mkmf which is used to make makefiles for Ruby extensions
+require 'mkmf'
+
+# Give it a name
+extension_name = 'bitmapper'
+
+# The destination
+dir_config("bitmapper/#{extension_name}")
+
+# Do the work
+create_makefile("bitmapper/#{extension_name}")

data/lib/bitmapper.rb

@@ -0,0 +1,5 @@
+begin
+  require 'bitmapper/bitmapper'
+rescue LoadError =>e
+  puts "Error loading c binding for bitmapepr"
+end

metadata

@@ -0,0 +1,52 @@
+--- !ruby/object:Gem::Specification
+name: bitmapper
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Goutham Vel
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-06-11 00:00:00.000000000 Z
+dependencies: []
+description: PENDING
+email: gouthamvel@gmail.com
+executables: []
+extensions:
+- ext/bitmapper/extconf.rb
+extra_rdoc_files: []
+files:
+- lib/bitmapper.rb
+- ext/bitmapper/bitmapper.c
+- ext/bitmapper/bit_bucket.c
+- ext/bitmapper/bit_mapper_wrap.c
+- ext/bitmapper/bit_bucket.h
+- ext/bitmapper/bit_mapper_wrap.h
+- ext/bitmapper/extconf.rb
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: A fast bit map filter!
+test_files: []