dry-monads-sorbet 1.1.6 → 1.1.7

Sign up to get free protection for your applications and to get access to all the features.
Files changed (111) hide show
  1. checksums.yaml +4 -4
  2. data/.github/workflows/ci.yml +14 -22
  3. data/.gitignore +3 -1
  4. data/CHANGELOG.md +4 -0
  5. data/Gemfile +1 -6
  6. data/bin/tapioca +29 -0
  7. data/dry-monads-sorbet.gemspec +3 -2
  8. data/lib/bundled_rbi/dry-monads.rbi +3 -3
  9. data/lib/dry/monads/sorbet/version.rb +1 -1
  10. data/nix/sources.json +14 -0
  11. data/nix/sources.nix +174 -0
  12. data/run_ci.sh +7 -0
  13. data/shell.nix +20 -0
  14. data/sorbet/config +6 -0
  15. data/sorbet/rbi/gems/{ast.rbi → ast@2.4.2.rbi} +28 -22
  16. data/sorbet/rbi/gems/byebug@11.1.3.rbi +1568 -0
  17. data/sorbet/rbi/gems/coderay@1.1.3.rbi +1005 -0
  18. data/sorbet/rbi/gems/concurrent-ruby@1.1.9.rbi +915 -0
  19. data/sorbet/rbi/gems/diff-lcs@1.4.4.rbi +8 -0
  20. data/sorbet/rbi/gems/docile@1.4.0.rbi +54 -0
  21. data/sorbet/rbi/gems/dry-core@0.7.1.rbi +92 -0
  22. data/sorbet/rbi/gems/dry-equalizer@0.3.0.rbi +28 -0
  23. data/sorbet/rbi/gems/dry-monads@1.4.0.rbi +697 -0
  24. data/sorbet/rbi/gems/ffaker@2.20.0.rbi +3171 -0
  25. data/sorbet/rbi/gems/method_source@1.0.0.rbi +72 -0
  26. data/sorbet/rbi/gems/parallel@1.21.0.rbi +113 -0
  27. data/sorbet/rbi/gems/parser@3.0.2.0.rbi +1189 -0
  28. data/sorbet/rbi/gems/pry-byebug@3.8.0.rbi +458 -0
  29. data/sorbet/rbi/gems/{pry.rbi → pry@0.14.1.rbi} +2264 -1727
  30. data/sorbet/rbi/gems/{rainbow.rbi → rainbow@3.0.0.rbi} +90 -55
  31. data/sorbet/rbi/gems/{rake.rbi → rake@13.0.6.rbi} +578 -431
  32. data/sorbet/rbi/gems/rb-fsevent@0.11.0.rbi +8 -0
  33. data/sorbet/rbi/gems/rb-readline@0.5.5.rbi +884 -0
  34. data/sorbet/rbi/gems/rbi@0.0.6.rbi +1405 -0
  35. data/sorbet/rbi/gems/regexp_parser@2.1.1.rbi +1120 -0
  36. data/sorbet/rbi/gems/{rexml.rbi → rexml@3.2.5.rbi} +564 -497
  37. data/sorbet/rbi/gems/{rspec-core.rbi → rspec-core@3.10.1.rbi} +2345 -1766
  38. data/sorbet/rbi/gems/{rspec-expectations.rbi → rspec-expectations@3.10.1.rbi} +1149 -698
  39. data/sorbet/rbi/gems/{rspec-mocks.rbi → rspec-mocks@3.10.2.rbi} +1299 -936
  40. data/sorbet/rbi/gems/rspec-support@3.10.2.rbi +509 -0
  41. data/sorbet/rbi/gems/rspec@3.10.0.rbi +38 -0
  42. data/sorbet/rbi/gems/rubocop-ast@1.12.0.rbi +1938 -0
  43. data/sorbet/rbi/gems/rubocop-rspec@2.5.0.rbi +1786 -0
  44. data/sorbet/rbi/gems/rubocop@1.22.1.rbi +13252 -0
  45. data/sorbet/rbi/gems/ruby-progressbar@1.11.0.rbi +405 -0
  46. data/sorbet/rbi/gems/simplecov-html@0.12.3.rbi +89 -0
  47. data/sorbet/rbi/gems/simplecov@0.21.2.rbi +577 -0
  48. data/sorbet/rbi/gems/simplecov_json_formatter@0.1.3.rbi +8 -0
  49. data/sorbet/rbi/gems/spoom@1.1.5.rbi +1241 -0
  50. data/sorbet/rbi/gems/stackprof@0.2.17.rbi +98 -0
  51. data/sorbet/rbi/gems/tapioca@0.5.2.rbi +949 -0
  52. data/sorbet/rbi/gems/thor@1.1.0.rbi +839 -0
  53. data/sorbet/rbi/gems/unicode-display_width@2.1.0.rbi +26 -0
  54. data/sorbet/rbi/gems/unparser@0.6.0.rbi +8 -0
  55. data/sorbet/tapioca/require.rb +4 -0
  56. metadata +65 -68
  57. data/.ruby-version +0 -1
  58. data/sorbet/rbi/gems/activesupport.rbi +0 -1722
  59. data/sorbet/rbi/gems/byebug.rbi +0 -1041
  60. data/sorbet/rbi/gems/coderay.rbi +0 -285
  61. data/sorbet/rbi/gems/concurrent-ruby.rbi +0 -1586
  62. data/sorbet/rbi/gems/docile.rbi +0 -32
  63. data/sorbet/rbi/gems/dry-core.rbi +0 -38
  64. data/sorbet/rbi/gems/dry-equalizer.rbi +0 -26
  65. data/sorbet/rbi/gems/dry-monads.rbi +0 -510
  66. data/sorbet/rbi/gems/em-websocket.rbi +0 -225
  67. data/sorbet/rbi/gems/eventmachine.rbi +0 -489
  68. data/sorbet/rbi/gems/ffaker.rbi +0 -60
  69. data/sorbet/rbi/gems/guard.rbi +0 -397
  70. data/sorbet/rbi/gems/http_parser.rb.rbi +0 -37
  71. data/sorbet/rbi/gems/i18n.rbi +0 -133
  72. data/sorbet/rbi/gems/kwalify.rbi +0 -340
  73. data/sorbet/rbi/gems/listen.rbi +0 -324
  74. data/sorbet/rbi/gems/lumberjack.rbi +0 -300
  75. data/sorbet/rbi/gems/method_source.rbi +0 -64
  76. data/sorbet/rbi/gems/multi_json.rbi +0 -62
  77. data/sorbet/rbi/gems/nenv.rbi +0 -60
  78. data/sorbet/rbi/gems/notiffany.rbi +0 -215
  79. data/sorbet/rbi/gems/parallel.rbi +0 -82
  80. data/sorbet/rbi/gems/parser.rbi +0 -1846
  81. data/sorbet/rbi/gems/pry-byebug.rbi +0 -155
  82. data/sorbet/rbi/gems/rb-fsevent.rbi +0 -31
  83. data/sorbet/rbi/gems/rb-readline.rbi +0 -767
  84. data/sorbet/rbi/gems/reek.rbi +0 -1027
  85. data/sorbet/rbi/gems/regexp_parser.rbi +0 -913
  86. data/sorbet/rbi/gems/rspec-support.rbi +0 -280
  87. data/sorbet/rbi/gems/rspec.rbi +0 -15
  88. data/sorbet/rbi/gems/rubocop-ast.rbi +0 -1053
  89. data/sorbet/rbi/gems/rubocop-rspec.rbi +0 -937
  90. data/sorbet/rbi/gems/rubocop.rbi +0 -6841
  91. data/sorbet/rbi/gems/ruby-progressbar.rbi +0 -305
  92. data/sorbet/rbi/gems/shellany.rbi +0 -29
  93. data/sorbet/rbi/gems/shoulda-matchers.rbi +0 -1848
  94. data/sorbet/rbi/gems/simplecov-html.rbi +0 -35
  95. data/sorbet/rbi/gems/simplecov.rbi +0 -361
  96. data/sorbet/rbi/gems/sqlite3.rbi +0 -354
  97. data/sorbet/rbi/gems/stackprof.rbi +0 -52
  98. data/sorbet/rbi/gems/thor.rbi +0 -32
  99. data/sorbet/rbi/gems/thread_safe.rbi +0 -82
  100. data/sorbet/rbi/gems/timecop.rbi +0 -98
  101. data/sorbet/rbi/gems/tzinfo.rbi +0 -406
  102. data/sorbet/rbi/gems/unicode-display_width.rbi +0 -17
  103. data/sorbet/rbi/hidden-definitions/errors.txt +0 -7267
  104. data/sorbet/rbi/hidden-definitions/hidden.rbi +0 -14661
  105. data/sorbet/rbi/sorbet-typed/lib/activesupport/>=6.0.0.rc1/activesupport.rbi +0 -23
  106. data/sorbet/rbi/sorbet-typed/lib/activesupport/all/activesupport.rbi +0 -1431
  107. data/sorbet/rbi/sorbet-typed/lib/minitest/all/minitest.rbi +0 -108
  108. data/sorbet/rbi/sorbet-typed/lib/rainbow/all/rainbow.rbi +0 -276
  109. data/sorbet/rbi/sorbet-typed/lib/rubocop/~>0.85/rubocop.rbi +0 -2072
  110. data/sorbet/rbi/sorbet-typed/lib/rubocop-rspec/~>1.39/rubocop-rspec.rbi +0 -398
  111. data/sorbet/rbi/todo.rbi +0 -8
@@ -1,1586 +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.6
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 worker_died(worker); end
470
- def worker_not_old_enough(worker); end
471
- def worker_task_completed; end
472
- end
473
- class Concurrent::RubyThreadPoolExecutor::Worker
474
- def <<(message); end
475
- def create_worker(queue, pool, idletime); end
476
- def initialize(pool, id); end
477
- def kill; end
478
- def run_task(pool, task, args); end
479
- def stop; end
480
- include Concurrent::Concern::Logging
481
- end
482
- class Concurrent::ThreadPoolExecutor < Concurrent::RubyThreadPoolExecutor
483
- end
484
- class Concurrent::CachedThreadPool < Concurrent::ThreadPoolExecutor
485
- def initialize(opts = nil); end
486
- def ns_initialize(opts); end
487
- end
488
- class Concurrent::Utility::ProcessorCounter
489
- def compute_physical_processor_count; end
490
- def compute_processor_count; end
491
- def initialize; end
492
- def physical_processor_count; end
493
- def processor_count; end
494
- end
495
- class Concurrent::MutexAtomicBoolean < Concurrent::Synchronization::LockableObject
496
- def false?; end
497
- def initialize(initial = nil); end
498
- def make_false; end
499
- def make_true; end
500
- def ns_initialize(initial); end
501
- def ns_make_value(value); end
502
- def true?; end
503
- def value; end
504
- def value=(value); end
505
- end
506
- class Concurrent::AtomicBoolean < Concurrent::MutexAtomicBoolean
507
- def inspect; end
508
- def to_s; end
509
- end
510
- module Concurrent::Utility::NativeInteger
511
- def ensure_integer(value); end
512
- def ensure_integer_and_bounds(value); end
513
- def ensure_lower_bound(value); end
514
- def ensure_positive(value); end
515
- def ensure_positive_and_no_zero(value); end
516
- def ensure_upper_bound(value); end
517
- extend Concurrent::Utility::NativeInteger
518
- end
519
- class Concurrent::MutexAtomicFixnum < Concurrent::Synchronization::LockableObject
520
- def compare_and_set(expect, update); end
521
- def decrement(delta = nil); end
522
- def down(delta = nil); end
523
- def increment(delta = nil); end
524
- def initialize(initial = nil); end
525
- def ns_initialize(initial); end
526
- def ns_set(value); end
527
- def up(delta = nil); end
528
- def update; end
529
- def value; end
530
- def value=(value); end
531
- end
532
- class Concurrent::AtomicFixnum < Concurrent::MutexAtomicFixnum
533
- def inspect; end
534
- def to_s; end
535
- end
536
- class Concurrent::CyclicBarrier < Concurrent::Synchronization::LockableObject
537
- def broken?; end
538
- def initialize(parties, &block); end
539
- def ns_generation_done(generation, status, continue = nil); end
540
- def ns_initialize(parties, &block); end
541
- def ns_next_generation; end
542
- def number_waiting; end
543
- def parties; end
544
- def reset; end
545
- def wait(timeout = nil); end
546
- end
547
- class Concurrent::CyclicBarrier::Generation < Struct
548
- def self.[](*arg0); end
549
- def self.inspect; end
550
- def self.members; end
551
- def self.new(*arg0); end
552
- def status; end
553
- def status=(_); end
554
- end
555
- class Concurrent::MutexCountDownLatch < Concurrent::Synchronization::LockableObject
556
- def count; end
557
- def count_down; end
558
- def initialize(count = nil); end
559
- def ns_initialize(count); end
560
- def wait(timeout = nil); end
561
- end
562
- class Concurrent::CountDownLatch < Concurrent::MutexCountDownLatch
563
- end
564
- class Concurrent::ReadWriteLock < Concurrent::Synchronization::Object
565
- def acquire_read_lock; end
566
- def acquire_write_lock; end
567
- def has_waiters?; end
568
- def initialize; end
569
- def max_readers?(c = nil); end
570
- def max_writers?(c = nil); end
571
- def release_read_lock; end
572
- def release_write_lock; end
573
- def running_readers(c = nil); end
574
- def running_readers?(c = nil); end
575
- def running_writer?(c = nil); end
576
- def self.new(*args, &block); end
577
- def waiting_writer?(c = nil); end
578
- def waiting_writers(c = nil); end
579
- def with_read_lock; end
580
- def with_write_lock; end
581
- def write_locked?; end
582
- end
583
- class Concurrent::AbstractThreadLocalVar
584
- def allocate_storage; end
585
- def bind(value, &block); end
586
- def default; end
587
- def initialize(default = nil, &default_block); end
588
- def value; end
589
- def value=(value); end
590
- end
591
- class Concurrent::RubyThreadLocalVar < Concurrent::AbstractThreadLocalVar
592
- def allocate_storage; end
593
- def get_default; end
594
- def get_threadlocal_array(thread = nil); end
595
- def self.thread_finalizer(id); end
596
- def self.thread_local_finalizer(index); end
597
- def set_threadlocal_array(array, thread = nil); end
598
- def value; end
599
- def value=(value); end
600
- def value_for(thread); end
601
- end
602
- class Concurrent::ThreadLocalVar < Concurrent::RubyThreadLocalVar
603
- end
604
- class Concurrent::ReentrantReadWriteLock < Concurrent::Synchronization::Object
605
- def acquire_read_lock; end
606
- def acquire_write_lock; end
607
- def initialize; end
608
- def max_readers?(c = nil); end
609
- def max_writers?(c = nil); end
610
- def release_read_lock; end
611
- def release_write_lock; end
612
- def running_readers(c = nil); end
613
- def running_readers?(c = nil); end
614
- def running_writer?(c = nil); end
615
- def self.new(*args, &block); end
616
- def try_read_lock; end
617
- def try_write_lock; end
618
- def waiting_or_running_writer?(c = nil); end
619
- def waiting_writers(c = nil); end
620
- def with_read_lock; end
621
- def with_write_lock; end
622
- end
623
- class Concurrent::MutexSemaphore < Concurrent::Synchronization::LockableObject
624
- def acquire(permits = nil); end
625
- def available_permits; end
626
- def drain_permits; end
627
- def initialize(count); end
628
- def ns_initialize(count); end
629
- def reduce_permits(reduction); end
630
- def release(permits = nil); end
631
- def try_acquire(permits = nil, timeout = nil); end
632
- def try_acquire_now(permits); end
633
- def try_acquire_timed(permits, timeout); end
634
- end
635
- class Concurrent::Semaphore < Concurrent::MutexSemaphore
636
- end
637
- class Concurrent::FixedThreadPool < Concurrent::ThreadPoolExecutor
638
- def initialize(num_threads, opts = nil); end
639
- end
640
- class Concurrent::SimpleExecutorService < Concurrent::RubyExecutorService
641
- def <<(task); end
642
- def kill; end
643
- def ns_initialize(*args); end
644
- def post(*args, &task); end
645
- def running?; end
646
- def self.<<(task); end
647
- def self.post(*args); end
648
- def shutdown; end
649
- def shutdown?; end
650
- def shuttingdown?; end
651
- def wait_for_termination(timeout = nil); end
652
- end
653
- class Concurrent::IndirectImmediateExecutor < Concurrent::ImmediateExecutor
654
- def initialize; end
655
- def post(*args, &task); end
656
- end
657
- class Concurrent::RubySingleThreadExecutor < Concurrent::RubyThreadPoolExecutor
658
- def initialize(opts = nil); end
659
- end
660
- class Concurrent::SafeTaskExecutor < Concurrent::Synchronization::LockableObject
661
- def execute(*args); end
662
- def initialize(task, opts = nil); end
663
- end
664
- class Concurrent::SerializedExecution < Concurrent::Synchronization::LockableObject
665
- def call_job(job); end
666
- def initialize; end
667
- def ns_initialize; end
668
- def post(executor, *args, &task); end
669
- def posts(posts); end
670
- def work(job); end
671
- include Concurrent::Concern::Logging
672
- end
673
- class Concurrent::SerializedExecution::Job < Struct
674
- def args; end
675
- def args=(_); end
676
- def block; end
677
- def block=(_); end
678
- def call; end
679
- def executor; end
680
- def executor=(_); end
681
- def self.[](*arg0); end
682
- def self.inspect; end
683
- def self.members; end
684
- def self.new(*arg0); end
685
- end
686
- class Concurrent::SerializedExecutionDelegator < SimpleDelegator
687
- def initialize(executor); end
688
- def post(*args, &task); end
689
- include Concurrent::SerialExecutorService
690
- end
691
- class Concurrent::SingleThreadExecutor < Concurrent::RubySingleThreadExecutor
692
- end
693
- class Concurrent::Collection::CopyOnWriteObserverSet < Concurrent::Synchronization::LockableObject
694
- def add_observer(observer = nil, func = nil, &block); end
695
- def clear_observers_and_return_old; end
696
- def count_observers; end
697
- def delete_observer(observer); end
698
- def delete_observers; end
699
- def initialize; end
700
- def notify_and_delete_observers(*args, &block); end
701
- def notify_observers(*args, &block); end
702
- def notify_to(observers, *args); end
703
- def ns_initialize; end
704
- def observers; end
705
- def observers=(new_set); end
706
- end
707
- class Concurrent::Collection::CopyOnNotifyObserverSet < Concurrent::Synchronization::LockableObject
708
- def add_observer(observer = nil, func = nil, &block); end
709
- def count_observers; end
710
- def delete_observer(observer); end
711
- def delete_observers; end
712
- def duplicate_and_clear_observers; end
713
- def duplicate_observers; end
714
- def initialize; end
715
- def notify_and_delete_observers(*args, &block); end
716
- def notify_observers(*args, &block); end
717
- def notify_to(observers, *args); end
718
- def ns_initialize; end
719
- end
720
- module Concurrent::Concern::Observable
721
- def add_observer(observer = nil, func = nil, &block); end
722
- def count_observers; end
723
- def delete_observer(observer); end
724
- def delete_observers; end
725
- def observers; end
726
- def observers=(arg0); end
727
- def with_observer(observer = nil, func = nil, &block); end
728
- end
729
- class Concurrent::IVar < Concurrent::Synchronization::LockableObject
730
- def add_observer(observer = nil, func = nil, &block); end
731
- def check_for_block_or_value!(block_given, value); end
732
- def complete(success, value, reason); end
733
- def complete_without_notification(success, value, reason); end
734
- def fail(reason = nil); end
735
- def initialize(value = nil, opts = nil, &block); end
736
- def notify_observers(value, reason); end
737
- def ns_complete_without_notification(success, value, reason); end
738
- def ns_initialize(value, opts); end
739
- def safe_execute(task, args = nil); end
740
- def set(value = nil); end
741
- def try_set(value = nil, &block); end
742
- include Concurrent::Concern::Obligation
743
- include Concurrent::Concern::Observable
744
- end
745
- module Concurrent::Options
746
- def self.executor(executor_identifier); end
747
- def self.executor_from_options(opts = nil); end
748
- end
749
- class Concurrent::ScheduledTask < Concurrent::IVar
750
- def <=>(other); end
751
- def cancel; end
752
- def cancelled?; end
753
- def execute; end
754
- def executor; end
755
- def fail(reason = nil); end
756
- def initial_delay; end
757
- def initialize(delay, opts = nil, &task); end
758
- def ns_reschedule(delay); end
759
- def ns_schedule(delay); end
760
- def process_task; end
761
- def processing?; end
762
- def reschedule(delay); end
763
- def reset; end
764
- def schedule_time; end
765
- def self.execute(delay, opts = nil, &task); end
766
- def set(value = nil); end
767
- def try_set(value = nil, &block); end
768
- include Comparable
769
- end
770
- class Concurrent::Collection::RubyNonConcurrentPriorityQueue
771
- def <<(item); end
772
- def clear; end
773
- def delete(item); end
774
- def deq; end
775
- def empty?; end
776
- def enq(item); end
777
- def has_priority?(item); end
778
- def include?(item); end
779
- def initialize(opts = nil); end
780
- def length; end
781
- def ordered?(x, y); end
782
- def peek; end
783
- def pop; end
784
- def push(item); end
785
- def self.from_list(list, opts = nil); end
786
- def shift; end
787
- def sink(k); end
788
- def size; end
789
- def swap(x, y); end
790
- def swim(k); end
791
- end
792
- class Concurrent::Collection::NonConcurrentPriorityQueue < Concurrent::Collection::RubyNonConcurrentPriorityQueue
793
- def <<(item); end
794
- def deq; end
795
- def enq(item); end
796
- def has_priority?(item); end
797
- def shift; end
798
- def size; end
799
- end
800
- class Concurrent::TimerSet < Concurrent::RubyExecutorService
801
- def <<(task); end
802
- def initialize(opts = nil); end
803
- def kill; end
804
- def ns_initialize(opts); end
805
- def ns_post_task(task); end
806
- def ns_reset_if_forked; end
807
- def ns_shutdown_execution; end
808
- def post(delay, *args, &task); end
809
- def post_task(task); end
810
- def process_tasks; end
811
- def remove_task(task); end
812
- end
813
- class Concurrent::AtomicMarkableReference < Concurrent::Synchronization::Object
814
- def __initialize_atomic_fields__; end
815
- def compare_and_set(expected_val, new_val, expected_mark, new_mark); end
816
- def compare_and_set_reference(expected, value); end
817
- def compare_and_swap(expected_val, new_val, expected_mark, new_mark); end
818
- def get; end
819
- def immutable_array(*args); end
820
- def initialize(value = nil, mark = nil); end
821
- def mark; end
822
- def marked?; end
823
- def reference; end
824
- def reference=(value); end
825
- def self.new(*args, &block); end
826
- def set(new_val, new_mark); end
827
- def swap_reference(value); end
828
- def try_update!; end
829
- def try_update; end
830
- def update; end
831
- def update_reference(&block); end
832
- def value; end
833
- end
834
- class Concurrent::Agent < Concurrent::Synchronization::LockableObject
835
- def <<(action); end
836
- def await; end
837
- def await_for!(timeout); end
838
- def await_for(timeout); end
839
- def deref; end
840
- def enqueue_action_job(action, args, executor); end
841
- def enqueue_await_job(latch); end
842
- def error; end
843
- def error_mode; end
844
- def execute_next_job; end
845
- def failed?; end
846
- def handle_error(error); end
847
- def initialize(initial, opts = nil); end
848
- def ns_enqueue_job(job, index = nil); end
849
- def ns_find_last_job_for_thread; end
850
- def ns_initialize(initial, opts); end
851
- def ns_post_next_job; end
852
- def ns_validate(value); end
853
- def post(*args, &action); end
854
- def reason; end
855
- def restart(new_value, opts = nil); end
856
- def self.await(*agents); end
857
- def self.await_for!(timeout, *agents); end
858
- def self.await_for(timeout, *agents); end
859
- def send!(*args, &action); end
860
- def send(*args, &action); end
861
- def send_off!(*args, &action); end
862
- def send_off(*args, &action); end
863
- def send_via!(executor, *args, &action); end
864
- def send_via(executor, *args, &action); end
865
- def stopped?; end
866
- def value; end
867
- def wait(timeout = nil); end
868
- include Concurrent::Concern::Observable
869
- end
870
- class Concurrent::Agent::Job < Struct
871
- def action; end
872
- def action=(_); end
873
- def args; end
874
- def args=(_); end
875
- def caller; end
876
- def caller=(_); end
877
- def executor; end
878
- def executor=(_); end
879
- def self.[](*arg0); end
880
- def self.inspect; end
881
- def self.members; end
882
- def self.new(*arg0); end
883
- end
884
- class Concurrent::Agent::Error < StandardError
885
- def initialize(message = nil); end
886
- end
887
- class Concurrent::Agent::ValidationError < Concurrent::Agent::Error
888
- def initialize(message = nil); end
889
- end
890
- class Concurrent::Atom < Concurrent::Synchronization::Object
891
- def __initialize_atomic_fields__; end
892
- def compare_and_set(old_value, new_value); end
893
- def compare_and_set_value(expected, value); end
894
- def deref; end
895
- def initialize(value, opts = nil); end
896
- def reset(new_value); end
897
- def self.new(*args, &block); end
898
- def swap(*args); end
899
- def swap_value(value); end
900
- def update_value(&block); end
901
- def valid?(new_value); end
902
- def value; end
903
- def value=(value); end
904
- include Concurrent::Concern::Observable
905
- end
906
- module Concurrent::ThreadSafe
907
- end
908
- module Concurrent::ThreadSafe::Util
909
- end
910
- class Concurrent::Array < Array
911
- end
912
- class Concurrent::Hash < Hash
913
- end
914
- class Concurrent::Set < Set
915
- end
916
- class Concurrent::Tuple
917
- def cas(i, old_value, new_value); end
918
- def compare_and_set(i, old_value, new_value); end
919
- def each; end
920
- def get(i); end
921
- def initialize(size); end
922
- def set(i, value); end
923
- def size; end
924
- def volatile_get(i); end
925
- def volatile_set(i, value); end
926
- include Enumerable
927
- end
928
- module Concurrent::Async
929
- def async; end
930
- def await; end
931
- def call; end
932
- def cast; end
933
- def init_synchronization; end
934
- def self.included(base); end
935
- def self.validate_argc(obj, method, *args); end
936
- end
937
- module Concurrent::Async::ClassMethods
938
- def new(*args, &block); end
939
- end
940
- class Concurrent::Async::AsyncDelegator < Concurrent::Synchronization::LockableObject
941
- def initialize(delegate); end
942
- def method_missing(method, *args, &block); end
943
- def perform; end
944
- def respond_to_missing?(method, include_private = nil); end
945
- end
946
- class Concurrent::Async::AwaitDelegator
947
- def initialize(delegate); end
948
- def method_missing(method, *args, &block); end
949
- def respond_to_missing?(method, include_private = nil); end
950
- end
951
- class Concurrent::Future < Concurrent::IVar
952
- def cancel; end
953
- def cancelled?; end
954
- def execute; end
955
- def initialize(opts = nil, &block); end
956
- def ns_initialize(value, opts); end
957
- def self.execute(opts = nil, &block); end
958
- def set(value = nil, &block); end
959
- def wait_or_cancel(timeout); end
960
- end
961
- class Concurrent::DependencyCounter
962
- def initialize(count, &block); end
963
- def update(time, value, reason); end
964
- end
965
- class Concurrent::Maybe < Concurrent::Synchronization::Object
966
- def <=>(other); end
967
- def fulfilled?; end
968
- def initialize(just, nothing); end
969
- def just; end
970
- def just?; end
971
- def nothing; end
972
- def nothing?; end
973
- def or(other); end
974
- def reason; end
975
- def rejected?; end
976
- def self.from(*args); end
977
- def self.just(value); end
978
- def self.new(*args, &block); end
979
- def self.nothing(error = nil); end
980
- def value; end
981
- include Comparable
982
- end
983
- class Concurrent::AbstractExchanger < Concurrent::Synchronization::Object
984
- def do_exchange(value, timeout); end
985
- def exchange!(value, timeout = nil); end
986
- def exchange(value, timeout = nil); end
987
- def initialize; end
988
- def try_exchange(value, timeout = nil); end
989
- end
990
- class Concurrent::RubyExchanger < Concurrent::AbstractExchanger
991
- def __initialize_atomic_fields__; end
992
- def compare_and_set_slot(expected, value); end
993
- def do_exchange(value, timeout); end
994
- def initialize; end
995
- def self.new(*args, &block); end
996
- def slot; end
997
- def slot=(value); end
998
- def swap_slot(value); end
999
- def update_slot(&block); end
1000
- end
1001
- class Concurrent::RubyExchanger::Node < Concurrent::Synchronization::Object
1002
- def __initialize_atomic_fields__; end
1003
- def compare_and_set_value(expected, value); end
1004
- def initialize(item); end
1005
- def item; end
1006
- def latch; end
1007
- def self.new(*args, &block); end
1008
- def swap_value(value); end
1009
- def update_value(&block); end
1010
- def value; end
1011
- def value=(value); end
1012
- end
1013
- class Concurrent::Exchanger < Concurrent::RubyExchanger
1014
- end
1015
- module Concurrent::Synchronization::AbstractStruct
1016
- def initialize(*values); end
1017
- def length; end
1018
- def members; end
1019
- def ns_each; end
1020
- def ns_each_pair; end
1021
- def ns_equality(other); end
1022
- def ns_get(member); end
1023
- def ns_initialize_copy; end
1024
- def ns_inspect; end
1025
- def ns_merge(other, &block); end
1026
- def ns_select; end
1027
- def ns_to_h; end
1028
- def ns_values; end
1029
- def ns_values_at(indexes); end
1030
- def pr_underscore(clazz); end
1031
- def self.define_struct_class(parent, base, name, members, &block); end
1032
- def size; end
1033
- end
1034
- module Concurrent::ImmutableStruct
1035
- def ==(other); end
1036
- def [](member); end
1037
- def each(&block); end
1038
- def each_pair(&block); end
1039
- def initialize_copy(original); end
1040
- def inspect; end
1041
- def merge(other, &block); end
1042
- def select(&block); end
1043
- def self.included(base); end
1044
- def self.new(*args, &block); end
1045
- def to_a; end
1046
- def to_h; end
1047
- def to_s; end
1048
- def values; end
1049
- def values_at(*indexes); end
1050
- include Concurrent::Synchronization::AbstractStruct
1051
- end
1052
- module Concurrent::MutableStruct
1053
- def ==(other); end
1054
- def [](member); end
1055
- def []=(member, value); end
1056
- def each(&block); end
1057
- def each_pair(&block); end
1058
- def initialize_copy(original); end
1059
- def inspect; end
1060
- def merge(other, &block); end
1061
- def select(&block); end
1062
- def self.new(*args, &block); end
1063
- def to_a; end
1064
- def to_h; end
1065
- def to_s; end
1066
- def values; end
1067
- def values_at(*indexes); end
1068
- include Concurrent::Synchronization::AbstractStruct
1069
- end
1070
- class Concurrent::MVar < Concurrent::Synchronization::Object
1071
- def borrow(timeout = nil); end
1072
- def empty?; end
1073
- def full?; end
1074
- def initialize(value = nil, opts = nil); end
1075
- def modify!; end
1076
- def modify(timeout = nil); end
1077
- def put(value, timeout = nil); end
1078
- def self.new(*args, &block); end
1079
- def set!(value); end
1080
- def synchronize(&block); end
1081
- def take(timeout = nil); end
1082
- def try_put!(value); end
1083
- def try_take!; end
1084
- def unlocked_empty?; end
1085
- def unlocked_full?; end
1086
- def wait_for_empty(timeout); end
1087
- def wait_for_full(timeout); end
1088
- def wait_while(condition, timeout); end
1089
- include Concurrent::Concern::Dereferenceable
1090
- end
1091
- class Concurrent::PromiseExecutionError < StandardError
1092
- end
1093
- class Concurrent::Promise < Concurrent::IVar
1094
- def catch(&block); end
1095
- def complete(success, value, reason); end
1096
- def execute; end
1097
- def fail(reason = nil); end
1098
- def flat_map(&block); end
1099
- def initialize(opts = nil, &block); end
1100
- def notify_child(child); end
1101
- def ns_initialize(value, opts); end
1102
- def on_error(&block); end
1103
- def on_fulfill(result); end
1104
- def on_reject(reason); end
1105
- def on_success(&block); end
1106
- def realize(task); end
1107
- def rescue(&block); end
1108
- def root?; end
1109
- def self.aggregate(method, *promises); end
1110
- def self.all?(*promises); end
1111
- def self.any?(*promises); end
1112
- def self.execute(opts = nil, &block); end
1113
- def self.fulfill(value, opts = nil); end
1114
- def self.reject(reason, opts = nil); end
1115
- def self.zip(*promises); end
1116
- def set(value = nil, &block); end
1117
- def set_pending; end
1118
- def set_state!(success, value, reason); end
1119
- def synchronized_set_state!(success, value, reason); end
1120
- def then(*args, &block); end
1121
- def zip(*others); end
1122
- end
1123
- module Concurrent::SettableStruct
1124
- def ==(other); end
1125
- def [](member); end
1126
- def []=(member, value); end
1127
- def each(&block); end
1128
- def each_pair(&block); end
1129
- def initialize_copy(original); end
1130
- def inspect; end
1131
- def merge(other, &block); end
1132
- def select(&block); end
1133
- def self.new(*args, &block); end
1134
- def to_a; end
1135
- def to_h; end
1136
- def to_s; end
1137
- def values; end
1138
- def values_at(*indexes); end
1139
- include Concurrent::Synchronization::AbstractStruct
1140
- end
1141
- class Concurrent::TimerTask < Concurrent::RubyExecutorService
1142
- def <<(task); end
1143
- def execute; end
1144
- def execute_task(completion); end
1145
- def execution_interval; end
1146
- def execution_interval=(value); end
1147
- def initialize(opts = nil, &task); end
1148
- def ns_initialize(opts, &task); end
1149
- def ns_kill_execution; end
1150
- def ns_shutdown_execution; end
1151
- def post(*args, &task); end
1152
- def running?; end
1153
- def schedule_next_task(interval = nil); end
1154
- def self.execute(opts = nil, &task); end
1155
- def timeout_interval; end
1156
- def timeout_interval=(value); end
1157
- def timeout_task(completion); end
1158
- include Concurrent::Concern::Dereferenceable
1159
- include Concurrent::Concern::Observable
1160
- end
1161
- class Concurrent::TVar < Concurrent::Synchronization::Object
1162
- def initialize(value); end
1163
- def self.new(*args, &block); end
1164
- def unsafe_increment_version; end
1165
- def unsafe_lock; end
1166
- def unsafe_value; end
1167
- def unsafe_value=(value); end
1168
- def unsafe_version; end
1169
- def value; end
1170
- def value=(value); end
1171
- end
1172
- class Concurrent::Transaction
1173
- def abort; end
1174
- def commit; end
1175
- def initialize; end
1176
- def read(tvar); end
1177
- def self.current; end
1178
- def self.current=(transaction); end
1179
- def unlock; end
1180
- def valid?; end
1181
- def write(tvar, value); end
1182
- end
1183
- class Concurrent::Transaction::ReadLogEntry < Struct
1184
- def self.[](*arg0); end
1185
- def self.inspect; end
1186
- def self.members; end
1187
- def self.new(*arg0); end
1188
- def tvar; end
1189
- def tvar=(_); end
1190
- def version; end
1191
- def version=(_); end
1192
- end
1193
- class Concurrent::Transaction::AbortError < StandardError
1194
- end
1195
- class Concurrent::Transaction::LeaveError < StandardError
1196
- end
1197
- class Concurrent::LockFreeStack < Concurrent::Synchronization::Object
1198
- def __initialize_atomic_fields__; end
1199
- def clear; end
1200
- def clear_each(&block); end
1201
- def clear_if(head); end
1202
- def compare_and_clear(head); end
1203
- def compare_and_pop(head); end
1204
- def compare_and_push(head, value); end
1205
- def compare_and_set_head(expected, value); end
1206
- def each(head = nil); end
1207
- def empty?(head = nil); end
1208
- def head; end
1209
- def head=(value); end
1210
- def initialize(head = nil); end
1211
- def inspect; end
1212
- def peek; end
1213
- def pop; end
1214
- def push(value); end
1215
- def replace_if(head, new_head); end
1216
- def self.new(*args, &block); end
1217
- def self.of1(value); end
1218
- def self.of2(value1, value2); end
1219
- def swap_head(value); end
1220
- def to_s; end
1221
- def update_head(&block); end
1222
- include Enumerable
1223
- end
1224
- class Concurrent::LockFreeStack::Node
1225
- def initialize(value, next_node); end
1226
- def next_node; end
1227
- def self.[](*arg0); end
1228
- def value; end
1229
- def value=(arg0); end
1230
- end
1231
- module Concurrent::ReInclude
1232
- def extended(base); end
1233
- def include(*modules); end
1234
- def included(base); end
1235
- end
1236
- module Concurrent::Promises
1237
- extend Concurrent::Promises::FactoryMethods
1238
- end
1239
- module Concurrent::Promises::FactoryMethods
1240
- def any(*futures_and_or_events); end
1241
- def any_event(*futures_and_or_events); end
1242
- def any_event_on(default_executor, *futures_and_or_events); end
1243
- def any_fulfilled_future(*futures_and_or_events); end
1244
- def any_fulfilled_future_on(default_executor, *futures_and_or_events); end
1245
- def any_resolved_future(*futures_and_or_events); end
1246
- def any_resolved_future_on(default_executor, *futures_and_or_events); end
1247
- def delay(*args, &task); end
1248
- def delay_on(default_executor, *args, &task); end
1249
- def fulfilled_future(value, default_executor = nil); end
1250
- def future(*args, &task); end
1251
- def future_on(default_executor, *args, &task); end
1252
- def make_future(argument = nil, default_executor = nil); end
1253
- def rejected_future(reason, default_executor = nil); end
1254
- def resolvable_event; end
1255
- def resolvable_event_on(default_executor = nil); end
1256
- def resolvable_future; end
1257
- def resolvable_future_on(default_executor = nil); end
1258
- def resolved_event(default_executor = nil); end
1259
- def resolved_future(fulfilled, value, reason, default_executor = nil); end
1260
- def schedule(intended_time, *args, &task); end
1261
- def schedule_on(default_executor, intended_time, *args, &task); end
1262
- def zip(*futures_and_or_events); end
1263
- def zip_events(*futures_and_or_events); end
1264
- def zip_events_on(default_executor, *futures_and_or_events); end
1265
- def zip_futures(*futures_and_or_events); end
1266
- def zip_futures_on(default_executor, *futures_and_or_events); end
1267
- extend Concurrent::Promises::FactoryMethods
1268
- extend Concurrent::Promises::FactoryMethods::Configuration
1269
- extend Concurrent::ReInclude
1270
- include Concurrent::Promises::FactoryMethods::Configuration
1271
- end
1272
- module Concurrent::Promises::FactoryMethods::Configuration
1273
- def default_executor; end
1274
- end
1275
- module Concurrent::Promises::InternalStates
1276
- end
1277
- class Concurrent::Promises::InternalStates::State
1278
- def resolved?; end
1279
- def to_sym; end
1280
- end
1281
- class Concurrent::Promises::InternalStates::Pending < Concurrent::Promises::InternalStates::State
1282
- def resolved?; end
1283
- def to_sym; end
1284
- end
1285
- class Concurrent::Promises::InternalStates::Reserved < Concurrent::Promises::InternalStates::Pending
1286
- end
1287
- class Concurrent::Promises::InternalStates::ResolvedWithResult < Concurrent::Promises::InternalStates::State
1288
- def apply; end
1289
- def fulfilled?; end
1290
- def reason; end
1291
- def resolved?; end
1292
- def result; end
1293
- def to_sym; end
1294
- def value; end
1295
- end
1296
- class Concurrent::Promises::InternalStates::Fulfilled < Concurrent::Promises::InternalStates::ResolvedWithResult
1297
- def apply(args, block); end
1298
- def fulfilled?; end
1299
- def initialize(value); end
1300
- def reason; end
1301
- def to_sym; end
1302
- def value; end
1303
- end
1304
- class Concurrent::Promises::InternalStates::FulfilledArray < Concurrent::Promises::InternalStates::Fulfilled
1305
- def apply(args, block); end
1306
- end
1307
- class Concurrent::Promises::InternalStates::Rejected < Concurrent::Promises::InternalStates::ResolvedWithResult
1308
- def apply(args, block); end
1309
- def fulfilled?; end
1310
- def initialize(reason); end
1311
- def reason; end
1312
- def to_sym; end
1313
- def value; end
1314
- end
1315
- class Concurrent::Promises::InternalStates::PartiallyRejected < Concurrent::Promises::InternalStates::ResolvedWithResult
1316
- def apply(args, block); end
1317
- def fulfilled?; end
1318
- def initialize(value, reason); end
1319
- def reason; end
1320
- def to_sym; end
1321
- def value; end
1322
- end
1323
- class Concurrent::Promises::AbstractEventFuture < Concurrent::Synchronization::Object
1324
- def __initialize_atomic_fields__; end
1325
- def add_callback(method, *args); end
1326
- def add_callback_clear_delayed_node(node); end
1327
- def add_callback_notify_blocked(promise, index); end
1328
- def async_callback_on_resolution(state, executor, args, callback); end
1329
- def blocks; end
1330
- def call_callback(method, state, args); end
1331
- def call_callbacks(state); end
1332
- def callback_clear_delayed_node(state, node); end
1333
- def callback_notify_blocked(state, promise, index); end
1334
- def callbacks; end
1335
- def chain(*args, &task); end
1336
- def chain_on(executor, *args, &task); end
1337
- def chain_resolvable(resolvable); end
1338
- def compare_and_set_internal_state(expected, value); end
1339
- def default_executor; end
1340
- def initialize(promise, default_executor); end
1341
- def inspect; end
1342
- def internal_state; end
1343
- def internal_state=(value); end
1344
- def on_resolution!(*args, &callback); end
1345
- def on_resolution(*args, &callback); end
1346
- def on_resolution_using(executor, *args, &callback); end
1347
- def pending?; end
1348
- def promise; end
1349
- def resolve_with(state, raise_on_reassign = nil, reserved = nil); end
1350
- def resolved?; end
1351
- def self.new(*args, &block); end
1352
- def state; end
1353
- def swap_internal_state(value); end
1354
- def tangle(resolvable); end
1355
- def to_s; end
1356
- def touch; end
1357
- def touched?; end
1358
- def update_internal_state(&block); end
1359
- def wait(timeout = nil); end
1360
- def wait_until_resolved(timeout); end
1361
- def waiting_threads; end
1362
- def with_async(executor, *args, &block); end
1363
- def with_default_executor(executor); end
1364
- def with_hidden_resolvable; end
1365
- include Concurrent::Promises::InternalStates
1366
- end
1367
- class Concurrent::Promises::Event < Concurrent::Promises::AbstractEventFuture
1368
- def &(other); end
1369
- def any(event_or_future); end
1370
- def callback_on_resolution(state, args, callback); end
1371
- def delay; end
1372
- def rejected_resolution(raise_on_reassign, state); end
1373
- def schedule(intended_time); end
1374
- def then(*args, &task); end
1375
- def to_event; end
1376
- def to_future; end
1377
- def with_default_executor(executor); end
1378
- def zip(other); end
1379
- def |(event_or_future); end
1380
- end
1381
- class Concurrent::Promises::Future < Concurrent::Promises::AbstractEventFuture
1382
- def &(other); end
1383
- def any(event_or_future); end
1384
- def apply(args, block); end
1385
- def async_callback_on_fulfillment(state, executor, args, callback); end
1386
- def async_callback_on_rejection(state, executor, args, callback); end
1387
- def callback_on_fulfillment(state, args, callback); end
1388
- def callback_on_rejection(state, args, callback); end
1389
- def callback_on_resolution(state, args, callback); end
1390
- def delay; end
1391
- def exception(*args); end
1392
- def flat(level = nil); end
1393
- def flat_event; end
1394
- def flat_future(level = nil); end
1395
- def fulfilled?; end
1396
- def inspect; end
1397
- def on_fulfillment!(*args, &callback); end
1398
- def on_fulfillment(*args, &callback); end
1399
- def on_fulfillment_using(executor, *args, &callback); end
1400
- def on_rejection!(*args, &callback); end
1401
- def on_rejection(*args, &callback); end
1402
- def on_rejection_using(executor, *args, &callback); end
1403
- def reason(timeout = nil, timeout_value = nil); end
1404
- def rejected?; end
1405
- def rejected_resolution(raise_on_reassign, state); end
1406
- def rescue(*args, &task); end
1407
- def rescue_on(executor, *args, &task); end
1408
- def result(timeout = nil); end
1409
- def run(run_test = nil); end
1410
- def run_test(v); end
1411
- def schedule(intended_time); end
1412
- def then(*args, &task); end
1413
- def then_on(executor, *args, &task); end
1414
- def to_event; end
1415
- def to_future; end
1416
- def to_s; end
1417
- def value!(timeout = nil, timeout_value = nil); end
1418
- def value(timeout = nil, timeout_value = nil); end
1419
- def wait!(timeout = nil); end
1420
- def wait_until_resolved!(timeout = nil); end
1421
- def with_default_executor(executor); end
1422
- def zip(other); end
1423
- def |(event_or_future); end
1424
- end
1425
- module Concurrent::Promises::Resolvable
1426
- include Concurrent::Promises::InternalStates
1427
- end
1428
- class Concurrent::Promises::ResolvableEvent < Concurrent::Promises::Event
1429
- def resolve(raise_on_reassign = nil, reserved = nil); end
1430
- def wait(timeout = nil, resolve_on_timeout = nil); end
1431
- def with_hidden_resolvable; end
1432
- include Concurrent::Promises::Resolvable
1433
- end
1434
- class Concurrent::Promises::ResolvableFuture < Concurrent::Promises::Future
1435
- def evaluate_to!(*args, &block); end
1436
- def evaluate_to(*args, &block); end
1437
- def fulfill(value, raise_on_reassign = nil, reserved = nil); end
1438
- def reason(timeout = nil, timeout_value = nil, resolve_on_timeout = nil); end
1439
- def reject(reason, raise_on_reassign = nil, reserved = nil); end
1440
- def resolve(fulfilled = nil, value = nil, reason = nil, raise_on_reassign = nil, reserved = nil); end
1441
- def result(timeout = nil, resolve_on_timeout = nil); end
1442
- def value!(timeout = nil, timeout_value = nil, resolve_on_timeout = nil); end
1443
- def value(timeout = nil, timeout_value = nil, resolve_on_timeout = nil); end
1444
- def wait!(timeout = nil, resolve_on_timeout = nil); end
1445
- def wait(timeout = nil, resolve_on_timeout = nil); end
1446
- def with_hidden_resolvable; end
1447
- include Concurrent::Promises::Resolvable
1448
- end
1449
- class Concurrent::Promises::AbstractPromise < Concurrent::Synchronization::Object
1450
- def default_executor; end
1451
- def delayed_because; end
1452
- def evaluate_to(*args, block); end
1453
- def event; end
1454
- def future; end
1455
- def initialize(future); end
1456
- def inspect; end
1457
- def resolve_with(new_state, raise_on_reassign = nil); end
1458
- def self.new(*args, &block); end
1459
- def state; end
1460
- def to_s; end
1461
- def touch; end
1462
- include Concurrent::Promises::InternalStates
1463
- end
1464
- class Concurrent::Promises::ResolvableEventPromise < Concurrent::Promises::AbstractPromise
1465
- def initialize(default_executor); end
1466
- end
1467
- class Concurrent::Promises::ResolvableFuturePromise < Concurrent::Promises::AbstractPromise
1468
- def evaluate_to(*args, block); end
1469
- def initialize(default_executor); end
1470
- end
1471
- class Concurrent::Promises::InnerPromise < Concurrent::Promises::AbstractPromise
1472
- end
1473
- class Concurrent::Promises::BlockedPromise < Concurrent::Promises::InnerPromise
1474
- def blocked_by; end
1475
- def clear_and_propagate_touch(stack_or_element = nil); end
1476
- def delayed_because; end
1477
- def initialize(delayed, blockers_count, future); end
1478
- def on_blocker_resolution(future, index); end
1479
- def on_resolvable(resolved_future, index); end
1480
- def process_on_blocker_resolution(future, index); end
1481
- def resolvable?(countdown, future, index); end
1482
- def self.add_delayed(delayed1, delayed2); end
1483
- def self.new(*args, &block); end
1484
- def self.new_blocked_by(blockers, *args, &block); end
1485
- def self.new_blocked_by1(blocker, *args, &block); end
1486
- def self.new_blocked_by2(blocker1, blocker2, *args, &block); end
1487
- def touch; end
1488
- end
1489
- class Concurrent::Promises::BlockedTaskPromise < Concurrent::Promises::BlockedPromise
1490
- def executor; end
1491
- def initialize(delayed, blockers_count, default_executor, executor, args, &task); end
1492
- end
1493
- class Concurrent::Promises::ThenPromise < Concurrent::Promises::BlockedTaskPromise
1494
- def initialize(delayed, blockers_count, default_executor, executor, args, &task); end
1495
- def on_resolvable(resolved_future, index); end
1496
- end
1497
- class Concurrent::Promises::RescuePromise < 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::ChainPromise < Concurrent::Promises::BlockedTaskPromise
1502
- def on_resolvable(resolved_future, index); end
1503
- end
1504
- class Concurrent::Promises::ImmediateEventPromise < Concurrent::Promises::InnerPromise
1505
- def initialize(default_executor); end
1506
- end
1507
- class Concurrent::Promises::ImmediateFuturePromise < Concurrent::Promises::InnerPromise
1508
- def initialize(default_executor, fulfilled, value, reason); end
1509
- end
1510
- class Concurrent::Promises::AbstractFlatPromise < Concurrent::Promises::BlockedPromise
1511
- def add_delayed_of(future); end
1512
- def initialize(delayed_because, blockers_count, event_or_future); end
1513
- def on_resolvable(resolved_future, index); end
1514
- def resolvable?(countdown, future, index); end
1515
- def touch; end
1516
- def touched?; end
1517
- end
1518
- class Concurrent::Promises::FlatEventPromise < Concurrent::Promises::AbstractFlatPromise
1519
- def initialize(delayed, blockers_count, default_executor); end
1520
- def process_on_blocker_resolution(future, index); end
1521
- end
1522
- class Concurrent::Promises::FlatFuturePromise < Concurrent::Promises::AbstractFlatPromise
1523
- def initialize(delayed, blockers_count, levels, default_executor); end
1524
- def process_on_blocker_resolution(future, index); end
1525
- end
1526
- class Concurrent::Promises::RunFuturePromise < Concurrent::Promises::AbstractFlatPromise
1527
- def initialize(delayed, blockers_count, default_executor, run_test); end
1528
- def process_on_blocker_resolution(future, index); end
1529
- end
1530
- class Concurrent::Promises::ZipEventEventPromise < Concurrent::Promises::BlockedPromise
1531
- def initialize(delayed, blockers_count, default_executor); end
1532
- def on_resolvable(resolved_future, index); end
1533
- end
1534
- class Concurrent::Promises::ZipFutureEventPromise < Concurrent::Promises::BlockedPromise
1535
- def initialize(delayed, blockers_count, default_executor); end
1536
- def on_resolvable(resolved_future, index); end
1537
- def process_on_blocker_resolution(future, index); end
1538
- end
1539
- class Concurrent::Promises::EventWrapperPromise < Concurrent::Promises::BlockedPromise
1540
- def initialize(delayed, blockers_count, default_executor); end
1541
- def on_resolvable(resolved_future, index); end
1542
- end
1543
- class Concurrent::Promises::FutureWrapperPromise < 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::ZipFuturesPromise < Concurrent::Promises::BlockedPromise
1548
- def initialize(delayed, blockers_count, default_executor); end
1549
- def on_resolvable(resolved_future, index); end
1550
- def process_on_blocker_resolution(future, index); end
1551
- end
1552
- class Concurrent::Promises::ZipEventsPromise < Concurrent::Promises::BlockedPromise
1553
- def initialize(delayed, blockers_count, default_executor); end
1554
- def on_resolvable(resolved_future, index); end
1555
- end
1556
- class Concurrent::Promises::AbstractAnyPromise < Concurrent::Promises::BlockedPromise
1557
- end
1558
- class Concurrent::Promises::AnyResolvedEventPromise < Concurrent::Promises::AbstractAnyPromise
1559
- def initialize(delayed, blockers_count, default_executor); end
1560
- def on_resolvable(resolved_future, index); end
1561
- def resolvable?(countdown, future, index); end
1562
- end
1563
- class Concurrent::Promises::AnyResolvedFuturePromise < Concurrent::Promises::AbstractAnyPromise
1564
- def initialize(delayed, blockers_count, default_executor); end
1565
- def on_resolvable(resolved_future, index); end
1566
- def resolvable?(countdown, future, index); end
1567
- end
1568
- class Concurrent::Promises::AnyFulfilledFuturePromise < Concurrent::Promises::AnyResolvedFuturePromise
1569
- def resolvable?(countdown, future, index); end
1570
- end
1571
- class Concurrent::Promises::DelayPromise < Concurrent::Promises::InnerPromise
1572
- def delayed_because; end
1573
- def initialize(default_executor); end
1574
- def touch; end
1575
- end
1576
- class Concurrent::Promises::ScheduledPromise < Concurrent::Promises::InnerPromise
1577
- def initialize(default_executor, intended_time); end
1578
- def inspect; end
1579
- def intended_time; end
1580
- end
1581
- class Concurrent::SynchronizedDelegator < SimpleDelegator
1582
- def initialize(obj); end
1583
- def method_missing(method, *args, &block); end
1584
- def setup; end
1585
- def teardown; end
1586
- end