muina 0.2.8 → 0.4.0

Sign up to get free protection for your applications and to get access to all the features.
Files changed (161) hide show
  1. checksums.yaml +4 -4
  2. data/LICENSE +25 -0
  3. data/README.md +0 -35
  4. data/lib/muina/maybe/none.rb +61 -0
  5. data/lib/muina/maybe/some.rb +62 -0
  6. data/lib/muina/maybe.rb +13 -0
  7. data/lib/muina/result/failure.rb +7 -18
  8. data/lib/muina/result/success.rb +7 -18
  9. data/lib/muina/result.rb +6 -8
  10. data/lib/muina/version.rb +1 -2
  11. data/lib/muina.rb +0 -32
  12. metadata +24 -225
  13. data/.github/workflows/main.yml +0 -16
  14. data/.gitignore +0 -5
  15. data/.mutant.yml +0 -38
  16. data/.rspec +0 -4
  17. data/.rubocop.yml +0 -181
  18. data/.ruby-version +0 -1
  19. data/.simplecov +0 -14
  20. data/CHANGELOG.md +0 -38
  21. data/Gemfile +0 -34
  22. data/Gemfile.lock +0 -265
  23. data/Guardfile +0 -24
  24. data/Rakefile +0 -13
  25. data/SECURITY.md +0 -14
  26. data/bin/bundle +0 -114
  27. data/bin/console +0 -15
  28. data/bin/flay +0 -29
  29. data/bin/flog +0 -29
  30. data/bin/guard +0 -29
  31. data/bin/irb +0 -29
  32. data/bin/lefthook +0 -29
  33. data/bin/mutant +0 -29
  34. data/bin/parlour +0 -29
  35. data/bin/rake +0 -29
  36. data/bin/rspec +0 -29
  37. data/bin/rubocop +0 -29
  38. data/bin/setup +0 -8
  39. data/bin/srb +0 -29
  40. data/bin/srb-rbi +0 -29
  41. data/bin/tapioca +0 -29
  42. data/exe/muina +0 -11
  43. data/lefthook.yml +0 -39
  44. data/lib/muina/action/params_factory.rb +0 -17
  45. data/lib/muina/action/step/command.rb +0 -33
  46. data/lib/muina/action/step/failure.rb +0 -18
  47. data/lib/muina/action/step/query.rb +0 -35
  48. data/lib/muina/action/step/result.rb +0 -56
  49. data/lib/muina/action/step.rb +0 -13
  50. data/lib/muina/action.rb +0 -73
  51. data/lib/muina/any.rb +0 -7
  52. data/lib/muina/classes.rb +0 -7
  53. data/lib/muina/deprecator.rb +0 -93
  54. data/lib/muina/entity.rb +0 -20
  55. data/lib/muina/module.rb +0 -6
  56. data/lib/muina/parameters.rb +0 -7
  57. data/lib/muina/params.rb +0 -19
  58. data/lib/muina/private_creation.rb +0 -12
  59. data/lib/muina/result/factory.rb +0 -37
  60. data/lib/muina/result/null.rb +0 -25
  61. data/lib/muina/service.rb +0 -25
  62. data/lib/muina/symbol_hash.rb +0 -7
  63. data/lib/muina/unit.rb +0 -10
  64. data/lib/muina/untyped_array.rb +0 -7
  65. data/lib/muina/untyped_hash.rb +0 -7
  66. data/lib/muina/value.rb +0 -24
  67. data/muina.gemspec +0 -35
  68. data/rbi/muina.rbi +0 -311
  69. data/sorbet/config +0 -2
  70. data/sorbet/rbi/gems/actionpack@6.1.4.rbi +0 -5045
  71. data/sorbet/rbi/gems/actionview@6.1.4.rbi +0 -2416
  72. data/sorbet/rbi/gems/activesupport@6.1.4.rbi +0 -3778
  73. data/sorbet/rbi/gems/ast@2.4.2.rbi +0 -54
  74. data/sorbet/rbi/gems/awesome_print@1.9.2.rbi +0 -322
  75. data/sorbet/rbi/gems/builder@3.2.4.rbi +0 -8
  76. data/sorbet/rbi/gems/byebug@11.1.3.rbi +0 -18
  77. data/sorbet/rbi/gems/coderay@1.1.3.rbi +0 -8
  78. data/sorbet/rbi/gems/colorize@0.8.1.rbi +0 -39
  79. data/sorbet/rbi/gems/commander@4.6.0.rbi +0 -8
  80. data/sorbet/rbi/gems/concurrent-ruby@1.1.9.rbi +0 -2403
  81. data/sorbet/rbi/gems/crass@1.0.6.rbi +0 -123
  82. data/sorbet/rbi/gems/diff-lcs@1.4.4.rbi +0 -185
  83. data/sorbet/rbi/gems/docile@1.4.0.rbi +0 -54
  84. data/sorbet/rbi/gems/erubi@1.10.0.rbi +0 -36
  85. data/sorbet/rbi/gems/erubis@2.7.0.rbi +0 -8
  86. data/sorbet/rbi/gems/faker@2.18.0.rbi +0 -2469
  87. data/sorbet/rbi/gems/ffi@1.15.3.rbi +0 -8
  88. data/sorbet/rbi/gems/flay@2.12.1.rbi +0 -178
  89. data/sorbet/rbi/gems/flog@4.6.4.rbi +0 -70
  90. data/sorbet/rbi/gems/formatador@0.3.0.rbi +0 -8
  91. data/sorbet/rbi/gems/guard-compat@1.2.1.rbi +0 -49
  92. data/sorbet/rbi/gems/guard-rspec@4.7.3.rbi +0 -233
  93. data/sorbet/rbi/gems/guard-rubocop@1.4.0.rbi +0 -66
  94. data/sorbet/rbi/gems/guard-shell@0.7.2.rbi +0 -69
  95. data/sorbet/rbi/gems/guard@2.18.0.rbi +0 -617
  96. data/sorbet/rbi/gems/highline@2.0.3.rbi +0 -8
  97. data/sorbet/rbi/gems/i18n@1.8.10.rbi +0 -616
  98. data/sorbet/rbi/gems/io-console@0.5.9.rbi +0 -8
  99. data/sorbet/rbi/gems/irb@1.3.6.rbi +0 -452
  100. data/sorbet/rbi/gems/lefthook@0.7.6.rbi +0 -8
  101. data/sorbet/rbi/gems/listen@3.6.0.rbi +0 -476
  102. data/sorbet/rbi/gems/loofah@2.10.0.rbi +0 -223
  103. data/sorbet/rbi/gems/lumberjack@1.2.8.rbi +0 -431
  104. data/sorbet/rbi/gems/method_source@1.0.0.rbi +0 -8
  105. data/sorbet/rbi/gems/minitest@5.14.4.rbi +0 -344
  106. data/sorbet/rbi/gems/mutant-license@0.1.1.1.4043027289354708743625974235631451632228.0.rbi +0 -8
  107. data/sorbet/rbi/gems/mutant-rspec@0.10.32.rbi +0 -8
  108. data/sorbet/rbi/gems/mutant@0.10.32.rbi +0 -4154
  109. data/sorbet/rbi/gems/nenv@0.3.0.rbi +0 -88
  110. data/sorbet/rbi/gems/nokogiri@1.11.7.rbi +0 -1422
  111. data/sorbet/rbi/gems/notiffany@0.1.3.rbi +0 -331
  112. data/sorbet/rbi/gems/parallel@1.20.1.rbi +0 -113
  113. data/sorbet/rbi/gems/parlour@6.0.1.rbi +0 -1726
  114. data/sorbet/rbi/gems/parser@3.0.2.0.rbi +0 -1683
  115. data/sorbet/rbi/gems/path_expander@1.1.0.rbi +0 -24
  116. data/sorbet/rbi/gems/polyfill@1.9.0.rbi +0 -393
  117. data/sorbet/rbi/gems/pry@0.14.1.rbi +0 -8
  118. data/sorbet/rbi/gems/racc@1.5.2.rbi +0 -47
  119. data/sorbet/rbi/gems/rack-test@1.1.0.rbi +0 -272
  120. data/sorbet/rbi/gems/rack@2.2.3.rbi +0 -1618
  121. data/sorbet/rbi/gems/rails-dom-testing@2.0.3.rbi +0 -92
  122. data/sorbet/rbi/gems/rails-html-sanitizer@1.3.0.rbi +0 -183
  123. data/sorbet/rbi/gems/rainbow@3.0.0.rbi +0 -153
  124. data/sorbet/rbi/gems/rake@13.0.6.rbi +0 -808
  125. data/sorbet/rbi/gems/rb-fsevent@0.11.0.rbi +0 -8
  126. data/sorbet/rbi/gems/rb-inotify@0.10.1.rbi +0 -8
  127. data/sorbet/rbi/gems/regexp_parser@2.1.1.rbi +0 -1120
  128. data/sorbet/rbi/gems/reline@0.2.6.rbi +0 -662
  129. data/sorbet/rbi/gems/rexml@3.2.5.rbi +0 -672
  130. data/sorbet/rbi/gems/rspec-core@3.10.1.rbi +0 -2509
  131. data/sorbet/rbi/gems/rspec-expectations@3.10.1.rbi +0 -1574
  132. data/sorbet/rbi/gems/rspec-mocks@3.10.2.rbi +0 -1462
  133. data/sorbet/rbi/gems/rspec-support@3.10.2.rbi +0 -509
  134. data/sorbet/rbi/gems/rspec@3.10.0.rbi +0 -38
  135. data/sorbet/rbi/gems/rubocop-ast@1.8.0.rbi +0 -2194
  136. data/sorbet/rbi/gems/rubocop-performance@1.11.4.rbi +0 -899
  137. data/sorbet/rbi/gems/rubocop-rake@0.6.0.rbi +0 -118
  138. data/sorbet/rbi/gems/rubocop-rspec@2.4.0.rbi +0 -1805
  139. data/sorbet/rbi/gems/rubocop-sorbet@0.6.2.rbi +0 -288
  140. data/sorbet/rbi/gems/rubocop@1.18.4.rbi +0 -13197
  141. data/sorbet/rbi/gems/ruby-progressbar@1.11.0.rbi +0 -405
  142. data/sorbet/rbi/gems/ruby_parser@3.16.0.rbi +0 -4528
  143. data/sorbet/rbi/gems/safe_type@1.1.1.rbi +0 -157
  144. data/sorbet/rbi/gems/sexp_processor@4.15.3.rbi +0 -359
  145. data/sorbet/rbi/gems/shellany@0.0.1.rbi +0 -28
  146. data/sorbet/rbi/gems/simplecov-html@0.12.3.rbi +0 -89
  147. data/sorbet/rbi/gems/simplecov@0.21.2.rbi +0 -577
  148. data/sorbet/rbi/gems/simplecov_json_formatter@0.1.3.rbi +0 -8
  149. data/sorbet/rbi/gems/sorbet-coerce@0.5.0.rbi +0 -42
  150. data/sorbet/rbi/gems/sorbet-rails@0.7.4.rbi +0 -8
  151. data/sorbet/rbi/gems/sorbet-struct-comparable@1.1.0.rbi +0 -17
  152. data/sorbet/rbi/gems/spoom@1.1.1.rbi +0 -1193
  153. data/sorbet/rbi/gems/tapioca@0.4.23.rbi +0 -1826
  154. data/sorbet/rbi/gems/thor@1.1.0.rbi +0 -838
  155. data/sorbet/rbi/gems/tzinfo@2.0.4.rbi +0 -856
  156. data/sorbet/rbi/gems/unicode-display_width@2.0.0.rbi +0 -26
  157. data/sorbet/rbi/gems/unparser@0.6.0.rbi +0 -2037
  158. data/sorbet/rbi/gems/zeitwerk@2.4.2.rbi +0 -173
  159. data/sorbet/rbi/todo.rbi +0 -8
  160. data/sorbet/rbi/typed_params.rbi +0 -7
  161. data/sorbet/tapioca/require.rb +0 -16
@@ -1,2403 +0,0 @@
1
- # DO NOT EDIT MANUALLY
2
- # This is an autogenerated file for types exported from the `concurrent-ruby` gem.
3
- # Please instead update this file by running `bin/tapioca sync`.
4
-
5
- # typed: true
6
-
7
- module Concurrent
8
- extend ::Concurrent::Utility::EngineDetector
9
- extend ::Concurrent::Utility::NativeExtensionLoader
10
- extend ::Logger::Severity
11
- extend ::Concurrent::Concern::Logging
12
- extend ::Concurrent::Concern::Deprecation
13
-
14
- private
15
-
16
- def abort_transaction; end
17
- def atomically; end
18
- def call_dataflow(method, executor, *inputs, &block); end
19
- def dataflow(*inputs, &block); end
20
- def dataflow!(*inputs, &block); end
21
- def dataflow_with(executor, *inputs, &block); end
22
- def dataflow_with!(executor, *inputs, &block); end
23
- def leave_transaction; end
24
- def monotonic_time; end
25
-
26
- class << self
27
- def abort_transaction; end
28
- def atomically; end
29
- def call_dataflow(method, executor, *inputs, &block); end
30
- def create_simple_logger(level = T.unsafe(nil), output = T.unsafe(nil)); end
31
- def create_stdlib_logger(level = T.unsafe(nil), output = T.unsafe(nil)); end
32
- def dataflow(*inputs, &block); end
33
- def dataflow!(*inputs, &block); end
34
- def dataflow_with(executor, *inputs, &block); end
35
- def dataflow_with!(executor, *inputs, &block); end
36
- def disable_at_exit_handlers!; end
37
- def executor(executor_identifier); end
38
- def global_fast_executor; end
39
- def global_immediate_executor; end
40
- def global_io_executor; end
41
- def global_logger; end
42
- def global_logger=(value); end
43
- def global_timer_set; end
44
- def leave_transaction; end
45
- def monotonic_time; end
46
- def new_fast_executor(opts = T.unsafe(nil)); end
47
- def new_io_executor(opts = T.unsafe(nil)); end
48
- def physical_processor_count; end
49
- def processor_count; end
50
- def processor_counter; end
51
- def use_simple_logger(level = T.unsafe(nil), output = T.unsafe(nil)); end
52
- def use_stdlib_logger(level = T.unsafe(nil), output = T.unsafe(nil)); end
53
- end
54
- end
55
-
56
- class Concurrent::AbstractExchanger < ::Concurrent::Synchronization::Object
57
- def initialize; end
58
-
59
- def exchange(value, timeout = T.unsafe(nil)); end
60
- def exchange!(value, timeout = T.unsafe(nil)); end
61
- def try_exchange(value, timeout = T.unsafe(nil)); end
62
-
63
- private
64
-
65
- def do_exchange(value, timeout); end
66
- end
67
-
68
- Concurrent::AbstractExchanger::CANCEL = T.let(T.unsafe(nil), Object)
69
-
70
- class Concurrent::AbstractExecutorService < ::Concurrent::Synchronization::LockableObject
71
- include ::Logger::Severity
72
- include ::Concurrent::Concern::Logging
73
- include ::Concurrent::ExecutorService
74
- include ::Concurrent::Concern::Deprecation
75
-
76
- def initialize(opts = T.unsafe(nil), &block); end
77
-
78
- def auto_terminate=(value); end
79
- def auto_terminate?; end
80
- def fallback_policy; end
81
- def kill; end
82
- def name; end
83
- def running?; end
84
- def shutdown; end
85
- def shutdown?; end
86
- def shuttingdown?; end
87
- def to_s; end
88
- def wait_for_termination(timeout = T.unsafe(nil)); end
89
-
90
- private
91
-
92
- def handle_fallback(*args); end
93
- def ns_auto_terminate?; end
94
- def ns_execute(*args, &task); end
95
- def ns_kill_execution; end
96
- def ns_shutdown_execution; end
97
- end
98
-
99
- Concurrent::AbstractExecutorService::FALLBACK_POLICIES = T.let(T.unsafe(nil), Array)
100
-
101
- class Concurrent::AbstractThreadLocalVar
102
- def initialize(default = T.unsafe(nil), &default_block); end
103
-
104
- def bind(value, &block); end
105
- def value; end
106
- def value=(value); end
107
-
108
- protected
109
-
110
- def allocate_storage; end
111
- def default; end
112
- end
113
-
114
- class Concurrent::Agent < ::Concurrent::Synchronization::LockableObject
115
- include ::Concurrent::Concern::Observable
116
-
117
- def initialize(initial, opts = T.unsafe(nil)); end
118
-
119
- def <<(action); end
120
- def await; end
121
- def await_for(timeout); end
122
- def await_for!(timeout); end
123
- def deref; end
124
- def error; end
125
- def error_mode; end
126
- def failed?; end
127
- def post(*args, &action); end
128
- def reason; end
129
- def restart(new_value, opts = T.unsafe(nil)); end
130
- def send(*args, &action); end
131
- def send!(*args, &action); end
132
- def send_off(*args, &action); end
133
- def send_off!(*args, &action); end
134
- def send_via(executor, *args, &action); end
135
- def send_via!(executor, *args, &action); end
136
- def stopped?; end
137
- def value; end
138
- def wait(timeout = T.unsafe(nil)); end
139
-
140
- private
141
-
142
- def enqueue_action_job(action, args, executor); end
143
- def enqueue_await_job(latch); end
144
- def execute_next_job; end
145
- def handle_error(error); end
146
- def ns_enqueue_job(job, index = T.unsafe(nil)); end
147
- def ns_find_last_job_for_thread; end
148
- def ns_initialize(initial, opts); end
149
- def ns_post_next_job; end
150
- def ns_validate(value); end
151
-
152
- class << self
153
- def await(*agents); end
154
- def await_for(timeout, *agents); end
155
- def await_for!(timeout, *agents); end
156
- end
157
- end
158
-
159
- Concurrent::Agent::AWAIT_ACTION = T.let(T.unsafe(nil), Proc)
160
- Concurrent::Agent::AWAIT_FLAG = T.let(T.unsafe(nil), Object)
161
- Concurrent::Agent::DEFAULT_ERROR_HANDLER = T.let(T.unsafe(nil), Proc)
162
- Concurrent::Agent::DEFAULT_VALIDATOR = T.let(T.unsafe(nil), Proc)
163
- Concurrent::Agent::ERROR_MODES = T.let(T.unsafe(nil), Array)
164
-
165
- class Concurrent::Agent::Error < ::StandardError
166
- def initialize(message = T.unsafe(nil)); end
167
- end
168
-
169
- class Concurrent::Agent::Job < ::Struct
170
- def action; end
171
- def action=(_); end
172
- def args; end
173
- def args=(_); end
174
- def caller; end
175
- def caller=(_); end
176
- def executor; end
177
- def executor=(_); end
178
-
179
- class << self
180
- def [](*_arg0); end
181
- def inspect; end
182
- def members; end
183
- def new(*_arg0); end
184
- end
185
- end
186
-
187
- class Concurrent::Agent::ValidationError < ::Concurrent::Agent::Error
188
- def initialize(message = T.unsafe(nil)); end
189
- end
190
-
191
- class Concurrent::Array < ::Array; end
192
- Concurrent::ArrayImplementation = Array
193
-
194
- module Concurrent::Async
195
- mixes_in_class_methods ::Concurrent::Async::ClassMethods
196
-
197
- def async; end
198
- def await; end
199
- def call; end
200
- def cast; end
201
- def init_synchronization; end
202
-
203
- class << self
204
- def included(base); end
205
- def validate_argc(obj, method, *args); end
206
- end
207
- end
208
-
209
- class Concurrent::Async::AsyncDelegator < ::Concurrent::Synchronization::LockableObject
210
- def initialize(delegate); end
211
-
212
- def method_missing(method, *args, &block); end
213
- def perform; end
214
- def reset_if_forked; end
215
-
216
- private
217
-
218
- def respond_to_missing?(method, include_private = T.unsafe(nil)); end
219
- end
220
-
221
- class Concurrent::Async::AwaitDelegator
222
- def initialize(delegate); end
223
-
224
- def method_missing(method, *args, &block); end
225
-
226
- private
227
-
228
- def respond_to_missing?(method, include_private = T.unsafe(nil)); end
229
- end
230
-
231
- module Concurrent::Async::ClassMethods
232
- def new(*args, &block); end
233
- end
234
-
235
- class Concurrent::Atom < ::Concurrent::Synchronization::Object
236
- include ::Concurrent::Concern::Observable
237
-
238
- def initialize(value, opts = T.unsafe(nil)); end
239
-
240
- def __initialize_atomic_fields__; end
241
- def compare_and_set(old_value, new_value); end
242
- def deref; end
243
- def reset(new_value); end
244
- def swap(*args); end
245
- def value; end
246
-
247
- private
248
-
249
- def compare_and_set_value(expected, value); end
250
- def swap_value(value); end
251
- def update_value(&block); end
252
- def valid?(new_value); end
253
- def value=(value); end
254
-
255
- class << self
256
- def new(*args, &block); end
257
- end
258
- end
259
-
260
- class Concurrent::AtomicBoolean < ::Concurrent::MutexAtomicBoolean
261
- def inspect; end
262
- def to_s; end
263
- end
264
-
265
- Concurrent::AtomicBooleanImplementation = Concurrent::MutexAtomicBoolean
266
-
267
- module Concurrent::AtomicDirectUpdate
268
- def try_update; end
269
- def try_update!; end
270
- def update; end
271
- end
272
-
273
- class Concurrent::AtomicFixnum < ::Concurrent::MutexAtomicFixnum
274
- def inspect; end
275
- def to_s; end
276
- end
277
-
278
- Concurrent::AtomicFixnumImplementation = Concurrent::MutexAtomicFixnum
279
-
280
- class Concurrent::AtomicMarkableReference < ::Concurrent::Synchronization::Object
281
- def initialize(value = T.unsafe(nil), mark = T.unsafe(nil)); end
282
-
283
- def __initialize_atomic_fields__; end
284
- def compare_and_set(expected_val, new_val, expected_mark, new_mark); end
285
- def compare_and_swap(expected_val, new_val, expected_mark, new_mark); end
286
- def get; end
287
- def mark; end
288
- def marked?; end
289
- def set(new_val, new_mark); end
290
- def try_update; end
291
- def try_update!; end
292
- def update; end
293
- def value; end
294
-
295
- private
296
-
297
- def compare_and_set_reference(expected, value); end
298
- def immutable_array(*args); end
299
- def reference; end
300
- def reference=(value); end
301
- def swap_reference(value); end
302
- def update_reference(&block); end
303
-
304
- class << self
305
- def new(*args, &block); end
306
- end
307
- end
308
-
309
- module Concurrent::AtomicNumericCompareAndSetWrapper
310
- def compare_and_set(old_value, new_value); end
311
- end
312
-
313
- class Concurrent::AtomicReference < ::Concurrent::MutexAtomicReference
314
- def inspect; end
315
- def to_s; end
316
- end
317
-
318
- Concurrent::AtomicReferenceImplementation = Concurrent::MutexAtomicReference
319
-
320
- class Concurrent::CRubySet < ::Set
321
- def initialize(*args, &block); end
322
-
323
- def &(*args); end
324
- def +(*args); end
325
- def -(*args); end
326
- def <(*args); end
327
- def <<(*args); end
328
- def <=(*args); end
329
- def ==(*args); end
330
- def ===(*args); end
331
- def >(*args); end
332
- def >=(*args); end
333
- def ^(*args); end
334
- def add(*args); end
335
- def add?(*args); end
336
- def classify(*args); end
337
- def clear(*args); end
338
- def collect!(*args); end
339
- def compare_by_identity(*args); end
340
- def compare_by_identity?(*args); end
341
- def delete(*args); end
342
- def delete?(*args); end
343
- def delete_if(*args); end
344
- def difference(*args); end
345
- def disjoint?(*args); end
346
- def divide(*args); end
347
- def each(*args); end
348
- def empty?(*args); end
349
- def eql?(*args); end
350
- def filter!(*args); end
351
- def flatten(*args); end
352
- def flatten!(*args); end
353
- def flatten_merge(*args); end
354
- def freeze(*args); end
355
- def hash(*args); end
356
- def include?(*args); end
357
- def inspect(*args); end
358
- def intersect?(*args); end
359
- def intersection(*args); end
360
- def keep_if(*args); end
361
- def length(*args); end
362
- def map!(*args); end
363
- def member?(*args); end
364
- def merge(*args); end
365
- def pretty_print(*args); end
366
- def pretty_print_cycle(*args); end
367
- def proper_subset?(*args); end
368
- def proper_superset?(*args); end
369
- def reject!(*args); end
370
- def replace(*args); end
371
- def reset(*args); end
372
- def select!(*args); end
373
- def size(*args); end
374
- def subset?(*args); end
375
- def subtract(*args); end
376
- def superset?(*args); end
377
- def taint(*args); end
378
- def to_a(*args); end
379
- def to_s(*args); end
380
- def to_set(*args); end
381
- def union(*args); end
382
- def untaint(*args); end
383
- def |(*args); end
384
-
385
- private
386
-
387
- def initialize_copy(other); end
388
- end
389
-
390
- class Concurrent::CachedThreadPool < ::Concurrent::ThreadPoolExecutor
391
- def initialize(opts = T.unsafe(nil)); end
392
-
393
- private
394
-
395
- def ns_initialize(opts); end
396
- end
397
-
398
- class Concurrent::CancelledOperationError < ::Concurrent::Error; end
399
- module Concurrent::Collection; end
400
-
401
- class Concurrent::Collection::CopyOnNotifyObserverSet < ::Concurrent::Synchronization::LockableObject
402
- def initialize; end
403
-
404
- def add_observer(observer = T.unsafe(nil), func = T.unsafe(nil), &block); end
405
- def count_observers; end
406
- def delete_observer(observer); end
407
- def delete_observers; end
408
- def notify_and_delete_observers(*args, &block); end
409
- def notify_observers(*args, &block); end
410
-
411
- protected
412
-
413
- def ns_initialize; end
414
-
415
- private
416
-
417
- def duplicate_and_clear_observers; end
418
- def duplicate_observers; end
419
- def notify_to(observers, *args); end
420
- end
421
-
422
- class Concurrent::Collection::CopyOnWriteObserverSet < ::Concurrent::Synchronization::LockableObject
423
- def initialize; end
424
-
425
- def add_observer(observer = T.unsafe(nil), func = T.unsafe(nil), &block); end
426
- def count_observers; end
427
- def delete_observer(observer); end
428
- def delete_observers; end
429
- def notify_and_delete_observers(*args, &block); end
430
- def notify_observers(*args, &block); end
431
-
432
- protected
433
-
434
- def ns_initialize; end
435
-
436
- private
437
-
438
- def clear_observers_and_return_old; end
439
- def notify_to(observers, *args); end
440
- def observers; end
441
- def observers=(new_set); end
442
- end
443
-
444
- Concurrent::Collection::MapImplementation = Concurrent::Collection::MriMapBackend
445
-
446
- class Concurrent::Collection::MriMapBackend < ::Concurrent::Collection::NonConcurrentMapBackend
447
- def initialize(options = T.unsafe(nil)); end
448
-
449
- def []=(key, value); end
450
- def clear; end
451
- def compute(key); end
452
- def compute_if_absent(key); end
453
- def compute_if_present(key); end
454
- def delete(key); end
455
- def delete_pair(key, value); end
456
- def get_and_set(key, value); end
457
- def merge_pair(key, value); end
458
- def replace_if_exists(key, new_value); end
459
- def replace_pair(key, old_value, new_value); end
460
- end
461
-
462
- class Concurrent::Collection::NonConcurrentMapBackend
463
- def initialize(options = T.unsafe(nil)); end
464
-
465
- def [](key); end
466
- def []=(key, value); end
467
- def clear; end
468
- def compute(key); end
469
- def compute_if_absent(key); end
470
- def compute_if_present(key); end
471
- def delete(key); end
472
- def delete_pair(key, value); end
473
- def each_pair; end
474
- def get_and_set(key, value); end
475
- def get_or_default(key, default_value); end
476
- def key?(key); end
477
- def merge_pair(key, value); end
478
- def replace_if_exists(key, new_value); end
479
- def replace_pair(key, old_value, new_value); end
480
- def size; end
481
-
482
- private
483
-
484
- def _get(key); end
485
- def _set(key, value); end
486
- def dupped_backend; end
487
- def initialize_copy(other); end
488
- def pair?(key, expected_value); end
489
- def store_computed_value(key, new_value); end
490
- end
491
-
492
- class Concurrent::Collection::NonConcurrentPriorityQueue < ::Concurrent::Collection::RubyNonConcurrentPriorityQueue
493
- def <<(item); end
494
- def deq; end
495
- def enq(item); end
496
- def has_priority?(item); end
497
- def shift; end
498
- def size; end
499
- end
500
-
501
- Concurrent::Collection::NonConcurrentPriorityQueueImplementation = Concurrent::Collection::RubyNonConcurrentPriorityQueue
502
-
503
- class Concurrent::Collection::RubyNonConcurrentPriorityQueue
504
- def initialize(opts = T.unsafe(nil)); end
505
-
506
- def <<(item); end
507
- def clear; end
508
- def delete(item); end
509
- def deq; end
510
- def empty?; end
511
- def enq(item); end
512
- def has_priority?(item); end
513
- def include?(item); end
514
- def length; end
515
- def peek; end
516
- def pop; end
517
- def push(item); end
518
- def shift; end
519
- def size; end
520
-
521
- private
522
-
523
- def ordered?(x, y); end
524
- def sink(k); end
525
- def swap(x, y); end
526
- def swim(k); end
527
-
528
- class << self
529
- def from_list(list, opts = T.unsafe(nil)); end
530
- end
531
- end
532
-
533
- module Concurrent::Concern; end
534
-
535
- module Concurrent::Concern::Deprecation
536
- include ::Logger::Severity
537
- include ::Concurrent::Concern::Logging
538
- extend ::Logger::Severity
539
- extend ::Concurrent::Concern::Logging
540
- extend ::Concurrent::Concern::Deprecation
541
-
542
- def deprecated(message, strip = T.unsafe(nil)); end
543
- def deprecated_method(old_name, new_name); end
544
- end
545
-
546
- module Concurrent::Concern::Dereferenceable
547
- def deref; end
548
- def value; end
549
-
550
- protected
551
-
552
- def apply_deref_options(value); end
553
- def ns_set_deref_options(opts); end
554
- def set_deref_options(opts = T.unsafe(nil)); end
555
- def value=(value); end
556
- end
557
-
558
- module Concurrent::Concern::Logging
559
- include ::Logger::Severity
560
-
561
- def log(level, progname, message = T.unsafe(nil), &block); end
562
- end
563
-
564
- module Concurrent::Concern::Obligation
565
- include ::Concurrent::Concern::Dereferenceable
566
-
567
- def complete?; end
568
- def exception(*args); end
569
- def fulfilled?; end
570
- def incomplete?; end
571
- def no_error!(timeout = T.unsafe(nil)); end
572
- def pending?; end
573
- def realized?; end
574
- def reason; end
575
- def rejected?; end
576
- def state; end
577
- def unscheduled?; end
578
- def value(timeout = T.unsafe(nil)); end
579
- def value!(timeout = T.unsafe(nil)); end
580
- def wait(timeout = T.unsafe(nil)); end
581
- def wait!(timeout = T.unsafe(nil)); end
582
-
583
- protected
584
-
585
- def compare_and_set_state(next_state, *expected_current); end
586
- def event; end
587
- def get_arguments_from(opts = T.unsafe(nil)); end
588
- def if_state(*expected_states); end
589
- def init_obligation; end
590
- def ns_check_state?(expected); end
591
- def ns_set_state(value); end
592
- def set_state(success, value, reason); end
593
- def state=(value); end
594
- end
595
-
596
- module Concurrent::Concern::Observable
597
- def add_observer(observer = T.unsafe(nil), func = T.unsafe(nil), &block); end
598
- def count_observers; end
599
- def delete_observer(observer); end
600
- def delete_observers; end
601
- def with_observer(observer = T.unsafe(nil), func = T.unsafe(nil), &block); end
602
-
603
- protected
604
-
605
- def observers; end
606
- def observers=(_arg0); end
607
- end
608
-
609
- class Concurrent::ConcurrentUpdateError < ::ThreadError; end
610
- Concurrent::ConcurrentUpdateError::CONC_UP_ERR_BACKTRACE = T.let(T.unsafe(nil), Array)
611
- class Concurrent::ConfigurationError < ::Concurrent::Error; end
612
- class Concurrent::CountDownLatch < ::Concurrent::MutexCountDownLatch; end
613
- Concurrent::CountDownLatchImplementation = Concurrent::MutexCountDownLatch
614
-
615
- class Concurrent::CyclicBarrier < ::Concurrent::Synchronization::LockableObject
616
- def initialize(parties, &block); end
617
-
618
- def broken?; end
619
- def number_waiting; end
620
- def parties; end
621
- def reset; end
622
- def wait(timeout = T.unsafe(nil)); end
623
-
624
- protected
625
-
626
- def ns_generation_done(generation, status, continue = T.unsafe(nil)); end
627
- def ns_initialize(parties, &block); end
628
- def ns_next_generation; end
629
- end
630
-
631
- class Concurrent::CyclicBarrier::Generation < ::Struct
632
- def status; end
633
- def status=(_); end
634
-
635
- class << self
636
- def [](*_arg0); end
637
- def inspect; end
638
- def members; end
639
- def new(*_arg0); end
640
- end
641
- end
642
-
643
- class Concurrent::Delay < ::Concurrent::Synchronization::LockableObject
644
- include ::Concurrent::Concern::Dereferenceable
645
- include ::Concurrent::Concern::Obligation
646
-
647
- def initialize(opts = T.unsafe(nil), &block); end
648
-
649
- def reconfigure(&block); end
650
- def value(timeout = T.unsafe(nil)); end
651
- def value!(timeout = T.unsafe(nil)); end
652
- def wait(timeout = T.unsafe(nil)); end
653
-
654
- protected
655
-
656
- def ns_initialize(opts, &block); end
657
-
658
- private
659
-
660
- def execute_task_once; end
661
- end
662
-
663
- class Concurrent::DependencyCounter
664
- def initialize(count, &block); end
665
-
666
- def update(time, value, reason); end
667
- end
668
-
669
- class Concurrent::Error < ::StandardError; end
670
-
671
- class Concurrent::Event < ::Concurrent::Synchronization::LockableObject
672
- def initialize; end
673
-
674
- def reset; end
675
- def set; end
676
- def set?; end
677
- def try?; end
678
- def wait(timeout = T.unsafe(nil)); end
679
-
680
- protected
681
-
682
- def ns_initialize; end
683
- def ns_set; end
684
- end
685
-
686
- class Concurrent::Exchanger < ::Concurrent::RubyExchanger; end
687
- Concurrent::ExchangerImplementation = Concurrent::RubyExchanger
688
-
689
- module Concurrent::ExecutorService
690
- include ::Logger::Severity
691
- include ::Concurrent::Concern::Logging
692
-
693
- def <<(task); end
694
- def can_overflow?; end
695
- def post(*args, &task); end
696
- def serialized?; end
697
- end
698
-
699
- class Concurrent::FixedThreadPool < ::Concurrent::ThreadPoolExecutor
700
- def initialize(num_threads, opts = T.unsafe(nil)); end
701
- end
702
-
703
- class Concurrent::Future < ::Concurrent::IVar
704
- def initialize(opts = T.unsafe(nil), &block); end
705
-
706
- def cancel; end
707
- def cancelled?; end
708
- def execute; end
709
- def set(value = T.unsafe(nil), &block); end
710
- def wait_or_cancel(timeout); end
711
-
712
- protected
713
-
714
- def ns_initialize(value, opts); end
715
-
716
- class << self
717
- def execute(opts = T.unsafe(nil), &block); end
718
- end
719
- end
720
-
721
- Concurrent::GLOBAL_FAST_EXECUTOR = T.let(T.unsafe(nil), Concurrent::Delay)
722
- Concurrent::GLOBAL_IMMEDIATE_EXECUTOR = T.let(T.unsafe(nil), Concurrent::ImmediateExecutor)
723
- Concurrent::GLOBAL_IO_EXECUTOR = T.let(T.unsafe(nil), Concurrent::Delay)
724
- Concurrent::GLOBAL_LOGGER = T.let(T.unsafe(nil), Concurrent::AtomicReference)
725
- Concurrent::GLOBAL_MONOTONIC_CLOCK = T.let(T.unsafe(nil), T.untyped)
726
- Concurrent::GLOBAL_TIMER_SET = T.let(T.unsafe(nil), Concurrent::Delay)
727
- class Concurrent::Hash < ::Hash; end
728
- Concurrent::HashImplementation = Hash
729
-
730
- class Concurrent::IVar < ::Concurrent::Synchronization::LockableObject
731
- include ::Concurrent::Concern::Dereferenceable
732
- include ::Concurrent::Concern::Obligation
733
- include ::Concurrent::Concern::Observable
734
-
735
- def initialize(value = T.unsafe(nil), opts = T.unsafe(nil), &block); end
736
-
737
- def add_observer(observer = T.unsafe(nil), func = T.unsafe(nil), &block); end
738
- def fail(reason = T.unsafe(nil)); end
739
- def set(value = T.unsafe(nil)); end
740
- def try_set(value = T.unsafe(nil), &block); end
741
-
742
- protected
743
-
744
- def check_for_block_or_value!(block_given, value); end
745
- def complete(success, value, reason); end
746
- def complete_without_notification(success, value, reason); end
747
- def notify_observers(value, reason); end
748
- def ns_complete_without_notification(success, value, reason); end
749
- def ns_initialize(value, opts); end
750
- def safe_execute(task, args = T.unsafe(nil)); end
751
- end
752
-
753
- class Concurrent::IllegalOperationError < ::Concurrent::Error; end
754
-
755
- class Concurrent::ImmediateExecutor < ::Concurrent::AbstractExecutorService
756
- include ::Concurrent::SerialExecutorService
757
-
758
- def initialize; end
759
-
760
- def <<(task); end
761
- def kill; end
762
- def post(*args, &task); end
763
- def running?; end
764
- def shutdown; end
765
- def shutdown?; end
766
- def shuttingdown?; end
767
- def wait_for_termination(timeout = T.unsafe(nil)); end
768
- end
769
-
770
- class Concurrent::ImmutabilityError < ::Concurrent::Error; end
771
-
772
- module Concurrent::ImmutableStruct
773
- include ::Concurrent::Synchronization::AbstractStruct
774
-
775
- def ==(other); end
776
- def [](member); end
777
- def each(&block); end
778
- def each_pair(&block); end
779
- def inspect; end
780
- def merge(other, &block); end
781
- def select(&block); end
782
- def to_a; end
783
- def to_h; end
784
- def to_s; end
785
- def values; end
786
- def values_at(*indexes); end
787
-
788
- private
789
-
790
- def initialize_copy(original); end
791
-
792
- class << self
793
- def included(base); end
794
- def new(*args, &block); end
795
- end
796
- end
797
-
798
- Concurrent::ImmutableStruct::FACTORY = T.let(T.unsafe(nil), T.untyped)
799
-
800
- class Concurrent::IndirectImmediateExecutor < ::Concurrent::ImmediateExecutor
801
- def initialize; end
802
-
803
- def post(*args, &task); end
804
- end
805
-
806
- class Concurrent::InitializationError < ::Concurrent::Error; end
807
- class Concurrent::LifecycleError < ::Concurrent::Error; end
808
-
809
- class Concurrent::LockFreeStack < ::Concurrent::Synchronization::Object
810
- include ::Enumerable
811
-
812
- def initialize(head = T.unsafe(nil)); end
813
-
814
- def __initialize_atomic_fields__; end
815
- def clear; end
816
- def clear_each(&block); end
817
- def clear_if(head); end
818
- def compare_and_clear(head); end
819
- def compare_and_pop(head); end
820
- def compare_and_push(head, value); end
821
- def each(head = T.unsafe(nil)); end
822
- def empty?(head = T.unsafe(nil)); end
823
- def inspect; end
824
- def peek; end
825
- def pop; end
826
- def push(value); end
827
- def replace_if(head, new_head); end
828
- def to_s; end
829
-
830
- private
831
-
832
- def compare_and_set_head(expected, value); end
833
- def head; end
834
- def head=(value); end
835
- def swap_head(value); end
836
- def update_head(&block); end
837
-
838
- class << self
839
- def new(*args, &block); end
840
- def of1(value); end
841
- def of2(value1, value2); end
842
- end
843
- end
844
-
845
- Concurrent::LockFreeStack::EMPTY = T.let(T.unsafe(nil), Concurrent::LockFreeStack::Node)
846
-
847
- class Concurrent::LockFreeStack::Node
848
- def initialize(value, next_node); end
849
-
850
- def next_node; end
851
- def value; end
852
- def value=(_arg0); end
853
-
854
- class << self
855
- def [](*_arg0); end
856
- end
857
- end
858
-
859
- class Concurrent::MVar < ::Concurrent::Synchronization::Object
860
- include ::Concurrent::Concern::Dereferenceable
861
-
862
- def initialize(value = T.unsafe(nil), opts = T.unsafe(nil)); end
863
-
864
- def borrow(timeout = T.unsafe(nil)); end
865
- def empty?; end
866
- def full?; end
867
- def modify(timeout = T.unsafe(nil)); end
868
- def modify!; end
869
- def put(value, timeout = T.unsafe(nil)); end
870
- def set!(value); end
871
- def take(timeout = T.unsafe(nil)); end
872
- def try_put!(value); end
873
- def try_take!; end
874
-
875
- protected
876
-
877
- def synchronize(&block); end
878
-
879
- private
880
-
881
- def unlocked_empty?; end
882
- def unlocked_full?; end
883
- def wait_for_empty(timeout); end
884
- def wait_for_full(timeout); end
885
- def wait_while(condition, timeout); end
886
-
887
- class << self
888
- def new(*args, &block); end
889
- end
890
- end
891
-
892
- Concurrent::MVar::EMPTY = T.let(T.unsafe(nil), Object)
893
- Concurrent::MVar::TIMEOUT = T.let(T.unsafe(nil), Object)
894
-
895
- class Concurrent::Map < ::Concurrent::Collection::MriMapBackend
896
- def initialize(options = T.unsafe(nil), &block); end
897
-
898
- def [](key); end
899
- def []=(key, value); end
900
- def each; end
901
- def each_key; end
902
- def each_pair; end
903
- def each_value; end
904
- def empty?; end
905
- def fetch(key, default_value = T.unsafe(nil)); end
906
- def fetch_or_store(key, default_value = T.unsafe(nil)); end
907
- def get(key); end
908
- def inspect; end
909
- def key(value); end
910
- def keys; end
911
- def marshal_dump; end
912
- def marshal_load(hash); end
913
- def put(key, value); end
914
- def put_if_absent(key, value); end
915
- def value?(value); end
916
- def values; end
917
-
918
- private
919
-
920
- def initialize_copy(other); end
921
- def populate_from(hash); end
922
- def raise_fetch_no_key; end
923
- def validate_options_hash!(options); end
924
- end
925
-
926
- class Concurrent::MaxRestartFrequencyError < ::Concurrent::Error; end
927
-
928
- class Concurrent::Maybe < ::Concurrent::Synchronization::Object
929
- include ::Comparable
930
-
931
- def initialize(just, nothing); end
932
-
933
- def <=>(other); end
934
- def fulfilled?; end
935
- def just; end
936
- def just?; end
937
- def nothing; end
938
- def nothing?; end
939
- def or(other); end
940
- def reason; end
941
- def rejected?; end
942
- def value; end
943
-
944
- class << self
945
- def from(*args); end
946
- def just(value); end
947
- def nothing(error = T.unsafe(nil)); end
948
-
949
- private
950
-
951
- def new(*args, &block); end
952
- end
953
- end
954
-
955
- Concurrent::Maybe::NONE = T.let(T.unsafe(nil), Object)
956
-
957
- class Concurrent::MultipleAssignmentError < ::Concurrent::Error
958
- def initialize(message = T.unsafe(nil), inspection_data = T.unsafe(nil)); end
959
-
960
- def inspect; end
961
- def inspection_data; end
962
- end
963
-
964
- class Concurrent::MultipleErrors < ::Concurrent::Error
965
- def initialize(errors, message = T.unsafe(nil)); end
966
-
967
- def errors; end
968
- end
969
-
970
- module Concurrent::MutableStruct
971
- include ::Concurrent::Synchronization::AbstractStruct
972
-
973
- def ==(other); end
974
- def [](member); end
975
- def []=(member, value); end
976
- def each(&block); end
977
- def each_pair(&block); end
978
- def inspect; end
979
- def merge(other, &block); end
980
- def select(&block); end
981
- def to_a; end
982
- def to_h; end
983
- def to_s; end
984
- def values; end
985
- def values_at(*indexes); end
986
-
987
- private
988
-
989
- def initialize_copy(original); end
990
-
991
- class << self
992
- def new(*args, &block); end
993
- end
994
- end
995
-
996
- Concurrent::MutableStruct::FACTORY = T.let(T.unsafe(nil), T.untyped)
997
-
998
- class Concurrent::MutexAtomicBoolean < ::Concurrent::Synchronization::LockableObject
999
- def initialize(initial = T.unsafe(nil)); end
1000
-
1001
- def false?; end
1002
- def make_false; end
1003
- def make_true; end
1004
- def true?; end
1005
- def value; end
1006
- def value=(value); end
1007
-
1008
- protected
1009
-
1010
- def ns_initialize(initial); end
1011
-
1012
- private
1013
-
1014
- def ns_make_value(value); end
1015
- end
1016
-
1017
- class Concurrent::MutexAtomicFixnum < ::Concurrent::Synchronization::LockableObject
1018
- def initialize(initial = T.unsafe(nil)); end
1019
-
1020
- def compare_and_set(expect, update); end
1021
- def decrement(delta = T.unsafe(nil)); end
1022
- def down(delta = T.unsafe(nil)); end
1023
- def increment(delta = T.unsafe(nil)); end
1024
- def up(delta = T.unsafe(nil)); end
1025
- def update; end
1026
- def value; end
1027
- def value=(value); end
1028
-
1029
- protected
1030
-
1031
- def ns_initialize(initial); end
1032
-
1033
- private
1034
-
1035
- def ns_set(value); end
1036
- end
1037
-
1038
- class Concurrent::MutexAtomicReference < ::Concurrent::Synchronization::LockableObject
1039
- include ::Concurrent::AtomicDirectUpdate
1040
- include ::Concurrent::AtomicNumericCompareAndSetWrapper
1041
-
1042
- def initialize(value = T.unsafe(nil)); end
1043
-
1044
- def _compare_and_set(old_value, new_value); end
1045
- def compare_and_swap(old_value, new_value); end
1046
- def get; end
1047
- def get_and_set(new_value); end
1048
- def set(new_value); end
1049
- def swap(new_value); end
1050
- def value; end
1051
- def value=(new_value); end
1052
-
1053
- protected
1054
-
1055
- def ns_initialize(value); end
1056
- end
1057
-
1058
- class Concurrent::MutexCountDownLatch < ::Concurrent::Synchronization::LockableObject
1059
- def initialize(count = T.unsafe(nil)); end
1060
-
1061
- def count; end
1062
- def count_down; end
1063
- def wait(timeout = T.unsafe(nil)); end
1064
-
1065
- protected
1066
-
1067
- def ns_initialize(count); end
1068
- end
1069
-
1070
- class Concurrent::MutexSemaphore < ::Concurrent::Synchronization::LockableObject
1071
- def initialize(count); end
1072
-
1073
- def acquire(permits = T.unsafe(nil)); end
1074
- def available_permits; end
1075
- def drain_permits; end
1076
- def reduce_permits(reduction); end
1077
- def release(permits = T.unsafe(nil)); end
1078
- def try_acquire(permits = T.unsafe(nil), timeout = T.unsafe(nil)); end
1079
-
1080
- protected
1081
-
1082
- def ns_initialize(count); end
1083
-
1084
- private
1085
-
1086
- def try_acquire_now(permits); end
1087
- def try_acquire_timed(permits, timeout); end
1088
- end
1089
-
1090
- Concurrent::NULL = T.let(T.unsafe(nil), Object)
1091
- Concurrent::NULL_LOGGER = T.let(T.unsafe(nil), Proc)
1092
-
1093
- module Concurrent::Options
1094
- class << self
1095
- def executor(executor_identifier); end
1096
- def executor_from_options(opts = T.unsafe(nil)); end
1097
- end
1098
- end
1099
-
1100
- class Concurrent::Promise < ::Concurrent::IVar
1101
- def initialize(opts = T.unsafe(nil), &block); end
1102
-
1103
- def catch(&block); end
1104
- def execute; end
1105
- def fail(reason = T.unsafe(nil)); end
1106
- def flat_map(&block); end
1107
- def on_error(&block); end
1108
- def on_success(&block); end
1109
- def rescue(&block); end
1110
- def set(value = T.unsafe(nil), &block); end
1111
- def then(*args, &block); end
1112
- def zip(*others); end
1113
-
1114
- protected
1115
-
1116
- def complete(success, value, reason); end
1117
- def notify_child(child); end
1118
- def ns_initialize(value, opts); end
1119
- def on_fulfill(result); end
1120
- def on_reject(reason); end
1121
- def realize(task); end
1122
- def root?; end
1123
- def set_pending; end
1124
- def set_state!(success, value, reason); end
1125
- def synchronized_set_state!(success, value, reason); end
1126
-
1127
- class << self
1128
- def aggregate(method, *promises); end
1129
- def all?(*promises); end
1130
- def any?(*promises); end
1131
- def execute(opts = T.unsafe(nil), &block); end
1132
- def fulfill(value, opts = T.unsafe(nil)); end
1133
- def reject(reason, opts = T.unsafe(nil)); end
1134
- def zip(*promises); end
1135
- end
1136
- end
1137
-
1138
- class Concurrent::PromiseExecutionError < ::StandardError; end
1139
-
1140
- module Concurrent::Promises
1141
- extend ::Concurrent::Promises::FactoryMethods::Configuration
1142
- extend ::Concurrent::Promises::FactoryMethods
1143
- end
1144
-
1145
- class Concurrent::Promises::AbstractAnyPromise < ::Concurrent::Promises::BlockedPromise; end
1146
-
1147
- class Concurrent::Promises::AbstractEventFuture < ::Concurrent::Synchronization::Object
1148
- include ::Concurrent::Promises::InternalStates
1149
-
1150
- def initialize(promise, default_executor); end
1151
-
1152
- def __initialize_atomic_fields__; end
1153
- def add_callback_clear_delayed_node(node); end
1154
- def add_callback_notify_blocked(promise, index); end
1155
- def blocks; end
1156
- def callbacks; end
1157
- def chain(*args, &task); end
1158
- def chain_on(executor, *args, &task); end
1159
- def chain_resolvable(resolvable); end
1160
- def default_executor; end
1161
- def inspect; end
1162
- def internal_state; end
1163
- def on_resolution(*args, &callback); end
1164
- def on_resolution!(*args, &callback); end
1165
- def on_resolution_using(executor, *args, &callback); end
1166
- def pending?; end
1167
- def promise; end
1168
- def resolve_with(state, raise_on_reassign = T.unsafe(nil), reserved = T.unsafe(nil)); end
1169
- def resolved?; end
1170
- def state; end
1171
- def tangle(resolvable); end
1172
- def to_s; end
1173
- def touch; end
1174
- def touched?; end
1175
- def wait(timeout = T.unsafe(nil)); end
1176
- def waiting_threads; end
1177
- def with_default_executor(executor); end
1178
- def with_hidden_resolvable; end
1179
-
1180
- private
1181
-
1182
- def add_callback(method, *args); end
1183
- def async_callback_on_resolution(state, executor, args, callback); end
1184
- def call_callback(method, state, args); end
1185
- def call_callbacks(state); end
1186
- def callback_clear_delayed_node(state, node); end
1187
- def callback_notify_blocked(state, promise, index); end
1188
- def compare_and_set_internal_state(expected, value); end
1189
- def internal_state=(value); end
1190
- def swap_internal_state(value); end
1191
- def update_internal_state(&block); end
1192
- def wait_until_resolved(timeout); end
1193
- def with_async(executor, *args, &block); end
1194
-
1195
- class << self
1196
- def new(*args, &block); end
1197
- end
1198
- end
1199
-
1200
- class Concurrent::Promises::AbstractFlatPromise < ::Concurrent::Promises::BlockedPromise
1201
- def initialize(delayed_because, blockers_count, event_or_future); end
1202
-
1203
- def touch; end
1204
-
1205
- private
1206
-
1207
- def add_delayed_of(future); end
1208
- def on_resolvable(resolved_future, index); end
1209
- def resolvable?(countdown, future, index); end
1210
- def touched?; end
1211
- end
1212
-
1213
- class Concurrent::Promises::AbstractPromise < ::Concurrent::Synchronization::Object
1214
- include ::Concurrent::Promises::InternalStates
1215
-
1216
- def initialize(future); end
1217
-
1218
- def default_executor; end
1219
- def delayed_because; end
1220
- def event; end
1221
- def future; end
1222
- def inspect; end
1223
- def state; end
1224
- def to_s; end
1225
- def touch; end
1226
-
1227
- private
1228
-
1229
- def evaluate_to(*args, block); end
1230
- def resolve_with(new_state, raise_on_reassign = T.unsafe(nil)); end
1231
-
1232
- class << self
1233
- def new(*args, &block); end
1234
- end
1235
- end
1236
-
1237
- class Concurrent::Promises::AnyFulfilledFuturePromise < ::Concurrent::Promises::AnyResolvedFuturePromise
1238
- private
1239
-
1240
- def resolvable?(countdown, future, index); end
1241
- end
1242
-
1243
- class Concurrent::Promises::AnyResolvedEventPromise < ::Concurrent::Promises::AbstractAnyPromise
1244
- def initialize(delayed, blockers_count, default_executor); end
1245
-
1246
- private
1247
-
1248
- def on_resolvable(resolved_future, index); end
1249
- def resolvable?(countdown, future, index); end
1250
- end
1251
-
1252
- class Concurrent::Promises::AnyResolvedFuturePromise < ::Concurrent::Promises::AbstractAnyPromise
1253
- def initialize(delayed, blockers_count, default_executor); end
1254
-
1255
- private
1256
-
1257
- def on_resolvable(resolved_future, index); end
1258
- def resolvable?(countdown, future, index); end
1259
- end
1260
-
1261
- class Concurrent::Promises::BlockedPromise < ::Concurrent::Promises::InnerPromise
1262
- def initialize(delayed, blockers_count, future); end
1263
-
1264
- def blocked_by; end
1265
- def delayed_because; end
1266
- def on_blocker_resolution(future, index); end
1267
- def touch; end
1268
-
1269
- private
1270
-
1271
- def clear_and_propagate_touch(stack_or_element = T.unsafe(nil)); end
1272
- def on_resolvable(resolved_future, index); end
1273
- def process_on_blocker_resolution(future, index); end
1274
- def resolvable?(countdown, future, index); end
1275
-
1276
- class << self
1277
- def add_delayed(delayed1, delayed2); end
1278
- def new_blocked_by(blockers, *args, &block); end
1279
- def new_blocked_by1(blocker, *args, &block); end
1280
- def new_blocked_by2(blocker1, blocker2, *args, &block); end
1281
- end
1282
- end
1283
-
1284
- class Concurrent::Promises::BlockedTaskPromise < ::Concurrent::Promises::BlockedPromise
1285
- def initialize(delayed, blockers_count, default_executor, executor, args, &task); end
1286
-
1287
- def executor; end
1288
- end
1289
-
1290
- class Concurrent::Promises::ChainPromise < ::Concurrent::Promises::BlockedTaskPromise
1291
- private
1292
-
1293
- def on_resolvable(resolved_future, index); end
1294
- end
1295
-
1296
- class Concurrent::Promises::DelayPromise < ::Concurrent::Promises::InnerPromise
1297
- def initialize(default_executor); end
1298
-
1299
- def delayed_because; end
1300
- def touch; end
1301
- end
1302
-
1303
- class Concurrent::Promises::Event < ::Concurrent::Promises::AbstractEventFuture
1304
- def &(other); end
1305
- def any(event_or_future); end
1306
- def delay; end
1307
- def schedule(intended_time); end
1308
- def then(*args, &task); end
1309
- def to_event; end
1310
- def to_future; end
1311
- def with_default_executor(executor); end
1312
- def zip(other); end
1313
- def |(event_or_future); end
1314
-
1315
- private
1316
-
1317
- def callback_on_resolution(state, args, callback); end
1318
- def rejected_resolution(raise_on_reassign, state); end
1319
- end
1320
-
1321
- class Concurrent::Promises::EventWrapperPromise < ::Concurrent::Promises::BlockedPromise
1322
- def initialize(delayed, blockers_count, default_executor); end
1323
-
1324
- private
1325
-
1326
- def on_resolvable(resolved_future, index); end
1327
- end
1328
-
1329
- module Concurrent::Promises::FactoryMethods
1330
- include ::Concurrent::Promises::FactoryMethods::Configuration
1331
- extend ::Concurrent::ReInclude
1332
- extend ::Concurrent::Promises::FactoryMethods
1333
- extend ::Concurrent::Promises::FactoryMethods::Configuration
1334
-
1335
- def any(*futures_and_or_events); end
1336
- def any_event(*futures_and_or_events); end
1337
- def any_event_on(default_executor, *futures_and_or_events); end
1338
- def any_fulfilled_future(*futures_and_or_events); end
1339
- def any_fulfilled_future_on(default_executor, *futures_and_or_events); end
1340
- def any_resolved_future(*futures_and_or_events); end
1341
- def any_resolved_future_on(default_executor, *futures_and_or_events); end
1342
- def delay(*args, &task); end
1343
- def delay_on(default_executor, *args, &task); end
1344
- def fulfilled_future(value, default_executor = T.unsafe(nil)); end
1345
- def future(*args, &task); end
1346
- def future_on(default_executor, *args, &task); end
1347
- def make_future(argument = T.unsafe(nil), default_executor = T.unsafe(nil)); end
1348
- def rejected_future(reason, default_executor = T.unsafe(nil)); end
1349
- def resolvable_event; end
1350
- def resolvable_event_on(default_executor = T.unsafe(nil)); end
1351
- def resolvable_future; end
1352
- def resolvable_future_on(default_executor = T.unsafe(nil)); end
1353
- def resolved_event(default_executor = T.unsafe(nil)); end
1354
- def resolved_future(fulfilled, value, reason, default_executor = T.unsafe(nil)); end
1355
- def schedule(intended_time, *args, &task); end
1356
- def schedule_on(default_executor, intended_time, *args, &task); end
1357
- def zip(*futures_and_or_events); end
1358
- def zip_events(*futures_and_or_events); end
1359
- def zip_events_on(default_executor, *futures_and_or_events); end
1360
- def zip_futures(*futures_and_or_events); end
1361
- def zip_futures_on(default_executor, *futures_and_or_events); end
1362
- end
1363
-
1364
- module Concurrent::Promises::FactoryMethods::Configuration
1365
- def default_executor; end
1366
- end
1367
-
1368
- class Concurrent::Promises::FlatEventPromise < ::Concurrent::Promises::AbstractFlatPromise
1369
- def initialize(delayed, blockers_count, default_executor); end
1370
-
1371
- private
1372
-
1373
- def process_on_blocker_resolution(future, index); end
1374
- end
1375
-
1376
- class Concurrent::Promises::FlatFuturePromise < ::Concurrent::Promises::AbstractFlatPromise
1377
- def initialize(delayed, blockers_count, levels, default_executor); end
1378
-
1379
- private
1380
-
1381
- def process_on_blocker_resolution(future, index); end
1382
- end
1383
-
1384
- class Concurrent::Promises::Future < ::Concurrent::Promises::AbstractEventFuture
1385
- def &(other); end
1386
- def any(event_or_future); end
1387
- def apply(args, block); end
1388
- def delay; end
1389
- def exception(*args); end
1390
- def flat(level = T.unsafe(nil)); end
1391
- def flat_event; end
1392
- def flat_future(level = T.unsafe(nil)); end
1393
- def fulfilled?; end
1394
- def inspect; end
1395
- def on_fulfillment(*args, &callback); end
1396
- def on_fulfillment!(*args, &callback); end
1397
- def on_fulfillment_using(executor, *args, &callback); end
1398
- def on_rejection(*args, &callback); end
1399
- def on_rejection!(*args, &callback); end
1400
- def on_rejection_using(executor, *args, &callback); end
1401
- def reason(timeout = T.unsafe(nil), timeout_value = T.unsafe(nil)); end
1402
- def rejected?; end
1403
- def rescue(*args, &task); end
1404
- def rescue_on(executor, *args, &task); end
1405
- def result(timeout = T.unsafe(nil)); end
1406
- def run(run_test = T.unsafe(nil)); end
1407
- def schedule(intended_time); end
1408
- def then(*args, &task); end
1409
- def then_on(executor, *args, &task); end
1410
- def to_event; end
1411
- def to_future; end
1412
- def to_s; end
1413
- def value(timeout = T.unsafe(nil), timeout_value = T.unsafe(nil)); end
1414
- def value!(timeout = T.unsafe(nil), timeout_value = T.unsafe(nil)); end
1415
- def wait!(timeout = T.unsafe(nil)); end
1416
- def with_default_executor(executor); end
1417
- def zip(other); end
1418
- def |(event_or_future); end
1419
-
1420
- private
1421
-
1422
- def async_callback_on_fulfillment(state, executor, args, callback); end
1423
- def async_callback_on_rejection(state, executor, args, callback); end
1424
- def callback_on_fulfillment(state, args, callback); end
1425
- def callback_on_rejection(state, args, callback); end
1426
- def callback_on_resolution(state, args, callback); end
1427
- def rejected_resolution(raise_on_reassign, state); end
1428
- def run_test(v); end
1429
- def wait_until_resolved!(timeout = T.unsafe(nil)); end
1430
- end
1431
-
1432
- class Concurrent::Promises::FutureWrapperPromise < ::Concurrent::Promises::BlockedPromise
1433
- def initialize(delayed, blockers_count, default_executor); end
1434
-
1435
- private
1436
-
1437
- def on_resolvable(resolved_future, index); end
1438
- end
1439
-
1440
- class Concurrent::Promises::ImmediateEventPromise < ::Concurrent::Promises::InnerPromise
1441
- def initialize(default_executor); end
1442
- end
1443
-
1444
- class Concurrent::Promises::ImmediateFuturePromise < ::Concurrent::Promises::InnerPromise
1445
- def initialize(default_executor, fulfilled, value, reason); end
1446
- end
1447
-
1448
- class Concurrent::Promises::InnerPromise < ::Concurrent::Promises::AbstractPromise; end
1449
- module Concurrent::Promises::InternalStates; end
1450
-
1451
- class Concurrent::Promises::InternalStates::Fulfilled < ::Concurrent::Promises::InternalStates::ResolvedWithResult
1452
- def initialize(value); end
1453
-
1454
- def apply(args, block); end
1455
- def fulfilled?; end
1456
- def reason; end
1457
- def to_sym; end
1458
- def value; end
1459
- end
1460
-
1461
- class Concurrent::Promises::InternalStates::FulfilledArray < ::Concurrent::Promises::InternalStates::Fulfilled
1462
- def apply(args, block); end
1463
- end
1464
-
1465
- Concurrent::Promises::InternalStates::PENDING = T.let(T.unsafe(nil), Concurrent::Promises::InternalStates::Pending)
1466
-
1467
- class Concurrent::Promises::InternalStates::PartiallyRejected < ::Concurrent::Promises::InternalStates::ResolvedWithResult
1468
- def initialize(value, reason); end
1469
-
1470
- def apply(args, block); end
1471
- def fulfilled?; end
1472
- def reason; end
1473
- def to_sym; end
1474
- def value; end
1475
- end
1476
-
1477
- class Concurrent::Promises::InternalStates::Pending < ::Concurrent::Promises::InternalStates::State
1478
- def resolved?; end
1479
- def to_sym; end
1480
- end
1481
-
1482
- Concurrent::Promises::InternalStates::RESERVED = T.let(T.unsafe(nil), Concurrent::Promises::InternalStates::Reserved)
1483
- Concurrent::Promises::InternalStates::RESOLVED = T.let(T.unsafe(nil), Concurrent::Promises::InternalStates::Fulfilled)
1484
-
1485
- class Concurrent::Promises::InternalStates::Rejected < ::Concurrent::Promises::InternalStates::ResolvedWithResult
1486
- def initialize(reason); end
1487
-
1488
- def apply(args, block); end
1489
- def fulfilled?; end
1490
- def reason; end
1491
- def to_sym; end
1492
- def value; end
1493
- end
1494
-
1495
- class Concurrent::Promises::InternalStates::Reserved < ::Concurrent::Promises::InternalStates::Pending; end
1496
-
1497
- class Concurrent::Promises::InternalStates::ResolvedWithResult < ::Concurrent::Promises::InternalStates::State
1498
- def apply; end
1499
- def fulfilled?; end
1500
- def reason; end
1501
- def resolved?; end
1502
- def result; end
1503
- def to_sym; end
1504
- def value; end
1505
- end
1506
-
1507
- class Concurrent::Promises::InternalStates::State
1508
- def resolved?; end
1509
- def to_sym; end
1510
- end
1511
-
1512
- class Concurrent::Promises::RescuePromise < ::Concurrent::Promises::BlockedTaskPromise
1513
- def initialize(delayed, blockers_count, default_executor, executor, args, &task); end
1514
-
1515
- private
1516
-
1517
- def on_resolvable(resolved_future, index); end
1518
- end
1519
-
1520
- module Concurrent::Promises::Resolvable
1521
- include ::Concurrent::Promises::InternalStates
1522
- end
1523
-
1524
- class Concurrent::Promises::ResolvableEvent < ::Concurrent::Promises::Event
1525
- include ::Concurrent::Promises::Resolvable
1526
-
1527
- def resolve(raise_on_reassign = T.unsafe(nil), reserved = T.unsafe(nil)); end
1528
- def wait(timeout = T.unsafe(nil), resolve_on_timeout = T.unsafe(nil)); end
1529
- def with_hidden_resolvable; end
1530
- end
1531
-
1532
- class Concurrent::Promises::ResolvableEventPromise < ::Concurrent::Promises::AbstractPromise
1533
- def initialize(default_executor); end
1534
- end
1535
-
1536
- class Concurrent::Promises::ResolvableFuture < ::Concurrent::Promises::Future
1537
- include ::Concurrent::Promises::Resolvable
1538
-
1539
- def evaluate_to(*args, &block); end
1540
- def evaluate_to!(*args, &block); end
1541
- def fulfill(value, raise_on_reassign = T.unsafe(nil), reserved = T.unsafe(nil)); end
1542
- def reason(timeout = T.unsafe(nil), timeout_value = T.unsafe(nil), resolve_on_timeout = T.unsafe(nil)); end
1543
- def reject(reason, raise_on_reassign = T.unsafe(nil), reserved = T.unsafe(nil)); end
1544
- def resolve(fulfilled = T.unsafe(nil), value = T.unsafe(nil), reason = T.unsafe(nil), raise_on_reassign = T.unsafe(nil), reserved = T.unsafe(nil)); end
1545
- def result(timeout = T.unsafe(nil), resolve_on_timeout = T.unsafe(nil)); end
1546
- def value(timeout = T.unsafe(nil), timeout_value = T.unsafe(nil), resolve_on_timeout = T.unsafe(nil)); end
1547
- def value!(timeout = T.unsafe(nil), timeout_value = T.unsafe(nil), resolve_on_timeout = T.unsafe(nil)); end
1548
- def wait(timeout = T.unsafe(nil), resolve_on_timeout = T.unsafe(nil)); end
1549
- def wait!(timeout = T.unsafe(nil), resolve_on_timeout = T.unsafe(nil)); end
1550
- def with_hidden_resolvable; end
1551
- end
1552
-
1553
- class Concurrent::Promises::ResolvableFuturePromise < ::Concurrent::Promises::AbstractPromise
1554
- def initialize(default_executor); end
1555
- end
1556
-
1557
- class Concurrent::Promises::RunFuturePromise < ::Concurrent::Promises::AbstractFlatPromise
1558
- def initialize(delayed, blockers_count, default_executor, run_test); end
1559
-
1560
- private
1561
-
1562
- def process_on_blocker_resolution(future, index); end
1563
- end
1564
-
1565
- class Concurrent::Promises::ScheduledPromise < ::Concurrent::Promises::InnerPromise
1566
- def initialize(default_executor, intended_time); end
1567
-
1568
- def inspect; end
1569
- def intended_time; end
1570
- end
1571
-
1572
- class Concurrent::Promises::ThenPromise < ::Concurrent::Promises::BlockedTaskPromise
1573
- def initialize(delayed, blockers_count, default_executor, executor, args, &task); end
1574
-
1575
- private
1576
-
1577
- def on_resolvable(resolved_future, index); end
1578
- end
1579
-
1580
- class Concurrent::Promises::ZipEventEventPromise < ::Concurrent::Promises::BlockedPromise
1581
- def initialize(delayed, blockers_count, default_executor); end
1582
-
1583
- private
1584
-
1585
- def on_resolvable(resolved_future, index); end
1586
- end
1587
-
1588
- class Concurrent::Promises::ZipEventsPromise < ::Concurrent::Promises::BlockedPromise
1589
- def initialize(delayed, blockers_count, default_executor); end
1590
-
1591
- private
1592
-
1593
- def on_resolvable(resolved_future, index); end
1594
- end
1595
-
1596
- class Concurrent::Promises::ZipFutureEventPromise < ::Concurrent::Promises::BlockedPromise
1597
- def initialize(delayed, blockers_count, default_executor); end
1598
-
1599
- private
1600
-
1601
- def on_resolvable(resolved_future, index); end
1602
- def process_on_blocker_resolution(future, index); end
1603
- end
1604
-
1605
- class Concurrent::Promises::ZipFuturesPromise < ::Concurrent::Promises::BlockedPromise
1606
- def initialize(delayed, blockers_count, default_executor); end
1607
-
1608
- private
1609
-
1610
- def on_resolvable(resolved_future, index); end
1611
- def process_on_blocker_resolution(future, index); end
1612
- end
1613
-
1614
- module Concurrent::ReInclude
1615
- def extended(base); end
1616
- def include(*modules); end
1617
- def included(base); end
1618
- end
1619
-
1620
- class Concurrent::ReadWriteLock < ::Concurrent::Synchronization::Object
1621
- def initialize; end
1622
-
1623
- def acquire_read_lock; end
1624
- def acquire_write_lock; end
1625
- def has_waiters?; end
1626
- def release_read_lock; end
1627
- def release_write_lock; end
1628
- def with_read_lock; end
1629
- def with_write_lock; end
1630
- def write_locked?; end
1631
-
1632
- private
1633
-
1634
- def max_readers?(c = T.unsafe(nil)); end
1635
- def max_writers?(c = T.unsafe(nil)); end
1636
- def running_readers(c = T.unsafe(nil)); end
1637
- def running_readers?(c = T.unsafe(nil)); end
1638
- def running_writer?(c = T.unsafe(nil)); end
1639
- def waiting_writer?(c = T.unsafe(nil)); end
1640
- def waiting_writers(c = T.unsafe(nil)); end
1641
-
1642
- class << self
1643
- def new(*args, &block); end
1644
- end
1645
- end
1646
-
1647
- Concurrent::ReadWriteLock::MAX_READERS = T.let(T.unsafe(nil), Integer)
1648
- Concurrent::ReadWriteLock::MAX_WRITERS = T.let(T.unsafe(nil), Integer)
1649
- Concurrent::ReadWriteLock::RUNNING_WRITER = T.let(T.unsafe(nil), Integer)
1650
- Concurrent::ReadWriteLock::WAITING_WRITER = T.let(T.unsafe(nil), Integer)
1651
-
1652
- class Concurrent::ReentrantReadWriteLock < ::Concurrent::Synchronization::Object
1653
- def initialize; end
1654
-
1655
- def acquire_read_lock; end
1656
- def acquire_write_lock; end
1657
- def release_read_lock; end
1658
- def release_write_lock; end
1659
- def try_read_lock; end
1660
- def try_write_lock; end
1661
- def with_read_lock; end
1662
- def with_write_lock; end
1663
-
1664
- private
1665
-
1666
- def max_readers?(c = T.unsafe(nil)); end
1667
- def max_writers?(c = T.unsafe(nil)); end
1668
- def running_readers(c = T.unsafe(nil)); end
1669
- def running_readers?(c = T.unsafe(nil)); end
1670
- def running_writer?(c = T.unsafe(nil)); end
1671
- def waiting_or_running_writer?(c = T.unsafe(nil)); end
1672
- def waiting_writers(c = T.unsafe(nil)); end
1673
-
1674
- class << self
1675
- def new(*args, &block); end
1676
- end
1677
- end
1678
-
1679
- Concurrent::ReentrantReadWriteLock::MAX_READERS = T.let(T.unsafe(nil), Integer)
1680
- Concurrent::ReentrantReadWriteLock::MAX_WRITERS = T.let(T.unsafe(nil), Integer)
1681
- Concurrent::ReentrantReadWriteLock::READER_BITS = T.let(T.unsafe(nil), Integer)
1682
- Concurrent::ReentrantReadWriteLock::READ_LOCK_MASK = T.let(T.unsafe(nil), Integer)
1683
- Concurrent::ReentrantReadWriteLock::RUNNING_WRITER = T.let(T.unsafe(nil), Integer)
1684
- Concurrent::ReentrantReadWriteLock::WAITING_WRITER = T.let(T.unsafe(nil), Integer)
1685
- Concurrent::ReentrantReadWriteLock::WRITER_BITS = T.let(T.unsafe(nil), Integer)
1686
- Concurrent::ReentrantReadWriteLock::WRITE_LOCK_HELD = T.let(T.unsafe(nil), Integer)
1687
- Concurrent::ReentrantReadWriteLock::WRITE_LOCK_MASK = T.let(T.unsafe(nil), Integer)
1688
- class Concurrent::RejectedExecutionError < ::Concurrent::Error; end
1689
- class Concurrent::ResourceLimitError < ::Concurrent::Error; end
1690
-
1691
- class Concurrent::RubyExchanger < ::Concurrent::AbstractExchanger
1692
- def initialize; end
1693
-
1694
- def __initialize_atomic_fields__; end
1695
- def compare_and_set_slot(expected, value); end
1696
- def slot; end
1697
- def slot=(value); end
1698
- def swap_slot(value); end
1699
- def update_slot(&block); end
1700
-
1701
- private
1702
-
1703
- def do_exchange(value, timeout); end
1704
-
1705
- class << self
1706
- def new(*args, &block); end
1707
- end
1708
- end
1709
-
1710
- class Concurrent::RubyExchanger::Node < ::Concurrent::Synchronization::Object
1711
- def initialize(item); end
1712
-
1713
- def __initialize_atomic_fields__; end
1714
- def compare_and_set_value(expected, value); end
1715
- def item; end
1716
- def latch; end
1717
- def swap_value(value); end
1718
- def update_value(&block); end
1719
- def value; end
1720
- def value=(value); end
1721
-
1722
- class << self
1723
- def new(*args, &block); end
1724
- end
1725
- end
1726
-
1727
- class Concurrent::RubyExecutorService < ::Concurrent::AbstractExecutorService
1728
- def initialize(*args, &block); end
1729
-
1730
- def kill; end
1731
- def post(*args, &task); end
1732
- def shutdown; end
1733
- def wait_for_termination(timeout = T.unsafe(nil)); end
1734
-
1735
- private
1736
-
1737
- def ns_running?; end
1738
- def ns_shutdown?; end
1739
- def ns_shutdown_execution; end
1740
- def ns_shuttingdown?; end
1741
- def stop_event; end
1742
- def stopped_event; end
1743
- end
1744
-
1745
- class Concurrent::RubySingleThreadExecutor < ::Concurrent::RubyThreadPoolExecutor
1746
- def initialize(opts = T.unsafe(nil)); end
1747
- end
1748
-
1749
- class Concurrent::RubyThreadLocalVar < ::Concurrent::AbstractThreadLocalVar
1750
- def value; end
1751
- def value=(value); end
1752
-
1753
- protected
1754
-
1755
- def allocate_storage; end
1756
-
1757
- private
1758
-
1759
- def get_default; end
1760
- def get_threadlocal_array(thread = T.unsafe(nil)); end
1761
- def next_index; end
1762
- def set_threadlocal_array(array, thread = T.unsafe(nil)); end
1763
- def value_for(thread); end
1764
-
1765
- class << self
1766
- def semi_sync(&block); end
1767
- def thread_finalizer(id); end
1768
- def thread_local_finalizer(index); end
1769
- end
1770
- end
1771
-
1772
- Concurrent::RubyThreadLocalVar::FREE = T.let(T.unsafe(nil), Array)
1773
- Concurrent::RubyThreadLocalVar::LOCK = T.let(T.unsafe(nil), Thread::Mutex)
1774
- Concurrent::RubyThreadLocalVar::THREAD_LOCAL_ARRAYS = T.let(T.unsafe(nil), Hash)
1775
-
1776
- class Concurrent::RubyThreadPoolExecutor < ::Concurrent::RubyExecutorService
1777
- def initialize(opts = T.unsafe(nil)); end
1778
-
1779
- def can_overflow?; end
1780
- def completed_task_count; end
1781
- def idletime; end
1782
- def largest_length; end
1783
- def length; end
1784
- def max_length; end
1785
- def max_queue; end
1786
- def min_length; end
1787
- def queue_length; end
1788
- def ready_worker(worker); end
1789
- def remaining_capacity; end
1790
- def remove_busy_worker(worker); end
1791
- def scheduled_task_count; end
1792
- def synchronous; end
1793
- def worker_died(worker); end
1794
- def worker_not_old_enough(worker); end
1795
- def worker_task_completed; end
1796
-
1797
- private
1798
-
1799
- def ns_add_busy_worker; end
1800
- def ns_assign_worker(*args, &task); end
1801
- def ns_enqueue(*args, &task); end
1802
- def ns_execute(*args, &task); end
1803
- def ns_initialize(opts); end
1804
- def ns_kill_execution; end
1805
- def ns_limited_queue?; end
1806
- def ns_prune_pool; end
1807
- def ns_ready_worker(worker, success = T.unsafe(nil)); end
1808
- def ns_remove_busy_worker(worker); end
1809
- def ns_reset_if_forked; end
1810
- def ns_shutdown_execution; end
1811
- def ns_worker_died(worker); end
1812
- def ns_worker_not_old_enough(worker); end
1813
- end
1814
-
1815
- Concurrent::RubyThreadPoolExecutor::DEFAULT_MAX_POOL_SIZE = T.let(T.unsafe(nil), Integer)
1816
- Concurrent::RubyThreadPoolExecutor::DEFAULT_MAX_QUEUE_SIZE = T.let(T.unsafe(nil), Integer)
1817
- Concurrent::RubyThreadPoolExecutor::DEFAULT_MIN_POOL_SIZE = T.let(T.unsafe(nil), Integer)
1818
- Concurrent::RubyThreadPoolExecutor::DEFAULT_THREAD_IDLETIMEOUT = T.let(T.unsafe(nil), Integer)
1819
-
1820
- class Concurrent::RubyThreadPoolExecutor::Worker
1821
- include ::Logger::Severity
1822
- include ::Concurrent::Concern::Logging
1823
-
1824
- def initialize(pool, id); end
1825
-
1826
- def <<(message); end
1827
- def kill; end
1828
- def stop; end
1829
-
1830
- private
1831
-
1832
- def create_worker(queue, pool, idletime); end
1833
- def run_task(pool, task, args); end
1834
- end
1835
-
1836
- class Concurrent::SafeTaskExecutor < ::Concurrent::Synchronization::LockableObject
1837
- def initialize(task, opts = T.unsafe(nil)); end
1838
-
1839
- def execute(*args); end
1840
- end
1841
-
1842
- class Concurrent::ScheduledTask < ::Concurrent::IVar
1843
- include ::Comparable
1844
-
1845
- def initialize(delay, opts = T.unsafe(nil), &task); end
1846
-
1847
- def <=>(other); end
1848
- def cancel; end
1849
- def cancelled?; end
1850
- def execute; end
1851
- def executor; end
1852
- def initial_delay; end
1853
- def process_task; end
1854
- def processing?; end
1855
- def reschedule(delay); end
1856
- def reset; end
1857
- def schedule_time; end
1858
-
1859
- protected
1860
-
1861
- def ns_reschedule(delay); end
1862
- def ns_schedule(delay); end
1863
-
1864
- class << self
1865
- def execute(delay, opts = T.unsafe(nil), &task); end
1866
- end
1867
- end
1868
-
1869
- class Concurrent::Semaphore < ::Concurrent::MutexSemaphore; end
1870
- Concurrent::SemaphoreImplementation = Concurrent::MutexSemaphore
1871
-
1872
- module Concurrent::SerialExecutorService
1873
- include ::Logger::Severity
1874
- include ::Concurrent::Concern::Logging
1875
- include ::Concurrent::ExecutorService
1876
-
1877
- def serialized?; end
1878
- end
1879
-
1880
- class Concurrent::SerializedExecution < ::Concurrent::Synchronization::LockableObject
1881
- include ::Logger::Severity
1882
- include ::Concurrent::Concern::Logging
1883
-
1884
- def initialize; end
1885
-
1886
- def post(executor, *args, &task); end
1887
- def posts(posts); end
1888
-
1889
- private
1890
-
1891
- def call_job(job); end
1892
- def ns_initialize; end
1893
- def work(job); end
1894
- end
1895
-
1896
- class Concurrent::SerializedExecution::Job < ::Struct
1897
- def args; end
1898
- def args=(_); end
1899
- def block; end
1900
- def block=(_); end
1901
- def call; end
1902
- def executor; end
1903
- def executor=(_); end
1904
-
1905
- class << self
1906
- def [](*_arg0); end
1907
- def inspect; end
1908
- def members; end
1909
- def new(*_arg0); end
1910
- end
1911
- end
1912
-
1913
- class Concurrent::SerializedExecutionDelegator < ::SimpleDelegator
1914
- include ::Logger::Severity
1915
- include ::Concurrent::Concern::Logging
1916
- include ::Concurrent::ExecutorService
1917
- include ::Concurrent::SerialExecutorService
1918
-
1919
- def initialize(executor); end
1920
-
1921
- def post(*args, &task); end
1922
- end
1923
-
1924
- class Concurrent::Set < ::Concurrent::CRubySet; end
1925
- Concurrent::SetImplementation = Concurrent::CRubySet
1926
-
1927
- module Concurrent::SettableStruct
1928
- include ::Concurrent::Synchronization::AbstractStruct
1929
-
1930
- def ==(other); end
1931
- def [](member); end
1932
- def []=(member, value); end
1933
- def each(&block); end
1934
- def each_pair(&block); end
1935
- def inspect; end
1936
- def merge(other, &block); end
1937
- def select(&block); end
1938
- def to_a; end
1939
- def to_h; end
1940
- def to_s; end
1941
- def values; end
1942
- def values_at(*indexes); end
1943
-
1944
- private
1945
-
1946
- def initialize_copy(original); end
1947
-
1948
- class << self
1949
- def new(*args, &block); end
1950
- end
1951
- end
1952
-
1953
- Concurrent::SettableStruct::FACTORY = T.let(T.unsafe(nil), T.untyped)
1954
-
1955
- class Concurrent::SimpleExecutorService < ::Concurrent::RubyExecutorService
1956
- def <<(task); end
1957
- def kill; end
1958
- def post(*args, &task); end
1959
- def running?; end
1960
- def shutdown; end
1961
- def shutdown?; end
1962
- def shuttingdown?; end
1963
- def wait_for_termination(timeout = T.unsafe(nil)); end
1964
-
1965
- private
1966
-
1967
- def ns_initialize(*args); end
1968
-
1969
- class << self
1970
- def <<(task); end
1971
- def post(*args); end
1972
- end
1973
- end
1974
-
1975
- class Concurrent::SingleThreadExecutor < ::Concurrent::RubySingleThreadExecutor; end
1976
- Concurrent::SingleThreadExecutorImplementation = Concurrent::RubySingleThreadExecutor
1977
- module Concurrent::Synchronization; end
1978
-
1979
- class Concurrent::Synchronization::AbstractLockableObject < ::Concurrent::Synchronization::Object
1980
- protected
1981
-
1982
- def ns_broadcast; end
1983
- def ns_signal; end
1984
- def ns_wait(timeout = T.unsafe(nil)); end
1985
- def ns_wait_until(timeout = T.unsafe(nil), &condition); end
1986
- def synchronize; end
1987
- end
1988
-
1989
- class Concurrent::Synchronization::AbstractObject
1990
- def initialize; end
1991
-
1992
- def full_memory_barrier; end
1993
-
1994
- class << self
1995
- def attr_volatile(*names); end
1996
- end
1997
- end
1998
-
1999
- module Concurrent::Synchronization::AbstractStruct
2000
- def initialize(*values); end
2001
-
2002
- def length; end
2003
- def members; end
2004
- def size; end
2005
-
2006
- protected
2007
-
2008
- def ns_each; end
2009
- def ns_each_pair; end
2010
- def ns_equality(other); end
2011
- def ns_get(member); end
2012
- def ns_initialize_copy; end
2013
- def ns_inspect; end
2014
- def ns_merge(other, &block); end
2015
- def ns_select; end
2016
- def ns_to_h; end
2017
- def ns_values; end
2018
- def ns_values_at(indexes); end
2019
- def pr_underscore(clazz); end
2020
-
2021
- class << self
2022
- def define_struct_class(parent, base, name, members, &block); end
2023
- end
2024
- end
2025
-
2026
- class Concurrent::Synchronization::Condition < ::Concurrent::Synchronization::LockableObject
2027
- def initialize(lock); end
2028
-
2029
- def broadcast; end
2030
- def ns_broadcast; end
2031
- def ns_signal; end
2032
- def ns_wait(timeout = T.unsafe(nil)); end
2033
- def ns_wait_until(timeout = T.unsafe(nil), &condition); end
2034
- def signal; end
2035
- def wait(timeout = T.unsafe(nil)); end
2036
- def wait_until(timeout = T.unsafe(nil), &condition); end
2037
-
2038
- class << self
2039
- def private_new(*args, &block); end
2040
- end
2041
- end
2042
-
2043
- module Concurrent::Synchronization::ConditionSignalling
2044
- protected
2045
-
2046
- def ns_broadcast; end
2047
- def ns_signal; end
2048
- end
2049
-
2050
- class Concurrent::Synchronization::Lock < ::Concurrent::Synchronization::LockableObject
2051
- def broadcast; end
2052
- def signal; end
2053
- def wait(timeout = T.unsafe(nil)); end
2054
- def wait_until(timeout = T.unsafe(nil), &condition); end
2055
- end
2056
-
2057
- class Concurrent::Synchronization::LockableObject < ::Concurrent::Synchronization::MutexLockableObject
2058
- def new_condition; end
2059
- end
2060
-
2061
- Concurrent::Synchronization::LockableObjectImplementation = Concurrent::Synchronization::MutexLockableObject
2062
-
2063
- class Concurrent::Synchronization::MonitorLockableObject < ::Concurrent::Synchronization::AbstractLockableObject
2064
- include ::Concurrent::Synchronization::ConditionSignalling
2065
-
2066
- def initialize(*defaults); end
2067
-
2068
- protected
2069
-
2070
- def ns_wait(timeout = T.unsafe(nil)); end
2071
- def synchronize; end
2072
-
2073
- private
2074
-
2075
- def initialize_copy(other); end
2076
-
2077
- class << self
2078
- def new(*args, &block); end
2079
- end
2080
- end
2081
-
2082
- module Concurrent::Synchronization::MriAttrVolatile
2083
- mixes_in_class_methods ::Concurrent::Synchronization::MriAttrVolatile::ClassMethods
2084
-
2085
- def full_memory_barrier; end
2086
-
2087
- class << self
2088
- def included(base); end
2089
- end
2090
- end
2091
-
2092
- module Concurrent::Synchronization::MriAttrVolatile::ClassMethods
2093
- def attr_volatile(*names); end
2094
- end
2095
-
2096
- class Concurrent::Synchronization::MriObject < ::Concurrent::Synchronization::AbstractObject
2097
- include ::Concurrent::Synchronization::MriAttrVolatile
2098
- extend ::Concurrent::Synchronization::MriAttrVolatile::ClassMethods
2099
-
2100
- def initialize; end
2101
- end
2102
-
2103
- class Concurrent::Synchronization::MutexLockableObject < ::Concurrent::Synchronization::AbstractLockableObject
2104
- include ::Concurrent::Synchronization::ConditionSignalling
2105
-
2106
- def initialize(*defaults); end
2107
-
2108
- protected
2109
-
2110
- def ns_wait(timeout = T.unsafe(nil)); end
2111
- def synchronize; end
2112
-
2113
- private
2114
-
2115
- def initialize_copy(other); end
2116
-
2117
- class << self
2118
- def new(*args, &block); end
2119
- end
2120
- end
2121
-
2122
- class Concurrent::Synchronization::Object < ::Concurrent::Synchronization::MriObject
2123
- def initialize; end
2124
-
2125
- private
2126
-
2127
- def __initialize_atomic_fields__; end
2128
-
2129
- class << self
2130
- def atomic_attribute?(name); end
2131
- def atomic_attributes(inherited = T.unsafe(nil)); end
2132
- def attr_atomic(*names); end
2133
- def ensure_safe_initialization_when_final_fields_are_present; end
2134
- def safe_initialization!; end
2135
- def safe_initialization?; end
2136
-
2137
- private
2138
-
2139
- def define_initialize_atomic_fields; end
2140
- end
2141
- end
2142
-
2143
- Concurrent::Synchronization::ObjectImplementation = Concurrent::Synchronization::MriObject
2144
-
2145
- module Concurrent::Synchronization::RbxAttrVolatile
2146
- mixes_in_class_methods ::Concurrent::Synchronization::RbxAttrVolatile::ClassMethods
2147
-
2148
- def full_memory_barrier; end
2149
-
2150
- class << self
2151
- def included(base); end
2152
- end
2153
- end
2154
-
2155
- module Concurrent::Synchronization::RbxAttrVolatile::ClassMethods
2156
- def attr_volatile(*names); end
2157
- end
2158
-
2159
- class Concurrent::Synchronization::RbxLockableObject < ::Concurrent::Synchronization::AbstractLockableObject
2160
- def initialize(*defaults); end
2161
-
2162
- protected
2163
-
2164
- def ns_broadcast; end
2165
- def ns_signal; end
2166
- def ns_wait(timeout = T.unsafe(nil)); end
2167
- def synchronize(&block); end
2168
-
2169
- private
2170
-
2171
- def initialize_copy(other); end
2172
-
2173
- class << self
2174
- def new(*args, &block); end
2175
- end
2176
- end
2177
-
2178
- class Concurrent::Synchronization::RbxObject < ::Concurrent::Synchronization::AbstractObject
2179
- include ::Concurrent::Synchronization::RbxAttrVolatile
2180
- extend ::Concurrent::Synchronization::RbxAttrVolatile::ClassMethods
2181
-
2182
- def initialize; end
2183
- end
2184
-
2185
- module Concurrent::Synchronization::TruffleRubyAttrVolatile
2186
- mixes_in_class_methods ::Concurrent::Synchronization::TruffleRubyAttrVolatile::ClassMethods
2187
-
2188
- def full_memory_barrier; end
2189
-
2190
- class << self
2191
- def included(base); end
2192
- end
2193
- end
2194
-
2195
- module Concurrent::Synchronization::TruffleRubyAttrVolatile::ClassMethods
2196
- def attr_volatile(*names); end
2197
- end
2198
-
2199
- class Concurrent::Synchronization::TruffleRubyObject < ::Concurrent::Synchronization::AbstractObject
2200
- include ::Concurrent::Synchronization::TruffleRubyAttrVolatile
2201
- extend ::Concurrent::Synchronization::TruffleRubyAttrVolatile::ClassMethods
2202
-
2203
- def initialize; end
2204
- end
2205
-
2206
- Concurrent::Synchronization::Volatile = Concurrent::Synchronization::MriAttrVolatile
2207
-
2208
- class Concurrent::SynchronizedDelegator < ::SimpleDelegator
2209
- def initialize(obj); end
2210
-
2211
- def method_missing(method, *args, &block); end
2212
- def setup; end
2213
- def teardown; end
2214
- end
2215
-
2216
- class Concurrent::TVar < ::Concurrent::Synchronization::Object
2217
- def initialize(value); end
2218
-
2219
- def unsafe_increment_version; end
2220
- def unsafe_lock; end
2221
- def unsafe_value; end
2222
- def unsafe_value=(value); end
2223
- def unsafe_version; end
2224
- def value; end
2225
- def value=(value); end
2226
-
2227
- class << self
2228
- def new(*args, &block); end
2229
- end
2230
- end
2231
-
2232
- class Concurrent::ThreadLocalVar < ::Concurrent::RubyThreadLocalVar; end
2233
- Concurrent::ThreadLocalVarImplementation = Concurrent::RubyThreadLocalVar
2234
- class Concurrent::ThreadPoolExecutor < ::Concurrent::RubyThreadPoolExecutor; end
2235
- Concurrent::ThreadPoolExecutorImplementation = Concurrent::RubyThreadPoolExecutor
2236
- module Concurrent::ThreadSafe; end
2237
-
2238
- module Concurrent::ThreadSafe::Util
2239
- class << self
2240
- def make_synchronized_on_cruby(klass); end
2241
- def make_synchronized_on_rbx(klass); end
2242
- def make_synchronized_on_truffleruby(klass); end
2243
- end
2244
- end
2245
-
2246
- Concurrent::ThreadSafe::Util::CPU_COUNT = T.let(T.unsafe(nil), Integer)
2247
- Concurrent::ThreadSafe::Util::FIXNUM_BIT_SIZE = T.let(T.unsafe(nil), Integer)
2248
- Concurrent::ThreadSafe::Util::MAX_INT = T.let(T.unsafe(nil), Integer)
2249
- class Concurrent::TimeoutError < ::Concurrent::Error; end
2250
-
2251
- class Concurrent::TimerSet < ::Concurrent::RubyExecutorService
2252
- def initialize(opts = T.unsafe(nil)); end
2253
-
2254
- def kill; end
2255
- def post(delay, *args, &task); end
2256
-
2257
- private
2258
-
2259
- def ns_initialize(opts); end
2260
- def ns_post_task(task); end
2261
- def ns_reset_if_forked; end
2262
- def ns_shutdown_execution; end
2263
- def post_task(task); end
2264
- def process_tasks; end
2265
- def remove_task(task); end
2266
- end
2267
-
2268
- class Concurrent::TimerTask < ::Concurrent::RubyExecutorService
2269
- include ::Concurrent::Concern::Dereferenceable
2270
- include ::Concurrent::Concern::Observable
2271
-
2272
- def initialize(opts = T.unsafe(nil), &task); end
2273
-
2274
- def execute; end
2275
- def execution_interval; end
2276
- def execution_interval=(value); end
2277
- def running?; end
2278
- def timeout_interval; end
2279
- def timeout_interval=(value); end
2280
-
2281
- private
2282
-
2283
- def execute_task(completion); end
2284
- def ns_initialize(opts, &task); end
2285
- def ns_kill_execution; end
2286
- def ns_shutdown_execution; end
2287
- def schedule_next_task(interval = T.unsafe(nil)); end
2288
- def timeout_task(completion); end
2289
-
2290
- class << self
2291
- def execute(opts = T.unsafe(nil), &task); end
2292
- end
2293
- end
2294
-
2295
- Concurrent::TimerTask::EXECUTION_INTERVAL = T.let(T.unsafe(nil), Integer)
2296
- Concurrent::TimerTask::TIMEOUT_INTERVAL = T.let(T.unsafe(nil), Integer)
2297
-
2298
- class Concurrent::Transaction
2299
- def initialize; end
2300
-
2301
- def abort; end
2302
- def commit; end
2303
- def read(tvar); end
2304
- def unlock; end
2305
- def valid?; end
2306
- def write(tvar, value); end
2307
-
2308
- class << self
2309
- def current; end
2310
- def current=(transaction); end
2311
- end
2312
- end
2313
-
2314
- Concurrent::Transaction::ABORTED = T.let(T.unsafe(nil), Object)
2315
- class Concurrent::Transaction::AbortError < ::StandardError; end
2316
- class Concurrent::Transaction::LeaveError < ::StandardError; end
2317
-
2318
- class Concurrent::Transaction::ReadLogEntry < ::Struct
2319
- def tvar; end
2320
- def tvar=(_); end
2321
- def version; end
2322
- def version=(_); end
2323
-
2324
- class << self
2325
- def [](*_arg0); end
2326
- def inspect; end
2327
- def members; end
2328
- def new(*_arg0); end
2329
- end
2330
- end
2331
-
2332
- class Concurrent::Tuple
2333
- include ::Enumerable
2334
-
2335
- def initialize(size); end
2336
-
2337
- def cas(i, old_value, new_value); end
2338
- def compare_and_set(i, old_value, new_value); end
2339
- def each; end
2340
- def get(i); end
2341
- def set(i, value); end
2342
- def size; end
2343
- def volatile_get(i); end
2344
- def volatile_set(i, value); end
2345
- end
2346
-
2347
- Concurrent::Tuple::Tuple = Array
2348
- module Concurrent::Utility; end
2349
-
2350
- module Concurrent::Utility::EngineDetector
2351
- def on_cruby?; end
2352
- def on_jruby?; end
2353
- def on_jruby_9000?; end
2354
- def on_linux?; end
2355
- def on_osx?; end
2356
- def on_rbx?; end
2357
- def on_truffleruby?; end
2358
- def on_windows?; end
2359
- def ruby_engine; end
2360
- def ruby_version(version = T.unsafe(nil), comparison, major, minor, patch); end
2361
- end
2362
-
2363
- module Concurrent::Utility::NativeExtensionLoader
2364
- def allow_c_extensions?; end
2365
- def c_extensions_loaded?; end
2366
- def java_extensions_loaded?; end
2367
- def load_native_extensions; end
2368
-
2369
- private
2370
-
2371
- def load_error_path(error); end
2372
- def set_c_extensions_loaded; end
2373
- def set_java_extensions_loaded; end
2374
- def try_load_c_extension(path); end
2375
- end
2376
-
2377
- module Concurrent::Utility::NativeInteger
2378
- extend ::Concurrent::Utility::NativeInteger
2379
-
2380
- def ensure_integer(value); end
2381
- def ensure_integer_and_bounds(value); end
2382
- def ensure_lower_bound(value); end
2383
- def ensure_positive(value); end
2384
- def ensure_positive_and_no_zero(value); end
2385
- def ensure_upper_bound(value); end
2386
- end
2387
-
2388
- Concurrent::Utility::NativeInteger::MAX_VALUE = T.let(T.unsafe(nil), Integer)
2389
- Concurrent::Utility::NativeInteger::MIN_VALUE = T.let(T.unsafe(nil), Integer)
2390
-
2391
- class Concurrent::Utility::ProcessorCounter
2392
- def initialize; end
2393
-
2394
- def physical_processor_count; end
2395
- def processor_count; end
2396
-
2397
- private
2398
-
2399
- def compute_physical_processor_count; end
2400
- def compute_processor_count; end
2401
- end
2402
-
2403
- Concurrent::VERSION = T.let(T.unsafe(nil), String)