bitfield 0.9.1 → 0.9.2

data/README.rdoc

@@ -1,6 +1,6 @@
 = BitField
 
- This C extensions wraps boost::dynamic_bitset and makes it available
+ This C extension wraps boost::dynamic_bitset and makes it available
 as a native Ruby class. The bitset behaves like an an array allowing
 only values of 0 and 1. Using this extension is easy:
 
@@ -8,8 +8,8 @@ only values of 0 and 1. Using this extension is easy:
     puts b              # Prints '0000000000' where the last bit is b[0]
     b[0..3] = Array.new(4) {1}  # Sets bits 0 to 3 to 1
     
-Enjoy :)
-
+Note that in contrast to the Ruby Array behaviour the BitField does not
+automatically grow in size.
 
 = Licence
-Copyright(c) 2011 Fabian Becker, released under 3-clause BSD licence.
+Copyright(c) 2011 Fabian Becker, released under 2-clause BSD licence.

data/Rakefile

@@ -4,15 +4,15 @@ spec = Gem::Specification.new do |s|
   s.name              = 'bitfield'
   s.platform          = Gem::Platform::RUBY
   s.extensions        = FileList["ext/**/extconf.rb"]
-  s.version           = '0.9.1'
-  s.date              = "2011-10-25"
+  s.version           = '0.9.2'
+  s.date              = "2011-10-26"
   s.author            = 'Fabian Becker'
   s.email             = 'halfdan@xnorfz.de'
   s.homepage          = 'https://github.com/halfdan/ruby-bitfield/'
   s.summary           = "Wraps boost::dynamic_bitset and makes it available as a Ruby class 
                          for fast operations on a bitset"
 
-  s.description       = 'This C extensions wraps boost::dynamic_bitset and makes it available
+  s.description       = 'This C extension wraps boost::dynamic_bitset and makes it available
                          as a native Ruby class. The bitset behaves like an an array allowing
                          only values of 0 and 1.'
   

data/ext/bitfield/bitfield.cpp

@@ -32,17 +32,17 @@ static VALUE bf_init(VALUE self, VALUE size)
     BitField *ptr;
     Data_Get_Struct(self, BitField, ptr);
     ptr->data.resize(FIX2INT(size));
-	return self;
+    return self;
 }
 
 static VALUE bf_new(VALUE self, VALUE size)
 {
     VALUE *argv;
-	Check_Type(size, T_FIXNUM);
+    Check_Type(size, T_FIXNUM);
     BitField *ptr;
     argv[0] = size;
-	rb_obj_call_init(self, 1, argv);
-	return self;
+    rb_obj_call_init(self, 1, argv);
+    return self;
 }
 
 /**
@@ -51,27 +51,32 @@ static VALUE bf_new(VALUE self, VALUE size)
  */
 static VALUE bf_size(VALUE self)
 {
-	BitField *ptr;
-	Data_Get_Struct(self, BitField, ptr);
-	return INT2NUM(ptr->data.size());
+    BitField *ptr;
+    Data_Get_Struct(self, BitField, ptr);
+    return INT2NUM(ptr->data.size());
 }
 
 
 /**
- * Flips the n-th bit if position is given 
+ * Flips the n-th bit if position is given
  * flips all bits otherwise (TODO)
  */
 static VALUE bf_flip(int argc, VALUE *argv, VALUE self)
 {
     BitField *ptr;
     Data_Get_Struct(self, BitField, ptr);
-    if(argc == 1) {
-	Check_Type(argv[0], T_FIXNUM);
-	ptr->data[FIX2INT(argv[0])].flip();
-    } else if(argc == 0) {
-	ptr->data.flip();
-    } else {
-	rb_raise(rb_eArgError, "wrong number of arguments(%d for 1 or 0)", argc);
+    if(argc == 1)
+    {
+        Check_Type(argv[0], T_FIXNUM);
+        ptr->data[FIX2INT(argv[0])].flip();
+    }
+    else if(argc == 0)
+    {
+        ptr->data.flip();
+    }
+    else
+    {
+        rb_raise(rb_eArgError, "wrong number of arguments(%d for 1 or 0)", argc);
     }
     return Qnil;
 }
@@ -89,75 +94,99 @@ static VALUE bf_count(VALUE self)
 
 static VALUE bf_bit_set(VALUE self, VALUE position, VALUE value)
 {
-	BitField *ptr;
-	Data_Get_Struct(self, BitField, ptr);
+    BitField *ptr;
+    Data_Get_Struct(self, BitField, ptr);
 
-	if(rb_obj_is_kind_of(position, rb_cRange) 
-		&& rb_obj_is_kind_of(value, rb_cArray)) {
-		long beg, len;
-		VALUE tmp;
-		switch(rb_range_beg_len(position, &beg, &len, (long int)ptr->data.size()-1, 2)) {
-			case Qfalse:
-			case Qnil:
-				return Qfalse;
-			default:
-				for(long i = beg+len-1; i >= beg; i--) {
-					tmp = rb_ary_pop(value);
-					if(tmp != Qnil) {
-						ptr->data[i] = FIX2INT(tmp) % 2;
-					} else {
-						rb_raise(rb_eRangeError, "Array is smaller than given range.");
-					}
-				}
-		}
-	} else {
-		/* Sanity checks for position and value */
-		Check_Type(position, T_FIXNUM);
-		Check_Type(value, T_FIXNUM);
+    if(rb_obj_is_kind_of(position, rb_cRange)
+            && rb_obj_is_kind_of(value, rb_cArray))
+    {
+        long beg, len;
+        VALUE tmp;
+        switch(rb_range_beg_len(position, &beg, &len, (long int)ptr->data.size()-1, 2))
+        {
+            case Qfalse:
+            case Qnil:
+                return Qfalse;
+            default:
+                for(long i = beg+len-1; i >= beg; i--)
+                {
+                    tmp = rb_ary_pop(value);
+                    if(tmp != Qnil)
+                    {
+                        /* Is the array value a number? */
+                        Check_Type(tmp, T_FIXNUM);
+                        ptr->data[i] = FIX2INT(tmp) % 2;
+                    }
+                    else
+                    {
+                        rb_raise(rb_eRangeError, "Array is smaller than given range.");
+                    }
+                }
+        }
+    }
+    else
+    {
+        /* Sanity checks for position and value */
+        Check_Type(position, T_FIXNUM);
+        Check_Type(value, T_FIXNUM);
 
-		int pos = FIX2INT(position);
-		if(pos < 0 || pos >= ptr->data.size()) {
-			rb_raise(rb_eRangeError, "BitField out of range with value %d.", pos);
-		}
-		ptr->data[pos] = FIX2INT(value) % 2;
-	}
-	return Qnil;
+        int pos = FIX2INT(position);
+        if(pos < 0 || pos >= ptr->data.size())
+        {
+            rb_raise(rb_eRangeError, "BitField out of range with value %d.", pos);
+        }
+        ptr->data[pos] = FIX2INT(value) % 2;
+    }
+    return Qnil;
 }
 
 static VALUE bf_bit_get(VALUE self, VALUE position)
 {
-	BitField *ptr;
-	Data_Get_Struct(self, BitField, ptr);
+    BitField *ptr;
+    Data_Get_Struct(self, BitField, ptr);
 
-	/* Is position a range? */
-	if(rb_obj_is_kind_of(position, rb_cRange)) {
+    /* Is position a range? */
+    if(rb_obj_is_kind_of(position, rb_cRange))
+    {
         long beg, len;
         VALUE range_ary = rb_ary_new();
-        switch(rb_range_beg_len(position, &beg, &len, (long int)ptr->data.size()-1, 2)) {
+        switch(rb_range_beg_len(position, &beg, &len, (long int)ptr->data.size()-1, 2))
+        {
             case Qfalse:
             case Qnil:
                 return Qnil;
             default:
-                for(long i = beg; i < beg+len; i++) {
-                    rb_ary_push(range_ary, INT2NUM(ptr->data[i]));
+                for(long i = beg; i < beg+len; i++)
+                {
+                    if(i < 0 || i >= ptr->data.size()) {
+                        rb_ary_push(range_ary, Qnil);
+                    } else {
+                        rb_ary_push(range_ary, INT2NUM(ptr->data[i]));
+                    }
                 }
         }
-		return range_ary;
-	} else {
-		/* Sanity checks for position and value */
-		Check_Type(position, T_FIXNUM);
-		int pos = FIX2INT(position);
-		return INT2NUM(ptr->data[pos]);
-	}
+        return range_ary;
+    }
+    else
+    {
+        /* Sanity checks for position and value */
+        Check_Type(position, T_FIXNUM);
+        long pos = FIX2INT(position);
+        if(pos < 0 || pos >= ptr->data.size()) {
+            return Qnil;
+        } else {
+            return INT2NUM(ptr->data[pos]);
+        }
+    }
 }
 
 static VALUE bf_to_s(VALUE self)
 {
-	BitField *ptr;
-	Data_Get_Struct(self, BitField, ptr);
-	std::string buffer;
-	to_string(ptr->data, buffer);
-	return rb_str_new2(buffer.c_str());
+    BitField *ptr;
+    Data_Get_Struct(self, BitField, ptr);
+    std::string buffer;
+    to_string(ptr->data, buffer);
+    return rb_str_new2(buffer.c_str());
 }
 
 static VALUE bf_initialize_clone(VALUE self, VALUE orig)
@@ -170,8 +199,8 @@ static VALUE bf_initialize_clone(VALUE self, VALUE orig)
     return self;
 }
 
-/* 
- *Correctly free the struct 
+/*
+ *Correctly free the struct
  */
 void bf_free(BitField *ptr)
 {
@@ -181,86 +210,87 @@ void bf_free(BitField *ptr)
 static VALUE BitField_allocate(VALUE klass)
 {
     BitField *bf;
-	bf = ALLOC(BitField);
-	new(bf) BitField();
+    bf = ALLOC(BitField);
+    new(bf) BitField();
     VALUE tdata = Data_Wrap_Struct(klass, 0, bf_free, bf);
-	return tdata;
+    return tdata;
 }
 
 VALUE rb_cBitField;
 
 extern "C" {
-	void Init_bitfield() {
-		rb_cBitField = rb_define_class("BitField", rb_cObject);
+    void Init_bitfield()
+    {
+        rb_cBitField = rb_define_class("BitField", rb_cObject);
 
         rb_define_alloc_func(rb_cBitField, BitField_allocate);
 
         /* We do the same for .clone and .dup */
-		rb_define_method(
-			rb_cBitField,
-			"initialize_clone",
-			reinterpret_cast<VALUE(*)(...)>(bf_initialize_clone),
-			1
-		);
         rb_define_method(
-			rb_cBitField,
-			"initialize_dup",
-			reinterpret_cast<VALUE(*)(...)>(bf_initialize_clone),
-			1
-		);
+            rb_cBitField,
+            "initialize_clone",
+            reinterpret_cast<VALUE(*)(...)>(bf_initialize_clone),
+            1
+        );
+        rb_define_method(
+            rb_cBitField,
+            "initialize_dup",
+            reinterpret_cast<VALUE(*)(...)>(bf_initialize_clone),
+            1
+        );
 
         /* Returns the size of the bitset */
-		rb_define_method(
-			rb_cBitField,
-			"size",
-			reinterpret_cast<VALUE(*)(...)>(bf_size),
-			0
-		);
-		rb_define_method(
-			rb_cBitField,
-			"initialize",
-			reinterpret_cast<VALUE(*)(...)>(bf_init),
-			1
-		);
-		rb_define_method(
-			rb_cBitField,
-			"[]=",
-			reinterpret_cast<VALUE(*)(...)>(bf_bit_set),
-			2
-		);
-		rb_define_method(
-			rb_cBitField,
-			"[]",
-			reinterpret_cast<VALUE(*)(...)>(bf_bit_get),
-			1
-		);
-		rb_define_method(
-			rb_cBitField,
-			"to_s",
-			reinterpret_cast<VALUE(*)(...)>(bf_to_s),
-			0
-		);
-		rb_define_method(
-			rb_cBitField,
-			"flip",
-			reinterpret_cast<VALUE(*)(...)>(bf_flip),
-			-1
-		);
-		rb_define_method(
-			rb_cBitField,
-			"count",
-			reinterpret_cast<VALUE(*)(...)>(bf_count),
-			0
-		);
-	}
+        rb_define_method(
+            rb_cBitField,
+            "size",
+            reinterpret_cast<VALUE(*)(...)>(bf_size),
+            0
+        );
+        rb_define_method(
+            rb_cBitField,
+            "initialize",
+            reinterpret_cast<VALUE(*)(...)>(bf_init),
+            1
+        );
+        rb_define_method(
+            rb_cBitField,
+            "[]=",
+            reinterpret_cast<VALUE(*)(...)>(bf_bit_set),
+            2
+        );
+        rb_define_method(
+            rb_cBitField,
+            "[]",
+            reinterpret_cast<VALUE(*)(...)>(bf_bit_get),
+            1
+        );
+        rb_define_method(
+            rb_cBitField,
+            "to_s",
+            reinterpret_cast<VALUE(*)(...)>(bf_to_s),
+            0
+        );
+        rb_define_method(
+            rb_cBitField,
+            "flip",
+            reinterpret_cast<VALUE(*)(...)>(bf_flip),
+            -1
+        );
+        rb_define_method(
+            rb_cBitField,
+            "count",
+            reinterpret_cast<VALUE(*)(...)>(bf_count),
+            0
+        );
+    }
 }
 
 /* Library Code */
 BitField *BitFieldNew(int size)
 {
-	BitField *bf;
-	bf = ALLOC(BitField);
-	new(bf) BitField();
-	bf->data.resize(size);
-	return bf;
+    BitField *bf;
+    bf = ALLOC(BitField);
+    new(bf) BitField();
+    bf->data.resize(size);
+    return bf;
 }

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bitfield
 version: !ruby/object:Gem::Version
-  version: 0.9.1
+  version: 0.9.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,10 +9,9 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-10-25 00:00:00.000000000 +02:00
-default_executable: 
+date: 2011-10-26 00:00:00.000000000Z
 dependencies: []
-description: ! "This C extensions wraps boost::dynamic_bitset and makes it available\n
+description: ! "This C extension wraps boost::dynamic_bitset and makes it available\n
   \                        as a native Ruby class. The bitset behaves like an an array
   allowing\n                         only values of 0 and 1."
 email: halfdan@xnorfz.de
@@ -27,7 +26,6 @@ files:
 - ext/bitfield/bitfield.cpp
 - ext/bitfield/bitfield.hpp
 - ext/bitfield/extconf.rb
-has_rdoc: true
 homepage: https://github.com/halfdan/ruby-bitfield/
 licenses: []
 post_install_message: 
@@ -48,7 +46,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.6.2
+rubygems_version: 1.8.10
 signing_key: 
 specification_version: 3
 summary: Wraps boost::dynamic_bitset and makes it available as a Ruby class  for fast