Class Mmap
In: mmap.rb
Parent: Object

The Mmap class implement memory-mapped file objects

WARNING The variables $’ and $` are not available with gsub! and sub!

Methods
capitalize!    casecmp    chomp!    chop!    concat    count    crypt    delete!    downcase!    each    each_byte    each_line    empty?    extend    flush    freeze    frozen    gsub!    gsub!    include?    index    insert    length    lockall    madvise    mlock    mprotect    msync    munlock    munmap    new    reverse!    rindex    scan    scan    self    self    self    self    self    self    self    self    self    self    self    self    self    self    self    size    slice    slice!    split    squeeze!    strip!    sub!    sub!    sum    swapcase!    tr!    tr_s!    unlockall   
Included modules
Comparable Enumerable
Public Class methods
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 = {})

create a new Mmap object

unlockall()

reenable paging

Public Instance methods
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 the file

flush()

same than msync

munlock()

reenable paging

munmap()

terminate the association

Other methods with the same syntax than for the class String

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)
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| ...}

iterate on each line

each_line([rs]) {|line| ...}

same than each

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)

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