schema_dot_org 1.7.0 → 1.8

Sign up to get free protection for your applications and to get access to all the features.
@@ -1,1590 +0,0 @@
1
- # This file is autogenerated. Do not edit it by hand. Regenerate it with:
2
- # srb rbi gems
3
-
4
- # typed: true
5
- #
6
- # If you would like to make changes to this file, great! Please create the gem's shim here:
7
- #
8
- # https://github.com/sorbet/sorbet-typed/new/master?filename=lib/concurrent-ruby/all/concurrent-ruby.rbi
9
- #
10
- # concurrent-ruby-1.1.7
11
-
12
- module Concurrent
13
- def abort_transaction; end
14
- def atomically; end
15
- def call_dataflow(method, executor, *inputs, &block); end
16
- def dataflow!(*inputs, &block); end
17
- def dataflow(*inputs, &block); end
18
- def dataflow_with!(executor, *inputs, &block); end
19
- def dataflow_with(executor, *inputs, &block); end
20
- def leave_transaction; end
21
- def monotonic_time; end
22
- def self.abort_transaction; end
23
- def self.atomically; end
24
- def self.call_dataflow(method, executor, *inputs, &block); end
25
- def self.create_simple_logger(level = nil, output = nil); end
26
- def self.create_stdlib_logger(level = nil, output = nil); end
27
- def self.dataflow!(*inputs, &block); end
28
- def self.dataflow(*inputs, &block); end
29
- def self.dataflow_with!(executor, *inputs, &block); end
30
- def self.dataflow_with(executor, *inputs, &block); end
31
- def self.disable_at_exit_handlers!; end
32
- def self.executor(executor_identifier); end
33
- def self.global_fast_executor; end
34
- def self.global_immediate_executor; end
35
- def self.global_io_executor; end
36
- def self.global_logger; end
37
- def self.global_logger=(value); end
38
- def self.global_timer_set; end
39
- def self.leave_transaction; end
40
- def self.monotonic_time; end
41
- def self.new_fast_executor(opts = nil); end
42
- def self.new_io_executor(opts = nil); end
43
- def self.physical_processor_count; end
44
- def self.processor_count; end
45
- def self.processor_counter; end
46
- def self.use_simple_logger(level = nil, output = nil); end
47
- def self.use_stdlib_logger(level = nil, output = nil); end
48
- extend Concurrent::Concern::Deprecation
49
- extend Concurrent::Concern::Logging
50
- extend Concurrent::Utility::EngineDetector
51
- extend Concurrent::Utility::NativeExtensionLoader
52
- end
53
- module Concurrent::Utility
54
- end
55
- module Concurrent::Utility::EngineDetector
56
- def on_cruby?; end
57
- def on_jruby?; end
58
- def on_jruby_9000?; end
59
- def on_linux?; end
60
- def on_osx?; end
61
- def on_rbx?; end
62
- def on_truffleruby?; end
63
- def on_windows?; end
64
- def ruby_engine; end
65
- def ruby_version(version = nil, comparison, major, minor, patch); end
66
- end
67
- module Concurrent::Synchronization
68
- end
69
- class Concurrent::Synchronization::AbstractObject
70
- def full_memory_barrier; end
71
- def initialize; end
72
- def self.attr_volatile(*names); end
73
- end
74
- module Concurrent::Utility::NativeExtensionLoader
75
- def allow_c_extensions?; end
76
- def c_extensions_loaded?; end
77
- def java_extensions_loaded?; end
78
- def load_error_path(error); end
79
- def load_native_extensions; end
80
- def set_c_extensions_loaded; end
81
- def set_java_extensions_loaded; end
82
- def try_load_c_extension(path); end
83
- end
84
- module Concurrent::Synchronization::MriAttrVolatile
85
- def full_memory_barrier; end
86
- def self.included(base); end
87
- end
88
- module Concurrent::Synchronization::MriAttrVolatile::ClassMethods
89
- def attr_volatile(*names); end
90
- end
91
- class Concurrent::Synchronization::MriObject < Concurrent::Synchronization::AbstractObject
92
- def initialize; end
93
- extend Concurrent::Synchronization::MriAttrVolatile::ClassMethods
94
- include Concurrent::Synchronization::MriAttrVolatile
95
- end
96
- module Concurrent::Synchronization::RbxAttrVolatile
97
- def full_memory_barrier; end
98
- def self.included(base); end
99
- end
100
- module Concurrent::Synchronization::RbxAttrVolatile::ClassMethods
101
- def attr_volatile(*names); end
102
- end
103
- class Concurrent::Synchronization::RbxObject < Concurrent::Synchronization::AbstractObject
104
- def initialize; end
105
- extend Concurrent::Synchronization::RbxAttrVolatile::ClassMethods
106
- include Concurrent::Synchronization::RbxAttrVolatile
107
- end
108
- module Concurrent::Synchronization::TruffleRubyAttrVolatile
109
- def full_memory_barrier; end
110
- def self.included(base); end
111
- end
112
- module Concurrent::Synchronization::TruffleRubyAttrVolatile::ClassMethods
113
- def attr_volatile(*names); end
114
- end
115
- class Concurrent::Synchronization::TruffleRubyObject < Concurrent::Synchronization::AbstractObject
116
- def initialize; end
117
- extend Concurrent::Synchronization::TruffleRubyAttrVolatile::ClassMethods
118
- include Concurrent::Synchronization::TruffleRubyAttrVolatile
119
- end
120
- class Concurrent::Synchronization::Object < Concurrent::Synchronization::MriObject
121
- def __initialize_atomic_fields__; end
122
- def initialize; end
123
- def self.atomic_attribute?(name); end
124
- def self.atomic_attributes(inherited = nil); end
125
- def self.attr_atomic(*names); end
126
- def self.define_initialize_atomic_fields; end
127
- def self.ensure_safe_initialization_when_final_fields_are_present; end
128
- def self.safe_initialization!; end
129
- def self.safe_initialization?; end
130
- end
131
- class Concurrent::Synchronization::AbstractLockableObject < Concurrent::Synchronization::Object
132
- def ns_broadcast; end
133
- def ns_signal; end
134
- def ns_wait(timeout = nil); end
135
- def ns_wait_until(timeout = nil, &condition); end
136
- def synchronize; end
137
- end
138
- module Concurrent::Synchronization::ConditionSignalling
139
- def ns_broadcast; end
140
- def ns_signal; end
141
- end
142
- class Concurrent::Synchronization::MutexLockableObject < Concurrent::Synchronization::AbstractLockableObject
143
- def initialize(*defaults); end
144
- def ns_wait(timeout = nil); end
145
- def self.new(*args, &block); end
146
- def synchronize; end
147
- include Concurrent::Synchronization::ConditionSignalling
148
- end
149
- class Concurrent::Synchronization::MonitorLockableObject < Concurrent::Synchronization::AbstractLockableObject
150
- def initialize(*defaults); end
151
- def ns_wait(timeout = nil); end
152
- def self.new(*args, &block); end
153
- def synchronize; end
154
- include Concurrent::Synchronization::ConditionSignalling
155
- end
156
- class Concurrent::Synchronization::RbxLockableObject < Concurrent::Synchronization::AbstractLockableObject
157
- def initialize(*defaults); end
158
- def ns_broadcast; end
159
- def ns_signal; end
160
- def ns_wait(timeout = nil); end
161
- def self.new(*args, &block); end
162
- def synchronize(&block); end
163
- end
164
- class Concurrent::Synchronization::LockableObject < Concurrent::Synchronization::MutexLockableObject
165
- def new_condition; end
166
- end
167
- class Concurrent::Synchronization::Condition < Concurrent::Synchronization::LockableObject
168
- def broadcast; end
169
- def initialize(lock); end
170
- def ns_broadcast; end
171
- def ns_signal; end
172
- def ns_wait(timeout = nil); end
173
- def ns_wait_until(timeout = nil, &condition); end
174
- def self.new(*args, &block); end
175
- def self.private_new(*args, &block); end
176
- def signal; end
177
- def wait(timeout = nil); end
178
- def wait_until(timeout = nil, &condition); end
179
- end
180
- class Concurrent::Synchronization::Lock < Concurrent::Synchronization::LockableObject
181
- def broadcast; end
182
- def ns_broadcast; end
183
- def ns_signal; end
184
- def ns_wait(timeout = nil); end
185
- def ns_wait_until(timeout = nil, &condition); end
186
- def signal; end
187
- def synchronize; end
188
- def wait(timeout = nil); end
189
- def wait_until(timeout = nil, &condition); end
190
- end
191
- module Concurrent::Collection
192
- end
193
- class Concurrent::Collection::NonConcurrentMapBackend
194
- def [](key); end
195
- def []=(key, value); end
196
- def _get(key); end
197
- def _set(key, value); end
198
- def clear; end
199
- def compute(key); end
200
- def compute_if_absent(key); end
201
- def compute_if_present(key); end
202
- def delete(key); end
203
- def delete_pair(key, value); end
204
- def dupped_backend; end
205
- def each_pair; end
206
- def get_and_set(key, value); end
207
- def get_or_default(key, default_value); end
208
- def initialize(options = nil); end
209
- def initialize_copy(other); end
210
- def key?(key); end
211
- def merge_pair(key, value); end
212
- def pair?(key, expected_value); end
213
- def replace_if_exists(key, new_value); end
214
- def replace_pair(key, old_value, new_value); end
215
- def size; end
216
- def store_computed_value(key, new_value); end
217
- end
218
- class Concurrent::Collection::MriMapBackend < Concurrent::Collection::NonConcurrentMapBackend
219
- def []=(key, value); end
220
- def clear; end
221
- def compute(key); end
222
- def compute_if_absent(key); end
223
- def compute_if_present(key); end
224
- def delete(key); end
225
- def delete_pair(key, value); end
226
- def get_and_set(key, value); end
227
- def initialize(options = nil); end
228
- def merge_pair(key, value); end
229
- def replace_if_exists(key, new_value); end
230
- def replace_pair(key, old_value, new_value); end
231
- end
232
- class Concurrent::Map < Concurrent::Collection::MriMapBackend
233
- def [](key); end
234
- def each; end
235
- def each_key; end
236
- def each_pair; end
237
- def each_value; end
238
- def empty?; end
239
- def fetch(key, default_value = nil); end
240
- def fetch_or_store(key, default_value = nil); end
241
- def get(key); end
242
- def initialize(options = nil, &block); end
243
- def initialize_copy(other); end
244
- def inspect; end
245
- def key(value); end
246
- def keys; end
247
- def marshal_dump; end
248
- def marshal_load(hash); end
249
- def populate_from(hash); end
250
- def put(key, value); end
251
- def put_if_absent(key, value); end
252
- def raise_fetch_no_key; end
253
- def validate_options_hash!(options); end
254
- def value?(value); end
255
- def values; end
256
- end
257
- class Concurrent::Error < StandardError
258
- end
259
- class Concurrent::ConfigurationError < Concurrent::Error
260
- end
261
- class Concurrent::CancelledOperationError < Concurrent::Error
262
- end
263
- class Concurrent::LifecycleError < Concurrent::Error
264
- end
265
- class Concurrent::ImmutabilityError < Concurrent::Error
266
- end
267
- class Concurrent::IllegalOperationError < Concurrent::Error
268
- end
269
- class Concurrent::InitializationError < Concurrent::Error
270
- end
271
- class Concurrent::MaxRestartFrequencyError < Concurrent::Error
272
- end
273
- class Concurrent::MultipleAssignmentError < Concurrent::Error
274
- def initialize(message = nil, inspection_data = nil); end
275
- def inspect; end
276
- def inspection_data; end
277
- end
278
- class Concurrent::RejectedExecutionError < Concurrent::Error
279
- end
280
- class Concurrent::ResourceLimitError < Concurrent::Error
281
- end
282
- class Concurrent::TimeoutError < Concurrent::Error
283
- end
284
- class Concurrent::MultipleErrors < Concurrent::Error
285
- def errors; end
286
- def initialize(errors, message = nil); end
287
- end
288
- class Concurrent::Event < Concurrent::Synchronization::LockableObject
289
- def initialize; end
290
- def ns_initialize; end
291
- def ns_set; end
292
- def reset; end
293
- def set; end
294
- def set?; end
295
- def try?; end
296
- def wait(timeout = nil); end
297
- end
298
- module Concurrent::Concern
299
- end
300
- module Concurrent::Concern::Dereferenceable
301
- def apply_deref_options(value); end
302
- def deref; end
303
- def ns_set_deref_options(opts); end
304
- def set_deref_options(opts = nil); end
305
- def value; end
306
- def value=(value); end
307
- end
308
- module Concurrent::Concern::Obligation
309
- def compare_and_set_state(next_state, *expected_current); end
310
- def complete?; end
311
- def event; end
312
- def exception(*args); end
313
- def fulfilled?; end
314
- def get_arguments_from(opts = nil); end
315
- def if_state(*expected_states); end
316
- def incomplete?; end
317
- def init_obligation; end
318
- def no_error!(timeout = nil); end
319
- def ns_check_state?(expected); end
320
- def ns_set_state(value); end
321
- def pending?; end
322
- def realized?; end
323
- def reason; end
324
- def rejected?; end
325
- def set_state(success, value, reason); end
326
- def state; end
327
- def state=(value); end
328
- def unscheduled?; end
329
- def value!(timeout = nil); end
330
- def value(timeout = nil); end
331
- def wait!(timeout = nil); end
332
- def wait(timeout = nil); end
333
- include Concurrent::Concern::Dereferenceable
334
- end
335
- module Concurrent::Concern::Logging
336
- def log(level, progname, message = nil, &block); end
337
- include Logger::Severity
338
- end
339
- module Concurrent::Concern::Deprecation
340
- def deprecated(message, strip = nil); end
341
- def deprecated_method(old_name, new_name); end
342
- extend Concurrent::Concern::Deprecation
343
- include Concurrent::Concern::Logging
344
- end
345
- module Concurrent::ExecutorService
346
- def <<(task); end
347
- def can_overflow?; end
348
- def post(*args, &task); end
349
- def serialized?; end
350
- include Concurrent::Concern::Logging
351
- end
352
- class Concurrent::AbstractExecutorService < Concurrent::Synchronization::LockableObject
353
- def auto_terminate=(value); end
354
- def auto_terminate?; end
355
- def fallback_policy; end
356
- def handle_fallback(*args); end
357
- def initialize(opts = nil, &block); end
358
- def kill; end
359
- def name; end
360
- def ns_auto_terminate?; end
361
- def ns_execute(*args, &task); end
362
- def ns_kill_execution; end
363
- def ns_shutdown_execution; end
364
- def running?; end
365
- def shutdown; end
366
- def shutdown?; end
367
- def shuttingdown?; end
368
- def to_s; end
369
- def wait_for_termination(timeout = nil); end
370
- include Concurrent::Concern::Deprecation
371
- include Concurrent::ExecutorService
372
- end
373
- module Concurrent::SerialExecutorService
374
- def serialized?; end
375
- include Concurrent::ExecutorService
376
- end
377
- class Concurrent::ImmediateExecutor < Concurrent::AbstractExecutorService
378
- def <<(task); end
379
- def initialize; end
380
- def kill; end
381
- def post(*args, &task); end
382
- def running?; end
383
- def shutdown; end
384
- def shutdown?; end
385
- def shuttingdown?; end
386
- def wait_for_termination(timeout = nil); end
387
- include Concurrent::SerialExecutorService
388
- end
389
- class Concurrent::Delay < Concurrent::Synchronization::LockableObject
390
- def execute_task_once; end
391
- def initialize(opts = nil, &block); end
392
- def ns_initialize(opts, &block); end
393
- def reconfigure(&block); end
394
- def value!(timeout = nil); end
395
- def value(timeout = nil); end
396
- def wait(timeout = nil); end
397
- include Concurrent::Concern::Obligation
398
- end
399
- module Concurrent::AtomicNumericCompareAndSetWrapper
400
- def compare_and_set(old_value, new_value); end
401
- end
402
- class Concurrent::MutexAtomicReference < Concurrent::Synchronization::LockableObject
403
- def _compare_and_set(old_value, new_value); end
404
- def compare_and_swap(old_value, new_value); end
405
- def get; end
406
- def get_and_set(new_value); end
407
- def initialize(value = nil); end
408
- def ns_initialize(value); end
409
- def set(new_value); end
410
- def swap(new_value); end
411
- def value; end
412
- def value=(new_value); end
413
- include Concurrent::AtomicDirectUpdate
414
- include Concurrent::AtomicNumericCompareAndSetWrapper
415
- end
416
- module Concurrent::AtomicDirectUpdate
417
- def try_update!; end
418
- def try_update; end
419
- def update; end
420
- end
421
- class Concurrent::ConcurrentUpdateError < ThreadError
422
- end
423
- class Concurrent::AtomicReference < Concurrent::MutexAtomicReference
424
- def inspect; end
425
- def to_s; end
426
- end
427
- class Concurrent::RubyExecutorService < Concurrent::AbstractExecutorService
428
- def initialize(*args, &block); end
429
- def kill; end
430
- def ns_running?; end
431
- def ns_shutdown?; end
432
- def ns_shutdown_execution; end
433
- def ns_shuttingdown?; end
434
- def post(*args, &task); end
435
- def shutdown; end
436
- def stop_event; end
437
- def stopped_event; end
438
- def wait_for_termination(timeout = nil); end
439
- end
440
- class Concurrent::RubyThreadPoolExecutor < Concurrent::RubyExecutorService
441
- def can_overflow?; end
442
- def completed_task_count; end
443
- def idletime; end
444
- def initialize(opts = nil); end
445
- def largest_length; end
446
- def length; end
447
- def max_length; end
448
- def max_queue; end
449
- def min_length; end
450
- def ns_add_busy_worker; end
451
- def ns_assign_worker(*args, &task); end
452
- def ns_enqueue(*args, &task); end
453
- def ns_execute(*args, &task); end
454
- def ns_initialize(opts); end
455
- def ns_kill_execution; end
456
- def ns_limited_queue?; end
457
- def ns_prune_pool; end
458
- def ns_ready_worker(worker, success = nil); end
459
- def ns_remove_busy_worker(worker); end
460
- def ns_reset_if_forked; end
461
- def ns_shutdown_execution; end
462
- def ns_worker_died(worker); end
463
- def ns_worker_not_old_enough(worker); end
464
- def queue_length; end
465
- def ready_worker(worker); end
466
- def remaining_capacity; end
467
- def remove_busy_worker(worker); end
468
- def scheduled_task_count; end
469
- def synchronous; end
470
- def worker_died(worker); end
471
- def worker_not_old_enough(worker); end
472
- def worker_task_completed; end
473
- end
474
- class Concurrent::RubyThreadPoolExecutor::Worker
475
- def <<(message); end
476
- def create_worker(queue, pool, idletime); end
477
- def initialize(pool, id); end
478
- def kill; end
479
- def run_task(pool, task, args); end
480
- def stop; end
481
- include Concurrent::Concern::Logging
482
- end
483
- class Concurrent::ThreadPoolExecutor < Concurrent::RubyThreadPoolExecutor
484
- end
485
- class Concurrent::CachedThreadPool < Concurrent::ThreadPoolExecutor
486
- def initialize(opts = nil); end
487
- def ns_initialize(opts); end
488
- end
489
- class Concurrent::Utility::ProcessorCounter
490
- def compute_physical_processor_count; end
491
- def compute_processor_count; end
492
- def initialize; end
493
- def physical_processor_count; end
494
- def processor_count; end
495
- end
496
- class Concurrent::MutexAtomicBoolean < Concurrent::Synchronization::LockableObject
497
- def false?; end
498
- def initialize(initial = nil); end
499
- def make_false; end
500
- def make_true; end
501
- def ns_initialize(initial); end
502
- def ns_make_value(value); end
503
- def true?; end
504
- def value; end
505
- def value=(value); end
506
- end
507
- class Concurrent::AtomicBoolean < Concurrent::MutexAtomicBoolean
508
- def inspect; end
509
- def to_s; end
510
- end
511
- module Concurrent::Utility::NativeInteger
512
- def ensure_integer(value); end
513
- def ensure_integer_and_bounds(value); end
514
- def ensure_lower_bound(value); end
515
- def ensure_positive(value); end
516
- def ensure_positive_and_no_zero(value); end
517
- def ensure_upper_bound(value); end
518
- extend Concurrent::Utility::NativeInteger
519
- end
520
- class Concurrent::MutexAtomicFixnum < Concurrent::Synchronization::LockableObject
521
- def compare_and_set(expect, update); end
522
- def decrement(delta = nil); end
523
- def down(delta = nil); end
524
- def increment(delta = nil); end
525
- def initialize(initial = nil); end
526
- def ns_initialize(initial); end
527
- def ns_set(value); end
528
- def up(delta = nil); end
529
- def update; end
530
- def value; end
531
- def value=(value); end
532
- end
533
- class Concurrent::AtomicFixnum < Concurrent::MutexAtomicFixnum
534
- def inspect; end
535
- def to_s; end
536
- end
537
- class Concurrent::CyclicBarrier < Concurrent::Synchronization::LockableObject
538
- def broken?; end
539
- def initialize(parties, &block); end
540
- def ns_generation_done(generation, status, continue = nil); end
541
- def ns_initialize(parties, &block); end
542
- def ns_next_generation; end
543
- def number_waiting; end
544
- def parties; end
545
- def reset; end
546
- def wait(timeout = nil); end
547
- end
548
- class Concurrent::CyclicBarrier::Generation < Struct
549
- def self.[](*arg0); end
550
- def self.inspect; end
551
- def self.members; end
552
- def self.new(*arg0); end
553
- def status; end
554
- def status=(_); end
555
- end
556
- class Concurrent::MutexCountDownLatch < Concurrent::Synchronization::LockableObject
557
- def count; end
558
- def count_down; end
559
- def initialize(count = nil); end
560
- def ns_initialize(count); end
561
- def wait(timeout = nil); end
562
- end
563
- class Concurrent::CountDownLatch < Concurrent::MutexCountDownLatch
564
- end
565
- class Concurrent::ReadWriteLock < Concurrent::Synchronization::Object
566
- def acquire_read_lock; end
567
- def acquire_write_lock; end
568
- def has_waiters?; end
569
- def initialize; end
570
- def max_readers?(c = nil); end
571
- def max_writers?(c = nil); end
572
- def release_read_lock; end
573
- def release_write_lock; end
574
- def running_readers(c = nil); end
575
- def running_readers?(c = nil); end
576
- def running_writer?(c = nil); end
577
- def self.new(*args, &block); end
578
- def waiting_writer?(c = nil); end
579
- def waiting_writers(c = nil); end
580
- def with_read_lock; end
581
- def with_write_lock; end
582
- def write_locked?; end
583
- end
584
- class Concurrent::AbstractThreadLocalVar
585
- def allocate_storage; end
586
- def bind(value, &block); end
587
- def default; end
588
- def initialize(default = nil, &default_block); end
589
- def value; end
590
- def value=(value); end
591
- end
592
- class Concurrent::RubyThreadLocalVar < Concurrent::AbstractThreadLocalVar
593
- def allocate_storage; end
594
- def get_default; end
595
- def get_threadlocal_array(thread = nil); end
596
- def next_index; end
597
- def self.semi_sync(&block); end
598
- def self.thread_finalizer(id); end
599
- def self.thread_local_finalizer(index); end
600
- def set_threadlocal_array(array, thread = nil); end
601
- def value; end
602
- def value=(value); end
603
- def value_for(thread); end
604
- end
605
- class Concurrent::ThreadLocalVar < Concurrent::RubyThreadLocalVar
606
- end
607
- class Concurrent::ReentrantReadWriteLock < Concurrent::Synchronization::Object
608
- def acquire_read_lock; end
609
- def acquire_write_lock; end
610
- def initialize; end
611
- def max_readers?(c = nil); end
612
- def max_writers?(c = nil); end
613
- def release_read_lock; end
614
- def release_write_lock; end
615
- def running_readers(c = nil); end
616
- def running_readers?(c = nil); end
617
- def running_writer?(c = nil); end
618
- def self.new(*args, &block); end
619
- def try_read_lock; end
620
- def try_write_lock; end
621
- def waiting_or_running_writer?(c = nil); end
622
- def waiting_writers(c = nil); end
623
- def with_read_lock; end
624
- def with_write_lock; end
625
- end
626
- class Concurrent::MutexSemaphore < Concurrent::Synchronization::LockableObject
627
- def acquire(permits = nil); end
628
- def available_permits; end
629
- def drain_permits; end
630
- def initialize(count); end
631
- def ns_initialize(count); end
632
- def reduce_permits(reduction); end
633
- def release(permits = nil); end
634
- def try_acquire(permits = nil, timeout = nil); end
635
- def try_acquire_now(permits); end
636
- def try_acquire_timed(permits, timeout); end
637
- end
638
- class Concurrent::Semaphore < Concurrent::MutexSemaphore
639
- end
640
- class Concurrent::FixedThreadPool < Concurrent::ThreadPoolExecutor
641
- def initialize(num_threads, opts = nil); end
642
- end
643
- class Concurrent::SimpleExecutorService < Concurrent::RubyExecutorService
644
- def <<(task); end
645
- def kill; end
646
- def ns_initialize(*args); end
647
- def post(*args, &task); end
648
- def running?; end
649
- def self.<<(task); end
650
- def self.post(*args); end
651
- def shutdown; end
652
- def shutdown?; end
653
- def shuttingdown?; end
654
- def wait_for_termination(timeout = nil); end
655
- end
656
- class Concurrent::IndirectImmediateExecutor < Concurrent::ImmediateExecutor
657
- def initialize; end
658
- def post(*args, &task); end
659
- end
660
- class Concurrent::RubySingleThreadExecutor < Concurrent::RubyThreadPoolExecutor
661
- def initialize(opts = nil); end
662
- end
663
- class Concurrent::SafeTaskExecutor < Concurrent::Synchronization::LockableObject
664
- def execute(*args); end
665
- def initialize(task, opts = nil); end
666
- end
667
- class Concurrent::SerializedExecution < Concurrent::Synchronization::LockableObject
668
- def call_job(job); end
669
- def initialize; end
670
- def ns_initialize; end
671
- def post(executor, *args, &task); end
672
- def posts(posts); end
673
- def work(job); end
674
- include Concurrent::Concern::Logging
675
- end
676
- class Concurrent::SerializedExecution::Job < Struct
677
- def args; end
678
- def args=(_); end
679
- def block; end
680
- def block=(_); end
681
- def call; end
682
- def executor; end
683
- def executor=(_); end
684
- def self.[](*arg0); end
685
- def self.inspect; end
686
- def self.members; end
687
- def self.new(*arg0); end
688
- end
689
- class Concurrent::SerializedExecutionDelegator < SimpleDelegator
690
- def initialize(executor); end
691
- def post(*args, &task); end
692
- include Concurrent::SerialExecutorService
693
- end
694
- class Concurrent::SingleThreadExecutor < Concurrent::RubySingleThreadExecutor
695
- end
696
- class Concurrent::Collection::CopyOnWriteObserverSet < Concurrent::Synchronization::LockableObject
697
- def add_observer(observer = nil, func = nil, &block); end
698
- def clear_observers_and_return_old; end
699
- def count_observers; end
700
- def delete_observer(observer); end
701
- def delete_observers; end
702
- def initialize; end
703
- def notify_and_delete_observers(*args, &block); end
704
- def notify_observers(*args, &block); end
705
- def notify_to(observers, *args); end
706
- def ns_initialize; end
707
- def observers; end
708
- def observers=(new_set); end
709
- end
710
- class Concurrent::Collection::CopyOnNotifyObserverSet < Concurrent::Synchronization::LockableObject
711
- def add_observer(observer = nil, func = nil, &block); end
712
- def count_observers; end
713
- def delete_observer(observer); end
714
- def delete_observers; end
715
- def duplicate_and_clear_observers; end
716
- def duplicate_observers; end
717
- def initialize; end
718
- def notify_and_delete_observers(*args, &block); end
719
- def notify_observers(*args, &block); end
720
- def notify_to(observers, *args); end
721
- def ns_initialize; end
722
- end
723
- module Concurrent::Concern::Observable
724
- def add_observer(observer = nil, func = nil, &block); end
725
- def count_observers; end
726
- def delete_observer(observer); end
727
- def delete_observers; end
728
- def observers; end
729
- def observers=(arg0); end
730
- def with_observer(observer = nil, func = nil, &block); end
731
- end
732
- class Concurrent::IVar < Concurrent::Synchronization::LockableObject
733
- def add_observer(observer = nil, func = nil, &block); end
734
- def check_for_block_or_value!(block_given, value); end
735
- def complete(success, value, reason); end
736
- def complete_without_notification(success, value, reason); end
737
- def fail(reason = nil); end
738
- def initialize(value = nil, opts = nil, &block); end
739
- def notify_observers(value, reason); end
740
- def ns_complete_without_notification(success, value, reason); end
741
- def ns_initialize(value, opts); end
742
- def safe_execute(task, args = nil); end
743
- def set(value = nil); end
744
- def try_set(value = nil, &block); end
745
- include Concurrent::Concern::Obligation
746
- include Concurrent::Concern::Observable
747
- end
748
- module Concurrent::Options
749
- def self.executor(executor_identifier); end
750
- def self.executor_from_options(opts = nil); end
751
- end
752
- class Concurrent::ScheduledTask < Concurrent::IVar
753
- def <=>(other); end
754
- def cancel; end
755
- def cancelled?; end
756
- def execute; end
757
- def executor; end
758
- def fail(reason = nil); end
759
- def initial_delay; end
760
- def initialize(delay, opts = nil, &task); end
761
- def ns_reschedule(delay); end
762
- def ns_schedule(delay); end
763
- def process_task; end
764
- def processing?; end
765
- def reschedule(delay); end
766
- def reset; end
767
- def schedule_time; end
768
- def self.execute(delay, opts = nil, &task); end
769
- def set(value = nil); end
770
- def try_set(value = nil, &block); end
771
- include Comparable
772
- end
773
- class Concurrent::Collection::RubyNonConcurrentPriorityQueue
774
- def <<(item); end
775
- def clear; end
776
- def delete(item); end
777
- def deq; end
778
- def empty?; end
779
- def enq(item); end
780
- def has_priority?(item); end
781
- def include?(item); end
782
- def initialize(opts = nil); end
783
- def length; end
784
- def ordered?(x, y); end
785
- def peek; end
786
- def pop; end
787
- def push(item); end
788
- def self.from_list(list, opts = nil); end
789
- def shift; end
790
- def sink(k); end
791
- def size; end
792
- def swap(x, y); end
793
- def swim(k); end
794
- end
795
- class Concurrent::Collection::NonConcurrentPriorityQueue < Concurrent::Collection::RubyNonConcurrentPriorityQueue
796
- def <<(item); end
797
- def deq; end
798
- def enq(item); end
799
- def has_priority?(item); end
800
- def shift; end
801
- def size; end
802
- end
803
- class Concurrent::TimerSet < Concurrent::RubyExecutorService
804
- def <<(task); end
805
- def initialize(opts = nil); end
806
- def kill; end
807
- def ns_initialize(opts); end
808
- def ns_post_task(task); end
809
- def ns_reset_if_forked; end
810
- def ns_shutdown_execution; end
811
- def post(delay, *args, &task); end
812
- def post_task(task); end
813
- def process_tasks; end
814
- def remove_task(task); end
815
- end
816
- class Concurrent::AtomicMarkableReference < Concurrent::Synchronization::Object
817
- def __initialize_atomic_fields__; end
818
- def compare_and_set(expected_val, new_val, expected_mark, new_mark); end
819
- def compare_and_set_reference(expected, value); end
820
- def compare_and_swap(expected_val, new_val, expected_mark, new_mark); end
821
- def get; end
822
- def immutable_array(*args); end
823
- def initialize(value = nil, mark = nil); end
824
- def mark; end
825
- def marked?; end
826
- def reference; end
827
- def reference=(value); end
828
- def self.new(*args, &block); end
829
- def set(new_val, new_mark); end
830
- def swap_reference(value); end
831
- def try_update!; end
832
- def try_update; end
833
- def update; end
834
- def update_reference(&block); end
835
- def value; end
836
- end
837
- class Concurrent::Agent < Concurrent::Synchronization::LockableObject
838
- def <<(action); end
839
- def await; end
840
- def await_for!(timeout); end
841
- def await_for(timeout); end
842
- def deref; end
843
- def enqueue_action_job(action, args, executor); end
844
- def enqueue_await_job(latch); end
845
- def error; end
846
- def error_mode; end
847
- def execute_next_job; end
848
- def failed?; end
849
- def handle_error(error); end
850
- def initialize(initial, opts = nil); end
851
- def ns_enqueue_job(job, index = nil); end
852
- def ns_find_last_job_for_thread; end
853
- def ns_initialize(initial, opts); end
854
- def ns_post_next_job; end
855
- def ns_validate(value); end
856
- def post(*args, &action); end
857
- def reason; end
858
- def restart(new_value, opts = nil); end
859
- def self.await(*agents); end
860
- def self.await_for!(timeout, *agents); end
861
- def self.await_for(timeout, *agents); end
862
- def send!(*args, &action); end
863
- def send(*args, &action); end
864
- def send_off!(*args, &action); end
865
- def send_off(*args, &action); end
866
- def send_via!(executor, *args, &action); end
867
- def send_via(executor, *args, &action); end
868
- def stopped?; end
869
- def value; end
870
- def wait(timeout = nil); end
871
- include Concurrent::Concern::Observable
872
- end
873
- class Concurrent::Agent::Job < Struct
874
- def action; end
875
- def action=(_); end
876
- def args; end
877
- def args=(_); end
878
- def caller; end
879
- def caller=(_); end
880
- def executor; end
881
- def executor=(_); end
882
- def self.[](*arg0); end
883
- def self.inspect; end
884
- def self.members; end
885
- def self.new(*arg0); end
886
- end
887
- class Concurrent::Agent::Error < StandardError
888
- def initialize(message = nil); end
889
- end
890
- class Concurrent::Agent::ValidationError < Concurrent::Agent::Error
891
- def initialize(message = nil); end
892
- end
893
- class Concurrent::Atom < Concurrent::Synchronization::Object
894
- def __initialize_atomic_fields__; end
895
- def compare_and_set(old_value, new_value); end
896
- def compare_and_set_value(expected, value); end
897
- def deref; end
898
- def initialize(value, opts = nil); end
899
- def reset(new_value); end
900
- def self.new(*args, &block); end
901
- def swap(*args); end
902
- def swap_value(value); end
903
- def update_value(&block); end
904
- def valid?(new_value); end
905
- def value; end
906
- def value=(value); end
907
- include Concurrent::Concern::Observable
908
- end
909
- module Concurrent::ThreadSafe
910
- end
911
- module Concurrent::ThreadSafe::Util
912
- end
913
- class Concurrent::Array < Array
914
- end
915
- class Concurrent::Hash < Hash
916
- end
917
- class Concurrent::Set < Set
918
- end
919
- class Concurrent::Tuple
920
- def cas(i, old_value, new_value); end
921
- def compare_and_set(i, old_value, new_value); end
922
- def each; end
923
- def get(i); end
924
- def initialize(size); end
925
- def set(i, value); end
926
- def size; end
927
- def volatile_get(i); end
928
- def volatile_set(i, value); end
929
- include Enumerable
930
- end
931
- module Concurrent::Async
932
- def async; end
933
- def await; end
934
- def call; end
935
- def cast; end
936
- def init_synchronization; end
937
- def self.included(base); end
938
- def self.validate_argc(obj, method, *args); end
939
- end
940
- module Concurrent::Async::ClassMethods
941
- def new(*args, &block); end
942
- end
943
- class Concurrent::Async::AsyncDelegator < Concurrent::Synchronization::LockableObject
944
- def initialize(delegate); end
945
- def method_missing(method, *args, &block); end
946
- def perform; end
947
- def reset_if_forked; end
948
- def respond_to_missing?(method, include_private = nil); end
949
- end
950
- class Concurrent::Async::AwaitDelegator
951
- def initialize(delegate); end
952
- def method_missing(method, *args, &block); end
953
- def respond_to_missing?(method, include_private = nil); end
954
- end
955
- class Concurrent::Future < Concurrent::IVar
956
- def cancel; end
957
- def cancelled?; end
958
- def execute; end
959
- def initialize(opts = nil, &block); end
960
- def ns_initialize(value, opts); end
961
- def self.execute(opts = nil, &block); end
962
- def set(value = nil, &block); end
963
- def wait_or_cancel(timeout); end
964
- end
965
- class Concurrent::DependencyCounter
966
- def initialize(count, &block); end
967
- def update(time, value, reason); end
968
- end
969
- class Concurrent::Maybe < Concurrent::Synchronization::Object
970
- def <=>(other); end
971
- def fulfilled?; end
972
- def initialize(just, nothing); end
973
- def just; end
974
- def just?; end
975
- def nothing; end
976
- def nothing?; end
977
- def or(other); end
978
- def reason; end
979
- def rejected?; end
980
- def self.from(*args); end
981
- def self.just(value); end
982
- def self.new(*args, &block); end
983
- def self.nothing(error = nil); end
984
- def value; end
985
- include Comparable
986
- end
987
- class Concurrent::AbstractExchanger < Concurrent::Synchronization::Object
988
- def do_exchange(value, timeout); end
989
- def exchange!(value, timeout = nil); end
990
- def exchange(value, timeout = nil); end
991
- def initialize; end
992
- def try_exchange(value, timeout = nil); end
993
- end
994
- class Concurrent::RubyExchanger < Concurrent::AbstractExchanger
995
- def __initialize_atomic_fields__; end
996
- def compare_and_set_slot(expected, value); end
997
- def do_exchange(value, timeout); end
998
- def initialize; end
999
- def self.new(*args, &block); end
1000
- def slot; end
1001
- def slot=(value); end
1002
- def swap_slot(value); end
1003
- def update_slot(&block); end
1004
- end
1005
- class Concurrent::RubyExchanger::Node < Concurrent::Synchronization::Object
1006
- def __initialize_atomic_fields__; end
1007
- def compare_and_set_value(expected, value); end
1008
- def initialize(item); end
1009
- def item; end
1010
- def latch; end
1011
- def self.new(*args, &block); end
1012
- def swap_value(value); end
1013
- def update_value(&block); end
1014
- def value; end
1015
- def value=(value); end
1016
- end
1017
- class Concurrent::Exchanger < Concurrent::RubyExchanger
1018
- end
1019
- module Concurrent::Synchronization::AbstractStruct
1020
- def initialize(*values); end
1021
- def length; end
1022
- def members; end
1023
- def ns_each; end
1024
- def ns_each_pair; end
1025
- def ns_equality(other); end
1026
- def ns_get(member); end
1027
- def ns_initialize_copy; end
1028
- def ns_inspect; end
1029
- def ns_merge(other, &block); end
1030
- def ns_select; end
1031
- def ns_to_h; end
1032
- def ns_values; end
1033
- def ns_values_at(indexes); end
1034
- def pr_underscore(clazz); end
1035
- def self.define_struct_class(parent, base, name, members, &block); end
1036
- def size; end
1037
- end
1038
- module Concurrent::ImmutableStruct
1039
- def ==(other); end
1040
- def [](member); end
1041
- def each(&block); end
1042
- def each_pair(&block); end
1043
- def initialize_copy(original); end
1044
- def inspect; end
1045
- def merge(other, &block); end
1046
- def select(&block); end
1047
- def self.included(base); end
1048
- def self.new(*args, &block); end
1049
- def to_a; end
1050
- def to_h; end
1051
- def to_s; end
1052
- def values; end
1053
- def values_at(*indexes); end
1054
- include Concurrent::Synchronization::AbstractStruct
1055
- end
1056
- module Concurrent::MutableStruct
1057
- def ==(other); end
1058
- def [](member); end
1059
- def []=(member, value); end
1060
- def each(&block); end
1061
- def each_pair(&block); end
1062
- def initialize_copy(original); end
1063
- def inspect; end
1064
- def merge(other, &block); end
1065
- def select(&block); end
1066
- def self.new(*args, &block); end
1067
- def to_a; end
1068
- def to_h; end
1069
- def to_s; end
1070
- def values; end
1071
- def values_at(*indexes); end
1072
- include Concurrent::Synchronization::AbstractStruct
1073
- end
1074
- class Concurrent::MVar < Concurrent::Synchronization::Object
1075
- def borrow(timeout = nil); end
1076
- def empty?; end
1077
- def full?; end
1078
- def initialize(value = nil, opts = nil); end
1079
- def modify!; end
1080
- def modify(timeout = nil); end
1081
- def put(value, timeout = nil); end
1082
- def self.new(*args, &block); end
1083
- def set!(value); end
1084
- def synchronize(&block); end
1085
- def take(timeout = nil); end
1086
- def try_put!(value); end
1087
- def try_take!; end
1088
- def unlocked_empty?; end
1089
- def unlocked_full?; end
1090
- def wait_for_empty(timeout); end
1091
- def wait_for_full(timeout); end
1092
- def wait_while(condition, timeout); end
1093
- include Concurrent::Concern::Dereferenceable
1094
- end
1095
- class Concurrent::PromiseExecutionError < StandardError
1096
- end
1097
- class Concurrent::Promise < Concurrent::IVar
1098
- def catch(&block); end
1099
- def complete(success, value, reason); end
1100
- def execute; end
1101
- def fail(reason = nil); end
1102
- def flat_map(&block); end
1103
- def initialize(opts = nil, &block); end
1104
- def notify_child(child); end
1105
- def ns_initialize(value, opts); end
1106
- def on_error(&block); end
1107
- def on_fulfill(result); end
1108
- def on_reject(reason); end
1109
- def on_success(&block); end
1110
- def realize(task); end
1111
- def rescue(&block); end
1112
- def root?; end
1113
- def self.aggregate(method, *promises); end
1114
- def self.all?(*promises); end
1115
- def self.any?(*promises); end
1116
- def self.execute(opts = nil, &block); end
1117
- def self.fulfill(value, opts = nil); end
1118
- def self.reject(reason, opts = nil); end
1119
- def self.zip(*promises); end
1120
- def set(value = nil, &block); end
1121
- def set_pending; end
1122
- def set_state!(success, value, reason); end
1123
- def synchronized_set_state!(success, value, reason); end
1124
- def then(*args, &block); end
1125
- def zip(*others); end
1126
- end
1127
- module Concurrent::SettableStruct
1128
- def ==(other); end
1129
- def [](member); end
1130
- def []=(member, value); end
1131
- def each(&block); end
1132
- def each_pair(&block); end
1133
- def initialize_copy(original); end
1134
- def inspect; end
1135
- def merge(other, &block); end
1136
- def select(&block); end
1137
- def self.new(*args, &block); end
1138
- def to_a; end
1139
- def to_h; end
1140
- def to_s; end
1141
- def values; end
1142
- def values_at(*indexes); end
1143
- include Concurrent::Synchronization::AbstractStruct
1144
- end
1145
- class Concurrent::TimerTask < Concurrent::RubyExecutorService
1146
- def <<(task); end
1147
- def execute; end
1148
- def execute_task(completion); end
1149
- def execution_interval; end
1150
- def execution_interval=(value); end
1151
- def initialize(opts = nil, &task); end
1152
- def ns_initialize(opts, &task); end
1153
- def ns_kill_execution; end
1154
- def ns_shutdown_execution; end
1155
- def post(*args, &task); end
1156
- def running?; end
1157
- def schedule_next_task(interval = nil); end
1158
- def self.execute(opts = nil, &task); end
1159
- def timeout_interval; end
1160
- def timeout_interval=(value); end
1161
- def timeout_task(completion); end
1162
- include Concurrent::Concern::Dereferenceable
1163
- include Concurrent::Concern::Observable
1164
- end
1165
- class Concurrent::TVar < Concurrent::Synchronization::Object
1166
- def initialize(value); end
1167
- def self.new(*args, &block); end
1168
- def unsafe_increment_version; end
1169
- def unsafe_lock; end
1170
- def unsafe_value; end
1171
- def unsafe_value=(value); end
1172
- def unsafe_version; end
1173
- def value; end
1174
- def value=(value); end
1175
- end
1176
- class Concurrent::Transaction
1177
- def abort; end
1178
- def commit; end
1179
- def initialize; end
1180
- def read(tvar); end
1181
- def self.current; end
1182
- def self.current=(transaction); end
1183
- def unlock; end
1184
- def valid?; end
1185
- def write(tvar, value); end
1186
- end
1187
- class Concurrent::Transaction::ReadLogEntry < Struct
1188
- def self.[](*arg0); end
1189
- def self.inspect; end
1190
- def self.members; end
1191
- def self.new(*arg0); end
1192
- def tvar; end
1193
- def tvar=(_); end
1194
- def version; end
1195
- def version=(_); end
1196
- end
1197
- class Concurrent::Transaction::AbortError < StandardError
1198
- end
1199
- class Concurrent::Transaction::LeaveError < StandardError
1200
- end
1201
- class Concurrent::LockFreeStack < Concurrent::Synchronization::Object
1202
- def __initialize_atomic_fields__; end
1203
- def clear; end
1204
- def clear_each(&block); end
1205
- def clear_if(head); end
1206
- def compare_and_clear(head); end
1207
- def compare_and_pop(head); end
1208
- def compare_and_push(head, value); end
1209
- def compare_and_set_head(expected, value); end
1210
- def each(head = nil); end
1211
- def empty?(head = nil); end
1212
- def head; end
1213
- def head=(value); end
1214
- def initialize(head = nil); end
1215
- def inspect; end
1216
- def peek; end
1217
- def pop; end
1218
- def push(value); end
1219
- def replace_if(head, new_head); end
1220
- def self.new(*args, &block); end
1221
- def self.of1(value); end
1222
- def self.of2(value1, value2); end
1223
- def swap_head(value); end
1224
- def to_s; end
1225
- def update_head(&block); end
1226
- include Enumerable
1227
- end
1228
- class Concurrent::LockFreeStack::Node
1229
- def initialize(value, next_node); end
1230
- def next_node; end
1231
- def self.[](*arg0); end
1232
- def value; end
1233
- def value=(arg0); end
1234
- end
1235
- module Concurrent::ReInclude
1236
- def extended(base); end
1237
- def include(*modules); end
1238
- def included(base); end
1239
- end
1240
- module Concurrent::Promises
1241
- extend Concurrent::Promises::FactoryMethods
1242
- end
1243
- module Concurrent::Promises::FactoryMethods
1244
- def any(*futures_and_or_events); end
1245
- def any_event(*futures_and_or_events); end
1246
- def any_event_on(default_executor, *futures_and_or_events); end
1247
- def any_fulfilled_future(*futures_and_or_events); end
1248
- def any_fulfilled_future_on(default_executor, *futures_and_or_events); end
1249
- def any_resolved_future(*futures_and_or_events); end
1250
- def any_resolved_future_on(default_executor, *futures_and_or_events); end
1251
- def delay(*args, &task); end
1252
- def delay_on(default_executor, *args, &task); end
1253
- def fulfilled_future(value, default_executor = nil); end
1254
- def future(*args, &task); end
1255
- def future_on(default_executor, *args, &task); end
1256
- def make_future(argument = nil, default_executor = nil); end
1257
- def rejected_future(reason, default_executor = nil); end
1258
- def resolvable_event; end
1259
- def resolvable_event_on(default_executor = nil); end
1260
- def resolvable_future; end
1261
- def resolvable_future_on(default_executor = nil); end
1262
- def resolved_event(default_executor = nil); end
1263
- def resolved_future(fulfilled, value, reason, default_executor = nil); end
1264
- def schedule(intended_time, *args, &task); end
1265
- def schedule_on(default_executor, intended_time, *args, &task); end
1266
- def zip(*futures_and_or_events); end
1267
- def zip_events(*futures_and_or_events); end
1268
- def zip_events_on(default_executor, *futures_and_or_events); end
1269
- def zip_futures(*futures_and_or_events); end
1270
- def zip_futures_on(default_executor, *futures_and_or_events); end
1271
- extend Concurrent::Promises::FactoryMethods
1272
- extend Concurrent::Promises::FactoryMethods::Configuration
1273
- extend Concurrent::ReInclude
1274
- include Concurrent::Promises::FactoryMethods::Configuration
1275
- end
1276
- module Concurrent::Promises::FactoryMethods::Configuration
1277
- def default_executor; end
1278
- end
1279
- module Concurrent::Promises::InternalStates
1280
- end
1281
- class Concurrent::Promises::InternalStates::State
1282
- def resolved?; end
1283
- def to_sym; end
1284
- end
1285
- class Concurrent::Promises::InternalStates::Pending < Concurrent::Promises::InternalStates::State
1286
- def resolved?; end
1287
- def to_sym; end
1288
- end
1289
- class Concurrent::Promises::InternalStates::Reserved < Concurrent::Promises::InternalStates::Pending
1290
- end
1291
- class Concurrent::Promises::InternalStates::ResolvedWithResult < Concurrent::Promises::InternalStates::State
1292
- def apply; end
1293
- def fulfilled?; end
1294
- def reason; end
1295
- def resolved?; end
1296
- def result; end
1297
- def to_sym; end
1298
- def value; end
1299
- end
1300
- class Concurrent::Promises::InternalStates::Fulfilled < Concurrent::Promises::InternalStates::ResolvedWithResult
1301
- def apply(args, block); end
1302
- def fulfilled?; end
1303
- def initialize(value); end
1304
- def reason; end
1305
- def to_sym; end
1306
- def value; end
1307
- end
1308
- class Concurrent::Promises::InternalStates::FulfilledArray < Concurrent::Promises::InternalStates::Fulfilled
1309
- def apply(args, block); end
1310
- end
1311
- class Concurrent::Promises::InternalStates::Rejected < Concurrent::Promises::InternalStates::ResolvedWithResult
1312
- def apply(args, block); end
1313
- def fulfilled?; end
1314
- def initialize(reason); end
1315
- def reason; end
1316
- def to_sym; end
1317
- def value; end
1318
- end
1319
- class Concurrent::Promises::InternalStates::PartiallyRejected < Concurrent::Promises::InternalStates::ResolvedWithResult
1320
- def apply(args, block); end
1321
- def fulfilled?; end
1322
- def initialize(value, reason); end
1323
- def reason; end
1324
- def to_sym; end
1325
- def value; end
1326
- end
1327
- class Concurrent::Promises::AbstractEventFuture < Concurrent::Synchronization::Object
1328
- def __initialize_atomic_fields__; end
1329
- def add_callback(method, *args); end
1330
- def add_callback_clear_delayed_node(node); end
1331
- def add_callback_notify_blocked(promise, index); end
1332
- def async_callback_on_resolution(state, executor, args, callback); end
1333
- def blocks; end
1334
- def call_callback(method, state, args); end
1335
- def call_callbacks(state); end
1336
- def callback_clear_delayed_node(state, node); end
1337
- def callback_notify_blocked(state, promise, index); end
1338
- def callbacks; end
1339
- def chain(*args, &task); end
1340
- def chain_on(executor, *args, &task); end
1341
- def chain_resolvable(resolvable); end
1342
- def compare_and_set_internal_state(expected, value); end
1343
- def default_executor; end
1344
- def initialize(promise, default_executor); end
1345
- def inspect; end
1346
- def internal_state; end
1347
- def internal_state=(value); end
1348
- def on_resolution!(*args, &callback); end
1349
- def on_resolution(*args, &callback); end
1350
- def on_resolution_using(executor, *args, &callback); end
1351
- def pending?; end
1352
- def promise; end
1353
- def resolve_with(state, raise_on_reassign = nil, reserved = nil); end
1354
- def resolved?; end
1355
- def self.new(*args, &block); end
1356
- def state; end
1357
- def swap_internal_state(value); end
1358
- def tangle(resolvable); end
1359
- def to_s; end
1360
- def touch; end
1361
- def touched?; end
1362
- def update_internal_state(&block); end
1363
- def wait(timeout = nil); end
1364
- def wait_until_resolved(timeout); end
1365
- def waiting_threads; end
1366
- def with_async(executor, *args, &block); end
1367
- def with_default_executor(executor); end
1368
- def with_hidden_resolvable; end
1369
- include Concurrent::Promises::InternalStates
1370
- end
1371
- class Concurrent::Promises::Event < Concurrent::Promises::AbstractEventFuture
1372
- def &(other); end
1373
- def any(event_or_future); end
1374
- def callback_on_resolution(state, args, callback); end
1375
- def delay; end
1376
- def rejected_resolution(raise_on_reassign, state); end
1377
- def schedule(intended_time); end
1378
- def then(*args, &task); end
1379
- def to_event; end
1380
- def to_future; end
1381
- def with_default_executor(executor); end
1382
- def zip(other); end
1383
- def |(event_or_future); end
1384
- end
1385
- class Concurrent::Promises::Future < Concurrent::Promises::AbstractEventFuture
1386
- def &(other); end
1387
- def any(event_or_future); end
1388
- def apply(args, block); end
1389
- def async_callback_on_fulfillment(state, executor, args, callback); end
1390
- def async_callback_on_rejection(state, executor, args, callback); end
1391
- def callback_on_fulfillment(state, args, callback); end
1392
- def callback_on_rejection(state, args, callback); end
1393
- def callback_on_resolution(state, args, callback); end
1394
- def delay; end
1395
- def exception(*args); end
1396
- def flat(level = nil); end
1397
- def flat_event; end
1398
- def flat_future(level = nil); end
1399
- def fulfilled?; end
1400
- def inspect; end
1401
- def on_fulfillment!(*args, &callback); end
1402
- def on_fulfillment(*args, &callback); end
1403
- def on_fulfillment_using(executor, *args, &callback); end
1404
- def on_rejection!(*args, &callback); end
1405
- def on_rejection(*args, &callback); end
1406
- def on_rejection_using(executor, *args, &callback); end
1407
- def reason(timeout = nil, timeout_value = nil); end
1408
- def rejected?; end
1409
- def rejected_resolution(raise_on_reassign, state); end
1410
- def rescue(*args, &task); end
1411
- def rescue_on(executor, *args, &task); end
1412
- def result(timeout = nil); end
1413
- def run(run_test = nil); end
1414
- def run_test(v); end
1415
- def schedule(intended_time); end
1416
- def then(*args, &task); end
1417
- def then_on(executor, *args, &task); end
1418
- def to_event; end
1419
- def to_future; end
1420
- def to_s; end
1421
- def value!(timeout = nil, timeout_value = nil); end
1422
- def value(timeout = nil, timeout_value = nil); end
1423
- def wait!(timeout = nil); end
1424
- def wait_until_resolved!(timeout = nil); end
1425
- def with_default_executor(executor); end
1426
- def zip(other); end
1427
- def |(event_or_future); end
1428
- end
1429
- module Concurrent::Promises::Resolvable
1430
- include Concurrent::Promises::InternalStates
1431
- end
1432
- class Concurrent::Promises::ResolvableEvent < Concurrent::Promises::Event
1433
- def resolve(raise_on_reassign = nil, reserved = nil); end
1434
- def wait(timeout = nil, resolve_on_timeout = nil); end
1435
- def with_hidden_resolvable; end
1436
- include Concurrent::Promises::Resolvable
1437
- end
1438
- class Concurrent::Promises::ResolvableFuture < Concurrent::Promises::Future
1439
- def evaluate_to!(*args, &block); end
1440
- def evaluate_to(*args, &block); end
1441
- def fulfill(value, raise_on_reassign = nil, reserved = nil); end
1442
- def reason(timeout = nil, timeout_value = nil, resolve_on_timeout = nil); end
1443
- def reject(reason, raise_on_reassign = nil, reserved = nil); end
1444
- def resolve(fulfilled = nil, value = nil, reason = nil, raise_on_reassign = nil, reserved = nil); end
1445
- def result(timeout = nil, resolve_on_timeout = nil); end
1446
- def value!(timeout = nil, timeout_value = nil, resolve_on_timeout = nil); end
1447
- def value(timeout = nil, timeout_value = nil, resolve_on_timeout = nil); end
1448
- def wait!(timeout = nil, resolve_on_timeout = nil); end
1449
- def wait(timeout = nil, resolve_on_timeout = nil); end
1450
- def with_hidden_resolvable; end
1451
- include Concurrent::Promises::Resolvable
1452
- end
1453
- class Concurrent::Promises::AbstractPromise < Concurrent::Synchronization::Object
1454
- def default_executor; end
1455
- def delayed_because; end
1456
- def evaluate_to(*args, block); end
1457
- def event; end
1458
- def future; end
1459
- def initialize(future); end
1460
- def inspect; end
1461
- def resolve_with(new_state, raise_on_reassign = nil); end
1462
- def self.new(*args, &block); end
1463
- def state; end
1464
- def to_s; end
1465
- def touch; end
1466
- include Concurrent::Promises::InternalStates
1467
- end
1468
- class Concurrent::Promises::ResolvableEventPromise < Concurrent::Promises::AbstractPromise
1469
- def initialize(default_executor); end
1470
- end
1471
- class Concurrent::Promises::ResolvableFuturePromise < Concurrent::Promises::AbstractPromise
1472
- def evaluate_to(*args, block); end
1473
- def initialize(default_executor); end
1474
- end
1475
- class Concurrent::Promises::InnerPromise < Concurrent::Promises::AbstractPromise
1476
- end
1477
- class Concurrent::Promises::BlockedPromise < Concurrent::Promises::InnerPromise
1478
- def blocked_by; end
1479
- def clear_and_propagate_touch(stack_or_element = nil); end
1480
- def delayed_because; end
1481
- def initialize(delayed, blockers_count, future); end
1482
- def on_blocker_resolution(future, index); end
1483
- def on_resolvable(resolved_future, index); end
1484
- def process_on_blocker_resolution(future, index); end
1485
- def resolvable?(countdown, future, index); end
1486
- def self.add_delayed(delayed1, delayed2); end
1487
- def self.new(*args, &block); end
1488
- def self.new_blocked_by(blockers, *args, &block); end
1489
- def self.new_blocked_by1(blocker, *args, &block); end
1490
- def self.new_blocked_by2(blocker1, blocker2, *args, &block); end
1491
- def touch; end
1492
- end
1493
- class Concurrent::Promises::BlockedTaskPromise < Concurrent::Promises::BlockedPromise
1494
- def executor; end
1495
- def initialize(delayed, blockers_count, default_executor, executor, args, &task); end
1496
- end
1497
- class Concurrent::Promises::ThenPromise < Concurrent::Promises::BlockedTaskPromise
1498
- def initialize(delayed, blockers_count, default_executor, executor, args, &task); end
1499
- def on_resolvable(resolved_future, index); end
1500
- end
1501
- class Concurrent::Promises::RescuePromise < Concurrent::Promises::BlockedTaskPromise
1502
- def initialize(delayed, blockers_count, default_executor, executor, args, &task); end
1503
- def on_resolvable(resolved_future, index); end
1504
- end
1505
- class Concurrent::Promises::ChainPromise < Concurrent::Promises::BlockedTaskPromise
1506
- def on_resolvable(resolved_future, index); end
1507
- end
1508
- class Concurrent::Promises::ImmediateEventPromise < Concurrent::Promises::InnerPromise
1509
- def initialize(default_executor); end
1510
- end
1511
- class Concurrent::Promises::ImmediateFuturePromise < Concurrent::Promises::InnerPromise
1512
- def initialize(default_executor, fulfilled, value, reason); end
1513
- end
1514
- class Concurrent::Promises::AbstractFlatPromise < Concurrent::Promises::BlockedPromise
1515
- def add_delayed_of(future); end
1516
- def initialize(delayed_because, blockers_count, event_or_future); end
1517
- def on_resolvable(resolved_future, index); end
1518
- def resolvable?(countdown, future, index); end
1519
- def touch; end
1520
- def touched?; end
1521
- end
1522
- class Concurrent::Promises::FlatEventPromise < Concurrent::Promises::AbstractFlatPromise
1523
- def initialize(delayed, blockers_count, default_executor); end
1524
- def process_on_blocker_resolution(future, index); end
1525
- end
1526
- class Concurrent::Promises::FlatFuturePromise < Concurrent::Promises::AbstractFlatPromise
1527
- def initialize(delayed, blockers_count, levels, default_executor); end
1528
- def process_on_blocker_resolution(future, index); end
1529
- end
1530
- class Concurrent::Promises::RunFuturePromise < Concurrent::Promises::AbstractFlatPromise
1531
- def initialize(delayed, blockers_count, default_executor, run_test); end
1532
- def process_on_blocker_resolution(future, index); end
1533
- end
1534
- class Concurrent::Promises::ZipEventEventPromise < Concurrent::Promises::BlockedPromise
1535
- def initialize(delayed, blockers_count, default_executor); end
1536
- def on_resolvable(resolved_future, index); end
1537
- end
1538
- class Concurrent::Promises::ZipFutureEventPromise < Concurrent::Promises::BlockedPromise
1539
- def initialize(delayed, blockers_count, default_executor); end
1540
- def on_resolvable(resolved_future, index); end
1541
- def process_on_blocker_resolution(future, index); end
1542
- end
1543
- class Concurrent::Promises::EventWrapperPromise < Concurrent::Promises::BlockedPromise
1544
- def initialize(delayed, blockers_count, default_executor); end
1545
- def on_resolvable(resolved_future, index); end
1546
- end
1547
- class Concurrent::Promises::FutureWrapperPromise < Concurrent::Promises::BlockedPromise
1548
- def initialize(delayed, blockers_count, default_executor); end
1549
- def on_resolvable(resolved_future, index); end
1550
- end
1551
- class Concurrent::Promises::ZipFuturesPromise < Concurrent::Promises::BlockedPromise
1552
- def initialize(delayed, blockers_count, default_executor); end
1553
- def on_resolvable(resolved_future, index); end
1554
- def process_on_blocker_resolution(future, index); end
1555
- end
1556
- class Concurrent::Promises::ZipEventsPromise < Concurrent::Promises::BlockedPromise
1557
- def initialize(delayed, blockers_count, default_executor); end
1558
- def on_resolvable(resolved_future, index); end
1559
- end
1560
- class Concurrent::Promises::AbstractAnyPromise < Concurrent::Promises::BlockedPromise
1561
- end
1562
- class Concurrent::Promises::AnyResolvedEventPromise < Concurrent::Promises::AbstractAnyPromise
1563
- def initialize(delayed, blockers_count, default_executor); end
1564
- def on_resolvable(resolved_future, index); end
1565
- def resolvable?(countdown, future, index); end
1566
- end
1567
- class Concurrent::Promises::AnyResolvedFuturePromise < Concurrent::Promises::AbstractAnyPromise
1568
- def initialize(delayed, blockers_count, default_executor); end
1569
- def on_resolvable(resolved_future, index); end
1570
- def resolvable?(countdown, future, index); end
1571
- end
1572
- class Concurrent::Promises::AnyFulfilledFuturePromise < Concurrent::Promises::AnyResolvedFuturePromise
1573
- def resolvable?(countdown, future, index); end
1574
- end
1575
- class Concurrent::Promises::DelayPromise < Concurrent::Promises::InnerPromise
1576
- def delayed_because; end
1577
- def initialize(default_executor); end
1578
- def touch; end
1579
- end
1580
- class Concurrent::Promises::ScheduledPromise < Concurrent::Promises::InnerPromise
1581
- def initialize(default_executor, intended_time); end
1582
- def inspect; end
1583
- def intended_time; end
1584
- end
1585
- class Concurrent::SynchronizedDelegator < SimpleDelegator
1586
- def initialize(obj); end
1587
- def method_missing(method, *args, &block); end
1588
- def setup; end
1589
- def teardown; end
1590
- end