htslib 0.3.1 → 0.4.0

data/lib/hts/bcf/info.rb

@@ -6,7 +6,6 @@ module HTS
     class Info
       def initialize(record)
         @record = record
-        @p1 = FFI::MemoryPointer.new(:pointer) # FIXME: naming
       end
 
       # @note Specify the type. If you don't specify a type, it will still work, but it will be slower.
@@ -16,37 +15,55 @@ module HTS
       # I think they are better than `fetch_int`` and `fetch_float`.
       def get(key, type = nil)
         n = FFI::MemoryPointer.new(:int)
-        p1 = @p1
+        p1 = FFI::MemoryPointer.new(:pointer)
+        p1.write_pointer(FFI::Pointer::NULL)
         h = @record.header.struct
         r = @record.struct
 
-        info_values = proc do |typ|
+        info_values = proc do |typ, reader|
           ret = LibHTS.bcf_get_info_values(h, r, key, p1, n, typ)
           return nil if ret < 0 # return from method.
 
-          p1.read_pointer
+          dst = p1.read_pointer
+          begin
+            reader.call(dst, n.read_int)
+          ensure
+            LibHTS.hts_free(dst) unless dst.null?
+            p1.write_pointer(FFI::Pointer::NULL)
+          end
+        end
+
+        actual_type = ht_type_to_sym(get_info_type(key))
+        if type && actual_type && !info_type_compatible?(actual_type, type.to_sym)
+          raise InfoTypeError, "Tag #{key} is not #{type_label(type)} INFO field"
         end
 
-        type ||= ht_type_to_sym(get_info_type(key))
+        type ||= actual_type
+        return nil if actual_type && !key?(key)
 
         case type&.to_sym
         when :int, :int32
-          info_values.call(LibHTS::BCF_HT_INT)
-                     .read_array_of_int32(n.read_int)
+          info_values.call(LibHTS::BCF_HT_INT, ->(dst, len) { dst.read_array_of_int32(len) })
+        when :int64, :long
+          info_values.call(LibHTS::BCF_HT_LONG, ->(dst, len) { dst.read_array_of_int64(len) })
         when :float, :real
-          info_values.call(LibHTS::BCF_HT_REAL)
-                     .read_array_of_float(n.read_int)
+          info_values.call(LibHTS::BCF_HT_REAL, ->(dst, len) { dst.read_array_of_float(len) })
         when :flag, :bool
-          case ret = LibHTS.bcf_get_info_flag(h, r, key, p1, n)
-          when 1 then true
-          when 0 then false
-          when -1 then nil
-          else
-            raise "Unknown return value from bcf_get_info_flag: #{ret}"
+          begin
+            case ret = LibHTS.bcf_get_info_flag(h, r, key, p1, n)
+            when 1 then true
+            when 0 then false
+            when -1 then nil
+            else
+              raise InfoReadError, "Unknown return value from bcf_get_info_flag: #{ret}"
+            end
+          ensure
+            dst = p1.read_pointer
+            LibHTS.hts_free(dst) unless dst.null?
+            p1.write_pointer(FFI::Pointer::NULL)
           end
         when :string, :str
-          info_values.call(LibHTS::BCF_HT_STR)
-                     .read_string
+          info_values.call(LibHTS::BCF_HT_STR, ->(dst, _len) { dst.read_string })
         end
       end
 
@@ -60,6 +77,11 @@ module HTS
         get(key, :float)
       end
 
+      # For compatibility with HTS.cr.
+      def get_int64(key)
+        get(key, :int64)
+      end
+
       # For compatibility with HTS.cr.
       def get_string(key)
         get(key, :string)
@@ -74,6 +96,194 @@ module HTS
         get(key)
       end
 
+      # Set INFO field value with automatic type detection.
+      # @param key [String] INFO tag name
+      # @param value [Integer, Float, String, Array, true, false, nil] value to set
+      #   - Integer or Array<Integer> -> update_int
+      #   - Float or Array<Float,Integer> -> update_float
+      #   - String -> update_string
+      #   - true/false -> update_flag
+      #   - nil -> delete the INFO field
+      def []=(key, value)
+        case value
+        when nil
+          delete(key)
+        when true, false
+          update_flag(key, value)
+        when Integer
+          unless int32_range?(value)
+            raise RangeError,
+                  "Integer out of int32 range for []=. Current htslib backend does not support int64 INFO update."
+          end
+
+          update_int(key, [value])
+        when Float
+          update_float(key, [value])
+        when String
+          update_string(key, value)
+        when Array
+          if value.empty?
+            raise ArgumentError, "Cannot set INFO field to empty array. Use nil to delete."
+          elsif value.all? { |v| v.is_a?(Integer) }
+            unless value.all? { |v| int32_range?(v) }
+              raise RangeError,
+                    "Integer array contains out-of-int32 values for []=. Current htslib backend does not support int64 INFO update."
+            end
+
+            update_int(key, value)
+          elsif value.all? { |v| v.is_a?(Numeric) }
+            update_float(key, value)
+          else
+            raise ArgumentError, "INFO array must contain only integers or floats, got: #{value.map(&:class).uniq}"
+          end
+        else
+          raise ArgumentError, "Unsupported INFO value type: #{value.class}"
+        end
+      end
+
+      # Update INFO field with integer value(s).
+      # For compatibility with HTS.cr.
+      # @param key [String] INFO tag name
+      # @param values [Array<Integer>] integer values (use single-element array for scalar)
+      def update_int(key, values)
+        values = Array(values)
+        ptr = FFI::MemoryPointer.new(:int32, values.size)
+        ptr.write_array_of_int32(values)
+        ret = LibHTS.bcf_update_info(
+          @record.header.struct,
+          @record.struct,
+          key,
+          ptr,
+          values.size,
+          LibHTS::BCF_HT_INT
+        )
+        raise InfoUpdateError, "Failed to update INFO int field '#{key}': #{ret}" if ret < 0
+
+        ret
+      end
+
+      # Update INFO field with int64 value(s).
+      # @note int64 INFO values are primarily relevant for VCF output.
+      # @param key [String] INFO tag name
+      # @param values [Array<Integer>] integer values (use single-element array for scalar)
+      def update_int64(_key, _values)
+        raise UnsupportedInfoOperationError, "htslib backend does not implement int64 INFO update (BCF_HT_LONG)"
+      end
+
+      # Update INFO field with float value(s).
+      # For compatibility with HTS.cr.
+      # @param key [String] INFO tag name
+      # @param values [Array<Float>] float values (use single-element array for scalar)
+      def update_float(key, values)
+        values = Array(values).map(&:to_f)
+        ptr = FFI::MemoryPointer.new(:float, values.size)
+        ptr.write_array_of_float(values)
+        ret = LibHTS.bcf_update_info(
+          @record.header.struct,
+          @record.struct,
+          key,
+          ptr,
+          values.size,
+          LibHTS::BCF_HT_REAL
+        )
+        raise InfoUpdateError, "Failed to update INFO float field '#{key}': #{ret}" if ret < 0
+
+        ret
+      end
+
+      # Update INFO field with string value.
+      # For compatibility with HTS.cr.
+      # @param key [String] INFO tag name
+      # @param value [String] string value
+      def update_string(key, value)
+        ret = LibHTS.bcf_update_info(
+          @record.header.struct,
+          @record.struct,
+          key,
+          value.to_s,
+          1,
+          LibHTS::BCF_HT_STR
+        )
+        raise InfoUpdateError, "Failed to update INFO string field '#{key}': #{ret}" if ret < 0
+
+        ret
+      end
+
+      # Update INFO flag field.
+      # For compatibility with HTS.cr.
+      # @param key [String] INFO tag name
+      # @param present [Boolean] true to set flag, false to remove it
+      def update_flag(key, present = true)
+        ret = if present
+                LibHTS.bcf_update_info(
+                  @record.header.struct,
+                  @record.struct,
+                  key,
+                  FFI::Pointer::NULL,
+                  1,
+                  LibHTS::BCF_HT_FLAG
+                )
+              else
+                # Remove flag by setting n=0
+                LibHTS.bcf_update_info(
+                  @record.header.struct,
+                  @record.struct,
+                  key,
+                  FFI::Pointer::NULL,
+                  0,
+                  LibHTS::BCF_HT_FLAG
+                )
+              end
+        raise InfoUpdateError, "Failed to update INFO flag field '#{key}': #{ret}" if ret < 0
+
+        ret
+      end
+
+      # Delete an INFO field.
+      # @param key [String] INFO tag name
+      # @return [Boolean] true if field was deleted, false if it didn't exist
+      def delete(key)
+        type = get_info_type(key)
+        return false if type.nil?
+        return false unless key?(key)
+
+        # Delete by setting n=0
+        ret = LibHTS.bcf_update_info(
+          @record.header.struct,
+          @record.struct,
+          key,
+          FFI::Pointer::NULL,
+          0,
+          type
+        )
+        return false if ret < 0
+
+        true
+      end
+
+      # Check if an INFO field exists.
+      # @param key [String] INFO tag name
+      # @return [Boolean] true if the field exists
+      def key?(key)
+        type = header_info_type(key)
+        return false if type.nil?
+
+        ndst = FFI::MemoryPointer.new(:int)
+        ndst.write_int(0)
+        dst_ptr = FFI::MemoryPointer.new(:pointer)
+        dst_ptr.write_pointer(FFI::Pointer::NULL)
+
+        ret = LibHTS.bcf_get_info_values(@record.header.struct, @record.struct, key, dst_ptr, ndst, type)
+        type == LibHTS::BCF_HT_FLAG ? ret == 1 : ret >= 0
+      ensure
+        if dst_ptr
+          dst = dst_ptr.read_pointer
+          LibHTS.hts_free(dst) unless dst.null?
+        end
+      end
+
+      alias include? key?
+
       # FIXME: naming? room for improvement.
       def fields
         keys.map do |key|
@@ -119,16 +329,15 @@ module HTS
       end
 
       def get_info_type(key)
-        @record.struct[:n_info].times do |i|
-          info = LibHTS::BcfInfo.new(@record.struct[:d][:info] + i * LibHTS::BcfInfo.size)
-          k = info[:key]
-          id = LibHTS.bcf_hdr_int2id(@record.header.struct, LibHTS::BCF_DT_ID, k)
-          if id == key
-            type = LibHTS.bcf_hdr_id2type(@record.header.struct, LibHTS::BCF_HL_INFO, k)
-            return type
-          end
-        end
-        nil
+        header_info_type(key)
+      end
+
+      def header_info_type(key)
+        id = LibHTS.bcf_hdr_id2int(@record.header.struct, LibHTS::BCF_DT_ID, key)
+        return nil if id.negative?
+        return nil unless LibHTS.bcf_hdr_idinfo_exists(@record.header.struct, LibHTS::BCF_HL_INFO, id)
+
+        LibHTS.bcf_hdr_id2type(@record.header.struct, LibHTS::BCF_HL_INFO, id)
       end
 
       def ht_type_to_sym(t)
@@ -137,7 +346,39 @@ module HTS
         when LibHTS::BCF_HT_INT then :int
         when LibHTS::BCF_HT_REAL then :float
         when LibHTS::BCF_HT_STR then :string
-        when LibHTS::BCF_HT_LONG then :float
+        when LibHTS::BCF_HT_LONG then :int64
+        end
+      end
+
+      def int32_range?(value)
+        value >= -2_147_483_648 && value <= 2_147_483_647
+      end
+
+      def info_type_compatible?(actual_type, requested_type)
+        case requested_type
+        when :int, :int32
+          actual_type == :int
+        when :int64, :long
+          %i[int int64].include?(actual_type)
+        when :float, :real
+          actual_type == :float
+        when :flag, :bool
+          actual_type == :flag
+        when :string, :str
+          actual_type == :string
+        else
+          actual_type == requested_type
+        end
+      end
+
+      def type_label(type)
+        case type.to_sym
+        when :int, :int32 then "integer"
+        when :int64, :long then "integer"
+        when :float, :real then "float"
+        when :flag, :bool then "flag"
+        when :string, :str then "string"
+        else type.to_s
         end
       end
     end

data/lib/hts/bcf/record.rb

@@ -54,11 +54,11 @@ module HTS
       end
 
       def id=(id)
-        LibHTS.bcf_update_id(@header, @bcf1, id)
+        LibHTS.bcf_update_id(@header.struct, @bcf1, id)
       end
 
       def clear_id
-        LibHTS.bcf_update_id(@header, @bcf1, ".")
+        LibHTS.bcf_update_id(@header.struct, @bcf1, ".")
       end
 
       def ref
@@ -100,7 +100,7 @@ module HTS
         when 1
           id = d[:flt].read_int
           LibHTS.bcf_hdr_int2id(@header.struct, LibHTS::BCF_DT_ID, id)
-        when 2..nil
+        when 2..
           d[:flt].get_array_of_int(0, n_flt).map do |i|
             LibHTS.bcf_hdr_int2id(@header.struct, LibHTS::BCF_DT_ID, i)
           end
@@ -130,9 +130,13 @@ module HTS
 
       def to_s
         ksr = LibHTS::KString.new
-        raise "Failed to format record" if LibHTS.vcf_format(@header.struct, @bcf1, ksr) == -1
+        begin
+          raise "Failed to format record" if LibHTS.vcf_format(@header.struct, @bcf1, ksr) == -1
 
-        ksr[:s]
+          ksr.read_string_copy
+        ensure
+          ksr.free_buffer
+        end
       end
 
       private