Results for: "partition"

Gem::write_binary

Safely write a file in binary mode on all platforms.

Gem::ruby_version

A Gem::Version for the currently running Ruby.

Gem::rubygems_version

A Gem::Version for the currently running RubyGems

Process::clock_gettime

Returns a time returned by POSIX clock_gettime() function.

p Process.clock_gettime(Process::CLOCK_MONOTONIC)
#=> 896053.968060096

clock_id specifies a kind of clock. It is specified as a constant which begins with Process::CLOCK_ such as Process::CLOCK_REALTIME and Process::CLOCK_MONOTONIC.

The supported constants depends on OS and version. Ruby provides following types of clock_id if available.

CLOCK_REALTIME: SUSv2 to 4, Linux 2.5.63, FreeBSD 3.0, NetBSD 2.0, OpenBSD 2.1, macOS 10.12, Windows-8/Server-2012
CLOCK_MONOTONIC: SUSv3 to 4, Linux 2.5.63, FreeBSD 3.0, NetBSD 2.0, OpenBSD 3.4, macOS 10.12, Windows-2000
CLOCK_PROCESS_CPUTIME_ID: SUSv3 to 4, Linux 2.5.63, FreeBSD 9.3, OpenBSD 5.4, macOS 10.12
CLOCK_THREAD_CPUTIME_ID: SUSv3 to 4, Linux 2.5.63, FreeBSD 7.1, OpenBSD 5.4, macOS 10.12
CLOCK_VIRTUAL: FreeBSD 3.0, OpenBSD 2.1
CLOCK_PROF: FreeBSD 3.0, OpenBSD 2.1
CLOCK_REALTIME_FAST: FreeBSD 8.1
CLOCK_REALTIME_PRECISE: FreeBSD 8.1
CLOCK_REALTIME_COARSE: Linux 2.6.32
CLOCK_REALTIME_ALARM: Linux 3.0
CLOCK_MONOTONIC_FAST: FreeBSD 8.1
CLOCK_MONOTONIC_PRECISE: FreeBSD 8.1
CLOCK_MONOTONIC_COARSE: Linux 2.6.32
CLOCK_MONOTONIC_RAW: Linux 2.6.28, macOS 10.12
CLOCK_MONOTONIC_RAW_APPROX: macOS 10.12
CLOCK_BOOTTIME: Linux 2.6.39
CLOCK_BOOTTIME_ALARM: Linux 3.0
CLOCK_UPTIME: FreeBSD 7.0, OpenBSD 5.5
CLOCK_UPTIME_FAST: FreeBSD 8.1
CLOCK_UPTIME_RAW: macOS 10.12
CLOCK_UPTIME_RAW_APPROX: macOS 10.12
CLOCK_UPTIME_PRECISE: FreeBSD 8.1
CLOCK_SECOND: FreeBSD 8.1
CLOCK_TAI: Linux 3.10

Note that SUS stands for Single Unix Specification. SUS contains POSIX and clock_gettime is defined in the POSIX part. SUS defines CLOCK_REALTIME mandatory but CLOCK_MONOTONIC, CLOCK_PROCESS_CPUTIME_ID and CLOCK_THREAD_CPUTIME_ID are optional.

Also, several symbols are accepted as clock_id. There are emulations for clock_gettime().

For example, Process::CLOCK_REALTIME is defined as :GETTIMEOFDAY_BASED_CLOCK_REALTIME when clock_gettime() is not available.

Emulations for CLOCK_REALTIME:

:GETTIMEOFDAY_BASED_CLOCK_REALTIME: Use gettimeofday() defined by SUS. (SUSv4 obsoleted it, though.) The resolution is 1 microsecond.
:TIME_BASED_CLOCK_REALTIME: Use time() defined by ISO C. The resolution is 1 second.

Emulations for CLOCK_MONOTONIC:

:MACH_ABSOLUTE_TIME_BASED_CLOCK_MONOTONIC: Use mach_absolute_time(), available on Darwin. The resolution is CPU dependent.
:TIMES_BASED_CLOCK_MONOTONIC: Use the result value of times() defined by POSIX. POSIX defines it as “times() shall return the elapsed real time, in clock ticks, since an arbitrary point in the past (for example, system start-up time)”. For example, GNU/Linux returns a value based on jiffies and it is monotonic. However, 4.4BSD uses gettimeofday() and it is not monotonic. (FreeBSD uses clock_gettime(CLOCK_MONOTONIC) instead, though.) The resolution is the clock tick. “getconf CLK_TCK” command shows the clock ticks per second. (The clock ticks per second is defined by HZ macro in older systems.) If it is 100 and clock_t is 32 bits integer type, the resolution is 10 millisecond and cannot represent over 497 days.

Emulations for CLOCK_PROCESS_CPUTIME_ID:

:GETRUSAGE_BASED_CLOCK_PROCESS_CPUTIME_ID: Use getrusage() defined by SUS. getrusage() is used with RUSAGE_SELF to obtain the time only for the calling process (excluding the time for child processes). The result is addition of user time (ru_utime) and system time (ru_stime). The resolution is 1 microsecond.
:TIMES_BASED_CLOCK_PROCESS_CPUTIME_ID: Use times() defined by POSIX. The result is addition of user time (tms_utime) and system time (tms_stime). tms_cutime and tms_cstime are ignored to exclude the time for child processes. The resolution is the clock tick. “getconf CLK_TCK” command shows the clock ticks per second. (The clock ticks per second is defined by HZ macro in older systems.) If it is 100, the resolution is 10 millisecond.
:CLOCK_BASED_CLOCK_PROCESS_CPUTIME_ID: Use clock() defined by ISO C. The resolution is 1/CLOCKS_PER_SEC. CLOCKS_PER_SEC is the C-level macro defined by time.h. SUS defines CLOCKS_PER_SEC is 1000000. Non-Unix systems may define it a different value, though. If CLOCKS_PER_SEC is 1000000 as SUS, the resolution is 1 microsecond. If CLOCKS_PER_SEC is 1000000 and clock_t is 32 bits integer type, it cannot represent over 72 minutes.

If the given clock_id is not supported, Errno::EINVAL is raised.

unit specifies a type of the return value.

:float_second: number of seconds as a float (default)
:float_millisecond: number of milliseconds as a float
:float_microsecond: number of microseconds as a float
:second: number of seconds as an integer
:millisecond: number of milliseconds as an integer
:microsecond: number of microseconds as an integer
:nanosecond: number of nanoseconds as an integer

The underlying function, clock_gettime(), returns a number of nanoseconds. Float object (IEEE 754 double) is not enough to represent the return value for CLOCK_REALTIME. If the exact nanoseconds value is required, use :nanosecond as the unit.

The origin (zero) of the returned value varies. For example, system start up time, process start up time, the Epoch, etc.

The origin in CLOCK_REALTIME is defined as the Epoch (1970-01-01 00:00:00 UTC). But some systems count leap seconds and others doesn’t. So the result can be interpreted differently across systems. Time.now is recommended over CLOCK_REALTIME.

Gem::Package::TarReader::Entry#readpartial

No documentation available

OpenSSL::BN#negative?

No documentation available

OpenSSL::Cipher#authenticated?

Indicated whether this Cipher instance uses an Authenticated Encryption mode.

OpenSSL::Config::parse

Parses a given string as a blob that contains configuration for OpenSSL.

Psych::Parser#parse

Parse the YAML document contained in yaml. Events will be called on the handler set on the parser instance.

See Psych::Parser and Psych::Parser#handler

Ripper::Filter#parse

Starts the parser. init is a data accumulator and is passed to the next event handler (as of Enumerable#inject).

Socket::AncillaryData#timestamp

returns the timestamp as a time object.

ancillarydata should be one of following type:

SOL_SOCKET/SCM_TIMESTAMP (microsecond) GNU/Linux, FreeBSD, NetBSD, OpenBSD, Solaris, MacOS X
SOL_SOCKET/SCM_TIMESTAMPNS (nanosecond) GNU/Linux

SOL_SOCKET/SCM_BINTIME (2**(-64) second) FreeBSD

Addrinfo.udp(“127.0.0.1”, 0).bind {|s1|

Addrinfo.udp("127.0.0.1", 0).bind {|s2|
  s1.setsockopt(:SOCKET, :TIMESTAMP, true)
  s2.send "a", 0, s1.local_address
  ctl = s1.recvmsg.last
  p ctl    #=> #<Socket::AncillaryData: INET SOCKET TIMESTAMP 2009-02-24 17:35:46.775581>
  t = ctl.timestamp
  p t      #=> 2009-02-24 17:35:46 +0900
  p t.usec #=> 775581
  p t.nsec #=> 775581000
}

}

WIN32OLE::Method#params

returns array of WIN32OLE_PARAM object corresponding with method parameters.

tobj = WIN32OLE_TYPE.new('Microsoft Excel 9.0 Object Library', 'Workbook')
method = WIN32OLE_METHOD.new(tobj, 'SaveAs')
p method.params # => [Filename, FileFormat, Password, WriteResPassword,
                      ReadOnlyRecommended, CreateBackup, AccessMode,
                      ConflictResolution, AddToMru, TextCodepage,
                      TextVisualLayout]

WIN32OLE::Typelib#version

Returns the type library version.

tlib = WIN32OLE_TYPELIB.new('Microsoft Excel 9.0 Object Library')
puts tlib.version #-> "1.3"

WIN32OLE::Variant#vartype

Returns OLE variant type.

obj = WIN32OLE_VARIANT.new("string")
obj.vartype # => WIN32OLE::VARIANT::VT_BSTR

Zlib::Deflate#params

Changes the parameters of the deflate stream to allow changes between different types of data that require different types of compression. Any unprocessed data is flushed before changing the params.

See Zlib::Deflate.new for a description of level and strategy.

Zlib::GzipFile#mtime

Returns last modification time recorded in the gzip file header.

Zlib::GzipWriter#mtime=

Specify the modification time (mtime) in the gzip header. Using an Integer.

Setting the mtime in the gzip header does not effect the mtime of the file generated. Different utilities that expand the gzipped files may use the mtime header. For example the gunzip utility can use the ‘-N` flag which will set the resultant file’s mtime to the value in the header. By default many tools will set the mtime of the expanded file to the mtime of the gzipped file, not the mtime in the header.

If you do not set an mtime, the default value will be the time when compression started. Setting a value of 0 indicates no time stamp is available.

File::Stat#atime

Returns the last access time for this file as an object of class Time.

File.stat("testfile").atime   #=> Wed Dec 31 18:00:00 CST 1969

File::Stat#mtime

Returns the modification time of stat.

File.stat("testfile").mtime   #=> Wed Apr 09 08:53:14 CDT 2003

File::Stat#ctime

Returns the change time for stat (that is, the time directory information about the file was changed, not the file itself).

Note that on Windows (NTFS), returns creation time (birth time).

File.stat("testfile").ctime   #=> Wed Apr 09 08:53:14 CDT 2003

File::Stat#sticky?

Returns true if stat has its sticky bit set, false if it doesn’t or if the operating system doesn’t support this feature.

File.stat("testfile").sticky?   #=> false

CGI::Cookie::parse

Parse a raw cookie string into a hash of cookie-name=>Cookie pairs.

cookies = CGI::Cookie.parse("raw_cookie_string")
  # { "name1" => cookie1, "name2" => cookie2, ... }