Gecko [ lorencats.com ]

Name	Size	Permission
2.5.0	[ DIR ]	drwxr-xr-x
Ascii85	[ DIR ]	drwxr-xr-x
atomic	[ DIR ]	drwxr-xr-x
coderay	[ DIR ]	drwxr-xr-x
concurrent	[ DIR ]	drwxr-xr-x
did_you_mean	[ DIR ]	drwxr-xr-x
ffi	[ DIR ]	drwxr-xr-x
hamster	[ DIR ]	drwxr-xr-x
hashery	[ DIR ]	drwxr-xr-x
hoe	[ DIR ]	drwxr-xr-x
i18n	[ DIR ]	drwxr-xr-x
kramdown	[ DIR ]	drwxr-xr-x
memoist	[ DIR ]	drwxr-xr-x
minitest	[ DIR ]	drwxr-xr-x
multi_json	[ DIR ]	drwxr-xr-x
net	[ DIR ]	drwxr-xr-x
oj	[ DIR ]	drwxr-xr-x
pdf	[ DIR ]	drwxr-xr-x
power_assert	[ DIR ]	drwxr-xr-x
prawn	[ DIR ]	drwxr-xr-x
rake	[ DIR ]	drwxr-xr-x
rouge	[ DIR ]	drwxr-xr-x
rubygems	[ DIR ]	drwxr-xr-x
rugged	[ DIR ]	drwxr-xr-x
stringex	[ DIR ]	drwxr-xr-x
test	[ DIR ]	drwxr-xr-x
thread_safe	[ DIR ]	drwxr-xr-x
ttfunk	[ DIR ]	drwxr-xr-x
tzinfo	[ DIR ]	drwxr-xr-x
wavefile	[ DIR ]	drwxr-xr-x
xmlrpc	[ DIR ]	drwxr-xr-x
afm.rb	4.37 KB	-rw-r--r--
ascii85.rb	5.74 KB	-rw-r--r--
atomic.rb	948 B	-rw-r--r--
coderay.rb	8.92 KB	-rw-r--r--
concurrent-edge.rb	509 B	-rw-r--r--
concurrent.rb	5.46 KB	-rw-r--r--
did_you_mean.rb	1.53 KB	-rw-r--r--
ffi.rb	628 B	-rw-r--r--
hamster.rb	312 B	-rw-r--r--
hashery.rb	543 B	-rw-r--r--
i18n.rb	13.54 KB	-rw-r--r--
kramdown.rb	192 B	-rw-r--r--
memoist.rb	6.48 KB	-rw-r--r--
minitest.rb	22.3 KB	-rw-r--r--
multi_json.rb	4.15 KB	-rw-r--r--
net-telnet.rb	21 B	-rw-r--r--
oj.rb	348 B	-rw-r--r--
pdf-reader.rb	38 B	-rw-r--r--
power_assert.rb	2.69 KB	-rw-r--r--
prawn.rb	2.23 KB	-rw-r--r--
rake.rb	2.11 KB	-rw-r--r--
rc4.rb	822 B	-rw-r--r--
rouge.rb	2.81 KB	-rw-r--r--
rugged.rb	723 B	-rw-r--r--
stringex.rb	369 B	-rw-r--r--
stringex_lite.rb	405 B	-rw-r--r--
test-unit.rb	1.17 KB	-rw-r--r--
thread_safe.rb	1.88 KB	-rw-r--r--
ttfunk.rb	3.25 KB	-rw-r--r--
tzinfo.rb	1.02 KB	-rw-r--r--
wavefile.rb	1.09 KB	-rw-r--r--
xmlrpc.rb	7.99 KB	-rw-r--r--

Code Editor : concurrent.rb

require 'concurrent/version'
require 'concurrent/constants'
require 'concurrent/errors'
require 'concurrent/configuration'

require 'concurrent/atomics'
require 'concurrent/executors'
require 'concurrent/synchronization'

require 'concurrent/atomic/atomic_reference'
require 'concurrent/agent'
require 'concurrent/atom'
require 'concurrent/array'
require 'concurrent/hash'
require 'concurrent/map'
require 'concurrent/tuple'
require 'concurrent/async'
require 'concurrent/dataflow'
require 'concurrent/delay'
require 'concurrent/exchanger'
require 'concurrent/future'
require 'concurrent/immutable_struct'
require 'concurrent/ivar'
require 'concurrent/maybe'
require 'concurrent/mutable_struct'
require 'concurrent/mvar'
require 'concurrent/promise'
require 'concurrent/scheduled_task'
require 'concurrent/settable_struct'
require 'concurrent/timer_task'
require 'concurrent/tvar'

require 'concurrent/thread_safe/synchronized_delegator'
require 'concurrent/thread_safe/util'

require 'concurrent/options'

# @!macro [new] internal_implementation_note
#
#   @note **Private Implementation:** This abstraction is a private, internal
#     implementation detail. It should never be used directly.

# @!macro [new] monotonic_clock_warning
#
#   @note Time calculations one all platforms and languages are sensitive to
#     changes to the system clock. To alleviate the potential problems
#     associated with changing the system clock while an application is running,
#     most modern operating systems provide a monotonic clock that operates
#     independently of the system clock. A monotonic clock cannot be used to
#     determine human-friendly clock times. A monotonic clock is used exclusively
#     for calculating time intervals. Not all Ruby platforms provide access to an
#     operating system monotonic clock. On these platforms a pure-Ruby monotonic
#     clock will be used as a fallback. An operating system monotonic clock is both
#     faster and more reliable than the pure-Ruby implementation. The pure-Ruby
#     implementation should be fast and reliable enough for most non-realtime
#     operations. At this time the common Ruby platforms that provide access to an
#     operating system monotonic clock are MRI 2.1 and above and JRuby (all versions).
#
#   @see http://linux.die.net/man/3/clock_gettime Linux clock_gettime(3)

# @!macro [new] copy_options
#
#   ## Copy Options
#
#   Object references in Ruby are mutable. This can lead to serious
#   problems when the {#value} of an object is a mutable reference. Which
#   is always the case unless the value is a `Fixnum`, `Symbol`, or similar
#   "primitive" data type. Each instance can be configured with a few
#   options that can help protect the program from potentially dangerous
#   operations. Each of these options can be optionally set when the object
#   instance is created:
#
#   * `:dup_on_deref` When true the object will call the `#dup` method on
#     the `value` object every time the `#value` method is called
#     (default: false)
#   * `:freeze_on_deref` When true the object will call the `#freeze`
#     method on the `value` object every time the `#value` method is called
#     (default: false)
#   * `:copy_on_deref` When given a `Proc` object the `Proc` will be run
#     every time   the `#value` method is called. The `Proc` will be given
#     the current `value` as its only argument and the result returned by
#     the block will be the return   value of the `#value` call. When `nil`
#     this option will be ignored (default: nil)
#
#   When multiple deref options are set the order of operations is strictly defined.
#   The order of deref operations is:
#   * `:copy_on_deref`
#   * `:dup_on_deref`
#   * `:freeze_on_deref`
#
#   Because of this ordering there is no need to `#freeze` an object created by a
#   provided `:copy_on_deref` block. Simply set `:freeze_on_deref` to `true`.
#   Setting both `:dup_on_deref` to `true` and `:freeze_on_deref` to `true` is
#   as close to the behavior of a "pure" functional language (like Erlang, Clojure,
#   or Haskell) as we are likely to get in Ruby.

# @!macro [attach] deref_options
#
#   @option opts [Boolean] :dup_on_deref (false) Call `#dup` before
#     returning the data from {#value}
#   @option opts [Boolean] :freeze_on_deref (false) Call `#freeze` before
#     returning the data from {#value}
#   @option opts [Proc] :copy_on_deref (nil) When calling the {#value}
#     method, call the given proc passing the internal value as the sole
#     argument then return the new value returned from the proc.

# @!macro [attach] executor_and_deref_options
#
#   @param [Hash] opts the options used to define the behavior at update and deref
#     and to specify the executor on which to perform actions
#   @option opts [Executor] :executor when set use the given `Executor` instance.
#     Three special values are also supported: `:task` returns the global task pool,
#     `:operation` returns the global operation pool, and `:immediate` returns a new
#     `ImmediateExecutor` object.
#   @!macro deref_options

# Modern concurrency tools for Ruby. Inspired by Erlang, Clojure, Scala, Haskell,
# F#, C#, Java, and classic concurrency patterns.
#
# The design goals of this gem are:
#
# * Stay true to the spirit of the languages providing inspiration
# * But implement in a way that makes sense for Ruby
# * Keep the semantics as idiomatic Ruby as possible
# * Support features that make sense in Ruby
# * Exclude features that don't make sense in Ruby
# * Be small, lean, and loosely coupled
module Concurrent

end

${this.title}

Code Editor : concurrent.rb