constree 0.1.6 → 0.1.7
Sign up to get free protection for your applications and to get access to all the features.
- checksums.yaml +4 -4
- data/README.md +479 -12
- data/lib/constree/node.rb +20 -5
- data/lib/constree/version.rb +1 -1
- metadata +3 -3
checksums.yaml
CHANGED
@@ -1,7 +1,7 @@
|
|
1
1
|
---
|
2
2
|
SHA256:
|
3
|
-
metadata.gz:
|
4
|
-
data.tar.gz:
|
3
|
+
metadata.gz: bdccf3b020fb9b2b3a5c599bab8e5acedf62f08b8ed77b7f6afcdb9dbee7e074
|
4
|
+
data.tar.gz: 85c983124f2990e636e60ddddbe05fc19519a11bf3d9a69d63a3b416b35be6b9
|
5
5
|
SHA512:
|
6
|
-
metadata.gz:
|
7
|
-
data.tar.gz:
|
6
|
+
metadata.gz: f4162527720c2ba191a1b8cd7668100c43767e10935d3ec7eba79a77f4b90991d60d0e59390546fd0aa4745cb58cd623d6cd3b05c8ffc1bc7b8b7a22da424b5c
|
7
|
+
data.tar.gz: 1159cfc11945b68a73533552e6f019873da48a42930f1d37b6a42147e031542a366f6c51e2d7bdd5f869661263f6ffa7c1546ee2292f00d59236bf0317d0ae26
|
data/README.md
CHANGED
@@ -21,20 +21,487 @@ Or install it yourself as:
|
|
21
21
|
## Example: constants in Minitest::Spec
|
22
22
|
|
23
23
|
```ruby
|
24
|
-
irb(main):001:0> require
|
24
|
+
irb(main):001:0> require "concurrent-ruby"
|
25
25
|
=> true
|
26
26
|
irb(main):002:0> Constree.p Minitest::Spec
|
27
|
-
|
28
|
-
├─
|
29
|
-
│
|
30
|
-
|
31
|
-
├─
|
32
|
-
├─
|
33
|
-
├─
|
34
|
-
├─
|
35
|
-
├─
|
36
|
-
├─
|
37
|
-
|
27
|
+
Concurrent {:kla=>Module}
|
28
|
+
├─AbstractExchanger {:kla=>Class, :aft=>[Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
|
29
|
+
│ └─ClassMethods {:kla=>Module}
|
30
|
+
├─AbstractExecutorService {:kla=>Class, :aft=>[Concurrent::Concern::Deprecation, Concurrent::ExecutorService, Concurrent::Concern::Logging, Logger::Severity, Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
|
31
|
+
│ ├─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
|
32
|
+
│ ├─DEBUG {:kla=>Integer}
|
33
|
+
│ ├─ERROR {:kla=>Integer}
|
34
|
+
│ ├─FALLBACK_POLICIES {:kla=>Array}
|
35
|
+
│ ├─FATAL {:kla=>Integer}
|
36
|
+
│ ├─INFO {:kla=>Integer}
|
37
|
+
│ ├─UNKNOWN {:kla=>Integer}
|
38
|
+
│ └─WARN {:kla=>Integer}
|
39
|
+
├─AbstractThreadLocalVar {:kla=>Class, :aft=>[Object, Kernel, BasicObject]}
|
40
|
+
├─Agent {:kla=>Class, :aft=>[Concurrent::Concern::Observable, Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
|
41
|
+
│ ├─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
|
42
|
+
│ ├─Error {:kla=>Class, :aft=>[StandardError, Exception, Object, Kernel, BasicObject]}
|
43
|
+
│ └─ValidationError {:kla=>Class, :aft=>[Concurrent::Agent::Error, StandardError, Exception, Object, Kernel, BasicObject]}
|
44
|
+
├─Array {:kla=>Class, :aft=>[Array, Enumerable, Object, Kernel, BasicObject]}
|
45
|
+
├─Async {:kla=>Module}
|
46
|
+
├─Atom {:kla=>Class, :aft=>[Concurrent::Concern::Observable, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
|
47
|
+
│ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
|
48
|
+
├─AtomicBoolean {:kla=>Class, :aft=>[Concurrent::MutexAtomicBoolean, Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
|
49
|
+
│ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
|
50
|
+
├─AtomicDirectUpdate {:kla=>Module}
|
51
|
+
├─AtomicFixnum {:kla=>Class, :aft=>[Concurrent::MutexAtomicFixnum, Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
|
52
|
+
│ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
|
53
|
+
├─AtomicMarkableReference {:kla=>Class, :aft=>[Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
|
54
|
+
│ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
|
55
|
+
├─AtomicNumericCompareAndSetWrapper {:kla=>Module}
|
56
|
+
├─AtomicReference {:kla=>Class, :aft=>[Concurrent::MutexAtomicReference, Concurrent::AtomicNumericCompareAndSetWrapper, Concurrent::AtomicDirectUpdate, Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
|
57
|
+
│ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
|
58
|
+
├─CRubySet {:kla=>Class, :aft=>[Set, Enumerable, Object, Kernel, BasicObject]}
|
59
|
+
│ └─InspectKey {:kla=>Symbol}
|
60
|
+
├─CachedThreadPool {:kla=>Class, :aft=>[Concurrent::ThreadPoolExecutor, Concurrent::RubyThreadPoolExecutor, Concurrent::RubyExecutorService, Concurrent::AbstractExecutorService, Concurrent::Concern::Deprecation, Concurrent::ExecutorService, Concurrent::Concern::Logging, Logger::Severity, Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
|
61
|
+
│ ├─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
|
62
|
+
│ ├─DEBUG {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
|
63
|
+
│ ├─DEFAULT_MAX_POOL_SIZE {:kla=>Integer}
|
64
|
+
│ ├─DEFAULT_MAX_QUEUE_SIZE {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
|
65
|
+
│ ├─DEFAULT_MIN_POOL_SIZE {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
|
66
|
+
│ ├─DEFAULT_SYNCHRONOUS {:kla=>FalseClass}
|
67
|
+
│ ├─DEFAULT_THREAD_IDLETIMEOUT {:kla=>Integer}
|
68
|
+
│ ├─ERROR {:ref=>"Concurrent::AbstractExecutorService::ERROR"}
|
69
|
+
│ ├─FALLBACK_POLICIES {:ref=>"Concurrent::AbstractExecutorService::FALLBACK_POLICIES"}
|
70
|
+
│ ├─FATAL {:ref=>"Concurrent::AbstractExecutorService::FATAL"}
|
71
|
+
│ ├─INFO {:ref=>"Concurrent::AbstractExecutorService::INFO"}
|
72
|
+
│ ├─UNKNOWN {:ref=>"Concurrent::AbstractExecutorService::UNKNOWN"}
|
73
|
+
│ └─WARN {:ref=>"Concurrent::AbstractExecutorService::WARN"}
|
74
|
+
├─CancelledOperationError {:kla=>Class, :aft=>[Concurrent::Error, StandardError, Exception, Object, Kernel, BasicObject]}
|
75
|
+
├─Collection {:kla=>Module}
|
76
|
+
│ ├─CopyOnNotifyObserverSet {:kla=>Class, :aft=>[Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
|
77
|
+
│ │ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
|
78
|
+
│ ├─CopyOnWriteObserverSet {:kla=>Class, :aft=>[Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
|
79
|
+
│ │ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
|
80
|
+
│ ├─MapImplementation {:kla=>Class, :aft=>[Concurrent::Collection::NonConcurrentMapBackend, Object, Kernel, BasicObject]}
|
81
|
+
│ ├─MriMapBackend {:ref=>"Concurrent::Collection::MapImplementation"}
|
82
|
+
│ ├─NonConcurrentMapBackend {:kla=>Class, :aft=>[Object, Kernel, BasicObject]}
|
83
|
+
│ ├─NonConcurrentPriorityQueue {:kla=>Class, :aft=>[Concurrent::Collection::RubyNonConcurrentPriorityQueue, Object, Kernel, BasicObject]}
|
84
|
+
│ └─RubyNonConcurrentPriorityQueue {:kla=>Class, :aft=>[Object, Kernel, BasicObject]}
|
85
|
+
├─Concern {:kla=>Module}
|
86
|
+
│ ├─Deprecation {:kla=>Module, :aft=>[Concurrent::Concern::Logging, Logger::Severity]}
|
87
|
+
│ │ ├─DEBUG {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
|
88
|
+
│ │ ├─ERROR {:ref=>"Concurrent::AbstractExecutorService::ERROR"}
|
89
|
+
│ │ ├─FATAL {:ref=>"Concurrent::AbstractExecutorService::FATAL"}
|
90
|
+
│ │ ├─INFO {:ref=>"Concurrent::AbstractExecutorService::INFO"}
|
91
|
+
│ │ ├─UNKNOWN {:ref=>"Concurrent::AbstractExecutorService::UNKNOWN"}
|
92
|
+
│ │ └─WARN {:ref=>"Concurrent::AbstractExecutorService::WARN"}
|
93
|
+
│ ├─Dereferenceable {:kla=>Module}
|
94
|
+
│ ├─Logging {:kla=>Module, :aft=>[Logger::Severity]}
|
95
|
+
│ │ ├─DEBUG {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
|
96
|
+
│ │ ├─ERROR {:ref=>"Concurrent::AbstractExecutorService::ERROR"}
|
97
|
+
│ │ ├─FATAL {:ref=>"Concurrent::AbstractExecutorService::FATAL"}
|
98
|
+
│ │ ├─INFO {:ref=>"Concurrent::AbstractExecutorService::INFO"}
|
99
|
+
│ │ ├─UNKNOWN {:ref=>"Concurrent::AbstractExecutorService::UNKNOWN"}
|
100
|
+
│ │ └─WARN {:ref=>"Concurrent::AbstractExecutorService::WARN"}
|
101
|
+
│ ├─Obligation {:kla=>Module, :aft=>[Concurrent::Concern::Dereferenceable]}
|
102
|
+
│ └─Observable {:kla=>Module}
|
103
|
+
├─ConcurrentUpdateError {:kla=>Class, :aft=>[ThreadError, StandardError, Exception, Object, Kernel, BasicObject]}
|
104
|
+
│ └─CONC_UP_ERR_BACKTRACE {:kla=>Array}
|
105
|
+
├─ConfigurationError {:kla=>Class, :aft=>[Concurrent::Error, StandardError, Exception, Object, Kernel, BasicObject]}
|
106
|
+
├─CountDownLatch {:kla=>Class, :aft=>[Concurrent::MutexCountDownLatch, Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
|
107
|
+
│ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
|
108
|
+
├─CyclicBarrier {:kla=>Class, :aft=>[Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
|
109
|
+
│ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
|
110
|
+
├─Delay {:kla=>Class, :aft=>[Concurrent::Concern::Obligation, Concurrent::Concern::Dereferenceable, Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
|
111
|
+
│ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
|
112
|
+
├─DependencyCounter {:kla=>Class, :aft=>[Object, Kernel, BasicObject]}
|
113
|
+
├─Error {:kla=>Class, :aft=>[StandardError, Exception, Object, Kernel, BasicObject]}
|
114
|
+
├─Event {:kla=>Class, :aft=>[Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
|
115
|
+
│ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
|
116
|
+
├─Exchanger {:kla=>Class, :aft=>[Concurrent::RubyExchanger, Concurrent::AbstractExchanger, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
|
117
|
+
│ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
|
118
|
+
├─ExecutorService {:kla=>Module, :aft=>[Concurrent::Concern::Logging, Logger::Severity]}
|
119
|
+
│ ├─DEBUG {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
|
120
|
+
│ ├─ERROR {:ref=>"Concurrent::AbstractExecutorService::ERROR"}
|
121
|
+
│ ├─FATAL {:ref=>"Concurrent::AbstractExecutorService::FATAL"}
|
122
|
+
│ ├─INFO {:ref=>"Concurrent::AbstractExecutorService::INFO"}
|
123
|
+
│ ├─UNKNOWN {:ref=>"Concurrent::AbstractExecutorService::UNKNOWN"}
|
124
|
+
│ └─WARN {:ref=>"Concurrent::AbstractExecutorService::WARN"}
|
125
|
+
├─FixedThreadPool {:kla=>Class, :aft=>[Concurrent::ThreadPoolExecutor, Concurrent::RubyThreadPoolExecutor, Concurrent::RubyExecutorService, Concurrent::AbstractExecutorService, Concurrent::Concern::Deprecation, Concurrent::ExecutorService, Concurrent::Concern::Logging, Logger::Severity, Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
|
126
|
+
│ ├─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
|
127
|
+
│ ├─DEBUG {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
|
128
|
+
│ ├─DEFAULT_MAX_POOL_SIZE {:ref=>"Concurrent::CachedThreadPool::DEFAULT_MAX_POOL_SIZE"}
|
129
|
+
│ ├─DEFAULT_MAX_QUEUE_SIZE {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
|
130
|
+
│ ├─DEFAULT_MIN_POOL_SIZE {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
|
131
|
+
│ ├─DEFAULT_SYNCHRONOUS {:ref=>"Concurrent::CachedThreadPool::DEFAULT_SYNCHRONOUS"}
|
132
|
+
│ ├─DEFAULT_THREAD_IDLETIMEOUT {:ref=>"Concurrent::CachedThreadPool::DEFAULT_THREAD_IDLETIMEOUT"}
|
133
|
+
│ ├─ERROR {:ref=>"Concurrent::AbstractExecutorService::ERROR"}
|
134
|
+
│ ├─FALLBACK_POLICIES {:ref=>"Concurrent::AbstractExecutorService::FALLBACK_POLICIES"}
|
135
|
+
│ ├─FATAL {:ref=>"Concurrent::AbstractExecutorService::FATAL"}
|
136
|
+
│ ├─INFO {:ref=>"Concurrent::AbstractExecutorService::INFO"}
|
137
|
+
│ ├─UNKNOWN {:ref=>"Concurrent::AbstractExecutorService::UNKNOWN"}
|
138
|
+
│ └─WARN {:ref=>"Concurrent::AbstractExecutorService::WARN"}
|
139
|
+
├─Future {:kla=>Class, :aft=>[Concurrent::IVar, Concurrent::Concern::Observable, Concurrent::Concern::Obligation, Concurrent::Concern::Dereferenceable, Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
|
140
|
+
│ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
|
141
|
+
├─Hash {:kla=>Class, :aft=>[Hash, Enumerable, Object, Kernel, BasicObject]}
|
142
|
+
├─IVar {:kla=>Class, :aft=>[Concurrent::Concern::Observable, Concurrent::Concern::Obligation, Concurrent::Concern::Dereferenceable, Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
|
143
|
+
│ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
|
144
|
+
├─IllegalOperationError {:kla=>Class, :aft=>[Concurrent::Error, StandardError, Exception, Object, Kernel, BasicObject]}
|
145
|
+
├─ImmediateExecutor {:kla=>Class, :aft=>[Concurrent::SerialExecutorService, Concurrent::AbstractExecutorService, Concurrent::Concern::Deprecation, Concurrent::ExecutorService, Concurrent::Concern::Logging, Logger::Severity, Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
|
146
|
+
│ ├─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
|
147
|
+
│ ├─DEBUG {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
|
148
|
+
│ ├─ERROR {:ref=>"Concurrent::AbstractExecutorService::ERROR"}
|
149
|
+
│ ├─FALLBACK_POLICIES {:ref=>"Concurrent::AbstractExecutorService::FALLBACK_POLICIES"}
|
150
|
+
│ ├─FATAL {:ref=>"Concurrent::AbstractExecutorService::FATAL"}
|
151
|
+
│ ├─INFO {:ref=>"Concurrent::AbstractExecutorService::INFO"}
|
152
|
+
│ ├─UNKNOWN {:ref=>"Concurrent::AbstractExecutorService::UNKNOWN"}
|
153
|
+
│ └─WARN {:ref=>"Concurrent::AbstractExecutorService::WARN"}
|
154
|
+
├─ImmutabilityError {:kla=>Class, :aft=>[Concurrent::Error, StandardError, Exception, Object, Kernel, BasicObject]}
|
155
|
+
├─ImmutableStruct {:kla=>Module, :aft=>[Concurrent::Synchronization::AbstractStruct]}
|
156
|
+
├─IndirectImmediateExecutor {:kla=>Class, :aft=>[Concurrent::ImmediateExecutor, Concurrent::SerialExecutorService, Concurrent::AbstractExecutorService, Concurrent::Concern::Deprecation, Concurrent::ExecutorService, Concurrent::Concern::Logging, Logger::Severity, Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
|
157
|
+
│ ├─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
|
158
|
+
│ ├─DEBUG {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
|
159
|
+
│ ├─ERROR {:ref=>"Concurrent::AbstractExecutorService::ERROR"}
|
160
|
+
│ ├─FALLBACK_POLICIES {:ref=>"Concurrent::AbstractExecutorService::FALLBACK_POLICIES"}
|
161
|
+
│ ├─FATAL {:ref=>"Concurrent::AbstractExecutorService::FATAL"}
|
162
|
+
│ ├─INFO {:ref=>"Concurrent::AbstractExecutorService::INFO"}
|
163
|
+
│ ├─UNKNOWN {:ref=>"Concurrent::AbstractExecutorService::UNKNOWN"}
|
164
|
+
│ └─WARN {:ref=>"Concurrent::AbstractExecutorService::WARN"}
|
165
|
+
├─InitializationError {:kla=>Class, :aft=>[Concurrent::Error, StandardError, Exception, Object, Kernel, BasicObject]}
|
166
|
+
├─LifecycleError {:kla=>Class, :aft=>[Concurrent::Error, StandardError, Exception, Object, Kernel, BasicObject]}
|
167
|
+
├─LockFreeStack {:kla=>Class, :aft=>[Enumerable, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
|
168
|
+
│ ├─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
|
169
|
+
│ ├─EMPTY {:kla=>Concurrent::LockFreeStack::Node}
|
170
|
+
│ └─Node {:kla=>Class, :aft=>[Object, Kernel, BasicObject]}
|
171
|
+
├─MVar {:kla=>Class, :aft=>[Concurrent::Concern::Dereferenceable, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
|
172
|
+
│ ├─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
|
173
|
+
│ ├─EMPTY {:kla=>Object}
|
174
|
+
│ └─TIMEOUT {:kla=>Object}
|
175
|
+
├─Map {:kla=>Class, :aft=>[Concurrent::Collection::MriMapBackend, Concurrent::Collection::NonConcurrentMapBackend, Object, Kernel, BasicObject]}
|
176
|
+
├─MaxRestartFrequencyError {:kla=>Class, :aft=>[Concurrent::Error, StandardError, Exception, Object, Kernel, BasicObject]}
|
177
|
+
├─Maybe {:kla=>Class, :aft=>[Comparable, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
|
178
|
+
│ ├─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
|
179
|
+
│ └─NONE {:kla=>Object}
|
180
|
+
├─MultipleAssignmentError {:kla=>Class, :aft=>[Concurrent::Error, StandardError, Exception, Object, Kernel, BasicObject]}
|
181
|
+
├─MultipleErrors {:kla=>Class, :aft=>[Concurrent::Error, StandardError, Exception, Object, Kernel, BasicObject]}
|
182
|
+
├─MutableStruct {:kla=>Module, :aft=>[Concurrent::Synchronization::AbstractStruct]}
|
183
|
+
├─MutexAtomicBoolean {:kla=>Class, :aft=>[Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
|
184
|
+
│ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
|
185
|
+
├─MutexAtomicFixnum {:kla=>Class, :aft=>[Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
|
186
|
+
│ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
|
187
|
+
├─MutexAtomicReference {:kla=>Class, :aft=>[Concurrent::AtomicNumericCompareAndSetWrapper, Concurrent::AtomicDirectUpdate, Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
|
188
|
+
│ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
|
189
|
+
├─MutexCountDownLatch {:kla=>Class, :aft=>[Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
|
190
|
+
│ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
|
191
|
+
├─MutexSemaphore {:kla=>Class, :aft=>[Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
|
192
|
+
│ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
|
193
|
+
├─NULL {:kla=>Object}
|
194
|
+
├─NULL_LOGGER {:kla=>Proc}
|
195
|
+
├─Options {:kla=>Module}
|
196
|
+
├─Promise {:kla=>Class, :aft=>[Concurrent::IVar, Concurrent::Concern::Observable, Concurrent::Concern::Obligation, Concurrent::Concern::Dereferenceable, Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
|
197
|
+
│ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
|
198
|
+
├─PromiseExecutionError {:kla=>Class, :aft=>[StandardError, Exception, Object, Kernel, BasicObject]}
|
199
|
+
├─Promises {:kla=>Module}
|
200
|
+
│ ├─AbstractEventFuture {:kla=>Class, :aft=>[Concurrent::Promises::InternalStates, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
|
201
|
+
│ │ ├─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
|
202
|
+
│ │ ├─Fulfilled {:kla=>Class, :aft=>[Concurrent::Promises::InternalStates::ResolvedWithResult, Concurrent::Promises::InternalStates::State, Object, Kernel, BasicObject]}
|
203
|
+
│ │ ├─FulfilledArray {:kla=>Class, :aft=>[Concurrent::Promises::InternalStates::Fulfilled, Concurrent::Promises::InternalStates::ResolvedWithResult, Concurrent::Promises::InternalStates::State, Object, Kernel, BasicObject]}
|
204
|
+
│ │ ├─PENDING {:kla=>Concurrent::Promises::InternalStates::Pending}
|
205
|
+
│ │ ├─PartiallyRejected {:kla=>Class, :aft=>[Concurrent::Promises::InternalStates::ResolvedWithResult, Concurrent::Promises::InternalStates::State, Object, Kernel, BasicObject]}
|
206
|
+
│ │ ├─Pending {:kla=>Class, :aft=>[Concurrent::Promises::InternalStates::State, Object, Kernel, BasicObject]}
|
207
|
+
│ │ ├─RESERVED {:kla=>Concurrent::Promises::InternalStates::Reserved}
|
208
|
+
│ │ ├─RESOLVED {:kla=>Concurrent::Promises::InternalStates::Fulfilled}
|
209
|
+
│ │ ├─Rejected {:kla=>Class, :aft=>[Concurrent::Promises::InternalStates::ResolvedWithResult, Concurrent::Promises::InternalStates::State, Object, Kernel, BasicObject]}
|
210
|
+
│ │ ├─Reserved {:kla=>Class, :aft=>[Concurrent::Promises::InternalStates::Pending, Concurrent::Promises::InternalStates::State, Object, Kernel, BasicObject]}
|
211
|
+
│ │ ├─ResolvedWithResult {:kla=>Class, :aft=>[Concurrent::Promises::InternalStates::State, Object, Kernel, BasicObject]}
|
212
|
+
│ │ └─State {:kla=>Class, :aft=>[Object, Kernel, BasicObject]}
|
213
|
+
│ ├─Event {:kla=>Class, :aft=>[Concurrent::Promises::AbstractEventFuture, Concurrent::Promises::InternalStates, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
|
214
|
+
│ │ ├─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
|
215
|
+
│ │ ├─Fulfilled {:ref=>"Concurrent::Promises::AbstractEventFuture::Fulfilled"}
|
216
|
+
│ │ ├─FulfilledArray {:ref=>"Concurrent::Promises::AbstractEventFuture::FulfilledArray"}
|
217
|
+
│ │ ├─PENDING {:ref=>"Concurrent::Promises::AbstractEventFuture::PENDING"}
|
218
|
+
│ │ ├─PartiallyRejected {:ref=>"Concurrent::Promises::AbstractEventFuture::PartiallyRejected"}
|
219
|
+
│ │ ├─Pending {:ref=>"Concurrent::Promises::AbstractEventFuture::Pending"}
|
220
|
+
│ │ ├─RESERVED {:ref=>"Concurrent::Promises::AbstractEventFuture::RESERVED"}
|
221
|
+
│ │ ├─RESOLVED {:ref=>"Concurrent::Promises::AbstractEventFuture::RESOLVED"}
|
222
|
+
│ │ ├─Rejected {:ref=>"Concurrent::Promises::AbstractEventFuture::Rejected"}
|
223
|
+
│ │ ├─Reserved {:ref=>"Concurrent::Promises::AbstractEventFuture::Reserved"}
|
224
|
+
│ │ ├─ResolvedWithResult {:ref=>"Concurrent::Promises::AbstractEventFuture::ResolvedWithResult"}
|
225
|
+
│ │ └─State {:ref=>"Concurrent::Promises::AbstractEventFuture::State"}
|
226
|
+
│ ├─FactoryMethods {:kla=>Module, :aft=>[Concurrent::Promises::FactoryMethods::Configuration]}
|
227
|
+
│ │ └─Configuration {:kla=>Module}
|
228
|
+
│ ├─Future {:kla=>Class, :aft=>[Concurrent::Promises::AbstractEventFuture, Concurrent::Promises::InternalStates, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
|
229
|
+
│ │ ├─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
|
230
|
+
│ │ ├─Fulfilled {:ref=>"Concurrent::Promises::AbstractEventFuture::Fulfilled"}
|
231
|
+
│ │ ├─FulfilledArray {:ref=>"Concurrent::Promises::AbstractEventFuture::FulfilledArray"}
|
232
|
+
│ │ ├─PENDING {:ref=>"Concurrent::Promises::AbstractEventFuture::PENDING"}
|
233
|
+
│ │ ├─PartiallyRejected {:ref=>"Concurrent::Promises::AbstractEventFuture::PartiallyRejected"}
|
234
|
+
│ │ ├─Pending {:ref=>"Concurrent::Promises::AbstractEventFuture::Pending"}
|
235
|
+
│ │ ├─RESERVED {:ref=>"Concurrent::Promises::AbstractEventFuture::RESERVED"}
|
236
|
+
│ │ ├─RESOLVED {:ref=>"Concurrent::Promises::AbstractEventFuture::RESOLVED"}
|
237
|
+
│ │ ├─Rejected {:ref=>"Concurrent::Promises::AbstractEventFuture::Rejected"}
|
238
|
+
│ │ ├─Reserved {:ref=>"Concurrent::Promises::AbstractEventFuture::Reserved"}
|
239
|
+
│ │ ├─ResolvedWithResult {:ref=>"Concurrent::Promises::AbstractEventFuture::ResolvedWithResult"}
|
240
|
+
│ │ └─State {:ref=>"Concurrent::Promises::AbstractEventFuture::State"}
|
241
|
+
│ ├─Resolvable {:kla=>Module, :aft=>[Concurrent::Promises::InternalStates]}
|
242
|
+
│ │ ├─Fulfilled {:ref=>"Concurrent::Promises::AbstractEventFuture::Fulfilled"}
|
243
|
+
│ │ ├─FulfilledArray {:ref=>"Concurrent::Promises::AbstractEventFuture::FulfilledArray"}
|
244
|
+
│ │ ├─PENDING {:ref=>"Concurrent::Promises::AbstractEventFuture::PENDING"}
|
245
|
+
│ │ ├─PartiallyRejected {:ref=>"Concurrent::Promises::AbstractEventFuture::PartiallyRejected"}
|
246
|
+
│ │ ├─Pending {:ref=>"Concurrent::Promises::AbstractEventFuture::Pending"}
|
247
|
+
│ │ ├─RESERVED {:ref=>"Concurrent::Promises::AbstractEventFuture::RESERVED"}
|
248
|
+
│ │ ├─RESOLVED {:ref=>"Concurrent::Promises::AbstractEventFuture::RESOLVED"}
|
249
|
+
│ │ ├─Rejected {:ref=>"Concurrent::Promises::AbstractEventFuture::Rejected"}
|
250
|
+
│ │ ├─Reserved {:ref=>"Concurrent::Promises::AbstractEventFuture::Reserved"}
|
251
|
+
│ │ ├─ResolvedWithResult {:ref=>"Concurrent::Promises::AbstractEventFuture::ResolvedWithResult"}
|
252
|
+
│ │ └─State {:ref=>"Concurrent::Promises::AbstractEventFuture::State"}
|
253
|
+
│ ├─ResolvableEvent {:kla=>Class, :aft=>[Concurrent::Promises::Resolvable, Concurrent::Promises::Event, Concurrent::Promises::AbstractEventFuture, Concurrent::Promises::InternalStates, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
|
254
|
+
│ │ ├─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
|
255
|
+
│ │ ├─Fulfilled {:ref=>"Concurrent::Promises::AbstractEventFuture::Fulfilled"}
|
256
|
+
│ │ ├─FulfilledArray {:ref=>"Concurrent::Promises::AbstractEventFuture::FulfilledArray"}
|
257
|
+
│ │ ├─PENDING {:ref=>"Concurrent::Promises::AbstractEventFuture::PENDING"}
|
258
|
+
│ │ ├─PartiallyRejected {:ref=>"Concurrent::Promises::AbstractEventFuture::PartiallyRejected"}
|
259
|
+
│ │ ├─Pending {:ref=>"Concurrent::Promises::AbstractEventFuture::Pending"}
|
260
|
+
│ │ ├─RESERVED {:ref=>"Concurrent::Promises::AbstractEventFuture::RESERVED"}
|
261
|
+
│ │ ├─RESOLVED {:ref=>"Concurrent::Promises::AbstractEventFuture::RESOLVED"}
|
262
|
+
│ │ ├─Rejected {:ref=>"Concurrent::Promises::AbstractEventFuture::Rejected"}
|
263
|
+
│ │ ├─Reserved {:ref=>"Concurrent::Promises::AbstractEventFuture::Reserved"}
|
264
|
+
│ │ ├─ResolvedWithResult {:ref=>"Concurrent::Promises::AbstractEventFuture::ResolvedWithResult"}
|
265
|
+
│ │ └─State {:ref=>"Concurrent::Promises::AbstractEventFuture::State"}
|
266
|
+
│ └─ResolvableFuture {:kla=>Class, :aft=>[Concurrent::Promises::Resolvable, Concurrent::Promises::Future, Concurrent::Promises::AbstractEventFuture, Concurrent::Promises::InternalStates, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
|
267
|
+
│ ├─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
|
268
|
+
│ ├─Fulfilled {:ref=>"Concurrent::Promises::AbstractEventFuture::Fulfilled"}
|
269
|
+
│ ├─FulfilledArray {:ref=>"Concurrent::Promises::AbstractEventFuture::FulfilledArray"}
|
270
|
+
│ ├─PENDING {:ref=>"Concurrent::Promises::AbstractEventFuture::PENDING"}
|
271
|
+
│ ├─PartiallyRejected {:ref=>"Concurrent::Promises::AbstractEventFuture::PartiallyRejected"}
|
272
|
+
│ ├─Pending {:ref=>"Concurrent::Promises::AbstractEventFuture::Pending"}
|
273
|
+
│ ├─RESERVED {:ref=>"Concurrent::Promises::AbstractEventFuture::RESERVED"}
|
274
|
+
│ ├─RESOLVED {:ref=>"Concurrent::Promises::AbstractEventFuture::RESOLVED"}
|
275
|
+
│ ├─Rejected {:ref=>"Concurrent::Promises::AbstractEventFuture::Rejected"}
|
276
|
+
│ ├─Reserved {:ref=>"Concurrent::Promises::AbstractEventFuture::Reserved"}
|
277
|
+
│ ├─ResolvedWithResult {:ref=>"Concurrent::Promises::AbstractEventFuture::ResolvedWithResult"}
|
278
|
+
│ └─State {:ref=>"Concurrent::Promises::AbstractEventFuture::State"}
|
279
|
+
├─ReInclude {:kla=>Module}
|
280
|
+
├─ReadWriteLock {:kla=>Class, :aft=>[Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
|
281
|
+
│ ├─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
|
282
|
+
│ ├─MAX_READERS {:kla=>Integer}
|
283
|
+
│ ├─MAX_WRITERS {:kla=>Integer}
|
284
|
+
│ ├─RUNNING_WRITER {:kla=>Integer}
|
285
|
+
│ └─WAITING_WRITER {:kla=>Integer}
|
286
|
+
├─ReentrantReadWriteLock {:kla=>Class, :aft=>[Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
|
287
|
+
│ ├─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
|
288
|
+
│ ├─MAX_READERS {:ref=>"Concurrent::ReadWriteLock::MAX_READERS"}
|
289
|
+
│ ├─MAX_WRITERS {:ref=>"Concurrent::ReadWriteLock::MAX_WRITERS"}
|
290
|
+
│ ├─READER_BITS {:kla=>Integer}
|
291
|
+
│ ├─READ_LOCK_MASK {:ref=>"Concurrent::ReadWriteLock::MAX_READERS"}
|
292
|
+
│ ├─RUNNING_WRITER {:ref=>"Concurrent::ReadWriteLock::RUNNING_WRITER"}
|
293
|
+
│ ├─WAITING_WRITER {:ref=>"Concurrent::ReadWriteLock::WAITING_WRITER"}
|
294
|
+
│ ├─WRITER_BITS {:kla=>Integer}
|
295
|
+
│ ├─WRITE_LOCK_HELD {:ref=>"Concurrent::ReadWriteLock::WAITING_WRITER"}
|
296
|
+
│ └─WRITE_LOCK_MASK {:ref=>"Concurrent::ReadWriteLock::MAX_WRITERS"}
|
297
|
+
├─RejectedExecutionError {:kla=>Class, :aft=>[Concurrent::Error, StandardError, Exception, Object, Kernel, BasicObject]}
|
298
|
+
├─ResourceLimitError {:kla=>Class, :aft=>[Concurrent::Error, StandardError, Exception, Object, Kernel, BasicObject]}
|
299
|
+
├─RubyExchanger {:kla=>Class, :aft=>[Concurrent::AbstractExchanger, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
|
300
|
+
│ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
|
301
|
+
├─RubyExecutorService {:kla=>Class, :aft=>[Concurrent::AbstractExecutorService, Concurrent::Concern::Deprecation, Concurrent::ExecutorService, Concurrent::Concern::Logging, Logger::Severity, Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
|
302
|
+
│ ├─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
|
303
|
+
│ ├─DEBUG {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
|
304
|
+
│ ├─ERROR {:ref=>"Concurrent::AbstractExecutorService::ERROR"}
|
305
|
+
│ ├─FALLBACK_POLICIES {:ref=>"Concurrent::AbstractExecutorService::FALLBACK_POLICIES"}
|
306
|
+
│ ├─FATAL {:ref=>"Concurrent::AbstractExecutorService::FATAL"}
|
307
|
+
│ ├─INFO {:ref=>"Concurrent::AbstractExecutorService::INFO"}
|
308
|
+
│ ├─UNKNOWN {:ref=>"Concurrent::AbstractExecutorService::UNKNOWN"}
|
309
|
+
│ └─WARN {:ref=>"Concurrent::AbstractExecutorService::WARN"}
|
310
|
+
├─RubySingleThreadExecutor {:kla=>Class, :aft=>[Concurrent::RubyThreadPoolExecutor, Concurrent::RubyExecutorService, Concurrent::AbstractExecutorService, Concurrent::Concern::Deprecation, Concurrent::ExecutorService, Concurrent::Concern::Logging, Logger::Severity, Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
|
311
|
+
│ ├─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
|
312
|
+
│ ├─DEBUG {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
|
313
|
+
│ ├─DEFAULT_MAX_POOL_SIZE {:ref=>"Concurrent::CachedThreadPool::DEFAULT_MAX_POOL_SIZE"}
|
314
|
+
│ ├─DEFAULT_MAX_QUEUE_SIZE {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
|
315
|
+
│ ├─DEFAULT_MIN_POOL_SIZE {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
|
316
|
+
│ ├─DEFAULT_SYNCHRONOUS {:ref=>"Concurrent::CachedThreadPool::DEFAULT_SYNCHRONOUS"}
|
317
|
+
│ ├─DEFAULT_THREAD_IDLETIMEOUT {:ref=>"Concurrent::CachedThreadPool::DEFAULT_THREAD_IDLETIMEOUT"}
|
318
|
+
│ ├─ERROR {:ref=>"Concurrent::AbstractExecutorService::ERROR"}
|
319
|
+
│ ├─FALLBACK_POLICIES {:ref=>"Concurrent::AbstractExecutorService::FALLBACK_POLICIES"}
|
320
|
+
│ ├─FATAL {:ref=>"Concurrent::AbstractExecutorService::FATAL"}
|
321
|
+
│ ├─INFO {:ref=>"Concurrent::AbstractExecutorService::INFO"}
|
322
|
+
│ ├─UNKNOWN {:ref=>"Concurrent::AbstractExecutorService::UNKNOWN"}
|
323
|
+
│ └─WARN {:ref=>"Concurrent::AbstractExecutorService::WARN"}
|
324
|
+
├─RubyThreadLocalVar {:kla=>Class, :aft=>[Concurrent::AbstractThreadLocalVar, Object, Kernel, BasicObject]}
|
325
|
+
├─RubyThreadPoolExecutor {:kla=>Class, :aft=>[Concurrent::RubyExecutorService, Concurrent::AbstractExecutorService, Concurrent::Concern::Deprecation, Concurrent::ExecutorService, Concurrent::Concern::Logging, Logger::Severity, Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
|
326
|
+
│ ├─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
|
327
|
+
│ ├─DEBUG {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
|
328
|
+
│ ├─DEFAULT_MAX_POOL_SIZE {:ref=>"Concurrent::CachedThreadPool::DEFAULT_MAX_POOL_SIZE"}
|
329
|
+
│ ├─DEFAULT_MAX_QUEUE_SIZE {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
|
330
|
+
│ ├─DEFAULT_MIN_POOL_SIZE {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
|
331
|
+
│ ├─DEFAULT_SYNCHRONOUS {:ref=>"Concurrent::CachedThreadPool::DEFAULT_SYNCHRONOUS"}
|
332
|
+
│ ├─DEFAULT_THREAD_IDLETIMEOUT {:ref=>"Concurrent::CachedThreadPool::DEFAULT_THREAD_IDLETIMEOUT"}
|
333
|
+
│ ├─ERROR {:ref=>"Concurrent::AbstractExecutorService::ERROR"}
|
334
|
+
│ ├─FALLBACK_POLICIES {:ref=>"Concurrent::AbstractExecutorService::FALLBACK_POLICIES"}
|
335
|
+
│ ├─FATAL {:ref=>"Concurrent::AbstractExecutorService::FATAL"}
|
336
|
+
│ ├─INFO {:ref=>"Concurrent::AbstractExecutorService::INFO"}
|
337
|
+
│ ├─UNKNOWN {:ref=>"Concurrent::AbstractExecutorService::UNKNOWN"}
|
338
|
+
│ └─WARN {:ref=>"Concurrent::AbstractExecutorService::WARN"}
|
339
|
+
├─SafeTaskExecutor {:kla=>Class, :aft=>[Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
|
340
|
+
│ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
|
341
|
+
├─ScheduledTask {:kla=>Class, :aft=>[Comparable, Concurrent::IVar, Concurrent::Concern::Observable, Concurrent::Concern::Obligation, Concurrent::Concern::Dereferenceable, Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
|
342
|
+
│ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
|
343
|
+
├─Semaphore {:kla=>Class, :aft=>[Concurrent::MutexSemaphore, Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
|
344
|
+
│ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
|
345
|
+
├─SerialExecutorService {:kla=>Module, :aft=>[Concurrent::ExecutorService, Concurrent::Concern::Logging, Logger::Severity]}
|
346
|
+
│ ├─DEBUG {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
|
347
|
+
│ ├─ERROR {:ref=>"Concurrent::AbstractExecutorService::ERROR"}
|
348
|
+
│ ├─FATAL {:ref=>"Concurrent::AbstractExecutorService::FATAL"}
|
349
|
+
│ ├─INFO {:ref=>"Concurrent::AbstractExecutorService::INFO"}
|
350
|
+
│ ├─UNKNOWN {:ref=>"Concurrent::AbstractExecutorService::UNKNOWN"}
|
351
|
+
│ └─WARN {:ref=>"Concurrent::AbstractExecutorService::WARN"}
|
352
|
+
├─SerializedExecution {:kla=>Class, :aft=>[Concurrent::Concern::Logging, Logger::Severity, Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
|
353
|
+
│ ├─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
|
354
|
+
│ ├─DEBUG {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
|
355
|
+
│ ├─ERROR {:ref=>"Concurrent::AbstractExecutorService::ERROR"}
|
356
|
+
│ ├─FATAL {:ref=>"Concurrent::AbstractExecutorService::FATAL"}
|
357
|
+
│ ├─INFO {:ref=>"Concurrent::AbstractExecutorService::INFO"}
|
358
|
+
│ ├─Job {:kla=>Class, :aft=>[Struct, Enumerable, Object, Kernel, BasicObject]}
|
359
|
+
│ │ ├─Group {:kla=>Class, :aft=>[Struct, Enumerable, Object, Kernel, BasicObject]}
|
360
|
+
│ │ │ ├─Group {:ref=>"Concurrent::SerializedExecution::Job::Group"}
|
361
|
+
│ │ │ ├─Passwd {:kla=>Class, :aft=>[Struct, Enumerable, Object, Kernel, BasicObject]}
|
362
|
+
│ │ │ │ ├─Group {:ref=>"Concurrent::SerializedExecution::Job::Group"}
|
363
|
+
│ │ │ │ ├─Passwd {:ref=>"Concurrent::SerializedExecution::Job::Group::Passwd"}
|
364
|
+
│ │ │ │ └─Tms {:kla=>Class, :aft=>[Struct, Enumerable, Object, Kernel, BasicObject]}
|
365
|
+
│ │ │ │ ├─Group {:ref=>"Concurrent::SerializedExecution::Job::Group"}
|
366
|
+
│ │ │ │ ├─Passwd {:ref=>"Concurrent::SerializedExecution::Job::Group::Passwd"}
|
367
|
+
│ │ │ │ └─Tms {:ref=>"Concurrent::SerializedExecution::Job::Group::Passwd::Tms"}
|
368
|
+
│ │ │ └─Tms {:ref=>"Concurrent::SerializedExecution::Job::Group::Passwd::Tms"}
|
369
|
+
│ │ ├─Passwd {:ref=>"Concurrent::SerializedExecution::Job::Group::Passwd"}
|
370
|
+
│ │ └─Tms {:ref=>"Concurrent::SerializedExecution::Job::Group::Passwd::Tms"}
|
371
|
+
│ ├─UNKNOWN {:ref=>"Concurrent::AbstractExecutorService::UNKNOWN"}
|
372
|
+
│ └─WARN {:ref=>"Concurrent::AbstractExecutorService::WARN"}
|
373
|
+
├─SerializedExecutionDelegator {:kla=>Class, :aft=>[Concurrent::SerialExecutorService, Concurrent::ExecutorService, Concurrent::Concern::Logging, Logger::Severity, SimpleDelegator, Delegator, #<Module:0x00005574e9d301b8>, BasicObject]}
|
374
|
+
│ ├─BasicObject {:kla=>Class}
|
375
|
+
│ │ └─BasicObject {:ref=>"Concurrent::SerializedExecutionDelegator::BasicObject"}
|
376
|
+
│ ├─DEBUG {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
|
377
|
+
│ ├─ERROR {:ref=>"Concurrent::AbstractExecutorService::ERROR"}
|
378
|
+
│ ├─FATAL {:ref=>"Concurrent::AbstractExecutorService::FATAL"}
|
379
|
+
│ ├─INFO {:ref=>"Concurrent::AbstractExecutorService::INFO"}
|
380
|
+
│ ├─RUBYGEMS_ACTIVATION_MONITOR {:kla=>Monitor}
|
381
|
+
│ ├─UNKNOWN {:ref=>"Concurrent::AbstractExecutorService::UNKNOWN"}
|
382
|
+
│ └─WARN {:ref=>"Concurrent::AbstractExecutorService::WARN"}
|
383
|
+
├─Set {:kla=>Class, :aft=>[Concurrent::CRubySet, Set, Enumerable, Object, Kernel, BasicObject]}
|
384
|
+
│ └─InspectKey {:ref=>"Concurrent::CRubySet::InspectKey"}
|
385
|
+
├─SettableStruct {:kla=>Module, :aft=>[Concurrent::Synchronization::AbstractStruct]}
|
386
|
+
├─SimpleExecutorService {:kla=>Class, :aft=>[Concurrent::RubyExecutorService, Concurrent::AbstractExecutorService, Concurrent::Concern::Deprecation, Concurrent::ExecutorService, Concurrent::Concern::Logging, Logger::Severity, Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
|
387
|
+
│ ├─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
|
388
|
+
│ ├─DEBUG {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
|
389
|
+
│ ├─ERROR {:ref=>"Concurrent::AbstractExecutorService::ERROR"}
|
390
|
+
│ ├─FALLBACK_POLICIES {:ref=>"Concurrent::AbstractExecutorService::FALLBACK_POLICIES"}
|
391
|
+
│ ├─FATAL {:ref=>"Concurrent::AbstractExecutorService::FATAL"}
|
392
|
+
│ ├─INFO {:ref=>"Concurrent::AbstractExecutorService::INFO"}
|
393
|
+
│ ├─UNKNOWN {:ref=>"Concurrent::AbstractExecutorService::UNKNOWN"}
|
394
|
+
│ └─WARN {:ref=>"Concurrent::AbstractExecutorService::WARN"}
|
395
|
+
├─SingleThreadExecutor {:kla=>Class, :aft=>[Concurrent::RubySingleThreadExecutor, Concurrent::RubyThreadPoolExecutor, Concurrent::RubyExecutorService, Concurrent::AbstractExecutorService, Concurrent::Concern::Deprecation, Concurrent::ExecutorService, Concurrent::Concern::Logging, Logger::Severity, Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
|
396
|
+
│ ├─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
|
397
|
+
│ ├─DEBUG {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
|
398
|
+
│ ├─DEFAULT_MAX_POOL_SIZE {:ref=>"Concurrent::CachedThreadPool::DEFAULT_MAX_POOL_SIZE"}
|
399
|
+
│ ├─DEFAULT_MAX_QUEUE_SIZE {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
|
400
|
+
│ ├─DEFAULT_MIN_POOL_SIZE {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
|
401
|
+
│ ├─DEFAULT_SYNCHRONOUS {:ref=>"Concurrent::CachedThreadPool::DEFAULT_SYNCHRONOUS"}
|
402
|
+
│ ├─DEFAULT_THREAD_IDLETIMEOUT {:ref=>"Concurrent::CachedThreadPool::DEFAULT_THREAD_IDLETIMEOUT"}
|
403
|
+
│ ├─ERROR {:ref=>"Concurrent::AbstractExecutorService::ERROR"}
|
404
|
+
│ ├─FALLBACK_POLICIES {:ref=>"Concurrent::AbstractExecutorService::FALLBACK_POLICIES"}
|
405
|
+
│ ├─FATAL {:ref=>"Concurrent::AbstractExecutorService::FATAL"}
|
406
|
+
│ ├─INFO {:ref=>"Concurrent::AbstractExecutorService::INFO"}
|
407
|
+
│ ├─UNKNOWN {:ref=>"Concurrent::AbstractExecutorService::UNKNOWN"}
|
408
|
+
│ └─WARN {:ref=>"Concurrent::AbstractExecutorService::WARN"}
|
409
|
+
├─Synchronization {:kla=>Module}
|
410
|
+
│ ├─AbstractLockableObject {:kla=>Class, :aft=>[Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
|
411
|
+
│ │ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
|
412
|
+
│ ├─AbstractObject {:kla=>Class, :aft=>[Object, Kernel, BasicObject]}
|
413
|
+
│ ├─AbstractStruct {:kla=>Module}
|
414
|
+
│ ├─Condition {:kla=>Class, :aft=>[Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
|
415
|
+
│ │ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
|
416
|
+
│ ├─ConditionSignalling {:kla=>Module}
|
417
|
+
│ ├─Lock {:kla=>Class, :aft=>[Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
|
418
|
+
│ │ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
|
419
|
+
│ ├─LockableObject {:kla=>Class, :aft=>[Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
|
420
|
+
│ │ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
|
421
|
+
│ ├─MonitorLockableObject {:kla=>Class, :aft=>[Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
|
422
|
+
│ │ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
|
423
|
+
│ ├─MriAttrVolatile {:kla=>Module}
|
424
|
+
│ │ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
|
425
|
+
│ ├─MriObject {:kla=>Class, :aft=>[Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
|
426
|
+
│ │ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
|
427
|
+
│ ├─MutexLockableObject {:kla=>Class, :aft=>[Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
|
428
|
+
│ │ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
|
429
|
+
│ ├─Object {:kla=>Class, :aft=>[Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
|
430
|
+
│ │ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
|
431
|
+
│ ├─RbxAttrVolatile {:kla=>Module}
|
432
|
+
│ │ └─ClassMethods {:kla=>Module}
|
433
|
+
│ ├─RbxLockableObject {:kla=>Class, :aft=>[Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
|
434
|
+
│ │ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
|
435
|
+
│ ├─RbxObject {:kla=>Class, :aft=>[Concurrent::Synchronization::RbxAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
|
436
|
+
│ │ └─ClassMethods {:ref=>"Concurrent::Synchronization::RbxAttrVolatile::ClassMethods"}
|
437
|
+
│ ├─TruffleRubyAttrVolatile {:kla=>Module}
|
438
|
+
│ │ └─ClassMethods {:kla=>Module}
|
439
|
+
│ ├─TruffleRubyObject {:kla=>Class, :aft=>[Concurrent::Synchronization::TruffleRubyAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
|
440
|
+
│ │ └─ClassMethods {:ref=>"Concurrent::Synchronization::TruffleRubyAttrVolatile::ClassMethods"}
|
441
|
+
│ └─Volatile {:ref=>"Concurrent::Synchronization::MriAttrVolatile"}
|
442
|
+
├─SynchronizedDelegator {:kla=>Class, :aft=>[SimpleDelegator, Delegator, #<Module:0x00005574e9d301b8>, BasicObject]}
|
443
|
+
│ ├─BasicObject {:ref=>"Concurrent::SerializedExecutionDelegator::BasicObject"}
|
444
|
+
│ └─RUBYGEMS_ACTIVATION_MONITOR {:ref=>"Concurrent::SerializedExecutionDelegator::RUBYGEMS_ACTIVATION_MONITOR"}
|
445
|
+
├─TVar {:kla=>Class, :aft=>[Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
|
446
|
+
│ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
|
447
|
+
├─ThreadLocalVar {:kla=>Class, :aft=>[Concurrent::RubyThreadLocalVar, Concurrent::AbstractThreadLocalVar, Object, Kernel, BasicObject]}
|
448
|
+
├─ThreadPoolExecutor {:kla=>Class, :aft=>[Concurrent::RubyThreadPoolExecutor, Concurrent::RubyExecutorService, Concurrent::AbstractExecutorService, Concurrent::Concern::Deprecation, Concurrent::ExecutorService, Concurrent::Concern::Logging, Logger::Severity, Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
|
449
|
+
│ ├─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
|
450
|
+
│ ├─DEBUG {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
|
451
|
+
│ ├─DEFAULT_MAX_POOL_SIZE {:ref=>"Concurrent::CachedThreadPool::DEFAULT_MAX_POOL_SIZE"}
|
452
|
+
│ ├─DEFAULT_MAX_QUEUE_SIZE {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
|
453
|
+
│ ├─DEFAULT_MIN_POOL_SIZE {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
|
454
|
+
│ ├─DEFAULT_SYNCHRONOUS {:ref=>"Concurrent::CachedThreadPool::DEFAULT_SYNCHRONOUS"}
|
455
|
+
│ ├─DEFAULT_THREAD_IDLETIMEOUT {:ref=>"Concurrent::CachedThreadPool::DEFAULT_THREAD_IDLETIMEOUT"}
|
456
|
+
│ ├─ERROR {:ref=>"Concurrent::AbstractExecutorService::ERROR"}
|
457
|
+
│ ├─FALLBACK_POLICIES {:ref=>"Concurrent::AbstractExecutorService::FALLBACK_POLICIES"}
|
458
|
+
│ ├─FATAL {:ref=>"Concurrent::AbstractExecutorService::FATAL"}
|
459
|
+
│ ├─INFO {:ref=>"Concurrent::AbstractExecutorService::INFO"}
|
460
|
+
│ ├─UNKNOWN {:ref=>"Concurrent::AbstractExecutorService::UNKNOWN"}
|
461
|
+
│ └─WARN {:ref=>"Concurrent::AbstractExecutorService::WARN"}
|
462
|
+
├─ThreadSafe {:kla=>Module}
|
463
|
+
│ └─Util {:kla=>Module}
|
464
|
+
│ ├─CPU_COUNT {:kla=>Integer}
|
465
|
+
│ ├─FIXNUM_BIT_SIZE {:kla=>Integer}
|
466
|
+
│ └─MAX_INT {:kla=>Integer}
|
467
|
+
├─TimeoutError {:kla=>Class, :aft=>[Concurrent::Error, StandardError, Exception, Object, Kernel, BasicObject]}
|
468
|
+
├─TimerSet {:kla=>Class, :aft=>[Concurrent::RubyExecutorService, Concurrent::AbstractExecutorService, Concurrent::Concern::Deprecation, Concurrent::ExecutorService, Concurrent::Concern::Logging, Logger::Severity, Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
|
469
|
+
│ ├─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
|
470
|
+
│ ├─DEBUG {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
|
471
|
+
│ ├─ERROR {:ref=>"Concurrent::AbstractExecutorService::ERROR"}
|
472
|
+
│ ├─FALLBACK_POLICIES {:ref=>"Concurrent::AbstractExecutorService::FALLBACK_POLICIES"}
|
473
|
+
│ ├─FATAL {:ref=>"Concurrent::AbstractExecutorService::FATAL"}
|
474
|
+
│ ├─INFO {:ref=>"Concurrent::AbstractExecutorService::INFO"}
|
475
|
+
│ ├─UNKNOWN {:ref=>"Concurrent::AbstractExecutorService::UNKNOWN"}
|
476
|
+
│ └─WARN {:ref=>"Concurrent::AbstractExecutorService::WARN"}
|
477
|
+
├─TimerTask {:kla=>Class, :aft=>[Concurrent::Concern::Observable, Concurrent::Concern::Dereferenceable, Concurrent::RubyExecutorService, Concurrent::AbstractExecutorService, Concurrent::Concern::Deprecation, Concurrent::ExecutorService, Concurrent::Concern::Logging, Logger::Severity, Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
|
478
|
+
│ ├─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
|
479
|
+
│ ├─DEBUG {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
|
480
|
+
│ ├─ERROR {:ref=>"Concurrent::AbstractExecutorService::ERROR"}
|
481
|
+
│ ├─EXECUTION_INTERVAL {:ref=>"Concurrent::CachedThreadPool::DEFAULT_THREAD_IDLETIMEOUT"}
|
482
|
+
│ ├─FALLBACK_POLICIES {:ref=>"Concurrent::AbstractExecutorService::FALLBACK_POLICIES"}
|
483
|
+
│ ├─FATAL {:ref=>"Concurrent::AbstractExecutorService::FATAL"}
|
484
|
+
│ ├─INFO {:ref=>"Concurrent::AbstractExecutorService::INFO"}
|
485
|
+
│ ├─TIMEOUT_INTERVAL {:kla=>Integer}
|
486
|
+
│ ├─UNKNOWN {:ref=>"Concurrent::AbstractExecutorService::UNKNOWN"}
|
487
|
+
│ └─WARN {:ref=>"Concurrent::AbstractExecutorService::WARN"}
|
488
|
+
├─Transaction {:kla=>Class, :aft=>[Object, Kernel, BasicObject]}
|
489
|
+
│ ├─ABORTED {:kla=>Object}
|
490
|
+
│ ├─AbortError {:kla=>Class, :aft=>[StandardError, Exception, Object, Kernel, BasicObject]}
|
491
|
+
│ ├─LeaveError {:kla=>Class, :aft=>[StandardError, Exception, Object, Kernel, BasicObject]}
|
492
|
+
│ └─OpenEntry {:kla=>Class, :aft=>[Struct, Enumerable, Object, Kernel, BasicObject]}
|
493
|
+
│ ├─Group {:ref=>"Concurrent::SerializedExecution::Job::Group"}
|
494
|
+
│ ├─Passwd {:ref=>"Concurrent::SerializedExecution::Job::Group::Passwd"}
|
495
|
+
│ └─Tms {:ref=>"Concurrent::SerializedExecution::Job::Group::Passwd::Tms"}
|
496
|
+
├─Tuple {:kla=>Class, :aft=>[Enumerable, Object, Kernel, BasicObject]}
|
497
|
+
├─Utility {:kla=>Module}
|
498
|
+
│ ├─EngineDetector {:kla=>Module}
|
499
|
+
│ ├─NativeExtensionLoader {:kla=>Module}
|
500
|
+
│ ├─NativeInteger {:kla=>Module}
|
501
|
+
│ │ ├─MAX_VALUE {:ref=>"Concurrent::ThreadSafe::Util::MAX_INT"}
|
502
|
+
│ │ └─MIN_VALUE {:kla=>Integer}
|
503
|
+
│ └─ProcessorCounter {:kla=>Class, :aft=>[Object, Kernel, BasicObject]}
|
504
|
+
└─VERSION {:kla=>String}
|
38
505
|
=> nil
|
39
506
|
```
|
40
507
|
|
data/lib/constree/node.rb
CHANGED
@@ -6,7 +6,7 @@ module Constree
|
|
6
6
|
include TreeGraph
|
7
7
|
|
8
8
|
def label_for_tree_graph
|
9
|
-
display_name
|
9
|
+
"#{display_name} #{verbose}"
|
10
10
|
end
|
11
11
|
|
12
12
|
def children_for_tree_graph
|
@@ -17,8 +17,9 @@ module Constree
|
|
17
17
|
|
18
18
|
def sub_nodes
|
19
19
|
return [] unless constant.is_a? Module
|
20
|
-
constant.constants.map do |name|
|
21
|
-
|
20
|
+
constant.constants.sort!.map! do |name|
|
21
|
+
const_value = constant.const_get(name)
|
22
|
+
Node.new(const_value, name, self)
|
22
23
|
end
|
23
24
|
end
|
24
25
|
|
@@ -39,8 +40,22 @@ module Constree
|
|
39
40
|
constant == other.constant
|
40
41
|
end
|
41
42
|
|
42
|
-
def
|
43
|
-
|
43
|
+
def verbose
|
44
|
+
return {ref: ref.full_name} if ref
|
45
|
+
|
46
|
+
info = {kla: constant.class}
|
47
|
+
return info unless constant.is_a? Module
|
48
|
+
|
49
|
+
ancestors = constant.ancestors
|
50
|
+
idx = ancestors.index(constant)
|
51
|
+
if idx > 0 && !(before = ancestors[0 .. (idx - 1)]).empty?
|
52
|
+
info[:bef] = before
|
53
|
+
end
|
54
|
+
unless (after = ancestors[(idx + 1) .. -1]).empty?
|
55
|
+
info[:aft] = after
|
56
|
+
end
|
57
|
+
|
58
|
+
info
|
44
59
|
end
|
45
60
|
|
46
61
|
def not_yet? seen
|
data/lib/constree/version.rb
CHANGED
metadata
CHANGED
@@ -1,14 +1,14 @@
|
|
1
1
|
--- !ruby/object:Gem::Specification
|
2
2
|
name: constree
|
3
3
|
version: !ruby/object:Gem::Version
|
4
|
-
version: 0.1.
|
4
|
+
version: 0.1.7
|
5
5
|
platform: ruby
|
6
6
|
authors:
|
7
7
|
- ken
|
8
8
|
autorequire:
|
9
9
|
bindir: exe
|
10
10
|
cert_chain: []
|
11
|
-
date:
|
11
|
+
date: 2022-12-10 00:00:00.000000000 Z
|
12
12
|
dependencies:
|
13
13
|
- !ruby/object:Gem::Dependency
|
14
14
|
name: bundler
|
@@ -106,7 +106,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
|
|
106
106
|
- !ruby/object:Gem::Version
|
107
107
|
version: '0'
|
108
108
|
requirements: []
|
109
|
-
rubygems_version: 3.
|
109
|
+
rubygems_version: 3.1.6
|
110
110
|
signing_key:
|
111
111
|
specification_version: 4
|
112
112
|
summary: recursively show the structure of constants in a module
|