Skip to content
This repository

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
branch: master
Fetching contributors…

Octocat-spinner-32-eaf2f5

Cannot retrieve contributors at this time

file 254 lines (169 sloc) 5.716 kb
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 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
=begin
= Mmap

((<Download|URL:ftp://moulon.inra.fr/pub/ruby/>))

The Mmap class implement memory-mapped file objects

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

== SuperClass

Object

== Included Modules

* Comparable
* Enumerable

== 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 = {})
--- 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

== 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
     flush the file

--- 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) >= 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

=end
Something went wrong with that request. Please try again.