The Mmap class implement memory-mapped file objects
require 'mmap'
mmap = Mmap.new(__FILE__)
mmap.advise(Mmap::MADV_SEQUENTIAL)
mmap.each do |line|
puts line
end
gem install mmap
rake docs
WARNING: The variables $' and $` are not available with gsub! and sub!
Object
Comparable
Enumerable
lockall(flag)
:
disable paging of all pages mapped. |flag|
can be
Mmap::MCL_CURRENT
or Mmap::MCL_FUTURE
new(file, mode = "r", protection = Mmap::MAP_SHARED, options = {})
new(nil, length, protection = Mmap::MAP_SHARED, options = {})
:
create a new Mmap object
file
: Pathname of the file, if nil
is given an anonymous map
is created Mmanp::MAP_ANON
mode
: Mode to open the file, it can be r
, w
, rw
, a
protection
: specify the nature of the mapping
Mmap::MAP_SHARED
:
Creates a mapping that's shared with all other processes
mapping the same areas of the file.
The default value is Mmap::MAP_SHARED
Mmap::MAP_PRIVATE
:
Creates a private copy-on-write mapping, so changes to the
contents of the mmap object will be private to this process
options
:
Hash. If one of the options length
or offset
is specified it will not possible to modify the size of
the mapped file.
length
: Maps length
bytes from the file
offset
: The mapping begin at offset
advice
: The type of the access (see #madvise
)
unlockall
: reenable paging
extend(count)
: add count
bytes to the file (i.e. pre-extend the file)
madvise(advice)
: advice
can have the value Mmap::MADV_NORMAL
,
Mmap::MADV_RANDOM
, Mmap::MADV_SEQUENTIAL
,
Mmap::MADV_WILLNEED
, Mmap::MADV_DONTNEED
mprotect(mode)
: change the mode, value must be r
, w
or rw
mlock
: disable paging
msync
flush
: flush the file
munlock
: reenable paging
munmap
: terminate the association
self == other
: comparison
self > other
: comparison
self >= other
: comparison
self < other
: comparison
self <= other
: comparison
self === other
: used for case
comparison
self << other
: append other
to self
self =~ other
: return an index of the match
self[nth]
: retrieve the nth
character
self[start..last]
: return a substring from start
to last
self[start, length]
: return a substring of lenght
characters from start
self[nth] = val
: change the nth
character with val
self[start..last] = val
: change substring from start
to last
with val
self[start, len] = val
: replace length
characters from start
with val
.
self <=> other
: comparison : return -1, 0, 1
casecmp(other) >= 1.7.1
:
concat(other)
: append the contents of other
capitalize!
: change the first character to uppercase letter
chop!
: chop off the last character
chomp!([rs])
: chop off the line ending character, specified by rs
count(o1 [, o2, ...])
: each parameter defines a set of character to count
crypt(salt)
: crypt with salt
delete!(str)
: delete every characters included in str
downcase!
: change all uppercase character to lowercase character
each_byte {|char|...}
: iterate on each byte
each([rs]) {|line|...}
: - each_line([rs]) {|line|...}
: iterate on each line
empty?
: return true
if the file is empty
freeze
: freeze the current file
frozen
: return true
if the file is frozen
gsub!(pattern, replace)
: global substitution
gsub!(pattern) {|str|...}
: global substitution
include?(other)
: return true
if other
is found
index(substr[, pos])
: return the index of substr
insert(index, str) >= 1.7.1
: insert str
at index
length
: return the size of the file
reverse!
: reverse the content of the file
rindex(substr[, pos])
: return the index of the last occurrence of substr
scan(pattern)
: return an array of all occurence matched by pattern
scan(pattern) {|str| ...}
: iterate through the file, matching the pattern
size
: return the size of the file
slice
: same than []
slice!
: delete the specified portion of the file
split([sep[, limit]])
: splits into a list of strings and return this array
squeeze!([str])
: squeezes sequences of the same characters which is included in str
strip!
: removes leading and trailing whitespace
sub!(pattern, replace)
: substitution
sub!(pattern) {|str| ...}
: substitution
sum([bits])
: return a checksum
swapcase!
: replaces all lowercase characters to uppercase characters, and vice-versa
tr!(search, replace)
: translate the character from search
to replace
tr_s!(search, replace)
: translate the character from search
to replace
, then
squeeze sequence of the same characters
upcase!
: replaces all lowercase characters to downcase characters
This extension module is copyrighted free software by Guy Decoux
You can redistribute it and/or modify it under the same term as Ruby.
Guy Decoux ts@moulon.inra.fr