htslib 0.4.2 → 0.6.0

data/lib/hts/bcf/header.rb

@@ -23,18 +23,17 @@ module HTS
 
       def initialize(arg = nil)
         case arg
-        when LibHTS::HtsFile
-          @bcf_hdr = LibHTS.bcf_hdr_read(arg)
-        when LibHTS::BcfHdr
-          @bcf_hdr = arg
+        when Native::BcfHeaderHandle
+          @native = arg
         when nil
-          @bcf_hdr = LibHTS.bcf_hdr_init("w")
+          @native = Native::BcfHeaderHandle.create
         else
           raise TypeError, "Invalid argument"
         end
 
         @sync_depth = 0
         @sync_needed = false
+        @schema_version = 0
         @subset_samples = nil
         @subset_imap = nil
         @subset_imap_pointer = nil
@@ -42,29 +41,23 @@ module HTS
         yield self if block_given?
       end
 
-      def struct
-        @bcf_hdr
-      end
-
-      def to_ptr
-        @bcf_hdr.to_ptr
-      end
-
       def get_version
-        LibHTS.bcf_hdr_get_version(@bcf_hdr)
+        @native.version
       end
+      alias version get_version
 
       def set_version(version)
-        rc = LibHTS.bcf_hdr_set_version(@bcf_hdr, version)
+        rc = @native.set_version(version)
         raise "Failed to set VCF header version" if rc.negative?
 
         mark_sync_needed!
         sync_if_needed!
         self
       end
+      alias version= set_version
 
       def nsamples
-        LibHTS.bcf_hdr_nsamples(@bcf_hdr)
+        @native.nsamples
       end
 
       def target_count
@@ -84,13 +77,10 @@ module HTS
       end
 
       def samples
-        # bcf_hdr_id2name is macro function
-        @bcf_hdr[:samples]
-          .read_array_of_pointer(nsamples)
-          .map(&:read_string)
+        @native.samples
       end
 
-      attr_reader :subset_samples, :subset_imap_pointer
+      attr_reader :subset_samples, :subset_imap_pointer, :schema_version
 
       def subset?
         !@subset_imap.nil?
@@ -104,27 +94,18 @@ module HTS
         subset_samples = normalize_subset_samples(samples)
         validate_subset_samples!(subset_samples)
 
-        imap_pointer = nil
-        if subset_samples.empty?
-          subset_hdr = LibHTS.bcf_hdr_subset(@bcf_hdr, 0, ::FFI::Pointer::NULL, ::FFI::Pointer::NULL)
-        else
-          encoded_samples = subset_samples.map { |name| FFI::MemoryPointer.from_string(name) }
-          sample_pointers = FFI::MemoryPointer.new(:pointer, subset_samples.length)
-          sample_pointers.write_array_of_pointer(encoded_samples)
-          imap_pointer = FFI::MemoryPointer.new(:int, subset_samples.length)
-          subset_hdr = LibHTS.bcf_hdr_subset(@bcf_hdr, subset_samples.length, sample_pointers, imap_pointer)
-        end
+        result = @native.subset(subset_samples)
+        raise SubsetError, "Failed to subset BCF header samples #{subset_samples.inspect}" unless result
 
-        raise SubsetError, "Failed to subset BCF header samples #{subset_samples.inspect}" if subset_hdr.to_ptr.null?
-
-        composed_imap = compose_subset_imap(read_subset_imap(imap_pointer, subset_samples.length))
-        self.class.new(subset_hdr).tap do |header|
+        subset_header, imap = result
+        composed_imap = compose_subset_imap(imap)
+        self.class.new(subset_header).tap do |header|
           header.send(:set_subset_state, subset_samples, composed_imap)
         end
       end
 
       def add_sample(sample, sync: true)
-        rc = LibHTS.bcf_hdr_add_sample(@bcf_hdr, sample)
+        rc = @native.add_sample(sample)
         raise "Failed to add sample #{sample}" if rc.negative?
 
         mark_sync_needed!
@@ -133,17 +114,14 @@ module HTS
       end
 
       def merge(hdr)
-        merged = LibHTS.bcf_hdr_merge(@bcf_hdr, hdr.struct)
-        raise "Failed to merge BCF headers" if merged.to_ptr.null?
-
-        @bcf_hdr = merged
+        @native.merge(hdr.__send__(:native_handle))
         mark_sync_needed!
         sync_if_needed!
         self
       end
 
       def sync
-        rc = LibHTS.bcf_hdr_sync(@bcf_hdr)
+        rc = @native.sync
         raise "Failed to sync BCF header" if rc.negative?
 
         @sync_needed = false
@@ -151,11 +129,13 @@ module HTS
       end
 
       def read_bcf(fname)
-        LibHTS.bcf_hdr_set(@bcf_hdr, fname)
+        result = @native.read_file(fname)
+        @schema_version += 1 unless result.negative?
+        result
       end
 
       def append(line)
-        rc = LibHTS.bcf_hdr_append(@bcf_hdr, line)
+        rc = @native.append(line)
         raise "Failed to append VCF header line" if rc.negative?
 
         mark_sync_needed!
@@ -164,18 +144,14 @@ module HTS
 
       def delete(bcf_hl_type, key = nil) # FIXME
         existed = hrec_exists?(bcf_hl_type, key)
-        type = bcf_hl_type_to_int(bcf_hl_type)
-        LibHTS.bcf_hdr_remove(@bcf_hdr, type, key)
+        @native.remove(bcf_hl_type.to_s, key)
         mark_sync_needed! if existed
         existed
       end
 
       def get_hrec(bcf_hl_type, key, value, str_class = nil)
-        type = bcf_hl_type_to_int(bcf_hl_type)
-        hrec = borrowed_hrec(type, key, value, str_class)
-        return nil if hrec.to_ptr.null?
-
-        HeaderRecord.new(owned_hrec(hrec))
+        hrec = @native.get_hrec(bcf_hl_type.to_s, key, value, str_class)
+        hrec ? HeaderRecord.new(hrec) : nil
       end
 
       def edit
@@ -251,33 +227,19 @@ module HTS
       end
 
       def seqnames
-        n = FFI::MemoryPointer.new(:int)
-        names = LibHTS.bcf_hdr_seqnames(@bcf_hdr, n)
-        begin
-          names.read_array_of_pointer(n.read_int)
-               .map(&:read_string)
-        ensure
-          LibHTS.hts_free(names) unless names.null?
-        end
+        @native.seqnames
       end
 
       def to_s
-        kstr = LibHTS::KString.new
-        begin
-          raise "Failed to get header string" if LibHTS.bcf_hdr_format(@bcf_hdr, 0, kstr).negative?
-
-          kstr.read_string_copy
-        ensure
-          kstr.free_buffer
-        end
+        @native.to_s
       end
 
       def name2id(name)
-        LibHTS.bcf_hdr_name2id(@bcf_hdr, name)
+        @native.name2id(name)
       end
 
       def id2name(id)
-        LibHTS.bcf_hdr_id2name(@bcf_hdr, id)
+        @native.id2name(id)
       end
 
       private
@@ -324,6 +286,7 @@ module HTS
 
       def mark_sync_needed!
         @sync_needed = true
+        @schema_version += 1
       end
 
       def sync_if_needed!
@@ -331,58 +294,26 @@ module HTS
       end
 
       def hrec_exists?(bcf_hl_type, key)
-        type = bcf_hl_type_to_int(bcf_hl_type)
-        lookup_key, lookup_value, str_class = hrec_lookup_args(type, key)
-        hrec = borrowed_hrec(type, lookup_key, lookup_value, str_class)
-        !hrec.to_ptr.null?
-      end
-
-      def borrowed_hrec(type, key, value, str_class)
-        LibHTS.bcf_hdr_get_hrec(@bcf_hdr, type, key, value, str_class)
-      end
-
-      def owned_hrec(hrec)
-        LibHTS.bcf_hrec_dup(hrec).tap do |owned|
-          raise "Failed to duplicate BCF header record" if owned.to_ptr.null?
-        end
+        lookup_key, lookup_value, str_class = hrec_lookup_args(bcf_hl_type, key)
+        !@native.get_hrec(bcf_hl_type.to_s, lookup_key, lookup_value, str_class).nil?
       end
 
       def hrec_lookup_args(type, key)
-        case type
-        when LibHTS::BCF_HL_FLT, LibHTS::BCF_HL_INFO, LibHTS::BCF_HL_FMT, LibHTS::BCF_HL_CTG
+        case type.to_s.upcase
+        when "FILTER", "FIL", "INFO", "FORMAT", "FMT", "CONTIG", "CTG"
           ["ID", key, nil]
-        when LibHTS::BCF_HL_GEN
+        when "GENOTYPE", "GEN"
           [key, nil, nil]
         else
           ["ID", key, nil]
         end
       end
 
-      def bcf_hl_type_to_int(bcf_hl_type)
-        return bcf_hl_type if bcf_hl_type.is_a?(Integer)
-
-        case bcf_hl_type.to_s.upcase
-        when "FILTER", "FIL"
-          LibHTS::BCF_HL_FLT
-        when "INFO"
-          LibHTS::BCF_HL_INFO
-        when "FORMAT", "FMT"
-          LibHTS::BCF_HL_FMT
-        when "CONTIG", "CTG"
-          LibHTS::BCF_HL_CTG
-        when "STRUCTURED", "STR"
-          LibHTS::BCF_HL_STR
-        when "GENOTYPE", "GEN"
-          LibHTS::BCF_HL_GEN
-        else
-          raise TypeError, "Invalid argument"
-        end
-      end
-
       def initialize_copy(orig)
-        @bcf_hdr = LibHTS.bcf_hdr_dup(orig.struct)
+        @native = orig.__send__(:native_handle).duplicate
         @sync_depth = 0
         @sync_needed = false
+        @schema_version = orig.schema_version
         set_subset_state(orig.subset_samples, orig.send(:subset_imap))
       end
 
@@ -393,7 +324,7 @@ module HTS
       def set_subset_state(samples, imap)
         @subset_samples = samples&.dup
         @subset_imap = imap&.dup
-        @subset_imap_pointer = build_subset_imap_pointer(@subset_imap)
+        @subset_imap_pointer = nil
       end
 
       private
@@ -417,25 +348,12 @@ module HTS
         raise UnknownSampleError, "Unknown sample names: #{missing.join(', ')}" unless missing.empty?
       end
 
-      def read_subset_imap(pointer, length)
-        return [] if length.zero?
-
-        pointer.read_array_of_int(length)
-      end
-
       def compose_subset_imap(imap)
         base_imap = @subset_imap || Array.new(samples.length, &:itself)
         imap.map { |index| base_imap.fetch(index) }
       end
 
-      def build_subset_imap_pointer(imap)
-        return nil unless imap
-        return nil if imap.empty?
-
-        FFI::MemoryPointer.new(:int, imap.length).tap do |pointer|
-          pointer.write_array_of_int(imap)
-        end
-      end
+      def native_handle = @native
     end
   end
 end

data/lib/hts/bcf/header_record.rb

@@ -3,47 +3,21 @@
 module HTS
   class Bcf < Hts
     class HeaderRecord
-      def initialize(arg = nil)
-        case arg
-        when LibHTS::BcfHrec
-          @bcf_hrec = arg
-        else
-          raise TypeError, "Invalid argument"
-        end
-      end
+      def initialize(native)
+        raise TypeError, "Invalid argument" unless native.is_a?(Native::BcfHeaderRecordHandle)
 
-      def struct
-        @bcf_hrec
+        @native = native
       end
 
-      def add_key(key)
-        LibHTS.bcf_hrec_add_key(@bcf_hrec, key, key.length)
-      end
-
-      def set_value(i, val, quote: true)
-        is_quoted = quote ? 1 : 0
-        LibHTS.bcf_hrec_set_val(@bcf_hrec, i, val, val.length, is_quoted)
-      end
-
-      def find_key(key)
-        LibHTS.bcf_hrec_find_key(@bcf_hrec, key)
-      end
-
-      def to_s
-        kstr = LibHTS::KString.new
-        begin
-          LibHTS.bcf_hrec_format(@bcf_hrec, kstr)
-          kstr.read_string_copy
-        ensure
-          kstr.free_buffer
-        end
-      end
+      def add_key(key) = @native.add_key(key)
+      def set_value(index, value, quote: true) = @native.set_value(index, value, quote)
+      def find_key(key) = @native.find_key(key)
+      def to_s = @native.to_s
 
       private
 
-      def initialize_copy(orig)
-        @bcf_hrec = LibHTS.bcf_hrec_dup(orig.struct)
-      end
+      def native_handle = @native
+      def initialize_copy(original) = (@native = original.__send__(:native_handle).duplicate)
     end
   end
 end