Results for: "partition"

Like Enumerable#compact, but chains operation to be lazy-evaluated.

Releases the lock held in the associated monitor and waits; reacquires the lock on wakeup.

If timeout is given, this method returns after timeout seconds passed, even if no other thread doesn’t signal.

No documentation available

Enables or disables padding. By default encryption operations are padded using standard block padding and the padding is checked and removed when decrypting. If the pad parameter is zero then no padding is performed, the total amount of data encrypted or decrypted must then be a multiple of the block size or an error will occur.

See EVP_CIPHER_CTX_set_padding for further information.

Convert path string to a class

No documentation available

Emit a scalar with value

Called when a scalar value is found. The scalar may have an anchor, a tag, be implicitly plain or implicitly quoted

value is the string value of the scalar anchor is an associated anchor or nil tag is an associated tag or nil plain is a boolean value quoted is a boolean value style is an integer indicating the string style

See the constants in Psych::Nodes::Scalar for the possible values of style

Example

Here is a YAML document that exercises most of the possible ways this method can be called:

---
- !str "foo"
- &anchor fun
- many
  lines
- |
  many
  newlines

The above YAML document contains a list with four strings. Here are the parameters sent to this method in the same order:

# value               anchor    tag     plain   quoted  style
["foo",               nil,      "!str", false,  false,  3    ]
["fun",               "anchor", nil,    true,   false,  1    ]
["many lines",        nil,      nil,    true,   false,  1    ]
["many\nnewlines\n",  nil,      nil,    false,  true,   4    ]

Returns a Psych::Parser::Mark object that contains line, column, and index information.

No documentation available

Emit a scalar with value, anchor, tag, and a plain or quoted string type with style.

See Psych::Handler#scalar

Get the output style, canonical or not.

Set the output style to canonical, or not.

Calls String#unpack on sockopt.data.

sockopt = Socket::Option.new(:INET, :SOCKET, :KEEPALIVE, [1].pack("i"))
p sockopt.unpack("i")      #=> [1]
p sockopt.data.unpack("i") #=> [1]

Write data to a registry value named name. When name is nil, write to the ‘default’ value.

type is type value. (see Registry::Constants module) Class of data must be same as which read method returns.

Write value to a registry value named name.

The value type is REG_SZ(write_s), REG_DWORD(write_i), or REG_BINARY(write_bin).

Write value to a registry value named name.

The value type is REG_SZ(write_s), REG_DWORD(write_i), or REG_BINARY(write_bin).

Same as IO.

See Zlib::GzipReader documentation for a description.

Returns true if stat is writable by the effective user id of this process.

File.stat("testfile").writable?   #=> true

Returns true if the file is a character device, false if it isn’t or if the operating system doesn’t support this feature.

File.stat("/dev/tty").chardev?   #=> true

If the buffer is shared, meaning it references memory that can be shared with other processes (and thus might change without being modified locally).

# Create a test file:
File.write('test.txt', 'test')

# Create a shared mapping from the given file, the file must be opened in
# read-write mode unless we also specify IO::Buffer::READONLY:
buffer = IO::Buffer.map(File.open('test.txt', 'r+'), nil, 0)
# => #<IO::Buffer 0x00007f1bffd5e000+4 EXTERNAL MAPPED SHARED>

# Write to the buffer, which will modify the mapped file:
buffer.set_string('b', 0)
# => 1

# The file itself is modified:
File.read('test.txt')
# => "best"

If the buffer is read only, meaning the buffer cannot be modified using set_value, set_string or copy and similar.

Frozen strings and read-only files create read-only buffers.

Fill buffer with value, starting with offset and going for length bytes.

buffer = IO::Buffer.for('test').dup
# =>
#   <IO::Buffer 0x00007fca40087c38+4 INTERNAL>
#   0x00000000  74 65 73 74         test

buffer.clear
# =>
#   <IO::Buffer 0x00007fca40087c38+4 INTERNAL>
#   0x00000000  00 00 00 00         ....

buf.clear(1) # fill with 1
# =>
#   <IO::Buffer 0x00007fca40087c38+4 INTERNAL>
#   0x00000000  01 01 01 01         ....

buffer.clear(2, 1, 2) # fill with 2, starting from offset 1, for 2 bytes
# =>
#   <IO::Buffer 0x00007fca40087c38+4 INTERNAL>
#   0x00000000  01 02 02 01         ....

buffer.clear(2, 1) # fill with 2, starting from offset 1
# =>
#   <IO::Buffer 0x00007fca40087c38+4 INTERNAL>
#   0x00000000  01 02 02 02         ....

Write at least length bytes from the buffer starting at offset, into the io. If an error occurs, return -errno.

If length is not given or nil, it defaults to the size of the buffer minus the offset, i.e. the entire buffer.

If length is zero, exactly one write operation will occur.

If offset is not given, it defaults to zero, i.e. the beginning of the buffer.

out = File.open('output.txt', 'wb')
IO::Buffer.for('1234567').write(out, 3)

This leads to 123 being written into output.txt

Search took: 4ms  ·  Total Results: 2830