bindata 0.9.1 → 0.9.2

data/ChangeLog

@@ -1,5 +1,13 @@
 = BinData Changelog
 
+== Version 0.9.2 (2008-07-18)
+
+* Added lazy instantiation to allow recursive definitions.
+* Array elements can be appended at any position.
+* Deprecated the :readwrite parameter.
+* Removed feature where Struct fields names could be nil.
+* Reworked sanitizing system.
+
 == Version 0.9.1 (2008-06-15)
 
 * Implemented bit fields.

data/TODO

@@ -1,9 +1,3 @@
 * Think how offset_of should work.
 
-* Need optional parameter for fields
-
-* Should I add seek capability?
-
 * Add (Multi|Single)Value.custom_parameters
-
-* BitFields

data/lib/bindata.rb

@@ -18,5 +18,5 @@ require 'bindata/struct'
 # A declarative way to read and write structured binary data.
 # 
 module BinData
-  VERSION = "0.9.1"
+  VERSION = "0.9.2"
 end

data/lib/bindata/array.rb

@@ -60,7 +60,7 @@ module BinData
     class << self
       # Returns a sanitized +params+ that is of the form expected
       # by #initialize.
-      def sanitize_parameters(params, endian = nil)
+      def sanitize_parameters(sanitizer, params)
         params = params.dup
 
         unless params.has_key?(:initial_length) or params.has_key?(:read_until)
@@ -68,19 +68,16 @@ module BinData
           params[:initial_length] = 0
         end
 
+        if params.has_key?(:read_length)
+          warn ":read_length is not used with arrays.  You probably want to change this to :initial_length"
+        end
+
         if params.has_key?(:type)
           type, el_params = params[:type]
-          klass = lookup(type, endian)
-          raise TypeError, "unknown type '#{type}' for #{self}" if klass.nil?
-          params[:type] = [klass, SanitizedParameters.new(klass, el_params, endian)]
+          params[:type] = sanitizer.sanitize(type, el_params)
         end
 
-        super(params, endian)
-      end
-
-      # An array has no fields.
-      def all_possible_field_names(sanitized_params)
-        []
+        super(sanitizer, params)
       end
     end
 
@@ -104,7 +101,7 @@ module BinData
         elements.each { |f| return false if not f.clear? }
         true
       else
-        elements[index].clear?
+        (index < elements.length) ? elements[index].clear? : true
       end
     end
 
@@ -116,7 +113,7 @@ module BinData
         # do nothing as the array is already clear
       elsif index.nil?
         @element_list = nil
-      else
+      elsif index < elements.length
         elements[index].clear
       end
     end
@@ -127,16 +124,6 @@ module BinData
       return false
     end
 
-    # An array has no fields.
-    def field_names
-      []
-    end
-
-    # Returns a snapshot of the data in this array.
-    def snapshot
-      elements.collect { |e| e.snapshot }
-    end
-
     # To be called after calling #do_read.
     def done_read
       elements.each { |f| f.done_read }
@@ -146,15 +133,39 @@ module BinData
     # single_values then the +value+ may be provided to the call.
     # Returns the appended object, or value in the case of single_values.
     def append(value = nil)
+      # TODO: deprecate #append as it can be replaced with #push
       append_new_element
       self[-1] = value unless value.nil?
       self.last
     end
 
+    # Pushes the given object(s) on to the end of this array. 
+    # This expression returns the array itself, so several appends may 
+    # be chained together.
+    def push(*args)
+      args.each do |arg|
+        if @element_klass == arg.class
+          # TODO: need to modify arg.env to add_variable(:index) and
+          # to link arg.env to self.env
+          elements.push(arg)
+        else
+          append(arg)
+        end
+      end
+      self
+    end
+
     # Returns the element at +index+.  If the element is a single_value
     # then the value of the element is returned instead.
-    def [](*index)
-      data = elements[*index]
+    def [](*args)
+      if args.length == 1 and ::Integer === args[0]
+        # extend array automatically
+        while args[0] >= elements.length
+          append_new_element
+        end
+      end
+
+      data = elements[*args]
       if data.respond_to?(:each)
         data.collect { |el| (el && el.single_value?) ? el.value : el }
       else
@@ -166,8 +177,14 @@ module BinData
     # Sets the element at +index+.  If the element is a single_value
     # then the value of the element is set instead.
     def []=(index, value)
+      # extend array automatically
+      while index >= elements.length
+        append_new_element
+      end
+
       obj = elements[index]
       unless obj.single_value?
+        # TODO: allow setting objects, not just values
         raise NoMethodError, "undefined method `[]=' for #{self}", caller
       end
       obj.value = value
@@ -186,7 +203,12 @@ module BinData
     # form returns an empty array.
     def first(n = nil)
       if n.nil?
-        self[0]
+        if elements.empty?
+          # explicitly return nil as arrays grow automatically
+          nil
+        else
+          self[0]
+        end
       else
         self[0, n]
       end
@@ -256,6 +278,11 @@ module BinData
       end
     end
 
+    # Returns a snapshot of the data in this array.
+    def _snapshot
+      elements.collect { |e| e.snapshot }
+    end
+
     # Returns the list of all elements in the array.  The elements
     # will be instantiated on the first call to this method.
     def elements

data/lib/bindata/base.rb

@@ -1,7 +1,7 @@
 require 'bindata/io'
 require 'bindata/lazy'
-require 'bindata/sanitize'
 require 'bindata/registry'
+require 'bindata/sanitize'
 require 'stringio'
 
 module BinData
@@ -15,11 +15,11 @@ module BinData
   # Parameters may be provided at initialisation to control the behaviour of
   # an object.  These params are:
   #
-  # [<tt>:readwrite</tt>]     If false, calls to #read or #write will
-  #                           not perform any I/O.  Default is true.
-  # [<tt>:onlyif</tt>]        This is an alias for :readwrite.  It is generally
-  #                           used to indicate a data object is optional.
-  #                           not perform any I/O.  Default is true.
+  # [<tt>:readwrite</tt>]     Deprecated. An alias for :onlyif.
+  # [<tt>:onlyif</tt>]        Used to indicate a data object is optional.
+  #                           if false, calls to #read or #write will not
+  #                           perform any I/O, #num_bytes will return 0 and
+  #                           #snapshot will return nil.  Default is true.
   # [<tt>:check_offset</tt>]  Raise an error if the current IO offset doesn't
   #                           meet this criteria.  A boolean return indicates
   #                           success or failure.  Any other return is compared
@@ -41,7 +41,8 @@ module BinData
           @mandatory_parameters = []
           ancestors[1..-1].each do |parent|
             if parent.respond_to?(:mandatory_parameters)
-              @mandatory_parameters.concat(parent.mandatory_parameters)
+              pmp = parent.mandatory_parameters
+              @mandatory_parameters.concat(pmp)
             end
           end
         end
@@ -61,7 +62,8 @@ module BinData
           @optional_parameters = []
           ancestors[1..-1].each do |parent|
             if parent.respond_to?(:optional_parameters)
-              @optional_parameters.concat(parent.optional_parameters)
+              pop = parent.optional_parameters
+              @optional_parameters.concat(pop)
             end
           end
         end
@@ -81,7 +83,8 @@ module BinData
           @default_parameters = {}
           ancestors[1..-1].each do |parent|
             if parent.respond_to?(:default_parameters)
-              @default_parameters = @default_parameters.merge(parent.default_parameters)
+              pdp = parent.default_parameters
+              @default_parameters = @default_parameters.merge(pdp)
             end
           end
         end
@@ -100,7 +103,8 @@ module BinData
           @mutually_exclusive_parameters = []
           ancestors[1..-1].each do |parent|
             if parent.respond_to?(:mutually_exclusive_parameters)
-              @mutually_exclusive_parameters.concat(parent.mutually_exclusive_parameters)
+              pmep = parent.mutually_exclusive_parameters
+              @mutually_exclusive_parameters.concat(pmep)
             end
           end
         end
@@ -117,12 +121,13 @@ module BinData
 
       # Returns a sanitized +params+ that is of the form expected
       # by #initialize.
-      def sanitize_parameters(params, *args)
+      def sanitize_parameters(sanitizer, params, *args)
         params = params.dup
 
-        # replace :onlyif with :readwrite
-        if params.has_key?(:onlyif)
-          params[:readwrite] = params.delete(:onlyif)
+        # replace :readwrite with :onlyif
+        if params.has_key?(:readwrite)
+          warn ":readwrite is deprecated. Replacing with :onlyif"
+          params[:onlyif] = params.delete(:readwrite)
         end
 
         # add default parameters
@@ -163,28 +168,11 @@ module BinData
         Registry.instance.register(name, klass)
       end
       private :register
-
-      # Returns the class matching a previously registered +name+.
-      def lookup(name, endian = nil)
-        name = name.to_s
-        klass = Registry.instance.lookup(name)
-        if klass.nil? and endian != nil
-          # lookup failed so attempt endian lookup
-          if /^u?int\d{1,3}$/ =~ name
-            new_name = name + ((endian == :little) ? "le" : "be")
-            klass = Registry.instance.lookup(new_name)
-          elsif ["float", "double"].include?(name)
-            new_name = name + ((endian == :little) ? "_le" : "_be")
-            klass = Registry.instance.lookup(new_name)
-          end
-        end
-        klass
-      end
     end
 
     # Define the parameters we use in this class.
     optional_parameters :check_offset, :adjust_offset
-    default_parameters :readwrite => true
+    default_parameters :onlyif => true
     mutually_exclusive_parameters :check_offset, :adjust_offset
 
     # Creates a new data object.
@@ -194,7 +182,7 @@ module BinData
     # environment that these callable objects are evaluated in.
     def initialize(params = {}, env = nil)
       unless SanitizedParameters === params
-        params = SanitizedParameters.new(self.class, params)
+        params = Sanitizer.sanitize(self, params)
       end
 
       @params = params.accepted_parameters
@@ -221,7 +209,7 @@ module BinData
       clear
       check_offset(io)
 
-      if eval_param(:readwrite)
+      if eval_param(:onlyif)
         _do_read(io)
       end
     end
@@ -240,7 +228,7 @@ module BinData
     def do_write(io)
       raise ArgumentError, "io must be a BinData::IO" unless BinData::IO === io
 
-      if eval_param(:readwrite)
+      if eval_param(:onlyif)
         _do_write(io)
       end
     end
@@ -254,13 +242,23 @@ module BinData
 
     # Returns the number of bytes it will take to write this data.
     def do_num_bytes(what = nil)
-      if eval_param(:readwrite)
+      if eval_param(:onlyif)
         _do_num_bytes(what)
       else
         0
       end
     end
 
+    # Returns a snapshot of this data object.
+    # Returns nil if :onlyif is false
+    def snapshot
+      if eval_param(:onlyif)
+        _snapshot
+      else
+        nil
+      end
+    end
+
     # Returns the string representation of this data object.
     def to_s
       io = StringIO.new
@@ -336,14 +334,13 @@ module BinData
     ###########################################################################
     # To be implemented by subclasses
 
-    # Returns a list of the names of all possible field names for an object
-    # created with +sanitized_params+.
-    def self.all_possible_field_names(sanitized_params)
+    # Resets the internal state to that of a newly created object.
+    def clear
       raise NotImplementedError
     end
 
-    # Resets the internal state to that of a newly created object.
-    def clear
+    # Returns true if the object has not been changed since creation.
+    def clear?(*args)
       raise NotImplementedError
     end
 
@@ -353,17 +350,6 @@ module BinData
       raise NotImplementedError
     end
 
-    # Returns a list of the names of all fields accessible through this
-    # object.
-    def field_names
-      raise NotImplementedError
-    end
-
-    # Returns a snapshot of this data object.
-    def snapshot
-      raise NotImplementedError
-    end
-
     # To be called after calling #do_read.
     def done_read
       raise NotImplementedError
@@ -384,9 +370,14 @@ module BinData
       raise NotImplementedError
     end
 
+    # Returns a snapshot of this data object.
+    def _snapshot
+      raise NotImplementedError
+    end
+
     # Set visibility requirements of methods to implement
-    public :clear, :single_value?, :field_names, :snapshot, :done_read
-    private :_do_read, :_do_write, :_do_num_bytes
+    public :clear, :clear?, :single_value?, :done_read
+    private :_do_read, :_do_write, :_do_num_bytes, :_snapshot
 
     # End To be implemented by subclasses
     ###########################################################################

data/lib/bindata/bits.rb

@@ -50,757 +50,757 @@ module BinData
   end
 
   # 1 bit big endian bitfield.
-  class Bit1 < Single
+  class Bit1 < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 1, :big)
   end
 
   # 1 bit little endian bitfield.
-  class Bit1le < Single
+  class Bit1le < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 1, :little)
   end
 
   # 2 bit big endian bitfield.
-  class Bit2 < Single
+  class Bit2 < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 2, :big)
   end
 
   # 2 bit little endian bitfield.
-  class Bit2le < Single
+  class Bit2le < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 2, :little)
   end
 
   # 3 bit big endian bitfield.
-  class Bit3 < Single
+  class Bit3 < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 3, :big)
   end
 
   # 3 bit little endian bitfield.
-  class Bit3le < Single
+  class Bit3le < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 3, :little)
   end
 
   # 4 bit big endian bitfield.
-  class Bit4 < Single
+  class Bit4 < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 4, :big)
   end
 
   # 4 bit little endian bitfield.
-  class Bit4le < Single
+  class Bit4le < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 4, :little)
   end
 
   # 5 bit big endian bitfield.
-  class Bit5 < Single
+  class Bit5 < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 5, :big)
   end
 
   # 5 bit little endian bitfield.
-  class Bit5le < Single
+  class Bit5le < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 5, :little)
   end
 
   # 6 bit big endian bitfield.
-  class Bit6 < Single
+  class Bit6 < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 6, :big)
   end
 
   # 6 bit little endian bitfield.
-  class Bit6le < Single
+  class Bit6le < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 6, :little)
   end
 
   # 7 bit big endian bitfield.
-  class Bit7 < Single
+  class Bit7 < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 7, :big)
   end
 
   # 7 bit little endian bitfield.
-  class Bit7le < Single
+  class Bit7le < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 7, :little)
   end
 
   # 8 bit big endian bitfield.
-  class Bit8 < Single
+  class Bit8 < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 8, :big)
   end
 
   # 8 bit little endian bitfield.
-  class Bit8le < Single
+  class Bit8le < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 8, :little)
   end
 
   # 9 bit big endian bitfield.
-  class Bit9 < Single
+  class Bit9 < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 9, :big)
   end
 
   # 9 bit little endian bitfield.
-  class Bit9le < Single
+  class Bit9le < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 9, :little)
   end
 
   # 10 bit big endian bitfield.
-  class Bit10 < Single
+  class Bit10 < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 10, :big)
   end
 
   # 10 bit little endian bitfield.
-  class Bit10le < Single
+  class Bit10le < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 10, :little)
   end
 
   # 11 bit big endian bitfield.
-  class Bit11 < Single
+  class Bit11 < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 11, :big)
   end
 
   # 11 bit little endian bitfield.
-  class Bit11le < Single
+  class Bit11le < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 11, :little)
   end
 
   # 12 bit big endian bitfield.
-  class Bit12 < Single
+  class Bit12 < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 12, :big)
   end
 
   # 12 bit little endian bitfield.
-  class Bit12le < Single
+  class Bit12le < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 12, :little)
   end
 
   # 13 bit big endian bitfield.
-  class Bit13 < Single
+  class Bit13 < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 13, :big)
   end
 
   # 13 bit little endian bitfield.
-  class Bit13le < Single
+  class Bit13le < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 13, :little)
   end
 
   # 14 bit big endian bitfield.
-  class Bit14 < Single
+  class Bit14 < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 14, :big)
   end
 
   # 14 bit little endian bitfield.
-  class Bit14le < Single
+  class Bit14le < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 14, :little)
   end
 
   # 15 bit big endian bitfield.
-  class Bit15 < Single
+  class Bit15 < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 15, :big)
   end
 
   # 15 bit little endian bitfield.
-  class Bit15le < Single
+  class Bit15le < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 15, :little)
   end
 
   # 16 bit big endian bitfield.
-  class Bit16 < Single
+  class Bit16 < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 16, :big)
   end
 
   # 16 bit little endian bitfield.
-  class Bit16le < Single
+  class Bit16le < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 16, :little)
   end
 
   # 17 bit big endian bitfield.
-  class Bit17 < Single
+  class Bit17 < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 17, :big)
   end
 
   # 17 bit little endian bitfield.
-  class Bit17le < Single
+  class Bit17le < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 17, :little)
   end
 
   # 18 bit big endian bitfield.
-  class Bit18 < Single
+  class Bit18 < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 18, :big)
   end
 
   # 18 bit little endian bitfield.
-  class Bit18le < Single
+  class Bit18le < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 18, :little)
   end
 
   # 19 bit big endian bitfield.
-  class Bit19 < Single
+  class Bit19 < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 19, :big)
   end
 
   # 19 bit little endian bitfield.
-  class Bit19le < Single
+  class Bit19le < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 19, :little)
   end
 
   # 20 bit big endian bitfield.
-  class Bit20 < Single
+  class Bit20 < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 20, :big)
   end
 
   # 20 bit little endian bitfield.
-  class Bit20le < Single
+  class Bit20le < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 20, :little)
   end
 
   # 21 bit big endian bitfield.
-  class Bit21 < Single
+  class Bit21 < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 21, :big)
   end
 
   # 21 bit little endian bitfield.
-  class Bit21le < Single
+  class Bit21le < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 21, :little)
   end
 
   # 22 bit big endian bitfield.
-  class Bit22 < Single
+  class Bit22 < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 22, :big)
   end
 
   # 22 bit little endian bitfield.
-  class Bit22le < Single
+  class Bit22le < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 22, :little)
   end
 
   # 23 bit big endian bitfield.
-  class Bit23 < Single
+  class Bit23 < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 23, :big)
   end
 
   # 23 bit little endian bitfield.
-  class Bit23le < Single
+  class Bit23le < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 23, :little)
   end
 
   # 24 bit big endian bitfield.
-  class Bit24 < Single
+  class Bit24 < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 24, :big)
   end
 
   # 24 bit little endian bitfield.
-  class Bit24le < Single
+  class Bit24le < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 24, :little)
   end
 
   # 25 bit big endian bitfield.
-  class Bit25 < Single
+  class Bit25 < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 25, :big)
   end
 
   # 25 bit little endian bitfield.
-  class Bit25le < Single
+  class Bit25le < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 25, :little)
   end
 
   # 26 bit big endian bitfield.
-  class Bit26 < Single
+  class Bit26 < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 26, :big)
   end
 
   # 26 bit little endian bitfield.
-  class Bit26le < Single
+  class Bit26le < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 26, :little)
   end
 
   # 27 bit big endian bitfield.
-  class Bit27 < Single
+  class Bit27 < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 27, :big)
   end
 
   # 27 bit little endian bitfield.
-  class Bit27le < Single
+  class Bit27le < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 27, :little)
   end
 
   # 28 bit big endian bitfield.
-  class Bit28 < Single
+  class Bit28 < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 28, :big)
   end
 
   # 28 bit little endian bitfield.
-  class Bit28le < Single
+  class Bit28le < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 28, :little)
   end
 
   # 29 bit big endian bitfield.
-  class Bit29 < Single
+  class Bit29 < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 29, :big)
   end
 
   # 29 bit little endian bitfield.
-  class Bit29le < Single
+  class Bit29le < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 29, :little)
   end
 
   # 30 bit big endian bitfield.
-  class Bit30 < Single
+  class Bit30 < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 30, :big)
   end
 
   # 30 bit little endian bitfield.
-  class Bit30le < Single
+  class Bit30le < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 30, :little)
   end
 
   # 31 bit big endian bitfield.
-  class Bit31 < Single
+  class Bit31 < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 31, :big)
   end
 
   # 31 bit little endian bitfield.
-  class Bit31le < Single
+  class Bit31le < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 31, :little)
   end
 
   # 32 bit big endian bitfield.
-  class Bit32 < Single
+  class Bit32 < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 32, :big)
   end
 
   # 32 bit little endian bitfield.
-  class Bit32le < Single
+  class Bit32le < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 32, :little)
   end
 
   # 33 bit big endian bitfield.
-  class Bit33 < Single
+  class Bit33 < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 33, :big)
   end
 
   # 33 bit little endian bitfield.
-  class Bit33le < Single
+  class Bit33le < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 33, :little)
   end
 
   # 34 bit big endian bitfield.
-  class Bit34 < Single
+  class Bit34 < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 34, :big)
   end
 
   # 34 bit little endian bitfield.
-  class Bit34le < Single
+  class Bit34le < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 34, :little)
   end
 
   # 35 bit big endian bitfield.
-  class Bit35 < Single
+  class Bit35 < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 35, :big)
   end
 
   # 35 bit little endian bitfield.
-  class Bit35le < Single
+  class Bit35le < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 35, :little)
   end
 
   # 36 bit big endian bitfield.
-  class Bit36 < Single
+  class Bit36 < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 36, :big)
   end
 
   # 36 bit little endian bitfield.
-  class Bit36le < Single
+  class Bit36le < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 36, :little)
   end
 
   # 37 bit big endian bitfield.
-  class Bit37 < Single
+  class Bit37 < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 37, :big)
   end
 
   # 37 bit little endian bitfield.
-  class Bit37le < Single
+  class Bit37le < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 37, :little)
   end
 
   # 38 bit big endian bitfield.
-  class Bit38 < Single
+  class Bit38 < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 38, :big)
   end
 
   # 38 bit little endian bitfield.
-  class Bit38le < Single
+  class Bit38le < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 38, :little)
   end
 
   # 39 bit big endian bitfield.
-  class Bit39 < Single
+  class Bit39 < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 39, :big)
   end
 
   # 39 bit little endian bitfield.
-  class Bit39le < Single
+  class Bit39le < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 39, :little)
   end
 
   # 40 bit big endian bitfield.
-  class Bit40 < Single
+  class Bit40 < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 40, :big)
   end
 
   # 40 bit little endian bitfield.
-  class Bit40le < Single
+  class Bit40le < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 40, :little)
   end
 
   # 41 bit big endian bitfield.
-  class Bit41 < Single
+  class Bit41 < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 41, :big)
   end
 
   # 41 bit little endian bitfield.
-  class Bit41le < Single
+  class Bit41le < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 41, :little)
   end
 
   # 42 bit big endian bitfield.
-  class Bit42 < Single
+  class Bit42 < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 42, :big)
   end
 
   # 42 bit little endian bitfield.
-  class Bit42le < Single
+  class Bit42le < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 42, :little)
   end
 
   # 43 bit big endian bitfield.
-  class Bit43 < Single
+  class Bit43 < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 43, :big)
   end
 
   # 43 bit little endian bitfield.
-  class Bit43le < Single
+  class Bit43le < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 43, :little)
   end
 
   # 44 bit big endian bitfield.
-  class Bit44 < Single
+  class Bit44 < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 44, :big)
   end
 
   # 44 bit little endian bitfield.
-  class Bit44le < Single
+  class Bit44le < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 44, :little)
   end
 
   # 45 bit big endian bitfield.
-  class Bit45 < Single
+  class Bit45 < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 45, :big)
   end
 
   # 45 bit little endian bitfield.
-  class Bit45le < Single
+  class Bit45le < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 45, :little)
   end
 
   # 46 bit big endian bitfield.
-  class Bit46 < Single
+  class Bit46 < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 46, :big)
   end
 
   # 46 bit little endian bitfield.
-  class Bit46le < Single
+  class Bit46le < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 46, :little)
   end
 
   # 47 bit big endian bitfield.
-  class Bit47 < Single
+  class Bit47 < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 47, :big)
   end
 
   # 47 bit little endian bitfield.
-  class Bit47le < Single
+  class Bit47le < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 47, :little)
   end
 
   # 48 bit big endian bitfield.
-  class Bit48 < Single
+  class Bit48 < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 48, :big)
   end
 
   # 48 bit little endian bitfield.
-  class Bit48le < Single
+  class Bit48le < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 48, :little)
   end
 
   # 49 bit big endian bitfield.
-  class Bit49 < Single
+  class Bit49 < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 49, :big)
   end
 
   # 49 bit little endian bitfield.
-  class Bit49le < Single
+  class Bit49le < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 49, :little)
   end
 
   # 50 bit big endian bitfield.
-  class Bit50 < Single
+  class Bit50 < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 50, :big)
   end
 
   # 50 bit little endian bitfield.
-  class Bit50le < Single
+  class Bit50le < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 50, :little)
   end
 
   # 51 bit big endian bitfield.
-  class Bit51 < Single
+  class Bit51 < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 51, :big)
   end
 
   # 51 bit little endian bitfield.
-  class Bit51le < Single
+  class Bit51le < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 51, :little)
   end
 
   # 52 bit big endian bitfield.
-  class Bit52 < Single
+  class Bit52 < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 52, :big)
   end
 
   # 52 bit little endian bitfield.
-  class Bit52le < Single
+  class Bit52le < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 52, :little)
   end
 
   # 53 bit big endian bitfield.
-  class Bit53 < Single
+  class Bit53 < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 53, :big)
   end
 
   # 53 bit little endian bitfield.
-  class Bit53le < Single
+  class Bit53le < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 53, :little)
   end
 
   # 54 bit big endian bitfield.
-  class Bit54 < Single
+  class Bit54 < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 54, :big)
   end
 
   # 54 bit little endian bitfield.
-  class Bit54le < Single
+  class Bit54le < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 54, :little)
   end
 
   # 55 bit big endian bitfield.
-  class Bit55 < Single
+  class Bit55 < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 55, :big)
   end
 
   # 55 bit little endian bitfield.
-  class Bit55le < Single
+  class Bit55le < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 55, :little)
   end
 
   # 56 bit big endian bitfield.
-  class Bit56 < Single
+  class Bit56 < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 56, :big)
   end
 
   # 56 bit little endian bitfield.
-  class Bit56le < Single
+  class Bit56le < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 56, :little)
   end
 
   # 57 bit big endian bitfield.
-  class Bit57 < Single
+  class Bit57 < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 57, :big)
   end
 
   # 57 bit little endian bitfield.
-  class Bit57le < Single
+  class Bit57le < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 57, :little)
   end
 
   # 58 bit big endian bitfield.
-  class Bit58 < Single
+  class Bit58 < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 58, :big)
   end
 
   # 58 bit little endian bitfield.
-  class Bit58le < Single
+  class Bit58le < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 58, :little)
   end
 
   # 59 bit big endian bitfield.
-  class Bit59 < Single
+  class Bit59 < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 59, :big)
   end
 
   # 59 bit little endian bitfield.
-  class Bit59le < Single
+  class Bit59le < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 59, :little)
   end
 
   # 60 bit big endian bitfield.
-  class Bit60 < Single
+  class Bit60 < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 60, :big)
   end
 
   # 60 bit little endian bitfield.
-  class Bit60le < Single
+  class Bit60le < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 60, :little)
   end
 
   # 61 bit big endian bitfield.
-  class Bit61 < Single
+  class Bit61 < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 61, :big)
   end
 
   # 61 bit little endian bitfield.
-  class Bit61le < Single
+  class Bit61le < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 61, :little)
   end
 
   # 62 bit big endian bitfield.
-  class Bit62 < Single
+  class Bit62 < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 62, :big)
   end
 
   # 62 bit little endian bitfield.
-  class Bit62le < Single
+  class Bit62le < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 62, :little)
   end
 
   # 63 bit big endian bitfield.
-  class Bit63 < Single
+  class Bit63 < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 63, :big)
   end
 
   # 63 bit little endian bitfield.
-  class Bit63le < Single
+  class Bit63le < BinData::Single
     register(self.name, self)
     BitField.create_methods(self, 63, :little)
   end