jfreeze-ruby-gdsii 1.0.1

data/lib/gdsii/record/datatypes/bitarray.rb

@@ -0,0 +1,101 @@
+require 'gdsii/record/datatypes/data.rb'
+
+module Gdsii
+
+  module RecData
+
+    #
+    # Class for BITARRAY data type
+    #
+    class BitArray < Data
+
+      # Value is an array of 16-bit integers which represent the bit array.
+      # To get a String of the bit array represented as an array of strings
+      # madeup of 16 1's and 0's consider using the #to_s_a or #to_s methods.
+      attr_reader :value
+
+      # Construct an Gdsii::RecData::BitArray data object.  The value is an
+      # array of 16-bit integers representing the bit array.  Examples:
+      #
+      #  record = Gdsii::RecData::BitArray.new([1234])
+      #  record.value.inspect #=> [1234]
+      #
+      # Or alternatively to initialize with an array of strings madeup of 16
+      # 1's and 0's, use Gdsii::RecData::BitArray.s_a_to_i_a:
+      #
+      #  arr = Gdsii::RecData::BitArray.s_a_to_i_a(["0000010011010010"])
+      #  record = Gdsii::RecData::BitArray.new(arr)
+      #  record.value.inspect #=> [1234]
+      #
+      def initialize(value)
+        super(GDT_BITARRAY, value)
+      end
+      
+      # Set the value for this object; verify that the value items are of
+      # type Fixnum (or at least can be coerced using "to_i").
+      def value=(value)
+        @value = Data.coerce_value(value, Integer, :to_i)
+      end
+
+      # Returns the size of the record *data* in bytes.  Each array element
+      # consumes 2 bytes.
+      def byte_size()
+        @value.length * 2
+      end
+
+      # Reads a BITARRAY record from the given file and for the length of bytes
+      # given and returns a new Gdsii::RecData::BitArray object.
+      def BitArray.read(file, byte_count)
+        raw = file.read(byte_count)
+        data = raw.unpack("n")
+        BitArray.new(data)
+      end
+
+      # Writes the integer values representing the bit array in this
+      # Gdsii::RecData::BitArray object to the given file as a GDSII BITARRAY
+      # record.
+      def write(file)
+        file.write @value.pack("n")
+      end
+
+      #
+      # Returns an array containing string representations for each of the
+      # 16-bit integers in the value.  Example:
+      #
+      #  record = Gdsii::RecData::BitArray.new([1234, 9876])
+      #  record.to_s_a.inspect #=> ["0000010011010010", "0010011010010100"]
+      #
+      def to_s_a()
+        @value.map {|string| [string].pack("n").unpack("B16")[0]}
+      end
+
+      #
+      # Returns a string containing string representations for each of the
+      # 16-bit integers in the value joined by spaces.  Example:
+      #
+      #  record = Gdsii::RecData::BitArray.new([1234, 9876])
+      #  record.to_s.inspect #=> "0000010011010010 0010011010010100"
+      #
+      def to_s()
+        to_s_a.join(' ')
+      end
+
+      #
+      # Converts an array of strings at 16 characters in length using 1's and
+      # 0's to an array of respective integer values.
+      #
+      #  arr = Gdsii::RecData::BitArray.s_a_to_i_a(["0000010011010010"])
+      #  arr.inspect #=> [1234]
+      #
+      # Also see #new for an example used in object construction.
+      #
+      def BitArray.s_a_to_i_a(value)
+        string_arr = Data.coerce_value(value, String, :to_s)
+        string_arr.map {|string| [string].pack("B16").unpack("n")[0]}
+      end
+
+    end
+
+  end
+
+end

data/lib/gdsii/record/datatypes/data.rb

@@ -0,0 +1,111 @@
+
+module Gdsii
+
+  module RecData
+
+    #
+    # Generic class to represent various record data types.  This class is 
+    # intended to be inherited and not called directly.
+    #
+    class Data
+
+      # Data type integer represented by one of the Gdsii::GDT_ constants.
+      attr_reader :type
+
+      # Pointer to the parent record object
+      attr_reader :record
+
+      # 
+      # Create a generic record data object.  Intended to be called internally
+      # by Gdsii::RecType classes - not intended to be called directly.
+      #
+      def initialize(type, value, record=nil)
+        if Data.valid_type?(type)
+          @type = type
+        else
+          raise TypeError,
+          "Invalid data type specified: #{type}"
+        end
+        @record = record
+        self.value = value
+      end
+
+      # Quick access to the data value array.  Equivalent to self.value[index].
+      def [](index); @value[index]; end
+
+      # Check that the given data type (as an integer) is valid as defined by
+      # the Gdsii::DATATYPE_INFO array.
+      def Data.valid_type?(type)
+        (0...DATATYPE_INFO.length).member?(type)
+      end
+
+      ########################################################################
+      # DATA TYPE SHORTCUTS
+      ########################################################################
+    
+      # Returns true if this record is an ASCII data type, false if not
+      def is_ascii?(); @type == GDT_ASCII; end
+
+      # Returns true if this record is an INT2 data type, false if not
+      def is_int2?(); @type == GDT_INT2; end
+
+      # Returns true if this record is an INT4 data type, false if not
+      def is_int4?(); @type == GDT_INT4; end
+
+      # Returns true if this record is a REAL8 data type, false if not
+      def is_real8?(); @type == GDT_REAL8; end
+
+      # Returns true if this record is a BITARRAY data type, false if not
+      def is_bitarray?(); @type == GDT_BITARRAY; end
+
+      # Returns true if this record is a NO_DATA data type, false if not
+      def is_no_data?(); @type == GDT_NO_DATA; end
+
+      # Returns true if this record is a REAL4 data type, false if not
+      def is_real4?(); @type == GDT_REAL4; end
+
+
+      ########################################################################
+      # PROTECTED METHODS (private to this class)
+      ########################################################################
+  
+      protected
+      
+      # Check the class for the given datum (single data element, NOT an array)
+      # and raises an exception if the datum does not match the given class.
+      def Data.ensure_class(datum, klass)
+        unless datum.kind_of?(klass)
+          raise TypeError,
+          "#{self.class.to_s} value must be descended from #{klass}; given: '#{datum.class}'"
+        end
+      end
+      
+      # Ensures that the given value is descended from the Array class.  If
+      # not, then an InvalidValue exception is raised.
+      def Data.ensure_array(value)
+        unless value.kind_of?(Array)
+          raise TypeError,
+          "All data must be descended from Array class; given: #{value.class}"
+        end
+      end
+ 
+      # Generic method for setting a value.  The classes that inherit from
+      # this class use this to coerce and validate their value.
+      def Data.coerce_value(value, klass, coerce_method)
+        Data.ensure_array value
+        value.each_with_index do |datum, i|
+          # Make sure that it matches the class; if not, try to coerce
+          unless datum.kind_of?(klass) 
+            if datum.respond_to?(coerce_method) then
+              the_method = datum.method(coerce_method)
+              value[i] = the_method.call
+            end
+            Data.ensure_class(value[i], klass)
+          end
+        end
+        value
+      end
+
+    end
+  end
+end

data/lib/gdsii/record/datatypes/int2.rb

@@ -0,0 +1,67 @@
+require 'gdsii/record/datatypes/data.rb'
+require 'gdsii/byte_order.rb'
+
+module Gdsii
+
+  module RecData
+
+    #
+    # Store a GDSII INT2 data type
+    #
+    class Int2 < Data
+      
+      # Value is an array of integers.
+      attr_reader :value
+     
+      # Construct an Gdsii::RecData::Int2 data object.  The value is an array
+      # of integers (Fixnum).
+      def initialize(value)
+        super(GDT_INT2, value)
+      end
+
+      # Set the value for this object; verify that the value items are of
+      # type Fixnum (or at least can be coerced using "to_i").
+      def value=(value)
+        @value = Data.coerce_value(value, Fixnum, :to_i)
+      end
+
+      # Returns the size of the record *data* in bytes.  Each array element
+      # consumes 2 bytes (hence INT2).
+      def byte_size()
+        @value.length * 2
+      end
+
+      # Reads an INT2 record from the given file and for the length of bytes
+      # given and returns a new Gdsii::RecData::Int2 object.
+      def Int2.read(file, byte_count)
+        data = []
+        while (byte_count > 0)
+          raw = file.read(2)
+          raw.reverse! if (ByteOrder::little_endian?)
+          data.push raw.unpack('s')[0]
+          byte_count -= 2
+        end
+        Int2.new(data)
+      end
+
+      # Writes the integer values in this Gdsii::RecData::Int2 object to the
+      # given file as a GDSII INT2 record.
+      def write(file)
+        value.each do |item|
+          # always write int2 as network order (as per GDSII spec)
+          file.write [item].pack('n')
+        end
+      end
+
+      # Converts the array of integer values to a string (values are joined by
+      # spaces).
+      def to_s()
+        value.map {|v| v.to_s}.join(' ')
+      end
+
+    end
+
+  end
+
+end 
+

data/lib/gdsii/record/datatypes/int4.rb

@@ -0,0 +1,65 @@
+require 'gdsii/record/datatypes/data.rb'
+require 'gdsii/byte_order.rb'
+
+module Gdsii
+
+  module RecData
+
+    #
+    # Class for INT4 data type
+    #
+    class Int4 < Data
+      
+      # Value is an array of integers.
+      attr_reader :value
+
+      # Construct an Gdsii::RecData::Int4 data object.  The value is an array
+      # of integers (Fixnum).
+      def initialize(value)
+        super(GDT_INT4, value)
+      end
+
+      # Set the value for this object; verify that the value items are of
+      # type Fixnum (or at least can be coerced using "to_i").
+      def value=(value)
+        @value = Data.coerce_value(value, Fixnum, :to_i)
+      end
+
+      # Returns the size of the record *data* in bytes.  Each array element
+      # consumes 4 bytes (hence INT4).
+      def byte_size()
+        @value.length * 4
+      end
+
+      # Reads an INT4 record from the given file and for the length of bytes
+      # given and returns a new Gdsii::RecData::Int4 object.
+      def Int4.read(file, byte_count)
+        data = []
+        while (byte_count > 0)
+          raw = file.read(4)
+          raw.reverse! if (ByteOrder::little_endian?)
+          data.push raw.unpack('i')[0]
+          byte_count -= 4
+        end
+        Int4.new(data)
+      end
+
+      # Writes the integer values in this Gdsii::RecData::Int2 object to the
+      # given file as a GDSII INT4 record.
+      def write(file)
+        value.each do |item|
+          # always write int4 in network order (as per GDSII spec)
+          file.write [item].pack('N')
+        end
+      end
+      
+      # Converts the array of integer values to a string (values are joined by
+      # spaces).
+      def to_s()
+        value.map {|v| v.to_s}.join(' ')
+      end
+
+    end
+
+  end
+end

data/lib/gdsii/record/datatypes/nodata.rb

@@ -0,0 +1,60 @@
+require 'gdsii/record/datatypes/data.rb'
+
+module Gdsii
+
+  module RecData
+
+    #
+    # Store a GDSII NODATA data type.  This data type has no value.
+    #
+    class NoData < Data
+
+      # Value will always be an empty array for a Gdsii::RecData::NoData object
+      attr_reader :value
+      
+      # Construct an NoData data object.  No value is given because there
+      # isn't a value for Gdsii::RecData::NoData.
+      def initialize()
+        super(GDT_NO_DATA, [])
+      end
+
+      # Throws an exception unless an empty arra is passed because there is
+      # no data associated with a Gdsii::RecData::NoData object.
+      def value=(value=[])
+        Data.ensure_array value
+        unless value.empty?
+          raise ArgumentError,
+          "GDT_NO_DATA must have an empty array; given length: #{value.length}"
+        end
+        @value = value
+      end
+
+      # Returns the size of the record *data* in bytes.  Since a
+      # Gdsii::RecData::NoData object has no data, 0 is always returned.
+      def byte_size(); 0; end
+
+      # Reads a NO_DATA record from the given file object and returns a
+      # new Gdsii::RecData::NoData object.
+      def NoData.read(file, byte_count=0)
+        # validate byte count
+        if byte_count > 0 then
+          raise ArgumentError,
+          "GDT_NO_DATA expects 0 bytes of record length; requested: #{byte_count}"
+        end
+        NoData.new()
+      end
+
+      # Performs no operation since there is no data in a Gdsii::RecType::NoData
+      # object to write to a file.  However this method is necessary so that
+      # it can respond to methods common to other Gdsii::RecType::Data
+      # descended classes.
+      def write(file); end
+
+      # Returns an empty string (which represents no data).
+      def to_s(); ''; end
+
+    end
+
+  end
+
+end 

data/lib/gdsii/record/datatypes/real4.rb

@@ -0,0 +1,51 @@
+require 'gdsii/record/datatypes/data.rb'
+
+module Gdsii
+
+  module RecData
+
+    #
+    # Class for REAL4 data type (UNSUPPORTED - will raise an exception)
+    #
+    class Real4 < Data
+
+      # Value is an array of floating point numbers
+      attr_reader :value
+
+      # Will raise an exception immediately as REAL4 is not supported in the
+      # GDSII specification.
+      def initialize(value)
+         raise "GDT_REAL4 is unsupported"
+      end
+
+      # Raises an TypeError exception as REAL4 is not supported
+      def value=(value)
+        raise "GDT_REAL4 is unsupported"
+      end
+
+      # Returns the size of the record *data* in bytes.  Each array element
+      # consumes 4 bytes (hence REAL4).
+      def byte_size()
+        @value.length * 4
+      end
+
+      # just create the Gdsii::RecData::Real4 object and raise the exception
+      def Real4.read(file, byte_count)
+        Real4.new([0])
+      end
+
+      # Raises an exception since REAL4 is unsupported
+      def write(file)
+         raise "GDT_REAL4 is unsupported"
+      end
+
+      # Converts the array of floating point values to a string (values are
+      # joined by spaces).
+      def to_s()
+        value.map {|v| v.to_s}.join(' ')
+      end
+
+    end
+
+  end
+end