Class: Bio::FlatFile::BufferedInputStream

Inherits:
Object
  • Object
show all
Defined in:
lib/bio/io/flatfile/buffer.rb

Overview

Wrapper for a IO (or IO-like) object. It can input with a buffer.

Instance Attribute Summary (collapse)

Class Method Summary (collapse)

Instance Method Summary (collapse)

Constructor Details

- (BufferedInputStream) initialize(io, path)

Creates a new input stream wrapper



24
25
26
27
28
29
# File 'lib/bio/io/flatfile/buffer.rb', line 24

def initialize(io, path)
  @io = io
  @path = path
  # initialize prefetch buffer
  @buffer = ''
end

Instance Attribute Details

- (Object) path (readonly)

Pathname, filename or URI to open the object. Like File#path, returned value isn't normalized.



171
172
173
# File 'lib/bio/io/flatfile/buffer.rb', line 171

def path
  @path
end

Class Method Details

+ (Object) for_io(io)

Creates a new input stream wrapper from the given IO object.



32
33
34
35
36
37
38
39
# File 'lib/bio/io/flatfile/buffer.rb', line 32

def self.for_io(io)
  begin
    path = io.path
  rescue NameError
    path = nil
  end
  self.new(io, path)
end

+ (Object) open_file(filename, *arg)

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.

Unlike File.open, the default is binary mode, unless text mode is explicity specified in mode.



49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
# File 'lib/bio/io/flatfile/buffer.rb', line 49

def self.open_file(filename, *arg)
  params = _parse_file_open_arg(*arg)
  if params[:textmode] or /t/ =~ params[:fmode_string].to_s then
    textmode = true
  else
    textmode = false
  end
  if block_given? then
    File.open(filename, *arg) do |fobj|
      fobj.binmode unless textmode
      yield self.new(fobj, filename)
    end
  else
    fobj = File.open(filename, *arg)
    fobj.binmode unless textmode
    self.new(fobj, filename)
  end
end

+ (Object) open_uri(uri, *arg)

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.



147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
# File 'lib/bio/io/flatfile/buffer.rb', line 147

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

Instance Method Details

- (Object) close

Closes the IO object if possible



179
180
181
# File 'lib/bio/io/flatfile/buffer.rb', line 179

def close
  @io.close
end

- (Boolean) eof?

Returns true if end-of-file. Otherwise, returns false.

Note that it returns false if internal buffer is this wrapper is not empty,

Returns:

  • (Boolean)


208
209
210
211
212
213
214
# File 'lib/bio/io/flatfile/buffer.rb', line 208

def eof?
  if @buffer.size > 0
    false
  else
    @io.eof?
  end
end

- (Object) getc

Same as IO#getc.



268
269
270
271
272
273
274
275
276
# File 'lib/bio/io/flatfile/buffer.rb', line 268

def getc
  if @buffer.size > 0 then
    r = @buffer[0]
    @buffer = @buffer[1..-1]
  else
    r = @io.getc
  end
  r
end

- (Object) gets(io_rs = $/)

Same as IO#gets.

Compatibility note: the bahavior of paragraph mode (io_rs = '') may differ from that of IO#gets('').



220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
# File 'lib/bio/io/flatfile/buffer.rb', line 220

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

- (Object) pos

Returns current file position



192
193
194
# File 'lib/bio/io/flatfile/buffer.rb', line 192

def pos
  @io.pos - @buffer.size
end

- (Object) pos=(p)

Sets current file position if possible Internal buffer in this wrapper is cleared.



198
199
200
201
202
# File 'lib/bio/io/flatfile/buffer.rb', line 198

def pos=(p)
  r = (@io.pos = p)
  @buffer = ''
  r
end

- (Object) prefetch_buffer

Gets current prefetch buffer



286
287
288
# File 'lib/bio/io/flatfile/buffer.rb', line 286

def prefetch_buffer
  @buffer
end

- (Object) prefetch_gets(*arg)

It does @io.gets, and addes returned string to the internal buffer, and returns the string.



292
293
294
295
296
# File 'lib/bio/io/flatfile/buffer.rb', line 292

def prefetch_gets(*arg)
  r = @io.gets(*arg)
  @buffer << r if r
  r
end

- (Object) prefetch_readpartial(*arg)

It does @io.readpartial, and addes returned string to the internal buffer, and returns the string.



300
301
302
303
304
# File 'lib/bio/io/flatfile/buffer.rb', line 300

def prefetch_readpartial(*arg)
  r = @io.readpartial(*arg)
  @buffer << r if r
  r
end

- (Object) rewind

Rewinds the IO object if possible Internal buffer in this wrapper is cleared.



185
186
187
188
189
# File 'lib/bio/io/flatfile/buffer.rb', line 185

def rewind
  r = @io.rewind
  @buffer = ''
  r
end

- (Object) skip_spaces

Skips space characters in the stream. returns nil.



308
309
310
311
312
313
314
315
316
317
# File 'lib/bio/io/flatfile/buffer.rb', line 308

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

- (Object) to_io

Converts to IO object if possible



174
175
176
# File 'lib/bio/io/flatfile/buffer.rb', line 174

def to_io
  @io.to_io
end

- (Object) ungetc(c)

Pushes back one character into the internal buffer. Unlike IO#getc, it can be called more than one time.



280
281
282
283
# File 'lib/bio/io/flatfile/buffer.rb', line 280

def ungetc(c)
  @buffer = sprintf("%c", c) + @buffer
  nil
end

- (Object) ungets(str)

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.



262
263
264
265
# File 'lib/bio/io/flatfile/buffer.rb', line 262

def ungets(str)
  @buffer = str + @buffer
  nil
end