JezK

Edit File: monitor.rbs

# 
# Use the Monitor class when you want to have a lock object for blocks with
# mutual exclusion.
#
#     require 'monitor'
#
#     lock = Monitor.new
#     lock.synchronize do
#       # exclusive access
#     end
#
class Monitor
  public

# 
  #
  def enter: () -> nil

# 
  #
  def exit: () -> nil

# 
  #
  def mon_check_owner: () -> nil

# 
  #
  alias mon_enter enter

# 
  #
  alias mon_exit exit

# 
  #
  def mon_locked?: () -> bool

# 
  #
  def mon_owned?: () -> bool

# 
  #
  alias mon_synchronize synchronize

# 
  #
  alias mon_try_enter try_enter

# 
  #
  def new_cond: () -> ::MonitorMixin::ConditionVariable

# 
  #
  def synchronize: [T] () { () -> T } -> T

# 
  #
  def try_enter: () -> bool

# 
  # for compatibility
  #
  alias try_mon_enter try_enter

# 
  #
  def wait_for_cond: (::MonitorMixin::ConditionVariable, Numeric? timeout) -> untyped
end

module MonitorMixin
  # 
  #
  def self.extend_object: (untyped obj) -> untyped

public

# 
  # Enters exclusive section.
  #
  def mon_enter: () -> nil

# 
  # Leaves exclusive section.
  #
  def mon_exit: () -> nil

# 
  # Returns true if this monitor is locked by any thread
  #
  def mon_locked?: () -> bool

# 
  # Returns true if this monitor is locked by current thread.
  #
  def mon_owned?: () -> bool

# 
  # Enters exclusive section and executes the block.  Leaves the exclusive section
  # automatically when the block exits.  See example under `MonitorMixin`.
  #
  def mon_synchronize: [T] () { () -> T } -> T

# 
  # Attempts to enter exclusive section.  Returns `false` if lock fails.
  #
  def mon_try_enter: () -> bool

# 
  # Creates a new MonitorMixin::ConditionVariable associated with the Monitor
  # object.
  #
  def new_cond: () -> ::MonitorMixin::ConditionVariable

# 
  #
  alias synchronize mon_synchronize

# 
  # For backward compatibility
  #
  alias try_mon_enter mon_try_enter

private

# 
  # Use `extend MonitorMixin` or `include MonitorMixin` instead of this
  # constructor.  Have look at the examples above to understand how to use this
  # module.
  #
  def initialize: (*untyped) { (*untyped) -> untyped } -> void

# 
  #
  def mon_check_owner: () -> nil

# 
  # Initializes the MonitorMixin after being included in a class or when an object
  # has been extended with the MonitorMixin
  #
  def mon_initialize: () -> untyped
end

# 
# FIXME: This isn't documented in Nutshell.
#
# Since MonitorMixin.new_cond returns a ConditionVariable, and the example above
# calls while_wait and signal, this class should be documented.
#
class MonitorMixin::ConditionVariable
  public

# 
  # Wakes up all threads waiting for this lock.
  #
  def broadcast: () -> Thread::ConditionVariable

# 
  # Wakes up the first thread in line waiting for this lock.
  #
  def signal: () -> Thread::ConditionVariable

# 
  # 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.
  #
  def wait: (?Numeric? timeout) -> untyped

# 
  # Calls wait repeatedly until the given block yields a truthy value.
  #
  def wait_until: () { () -> boolish } -> untyped

# 
  # Calls wait repeatedly while the given block yields a truthy value.
  #
  def wait_while: () { () -> boolish } -> untyped

private

# 
  #
  def initialize: (Monitor monitor) -> void
end

Veranstaltungen | Fairnetzt-Hochrhein

Keine Veranstaltung gefunden!