wwood-bioruby 1.2.11

data/lib/bio/io/flatfile/bdb.rb

@@ -0,0 +1,253 @@
+# 
+# bio/io/flatfile/bdb.rb - OBDA flatfile index by Berkley DB 
+# 
+# Copyright:: Copyright (C) 2002 GOTO Naohisa <ng@bioruby.org> 
+# License::   The Ruby License
+# 
+#  $Id: bdb.rb,v 1.10 2007/04/05 23:35:41 trevor Exp $ 
+# 
+ 
+begin 
+  require 'bdb' 
+rescue LoadError,NotImplementedError
+end 
+
+require 'bio/io/flatfile/index'
+require 'bio/io/flatfile/indexer'
+
+module Bio
+  class FlatFileIndex
+
+    module BDBdefault
+      def permission
+        (0666 & (0777 ^ File.umask))
+      end
+      module_function :permission
+
+      def flag_read
+        BDB::RDONLY
+      end
+      module_function :flag_read
+
+      def flag_write
+        (BDB::CREATE | BDB::TRUNCATE)
+      end
+      module_function :flag_write
+
+      def flag_append
+        'r+'
+      end
+      module_function :flag_append
+    end #module BDBdefault
+
+    class BDBwrapper
+      def initialize(name, filename, *arg)
+        @dbname = name
+        @file = nil
+        @filename = filename
+        #self.open(*arg)
+      end
+
+      def filename
+        File.join(@dbname, @filename)
+      end
+
+      def open(flag = BDBdefault.flag_read,
+               permission = BDBdefault.permission)
+        unless @file then
+          DEBUG.print "BDBwrapper: open #{filename}\n"
+          @file = BDB::Btree.open(filename, nil, flag, permission)
+        end
+        true
+      end
+
+      def close
+        if @file
+          DEBUG.print "BDBwrapper: close #{filename}\n"
+          @file.close
+          @file = nil
+        end
+        nil
+      end
+
+      def [](arg)
+        #self.open
+        if @file then
+          @file[arg]
+        else
+          nil
+        end
+      end
+
+      def []=(key, val)
+        #self.open
+        @file[key.to_s] = val.to_s
+      end
+
+      def writeback_array(prefix, array, *arg)
+        self.close
+        self.open(*arg)
+        array.each_with_index do |val, key|
+          @file["#{prefix}#{key}"] = val.to_s
+        end
+      end
+
+      def keys
+        if @file then
+          @file.keys
+        else
+          []
+        end
+      end
+    end #class BDBwrapper
+
+    module BDB_1
+      class BDBMappingFile
+        def self.open(*arg)
+          self.new(*arg)
+        end
+
+        def initialize(filename, flag = BDBdefault.flag_read,
+                       permission = BDBdefault.permission)
+          @filename = filename
+          @flag = flag
+          @permission = permission
+          #@bdb = BDB::Btree.open(@filename, nil, @flag, @permission)
+        end
+        attr_reader :filename
+        attr_accessor :flag, :permission
+
+        def open
+          unless @bdb then
+            DEBUG.print "BDBMappingFile: open #{@filename}\n"
+            @bdb = BDB::Btree.open(@filename, nil, @flag, @permission)
+            true
+          else
+            nil
+          end
+        end
+
+        def close
+          if @bdb then
+            DEBUG.print "BDBMappingFile: close #{@filename}\n"
+            @bdb.close
+            @bdb = nil
+          end
+          nil
+        end
+
+        def records
+          @bdb.size
+        end
+        alias size records
+
+        # methods for writing
+        def add(key, val)
+          open
+          val = val.to_a.join("\t")
+          s = @bdb[key]
+          if s then
+            s << "\t"
+            s << val
+            val = s
+          end
+          @bdb[key] = val
+          #DEBUG.print "add: key=#{key.inspect}, val=#{val.inspect}\n"
+          val
+        end
+
+        def add_exclusive(key, val)
+          open
+          val = val.to_a.join("\t")
+          s = @bdb[key]
+          if s then
+            raise RuntimeError, "keys must be unique, but key #{key.inspect} already exists"
+          end
+          @bdb[key] = val
+          #DEBUG.print "add_exclusive: key=#{key.inspect}, val=#{val.inspect}\n"
+          val
+        end
+
+        def add_overwrite(key, val)
+          open
+          val = val.to_a.join("\t")
+          s = @bdb[key]
+          if s then
+            DEBUG.print "Warining: overwrote unique id #{key.inspect}\n"
+          end
+          @bdb[key] = val
+          #DEBUG.print "add_overwrite: key=#{key.inspect}, val=#{val.inspect}\n"
+          val
+        end
+
+        def add_nr(key, val)
+          open
+          s = @bdb[key]
+          if s then
+            a = s.split("\t")
+          else
+            a = []
+          end
+          a.concat val.to_a
+          a.sort!
+          a.uniq!
+          str = a.join("\t")
+          @bdb[key] = str
+          #DEBUG.print "add_nr: key=#{key.inspect}, val=#{str.inspect}\n"
+          str
+        end
+            
+        # methods for searching
+        def search(key)
+          open
+          s = @bdb[key]
+          if s then
+            a = s.split("\t")
+            a
+          else
+            []
+          end
+        end
+      end #class BDBMappingFile
+
+      class PrimaryNameSpace < Template::NameSpace
+        def mapping(filename)
+          BDBMappingFile.new(filename)
+        end
+        def filename
+          File.join(dbname, "key_#{name}")
+        end
+        def search(key)
+          r = super(key)
+          unless r.empty? then
+            [ r ]
+          else
+            r
+          end
+        end
+      end #class PrimaryNameSpace
+
+      class SecondaryNameSpace < Template::NameSpace
+        def mapping(filename)
+          BDBMappingFile.new(filename)
+        end
+        def filename
+          File.join(dbname, "id_#{name}")
+        end #class SecondaryNameSpaces
+      
+        def search(key)
+          r = super(key)
+          file.close
+          r
+        end
+      end #class SecondaryNameSpace
+    end #module BDB_1
+
+  end #class FlatFileIndex
+end #module Bio
+
+=begin
+
+  * Classes/modules in this file are internal use only.
+
+=end

data/lib/bio/io/flatfile/buffer.rb

@@ -0,0 +1,237 @@
+#
+# = bio/io/flatfile/buffer.rb - Input stream buffer for FlatFile
+#
+#   Copyright (C) 2001-2006 Naohisa Goto <ng@bioruby.org>
+#
+# License:: The Ruby License
+#
+#  $Id:$
+#
+#
+# See documents for Bio::FlatFile::BufferedInputStream and Bio::FlatFile.
+#
+
+require 'bio/io/flatfile'
+
+module Bio
+
+  class FlatFile
+
+    # Wrapper for a IO (or IO-like) object.
+    # It can input with a buffer.
+    class BufferedInputStream
+      # Creates a new input stream wrapper
+      def initialize(io, path)
+        @io = io
+        @path = path
+        # initialize prefetch buffer
+        @buffer = ''
+      end
+
+      # Creates a new input stream wrapper from the given IO object.
+      def self.for_io(io)
+        begin
+          path = io.path
+        rescue NameError
+          path = nil
+        end
+        self.new(io, path)
+      end
+
+      # Creates a new input stream wrapper to open file _filename_
+      # by using File.open.
+      # *arg is passed to File.open.
+      #
+      # Like File.open, a block can be accepted.
+      def self.open_file(filename, *arg)
+        if block_given? then
+          File.open(filename, *arg) do |fobj|
+            yield self.new(fobj, filename)
+          end
+        else
+          fobj = File.open(filename, *arg)
+          self.new(fobj, filename)
+        end
+      end
+
+      # Creates a new input stream wrapper from URI specified as _uri_.
+      # by using OpenURI.open_uri or URI#open.
+      # _uri_ must be a String or URI object.
+      # *arg is passed to OpenURI.open_uri or URI#open.
+      #
+      # Like OpenURI.open_uri, it can accept a block.
+      def self.open_uri(uri, *arg)
+        if uri.kind_of?(URI)
+          if block_given?
+            uri.open(*arg) do |fobj|
+              yield self.new(fobj, uri.to_s)
+            end
+          else
+            fobj = uri.open(*arg)
+            self.new(fobj, uri.to_s)
+          end
+        else
+          if block_given?
+            OpenURI.open_uri(uri, *arg) do |fobj|
+              yield self.new(fobj, uri)
+            end
+          else
+            fobj = OpenURI.open_uri(uri, *arg)
+            self.new(fobj, uri)
+          end
+        end
+      end
+
+      # Pathname, filename or URI to open the object.
+      # Like File#path, returned value isn't normalized.
+      attr_reader :path
+
+      # Converts to IO object if possible
+      def to_io
+        @io.to_io
+      end
+
+      # Closes the IO object if possible
+      def close
+        @io.close
+      end
+
+      # Rewinds the IO object if possible
+      # Internal buffer in this wrapper is cleared.
+      def rewind
+        r = @io.rewind
+        @buffer = ''
+        r
+      end
+
+      # Returns current file position
+      def pos
+        @io.pos - @buffer.size
+      end
+
+      # Sets current file position if possible
+      # Internal buffer in this wrapper is cleared.
+      def pos=(p)
+        r = (@io.pos = p)
+        @buffer = ''
+        r
+      end
+
+      # Returns true if end-of-file. Otherwise, returns false.
+      #
+      # Note that it returns false if internal buffer is this wrapper
+      # is not empty,
+      def eof?
+        if @buffer.size > 0
+          false
+        else
+          @io.eof?
+        end
+      end
+
+      # Same as IO#gets.
+      #
+      # Compatibility note: the bahavior of paragraph mode (io_rs = '')
+      # may differ from that of IO#gets('').
+      def gets(io_rs = $/)
+        if @buffer.size > 0
+          if io_rs == nil then
+            r = @buffer + @io.gets(nil).to_s
+            @buffer = ''
+          else
+            if io_rs == '' then # io_rs.empty?
+              sp_rs = /((?:\r?\n){2,})/n
+            else
+              sp_rs = io_rs
+            end
+            a = @buffer.split(sp_rs, 2)
+            if a.size > 1 then
+              r = a.shift
+              r += (io_rs.empty? ? a.shift : io_rs)
+              @buffer = a.shift.to_s
+            else
+              @buffer << @io.gets(io_rs).to_s
+              a = @buffer.split(sp_rs, 2)
+              if a.size > 1 then
+                r = a.shift
+                r += (io_rs.empty? ? a.shift : io_rs)
+                @buffer = a.shift.to_s
+              else
+                r = @buffer
+                @buffer = ''
+              end
+            end
+          end
+          r
+        else
+          @io.gets(io_rs)
+        end
+      end
+
+      # Pushes back given str to the internal buffer.
+      # Returns nil.
+      # str must be read previously with the wrapper object.
+      #
+      # Note that in current implementation, the str can be everything,
+      # but please don't depend on it.
+      #
+      def ungets(str)
+        @buffer = str + @buffer
+        nil
+      end
+
+      # Same as IO#getc.
+      def getc
+        if @buffer.size > 0 then
+          r = @buffer[0]
+          @buffer = @buffer[1..-1]
+        else
+          r = @io.getc
+        end
+        r
+      end
+      
+      # Pushes back one character into the internal buffer.
+      # Unlike IO#getc, it can be called more than one time.
+      def ungetc(c)
+        @buffer = sprintf("%c", c) + @buffer
+        nil
+      end
+
+      # Gets current prefetch buffer
+      def prefetch_buffer
+        @buffer
+      end
+
+      # It does @io.gets,  and addes returned string
+      # to the internal buffer, and returns the string.
+      def prefetch_gets(*arg)
+        r = @io.gets(*arg)
+        @buffer << r if r
+        r
+      end
+      
+      # It does @io.readpartial, and addes returned string
+      # to the internal buffer, and returns the string.
+      def prefetch_readpartial(*arg)
+        r = @io.readpartial(*arg)
+        @buffer << r if r
+        r
+      end
+
+      # Skips space characters in the stream.
+      # returns nil.
+      def skip_spaces
+        ws = { ?\s => true, ?\n => true, ?\r => true, ?\t => true }
+        while r = self.getc
+          unless ws[r] then
+            self.ungetc(r)
+            break
+          end
+        end
+        nil
+      end
+    end #class BufferedInputStream
+
+  end #class FlatFile
+end #module Bio