25 | "License" shall mean the terms and conditions for use, reproduction,
26 | and distribution as defined by Sections 1 through 9 of this document.
27 |
28 |
29 |
30 | "Licensor" shall mean the copyright owner or entity authorized by
31 | the copyright owner that is granting the License.
32 |
33 |
34 |
35 | "Legal Entity" shall mean the union of the acting entity and all
36 | other entities that control, are controlled by, or are under common
37 | control with that entity. For the purposes of this definition,
38 | "control" means (i) the power, direct or indirect, to cause the
39 | direction or management of such entity, whether by contract or
40 | otherwise, or (ii) ownership of fifty percent (50%) or more of the
41 | outstanding shares, or (iii) beneficial ownership of such entity.
42 |
43 |
44 |
45 | "You" (or "Your") shall mean an individual or Legal Entity
46 | exercising permissions granted by this License.
47 |
48 |
49 |
50 | "Source" form shall mean the preferred form for making modifications,
51 | including but not limited to software source code, documentation
52 | source, and configuration files.
53 |
54 |
55 |
56 | "Object" form shall mean any form resulting from mechanical
57 | transformation or translation of a Source form, including but
58 | not limited to compiled object code, generated documentation,
59 | and conversions to other media types.
60 |
61 |
62 |
63 | "Work" shall mean the work of authorship, whether in Source or
64 | Object form, made available under the License, as indicated by a
65 | copyright notice that is included in or attached to the work
66 | (an example is provided in the Appendix below).
67 |
68 |
69 |
70 | "Derivative Works" shall mean any work, whether in Source or Object
71 | form, that is based on (or derived from) the Work and for which the
72 | editorial revisions, annotations, elaborations, or other modifications
73 | represent, as a whole, an original work of authorship. For the purposes
74 | of this License, Derivative Works shall not include works that remain
75 | separable from, or merely link (or bind by name) to the interfaces of,
76 | the Work and Derivative Works thereof.
77 |
78 |
79 |
80 | "Contribution" shall mean any work of authorship, including
81 | the original version of the Work and any modifications or additions
82 | to that Work or Derivative Works thereof, that is intentionally
83 | submitted to Licensor for inclusion in the Work by the copyright owner
84 | or by an individual or Legal Entity authorized to submit on behalf of
85 | the copyright owner. For the purposes of this definition, "submitted"
86 | means any form of electronic, verbal, or written communication sent
87 | to the Licensor or its representatives, including but not limited to
88 | communication on electronic mailing lists, source code control systems,
89 | and issue tracking systems that are managed by, or on behalf of, the
90 | Licensor for the purpose of discussing and improving the Work, but
91 | excluding communication that is conspicuously marked or otherwise
92 | designated in writing by the copyright owner as "Not a Contribution."
93 |
94 |
95 |
96 | "Contributor" shall mean Licensor and any individual or Legal Entity
97 | on behalf of whom a Contribution has been received by Licensor and
98 | subsequently incorporated within the Work.
99 |
100 |
101 |
2. Grant of Copyright License.
102 | Subject to the terms and conditions of
103 | this License, each Contributor hereby grants to You a perpetual,
104 | worldwide, non-exclusive, no-charge, royalty-free, irrevocable
105 | copyright license to reproduce, prepare Derivative Works of,
106 | publicly display, publicly perform, sublicense, and distribute the
107 | Work and such Derivative Works in Source or Object form.
108 |
109 |
110 |
3. Grant of Patent License.
111 | Subject to the terms and conditions of
112 | this License, each Contributor hereby grants to You a perpetual,
113 | worldwide, non-exclusive, no-charge, royalty-free, irrevocable
114 | (except as stated in this section) patent license to make, have made,
115 | use, offer to sell, sell, import, and otherwise transfer the Work,
116 | where such license applies only to those patent claims licensable
117 | by such Contributor that are necessarily infringed by their
118 | Contribution(s) alone or by combination of their Contribution(s)
119 | with the Work to which such Contribution(s) was submitted. If You
120 | institute patent litigation against any entity (including a
121 | cross-claim or counterclaim in a lawsuit) alleging that the Work
122 | or a Contribution incorporated within the Work constitutes direct
123 | or contributory patent infringement, then any patent licenses
124 | granted to You under this License for that Work shall terminate
125 | as of the date such litigation is filed.
126 |
127 |
128 |
4. Redistribution.
129 | You may reproduce and distribute copies of the
130 | Work or Derivative Works thereof in any medium, with or without
131 | modifications, and in Source or Object form, provided that You
132 | meet the following conditions:
133 |
134 |
135 |
You must give any other recipients of the Work or
136 | Derivative Works a copy of this License; and
137 |
138 |
139 |
You must cause any modified files to carry prominent notices
140 | stating that You changed the files; and
141 |
142 |
143 |
You must retain, in the Source form of any Derivative Works
144 | that You distribute, all copyright, patent, trademark, and
145 | attribution notices from the Source form of the Work,
146 | excluding those notices that do not pertain to any part of
147 | the Derivative Works; and
148 |
149 |
150 |
If the Work includes a "NOTICE" text file as part of its
151 | distribution, then any Derivative Works that You distribute must
152 | include a readable copy of the attribution notices contained
153 | within such NOTICE file, excluding those notices that do not
154 | pertain to any part of the Derivative Works, in at least one
155 | of the following places: within a NOTICE text file distributed
156 | as part of the Derivative Works; within the Source form or
157 | documentation, if provided along with the Derivative Works; or,
158 | within a display generated by the Derivative Works, if and
159 | wherever such third-party notices normally appear. The contents
160 | of the NOTICE file are for informational purposes only and
161 | do not modify the License. You may add Your own attribution
162 | notices within Derivative Works that You distribute, alongside
163 | or as an addendum to the NOTICE text from the Work, provided
164 | that such additional attribution notices cannot be construed
165 | as modifying the License.
166 |
167 |
168 | You may add Your own copyright statement to Your modifications and
169 | may provide additional or different license terms and conditions
170 | for use, reproduction, or distribution of Your modifications, or
171 | for any such Derivative Works as a whole, provided Your use,
172 | reproduction, and distribution of the Work otherwise complies with
173 | the conditions stated in this License.
174 |
175 |
5. Submission of Contributions.
176 | Unless You explicitly state otherwise,
177 | any Contribution intentionally submitted for inclusion in the Work
178 | by You to the Licensor shall be under the terms and conditions of
179 | this License, without any additional terms or conditions.
180 | Notwithstanding the above, nothing herein shall supersede or modify
181 | the terms of any separate license agreement you may have executed
182 | with Licensor regarding such Contributions.
183 |
184 |
185 |
6. Trademarks.
186 | This License does not grant permission to use the trade
187 | names, trademarks, service marks, or product names of the Licensor,
188 | except as required for reasonable and customary use in describing the
189 | origin of the Work and reproducing the content of the NOTICE file.
190 |
191 |
192 |
7. Disclaimer of Warranty.
193 | Unless required by applicable law or
194 | agreed to in writing, Licensor provides the Work (and each
195 | Contributor provides its Contributions) on an "AS IS" BASIS,
196 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
197 | implied, including, without limitation, any warranties or conditions
198 | of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
199 | PARTICULAR PURPOSE. You are solely responsible for determining the
200 | appropriateness of using or redistributing the Work and assume any
201 | risks associated with Your exercise of permissions under this License.
202 |
203 |
204 |
8. Limitation of Liability.
205 | In no event and under no legal theory,
206 | whether in tort (including negligence), contract, or otherwise,
207 | unless required by applicable law (such as deliberate and grossly
208 | negligent acts) or agreed to in writing, shall any Contributor be
209 | liable to You for damages, including any direct, indirect, special,
210 | incidental, or consequential damages of any character arising as a
211 | result of this License or out of the use or inability to use the
212 | Work (including but not limited to damages for loss of goodwill,
213 | work stoppage, computer failure or malfunction, or any and all
214 | other commercial damages or losses), even if such Contributor
215 | has been advised of the possibility of such damages.
216 |
217 |
218 |
9. Accepting Warranty or Additional Liability.
219 | While redistributing
220 | the Work or Derivative Works thereof, You may choose to offer,
221 | and charge a fee for, acceptance of support, warranty, indemnity,
222 | or other liability obligations and/or rights consistent with this
223 | License. However, in accepting such obligations, You may act only
224 | on Your own behalf and on Your sole responsibility, not on behalf
225 | of any other Contributor, and only if You agree to indemnify,
226 | defend, and hold each Contributor harmless for any liability
227 | incurred by, or claims asserted against, such Contributor by reason
228 | of your accepting any such warranty or additional liability.
229 |
230 |
231 |
232 | END OF TERMS AND CONDITIONS
233 |
234 |
235 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | About
2 | =============================
3 |
4 | This is a Java port of a concurrent trie hash map implementation from the Scala collections library. It is almost a line-by-line
5 | conversion from Scala to Java.
6 |
7 | Idea + implementation techniques can be found in these reports written by Aleksandar Prokopec:
8 | * http://infoscience.epfl.ch/record/166908/files/ctries-techreport.pdf - this is a nice introduction to Ctries, along with a correctness proof
9 | * http://lamp.epfl.ch/~prokopec/ctries-snapshot.pdf - a more up-to-date writeup which describes the snapshot operation
10 |
11 | The original Scala implementation can be found here and is a part of scala.collection.concurrent:
12 | * [Scala implementation](https://github.com/scala/scala/blob/930c85d6c96507d798d1847ea078eebf93dc0acb/src/library/scala/collection/concurrent/TrieMap.scala)
13 |
14 | Some of the tests and implementation details were borrowed from this project:
15 | * https://github.com/flegall/concurrent-hash-trie
16 |
17 | Implementation status :
18 | * The given implementation is complete and implements all features of the original Scala implementation including support for
19 | snapshots.
20 | * Wherever necessary, code was adapted to be more easily usable in Java, e.g. it returns Objects instead of Option as
21 | many methods of Scala's collections do.
22 | * This class implements all the ConcurrentMap & Iterator methods and passes all the tests. Can be used as a drop-in replacement
23 | for usual Java maps, including ConcurrentHashMap.
24 |
25 |
26 | What is a concurrent trie hash map also known as ctrie?
27 | ========================================================
28 | ctrie is a lock-Free Concurrent Hash Array Mapped Trie.
29 |
30 | A concurrent hash-trie or Ctrie is a concurrent thread-safe lock-free implementation of a hash array mapped trie.
31 |
32 | It is used to implement the concurrent map abstraction. It has particularly scalable concurrent insert and remove operations
33 | and is memory-efficient.
34 |
35 | It supports O(1), atomic, lock-free snapshots which are used to implement linearizable lock-free size, iterator and clear operations.
36 | The cost of evaluating the (lazy) snapshot is distributed across subsequent updates, thus making snapshot evaluation horizontally scalable.
37 |
38 | The original Scala-based implementation of the Ctrie is a part of the Scala standard library since the version 2.10.
39 |
40 | More info about Ctries:
41 |
42 | - http://infoscience.epfl.ch/record/166908/files/ctries-techreport.pdf - this is a nice introduction to Ctries, along with a correctness proof
43 | - http://lamp.epfl.ch/~prokopec/ctries-snapshot.pdf - a more up-to-date writeup (more coherent with the current version of the code) which describes the snapshot operation
44 |
45 |
46 | License
47 | ===============================
48 |
49 | This library is licensed under the Apache 2.0 license.
50 |
51 |
52 | Usage
53 | ===============================
54 |
55 | Usage of this library is very simple. Simply import the class com.romix.scala.collection.concurrent.TrieMap and use it as a usual Map.
56 |
57 | import com.romix.scala.collection.concurrent.TrieMap;
58 |
59 | Map myMap = new TrieMap ();
60 | myMap.put("key", "value");
61 |
62 |
63 | Building the library
64 | ===============================
65 |
66 | Use a usual `mvn clean install`
67 |
68 | Using the library with Maven projects
69 | =====================================
70 | The prebuilt binaries of the library are available from Maven central. Please use the following dependency in your POM files:
71 |
72 |
73 | com.github.romix
74 | java-concurrent-hash-trie-map
75 | 0.2.23
76 |
77 |
78 |
79 | External dependencies
80 | =====================================
81 | This library is self-contained. It does not depend on any additional libraries. In particular, it does not require the rather big Scala's
82 | standard library to be used.
83 |
84 |
--------------------------------------------------------------------------------
/pom.xml:
--------------------------------------------------------------------------------
1 |
2 | 4.0.0
3 |
4 | org.sonatype.oss
5 | oss-parent
6 | 7
7 |
8 | com.github.romix
9 | java-concurrent-hash-trie-map
10 | 0.2.24-SNAPSHOT
11 | TrieMap
12 | Java implementation of a concurrent trie hash map from Scala collections library
13 | bundle
14 | https://github.com/romix/java-concurrent-hash-trie-map
15 |
16 |
17 | The Apache Software License, Version 2.0
18 | http://www.apache.org/licenses/LICENSE-2.0.txt
19 | repo
20 |
21 |
22 |
23 | https://github.com/romix/java-concurrent-hash-trie-map
24 | scm:git:https://github.com/romix/java-concurrent-hash-trie-map.git
25 | scm:git:https://github.com/romix/java-concurrent-hash-trie-map.git
26 | HEAD
27 |
28 |
29 |
30 | romix
31 | Roman Levenstein
32 | romixlev@gmail.com
33 |
34 |
35 |
36 |
37 |
38 | org.apache.maven.plugins
39 | maven-compiler-plugin
40 | 2.3.2
41 |
42 | 1.6
43 | 1.6
44 | iso8859-1
45 |
46 |
47 |
48 | org.apache.maven.plugins
49 | maven-release-plugin
50 | 2.5
51 |
52 |
53 | pom.xml
54 |
55 |
56 |
57 |
58 | org.apache.felix
59 | maven-bundle-plugin
60 | 2.4.0
61 | true
62 |
63 |
64 | ${project.groupId}.${project.artifactId}
65 |
66 |
67 |
68 |
69 |
70 |
71 |
72 | junit
73 | junit
74 | 4.9
75 | test
76 |
77 |
78 |
79 |
80 | sonatype-nexus-staging
81 | Nexus Staging Repository
82 | https://oss.sonatype.org/service/local/staging/deploy/maven2/
83 |
84 |
85 | sonatype-nexus-snapshots
86 | Nexus Snapshots Repository
87 | https://oss.sonatype.org/content/repositories/snapshots/
88 |
89 |
90 |
91 |
--------------------------------------------------------------------------------
/src/main/java/com/romix/scala/None.java:
--------------------------------------------------------------------------------
1 | package com.romix.scala;
2 |
3 | /**
4 | * Mimic None in Scala
5 | *
6 | * @author Roman Levenstein
7 | *
8 | * @param
9 | */
10 | public class None extends Option{
11 |
12 | }
13 |
--------------------------------------------------------------------------------
/src/main/java/com/romix/scala/Option.java:
--------------------------------------------------------------------------------
1 | package com.romix.scala;
2 |
3 | /**
4 | * Mimic Option in Scala
5 | *
6 | * @author Roman Levenstein
7 | *
8 | * @param
9 | */
10 | @SuppressWarnings({"rawtypes", "unchecked"})
11 | public class Option {
12 | private static final None NONE = new None();
13 | public static Option makeOption(V o){
14 | return o != null ? new Some(o) : NONE;
15 | }
16 |
17 | public static Option makeOption(){
18 | return NONE;
19 | }
20 | public boolean nonEmpty () {
21 | return false;
22 | }
23 | }
24 |
--------------------------------------------------------------------------------
/src/main/java/com/romix/scala/Some.java:
--------------------------------------------------------------------------------
1 | package com.romix.scala;
2 |
3 | /**
4 | * Mimic Some in Scala
5 | *
6 | * @author Roman Levenstein
7 | *
8 | * @param
9 | */
10 | public class Some extends Option{
11 | final V value;
12 | public Some(V v) {
13 | value = v;
14 | }
15 |
16 | public V get() {
17 | return value;
18 | }
19 |
20 | public boolean nonEmpty () {
21 | return value != null;
22 | }
23 | }
24 |
--------------------------------------------------------------------------------
/src/main/java/com/romix/scala/collection/concurrent/BasicNode.java:
--------------------------------------------------------------------------------
1 | /* __ *\
2 | ** ________ ___ / / ___ Scala API **
3 | ** / __/ __// _ | / / / _ | (c) 2003-2012, LAMP/EPFL **
4 | ** __\ \/ /__/ __ |/ /__/ __ | http://scala-lang.org/ **
5 | ** /____/\___/_/ |_/____/_/ | | **
6 | ** |/ **
7 | \* */
8 |
9 | package com.romix.scala.collection.concurrent;
10 |
11 |
12 |
13 |
14 |
15 |
16 | abstract class BasicNode {
17 |
18 | public abstract String string(int lev);
19 |
20 | }
--------------------------------------------------------------------------------
/src/main/java/com/romix/scala/collection/concurrent/CNodeBase.java:
--------------------------------------------------------------------------------
1 | /* __ *\
2 | ** ________ ___ / / ___ Scala API **
3 | ** / __/ __// _ | / / / _ | (c) 2003-2012, LAMP/EPFL **
4 | ** __\ \/ /__/ __ |/ /__/ __ | http://scala-lang.org/ **
5 | ** /____/\___/_/ |_/____/_/ | | **
6 | ** |/ **
7 | \* */
8 |
9 | package com.romix.scala.collection.concurrent;
10 |
11 |
12 |
13 | import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
14 |
15 |
16 |
17 | abstract class CNodeBase extends MainNode {
18 |
19 | @SuppressWarnings("rawtypes")
20 | private static final AtomicIntegerFieldUpdater UPDATER = AtomicIntegerFieldUpdater.newUpdater(CNodeBase.class, "csize");
21 |
22 | private volatile int csize = -1;
23 |
24 | public boolean CAS_SIZE(int oldval, int nval) {
25 | return UPDATER.compareAndSet(this, oldval, nval);
26 | }
27 |
28 | public void WRITE_SIZE(int nval) {
29 | UPDATER.set(this, nval);
30 | }
31 |
32 | public int READ_SIZE() {
33 | return csize;
34 | }
35 |
36 | }
--------------------------------------------------------------------------------
/src/main/java/com/romix/scala/collection/concurrent/Gen.java:
--------------------------------------------------------------------------------
1 | /* __ *\
2 | ** ________ ___ / / ___ Scala API **
3 | ** / __/ __// _ | / / / _ | (c) 2003-2012, LAMP/EPFL **
4 | ** __\ \/ /__/ __ |/ /__/ __ | http://scala-lang.org/ **
5 | ** /____/\___/_/ |_/____/_/ | | **
6 | ** |/ **
7 | \* */
8 |
9 | package com.romix.scala.collection.concurrent;
10 |
11 |
12 |
13 |
14 |
15 |
16 | final class Gen {
17 | }
--------------------------------------------------------------------------------
/src/main/java/com/romix/scala/collection/concurrent/INodeBase.java:
--------------------------------------------------------------------------------
1 | /* __ *\
2 | ** ________ ___ / / ___ Scala API **
3 | ** / __/ __// _ | / / / _ | (c) 2003-2012, LAMP/EPFL **
4 | ** __\ \/ /__/ __ |/ /__/ __ | http://scala-lang.org/ **
5 | ** /____/\___/_/ |_/____/_/ | | **
6 | ** |/ **
7 | \* */
8 |
9 | package com.romix.scala.collection.concurrent;
10 |
11 |
12 |
13 | import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;
14 |
15 |
16 |
17 | abstract class INodeBase extends BasicNode {
18 |
19 | public static final AtomicReferenceFieldUpdater updater = AtomicReferenceFieldUpdater.newUpdater(INodeBase.class, MainNode.class, "mainnode");
20 |
21 | public static final Object RESTART = new Object();
22 |
23 | public volatile MainNode mainnode = null;
24 |
25 | public final Gen gen;
26 |
27 | public INodeBase(Gen generation) {
28 | gen = generation;
29 | }
30 |
31 | public BasicNode prev() {
32 | return null;
33 | }
34 |
35 | }
--------------------------------------------------------------------------------
/src/main/java/com/romix/scala/collection/concurrent/ListMap.java:
--------------------------------------------------------------------------------
1 | package com.romix.scala.collection.concurrent;
2 |
3 | import java.util.AbstractMap.SimpleImmutableEntry;
4 | import java.util.Iterator;
5 | import java.util.Map;
6 | import java.util.Map.Entry;
7 |
8 | import com.romix.scala.Option;
9 |
10 | /**
11 | * Mimic immutable ListMap in Scala
12 | *
13 | * @author Roman Levenstein
14 | *
15 | * @param
16 | */
17 | abstract class ListMap {
18 |
19 | ListMap next;
20 |
21 | static ListMap map(K k, V v, ListMap tail){
22 | return new Node (k, v, tail);
23 | }
24 |
25 | static ListMap map(K k, V v){
26 | return new Node (k, v, null);
27 | }
28 |
29 | static ListMap map(K k1, V v1, K k2, V v2){
30 | return new Node (k1, v1, new Node(k2,v2, null));
31 | }
32 |
33 | public abstract int size ();
34 |
35 | public abstract boolean isEmpty() ;
36 |
37 | abstract public boolean contains(K k, V v);
38 |
39 | abstract public boolean contains(K key);
40 |
41 | abstract public Option get (K key);
42 |
43 | abstract public ListMap add (K key, V value);
44 |
45 | abstract public ListMap remove (K key);
46 |
47 | abstract public Iterator> iterator();
48 |
49 |
50 | static class EmptyListMap extends ListMap {
51 | public ListMap add (K key, V value) {
52 | return ListMap.map(key, value, null);
53 | }
54 |
55 | public boolean contains(K k, V v) {
56 | return false;
57 | }
58 |
59 | public boolean contains(K k) {
60 | return false;
61 | }
62 |
63 | public ListMap remove(K key) {
64 | return this;
65 | }
66 |
67 | @Override
68 | public int size () {
69 | return 0;
70 | }
71 |
72 | @Override
73 | public boolean isEmpty () {
74 | return true;
75 | }
76 |
77 | @Override
78 | public Option get (K key) {
79 | return Option.makeOption (null);
80 | }
81 |
82 | @Override
83 | public Iterator> iterator () {
84 | return new EmptyListMapIterator ();
85 | }
86 |
87 | static class EmptyListMapIterator implements Iterator> {
88 |
89 | @Override
90 | public boolean hasNext () {
91 | return false;
92 | }
93 |
94 | @Override
95 | public Entry next () {
96 | return null;
97 | }
98 |
99 | @Override
100 | public void remove () {
101 | throw new RuntimeException("Operation not supported");
102 | }
103 |
104 | }
105 | }
106 |
107 | static class Node extends ListMap {
108 | final K k;
109 | final V v;
110 |
111 | Node(K k, V v, ListMap next) {
112 | this.k = k;
113 | this.v = v;
114 | this.next = next;
115 | }
116 |
117 | public ListMap add (K key, V value) {
118 | return ListMap.map(key, value, remove (key));
119 | }
120 |
121 | public boolean contains(K k, V v) {
122 | if(k.equals (this.k) && v.equals (this.v))
123 | return true;
124 | else if(next != null)
125 | return next.contains (k, v);
126 | return false;
127 | }
128 |
129 | public boolean contains(K k) {
130 | if(k.equals (this.k))
131 | return true;
132 | else if(next != null)
133 | return next.contains (k);
134 | return false;
135 | }
136 |
137 | public ListMap remove(K key) {
138 | if(!contains(key))
139 | return this;
140 | else
141 | return remove0(key);
142 | }
143 |
144 | private ListMap remove0 (K key) {
145 | ListMap n = this;
146 | ListMap newN = null;
147 | ListMap lastN = null;
148 | while (n != null) {
149 | if(n instanceof EmptyListMap) {
150 | newN.next = n;
151 | break;
152 | }
153 | Node nn = (Node)n;
154 | if (key.equals (nn.k)) {
155 | n = n.next;
156 | continue;
157 | } else {
158 | if (newN != null) {
159 | lastN.next = ListMap.map (nn.k, nn.v, null);
160 | lastN = lastN.next;
161 | } else {
162 | newN = ListMap.map (nn.k, nn.v, null);
163 | lastN = newN;
164 | }
165 | }
166 | n = n.next;
167 | }
168 | return newN;
169 | }
170 |
171 | @Override
172 | public int size () {
173 | if(next == null)
174 | return 1;
175 | else
176 | return 1+next.size ();
177 | }
178 |
179 | @Override
180 | public boolean isEmpty () {
181 | return false;
182 | }
183 |
184 | @Override
185 | public Option get (K key) {
186 | if(key.equals (k))
187 | return Option.makeOption (v);
188 | if(next != null)
189 | return next.get (key);
190 | return Option.makeOption (null);
191 | }
192 |
193 |
194 | @Override
195 | public Iterator> iterator () {
196 | return new NodeIterator (this);
197 | }
198 |
199 | static class NodeIterator implements Iterator> {
200 | ListMap n;
201 |
202 | public NodeIterator (Node n) {
203 | this.n = n;
204 | }
205 |
206 | @Override
207 | public boolean hasNext () {
208 | // return n!= null && n.next != null && !(n.next instanceof EmptyListMap);
209 | return n!= null && !(n instanceof EmptyListMap);
210 | }
211 |
212 | @Override
213 | public Entry next () {
214 | if (n instanceof Node) {
215 | Node nn = (Node) n;
216 | Entry res = new SimpleImmutableEntry (nn.k, nn.v);
217 | n = n.next;
218 | return res;
219 | } else {
220 | return null;
221 | }
222 | }
223 |
224 | @Override
225 | public void remove () {
226 | throw new RuntimeException("Operation not supported");
227 | }
228 |
229 | }
230 | }
231 | }
232 |
--------------------------------------------------------------------------------
/src/main/java/com/romix/scala/collection/concurrent/MainNode.java:
--------------------------------------------------------------------------------
1 | /* __ *\
2 | ** ________ ___ / / ___ Scala API **
3 | ** / __/ __// _ | / / / _ | (c) 2003-2012, LAMP/EPFL **
4 | ** __\ \/ /__/ __ |/ /__/ __ | http://scala-lang.org/ **
5 | ** /____/\___/_/ |_/____/_/ | | **
6 | ** |/ **
7 | \* */
8 |
9 | package com.romix.scala.collection.concurrent;
10 |
11 | import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;
12 |
13 | abstract class MainNode extends BasicNode {
14 |
15 | public static final AtomicReferenceFieldUpdater updater = AtomicReferenceFieldUpdater.newUpdater (MainNode.class, MainNode.class, "prev");
16 |
17 | public volatile MainNode prev = null;
18 |
19 | public abstract int cachedSize (Object ct);
20 |
21 | public boolean CAS_PREV (MainNode oldval, MainNode nval) {
22 | return updater.compareAndSet (this, oldval, nval);
23 | }
24 |
25 | public void WRITE_PREV (MainNode nval) {
26 | updater.set (this, nval);
27 | }
28 |
29 | // do we need this? unclear in the javadocs...
30 | // apparently not - volatile reads are supposed to be safe
31 | // regardless of whether there are concurrent ARFU updates
32 | public MainNode READ_PREV () {
33 | return updater.get (this);
34 | }
35 |
36 | }
37 |
--------------------------------------------------------------------------------
/src/main/java/com/romix/scala/collection/concurrent/TrieMap.java:
--------------------------------------------------------------------------------
1 | package com.romix.scala.collection.concurrent;
2 |
3 | import java.io.IOException;
4 | import java.io.ObjectInputStream;
5 | import java.io.ObjectOutputStream;
6 | import java.io.Serializable;
7 | import java.lang.reflect.Field;
8 | import java.util.AbstractMap;
9 | import java.util.AbstractSet;
10 | import java.util.ArrayList;
11 | import java.util.Arrays;
12 | import java.util.HashMap;
13 | import java.util.Iterator;
14 | import java.util.List;
15 | import java.util.Map;
16 | import java.util.NoSuchElementException;
17 | import java.util.Set;
18 | import java.util.concurrent.ConcurrentMap;
19 | import java.util.concurrent.ThreadLocalRandom;
20 | import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;
21 | import com.romix.scala.None;
22 | import com.romix.scala.Option;
23 | import com.romix.scala.Some;
24 |
25 | /***
26 | * This is a port of Scala's TrieMap class from the Scala Collections library.
27 | *
28 | * @author Roman Levenstein
29 | *
30 | * @param
31 | * @param
32 | */
33 | @SuppressWarnings({"unchecked", "rawtypes", "unused"})
34 | public class TrieMap extends AbstractMap implements ConcurrentMap, Serializable {
35 | private static final AtomicReferenceFieldUpdater ROOT_UPDATER = AtomicReferenceFieldUpdater.newUpdater(TrieMap.class, Object.class, "root");
36 | private static final long serialVersionUID = 1L;
37 | private static final Field READONLY_FIELD;
38 |
39 | static {
40 | final Field f;
41 | try {
42 | f = TrieMap.class.getDeclaredField("readOnly");
43 | } catch (NoSuchFieldException e) {
44 | throw new ExceptionInInitializerError(e);
45 | } catch (SecurityException e) {
46 | throw new ExceptionInInitializerError(e);
47 | }
48 | f.setAccessible(true);
49 | READONLY_FIELD = f;
50 | }
51 |
52 | /**
53 | * EntrySet
54 | */
55 | private transient final EntrySet entrySet = new EntrySet ();
56 |
57 | public static TrieMap empty () {
58 | return new TrieMap();
59 | }
60 |
61 | // static class MangledHashing extends Hashing {
62 | // int hash(K k) {
63 | // return util.hashing.byteswap32(k);
64 | // }
65 | // }
66 |
67 | static class INode extends INodeBase {
68 | static final Object KEY_PRESENT = new Object ();
69 | static final Object KEY_ABSENT = new Object ();
70 |
71 | static INode newRootNode () {
72 | Gen gen = new Gen ();
73 | CNode cn = new CNode (0, new BasicNode[] {}, gen);
74 | return new INode(cn, gen);
75 | }
76 |
77 | public INode (MainNode bn, Gen g) {
78 | super (g);
79 | WRITE (bn);
80 | }
81 |
82 | public INode (Gen g) {
83 | this (null, g);
84 | }
85 |
86 | final void WRITE (final MainNode nval) {
87 | INodeBase.updater.set (this, nval);
88 | }
89 |
90 | final boolean CAS (final MainNode old, final MainNode n) {
91 | return INodeBase.updater.compareAndSet (this, old, n);
92 | }
93 |
94 | final MainNode gcasRead (final TrieMap ct) {
95 | return GCAS_READ (ct);
96 | }
97 |
98 | final MainNode GCAS_READ (TrieMap ct) {
99 | MainNode m = /* READ */mainnode;
100 | MainNode prevval = /* READ */m.prev;
101 | if (prevval == null)
102 | return m;
103 | else
104 | return GCAS_Complete (m, ct);
105 | }
106 |
107 | private MainNode GCAS_Complete (MainNode m, final TrieMap ct) {
108 | while (true) {
109 | if (m == null)
110 | return null;
111 | else {
112 | // complete the GCAS
113 | MainNode prev = /* READ */m.prev;
114 | INode ctr = ct.readRoot (true);
115 |
116 | if (prev == null)
117 | return m;
118 |
119 | if (prev instanceof FailedNode) {
120 | // try to commit to previous value
121 | FailedNode fn = (FailedNode) prev;
122 | if (CAS (m, fn.prev))
123 | return fn.prev;
124 | else {
125 | // Tailrec
126 | // return GCAS_Complete (/* READ */mainnode, ct);
127 | m = /* READ */mainnode;
128 | continue;
129 | }
130 | } else {
131 | // Assume that you've read the root from the generation
132 | // G.
133 | // Assume that the snapshot algorithm is correct.
134 | // ==> you can only reach nodes in generations <= G.
135 | // ==> `gen` is <= G.
136 | // We know that `ctr.gen` is >= G.
137 | // ==> if `ctr.gen` = `gen` then they are both equal to
138 | // G.
139 | // ==> otherwise, we know that either `ctr.gen` > G,
140 | // `gen` <
141 | // G,
142 | // or both
143 | if ((ctr.gen == gen) && ct.nonReadOnly ()) {
144 | // try to commit
145 | if (m.CAS_PREV (prev, null))
146 | return m;
147 | else {
148 | // return GCAS_Complete (m, ct);
149 | // tailrec
150 | continue;
151 | }
152 | } else {
153 | // try to abort
154 | m.CAS_PREV (prev, new FailedNode (prev));
155 | return GCAS_Complete (/* READ */mainnode, ct);
156 | }
157 | }
158 | }
159 | }
160 | }
161 |
162 | final boolean GCAS (final MainNode old, final MainNode n, final TrieMap ct) {
163 | n.WRITE_PREV (old);
164 | if (CAS (old, n)) {
165 | GCAS_Complete (n, ct);
166 | return /* READ */n.prev == null;
167 | } else
168 | return false;
169 | }
170 |
171 | private boolean equal (final K k1, final K k2, final TrieMap ct) {
172 | return ct.equality ().equiv (k1, k2);
173 | }
174 |
175 | private INode inode (final MainNode cn) {
176 | INode nin = new INode (gen);
177 | nin.WRITE (cn);
178 | return nin;
179 | }
180 |
181 | final INode copyToGen (final Gen ngen, final TrieMap ct) {
182 | INode nin = new INode (ngen);
183 | MainNode main = GCAS_READ (ct);
184 | nin.WRITE (main);
185 | return nin;
186 | }
187 |
188 | /**
189 | * Inserts a key value pair, overwriting the old pair if the keys match.
190 | *
191 | * @return true if successful, false otherwise
192 | */
193 | final boolean rec_insert (final K k, final V v, final int hc, final int lev, final INode parent, final Gen startgen, final TrieMap ct) {
194 | while (true) {
195 | MainNode m = GCAS_READ (ct); // use -Yinline!
196 |
197 | if (m instanceof CNode) {
198 | // 1) a multiway node
199 | CNode cn = (CNode) m;
200 | int idx = (hc >>> lev) & 0x1f;
201 | int flag = 1 << idx;
202 | int bmp = cn.bitmap;
203 | int mask = flag - 1;
204 | int pos = Integer.bitCount (bmp & mask);
205 | if ((bmp & flag) != 0) {
206 | // 1a) insert below
207 | BasicNode cnAtPos = cn.array [pos];
208 | if (cnAtPos instanceof INode) {
209 | INode in = (INode) cnAtPos;
210 | if (startgen == in.gen)
211 | return in.rec_insert (k, v, hc, lev + 5, this, startgen, ct);
212 | else {
213 | if (GCAS (cn, cn.renewed (startgen, ct), ct)) {
214 | // return rec_insert (k, v, hc, lev, parent,
215 | // startgen, ct);
216 | // tailrec
217 | continue;
218 | } else
219 | return false;
220 | }
221 | } else if (cnAtPos instanceof SNode) {
222 | SNode sn = (SNode) cnAtPos;
223 | if (sn.hc == hc && equal (sn.k, k, ct))
224 | return GCAS (cn, cn.updatedAt (pos, new SNode (k, v, hc), gen), ct);
225 | else {
226 | CNode rn = (cn.gen == gen) ? cn : cn.renewed (gen, ct);
227 | MainNode nn = rn.updatedAt (pos, inode (CNode.dual (sn, sn.hc, new SNode (k, v, hc), hc, lev + 5, gen)), gen);
228 | return GCAS (cn, nn, ct);
229 | }
230 | }
231 | } else {
232 | CNode rn = (cn.gen == gen) ? cn : cn.renewed (gen, ct);
233 | MainNode ncnode = rn.insertedAt (pos, flag, new SNode (k, v, hc), gen);
234 | return GCAS (cn, ncnode, ct);
235 | }
236 | } else if (m instanceof TNode) {
237 | clean (parent, ct, lev - 5);
238 | return false;
239 | } else if (m instanceof LNode) {
240 | LNode ln = (LNode) m;
241 | MainNode nn = ln.inserted (k, v);
242 | return GCAS (ln, nn, ct);
243 | }
244 |
245 | throw new RuntimeException ("Should not happen");
246 | }
247 | }
248 |
249 | /**
250 | * Inserts a new key value pair, given that a specific condition is met.
251 | *
252 | * @param cond
253 | * null - don't care if the key was there
254 | * KEY_ABSENT - key wasn't there
255 | * KEY_PRESENT - key was there
256 | * other value `v` - key must be bound to `v`
257 | * @return null if unsuccessful, Option[V] otherwise (indicating
258 | * previous value bound to the key)
259 | */
260 | final Option rec_insertif (final K k, final V v, final int hc, final Object cond, final int lev, final INode parent, final Gen startgen, final TrieMap ct) {
261 | while (true) {
262 | MainNode m = GCAS_READ (ct); // use -Yinline!
263 |
264 | if (m instanceof CNode) {
265 | // 1) a multiway node
266 | CNode cn = (CNode) m;
267 | int idx = (hc >>> lev) & 0x1f;
268 | int flag = 1 << idx;
269 | int bmp = cn.bitmap;
270 | int mask = flag - 1;
271 | int pos = Integer.bitCount (bmp & mask);
272 |
273 | if ((bmp & flag) != 0) {
274 | // 1a) insert below
275 | BasicNode cnAtPos = cn.array [pos];
276 | if (cnAtPos instanceof INode) {
277 | INode in = (INode) cnAtPos;
278 | if (startgen == in.gen)
279 | return in.rec_insertif (k, v, hc, cond, lev + 5, this, startgen, ct);
280 | else {
281 | if (GCAS (cn, cn.renewed (startgen, ct), ct)) {
282 | // return rec_insertif (k, v, hc, cond, lev,
283 | // parent, startgen, ct);
284 | // tailrec
285 | continue;
286 | } else
287 | return null;
288 | }
289 | } else if (cnAtPos instanceof SNode) {
290 | SNode sn = (SNode) cnAtPos;
291 | if (cond == null) {
292 | if (sn.hc == hc && equal (sn.k, k, ct)) {
293 | if (GCAS (cn, cn.updatedAt (pos, new SNode (k, v, hc), gen), ct))
294 | return Option.makeOption(sn.v);
295 | else
296 | return null;
297 | } else {
298 | CNode rn = (cn.gen == gen) ? cn : cn.renewed (gen, ct);
299 | MainNode nn = rn.updatedAt (pos, inode (CNode.dual (sn, sn.hc, new SNode (k, v, hc), hc, lev + 5, gen)), gen);
300 | if (GCAS (cn, nn, ct))
301 | return Option.makeOption(); // None;
302 | else
303 | return null;
304 | }
305 |
306 | } else if (cond == INode.KEY_ABSENT) {
307 | if (sn.hc == hc && equal (sn.k, k, ct))
308 | return Option.makeOption(sn.v);
309 | else {
310 | CNode rn = (cn.gen == gen) ? cn : cn.renewed (gen, ct);
311 | MainNode nn = rn.updatedAt (pos, inode (CNode.dual (sn, sn.hc, new SNode (k, v, hc), hc, lev + 5, gen)), gen);
312 | if (GCAS (cn, nn, ct))
313 | return Option.makeOption (); // None
314 | else
315 | return null;
316 | }
317 | } else if (cond == INode.KEY_PRESENT) {
318 | if (sn.hc == hc && equal (sn.k, k, ct)) {
319 | if (GCAS (cn, cn.updatedAt (pos, new SNode (k, v, hc), gen), ct))
320 | return Option.makeOption (sn.v);
321 | else
322 | return null;
323 |
324 | } else
325 | return Option.makeOption ();// None;
326 | } else {
327 | if (sn.hc == hc && equal (sn.k, k, ct) && sn.v == cond) {
328 | if (GCAS (cn, cn.updatedAt (pos, new SNode (k, v, hc), gen), ct))
329 | return Option.makeOption (sn.v);
330 | else
331 | return null;
332 | } else
333 | return Option.makeOption (); // None
334 | }
335 |
336 | }
337 | } else if (cond == null || cond == INode.KEY_ABSENT) {
338 | CNode rn = (cn.gen == gen) ? cn : cn.renewed (gen, ct);
339 | CNode ncnode = rn.insertedAt (pos, flag, new SNode (k, v, hc), gen);
340 | if (GCAS (cn, ncnode, ct))
341 | return Option.makeOption ();// None
342 | else
343 | return null;
344 | } else if (cond == INode.KEY_PRESENT) {
345 | return Option.makeOption ();// None;
346 | } else
347 | return Option.makeOption (); // None
348 | } else if (m instanceof TNode) {
349 | clean (parent, ct, lev - 5);
350 | return null;
351 | } else if (m instanceof LNode) {
352 | // 3) an l-node
353 | LNode ln = (LNode) m;
354 | if (cond == null) {
355 | Option optv = ln.get (k);
356 | if (insertln (ln, k, v, ct))
357 | return optv;
358 | else
359 | return null;
360 | } else if (cond == INode.KEY_ABSENT) {
361 | Option t = ln.get (k);
362 | if (t == null || t instanceof None) {
363 | if (insertln (ln, k, v, ct))
364 | return Option.makeOption ();// None
365 | else
366 | return null;
367 | } else
368 | return t;
369 | } else if (cond == INode.KEY_PRESENT) {
370 | Option t = ln.get (k);
371 | if (t != null) {
372 | if (insertln (ln, k, v, ct))
373 | return t;
374 | else
375 | return null;
376 | } else
377 | return null; // None
378 | } else {
379 | Option t = ln.get (k);
380 | if (t != null) {
381 | if (((Some) t).get () == cond) {
382 | if (insertln (ln, k, v, ct))
383 | return new Some ((V) cond);
384 | else
385 | return null;
386 |
387 | } else
388 | return Option.makeOption ();
389 | }
390 | }
391 | }
392 |
393 | // throw new RuntimeException ("Should not happen");
394 | }
395 | }
396 |
397 | final boolean insertln (final LNode ln, final K k, final V v, final TrieMap ct) {
398 | LNode nn = ln.inserted (k, v);
399 | return GCAS (ln, nn, ct);
400 | }
401 |
402 | /**
403 | * Looks up the value associated with the key.
404 | *
405 | * @return null if no value has been found, RESTART if the operation
406 | * wasn't successful, or any other value otherwise
407 | */
408 | final Object rec_lookup (final K k, final int hc, int lev, INode parent, final Gen startgen, final TrieMap ct) {
409 | while (true) {
410 | MainNode m = GCAS_READ (ct); // use -Yinline!
411 |
412 | if (m instanceof CNode) {
413 | // 1) a multinode
414 | final CNode cn = (CNode) m;
415 | int idx = (hc >>> lev) & 0x1f;
416 | int flag = 1 << idx;
417 | int bmp = cn.bitmap;
418 | if ((bmp & flag) == 0)
419 | return null; // 1a) bitmap shows no binding
420 | else { // 1b) bitmap contains a value - descend
421 | int pos = (bmp == 0xffffffff) ? idx : Integer.bitCount (bmp & (flag - 1));
422 | final BasicNode sub = cn.array [pos];
423 | if (sub instanceof INode) {
424 | INode in = (INode) sub;
425 | if (ct.isReadOnly () || (startgen == ((INodeBase) sub).gen))
426 | return in.rec_lookup (k, hc, lev + 5, this, startgen, ct);
427 | else {
428 | if (GCAS (cn, cn.renewed (startgen, ct), ct)) {
429 | // return rec_lookup (k, hc, lev, parent,
430 | // startgen, ct);
431 | // Tailrec
432 | continue;
433 | } else
434 | return RESTART; // used to be throw
435 | // RestartException
436 | }
437 | } else if (sub instanceof SNode) {
438 | // 2) singleton node
439 | SNode sn = (SNode) sub;
440 | if (((SNode) sub).hc == hc && equal (sn.k, k, ct))
441 | return sn.v;
442 | else
443 | return null;
444 | }
445 | }
446 | } else if (m instanceof TNode) {
447 | // 3) non-live node
448 | return cleanReadOnly ((TNode) m, lev, parent, ct, k, hc);
449 | } else if (m instanceof LNode) {
450 | // 5) an l-node
451 | return ((LNode) m).get (k);
452 | }
453 |
454 | throw new RuntimeException ("Should not happen");
455 | }
456 | }
457 |
458 | private Object cleanReadOnly (final TNode tn, final int lev, final INode parent, final TrieMap ct, K k, int hc) {
459 | if (ct.nonReadOnly ()) {
460 | clean (parent, ct, lev - 5);
461 | return RESTART; // used to be throw RestartException
462 | } else {
463 | if (tn.hc == hc && equal(tn.k, k, ct))
464 | return tn.v;
465 | else
466 | return null;
467 | }
468 | }
469 |
470 | /**
471 | * Removes the key associated with the given value.
472 | *
473 | * @param v
474 | * if null, will remove the key irregardless of the value;
475 | * otherwise removes only if binding contains that exact key
476 | * and value
477 | * @return null if not successful, an Option[V] indicating the previous
478 | * value otherwise
479 | */
480 | final Option rec_remove (K k, V v, int hc, int lev, final INode parent, final Gen startgen, final TrieMap ct) {
481 | MainNode m = GCAS_READ (ct); // use -Yinline!
482 |
483 | if (m instanceof CNode) {
484 | CNode cn = (CNode) m;
485 | int idx = (hc >>> lev) & 0x1f;
486 | int bmp = cn.bitmap;
487 | int flag = 1 << idx;
488 | if ((bmp & flag) == 0)
489 | return Option.makeOption ();
490 | else {
491 | int pos = Integer.bitCount (bmp & (flag - 1));
492 | BasicNode sub = cn.array [pos];
493 | Option res = null;
494 | if (sub instanceof INode) {
495 | INode in = (INode) sub;
496 | if (startgen == in.gen)
497 | res = in.rec_remove (k, v, hc, lev + 5, this, startgen, ct);
498 | else {
499 | if (GCAS (cn, cn.renewed (startgen, ct), ct))
500 | res = rec_remove (k, v, hc, lev, parent, startgen, ct);
501 | }
502 |
503 | } else if (sub instanceof SNode) {
504 | SNode sn = (SNode) sub;
505 | if (sn.hc == hc && equal (sn.k, k, ct) && (v == null || v.equals(sn.v))) {
506 | MainNode ncn = cn.removedAt (pos, flag, gen).toContracted (lev);
507 | if (GCAS (cn, ncn, ct))
508 | res = Option.makeOption (sn.v);
509 | } else
510 | res = Option.makeOption ();
511 | }
512 |
513 | if (res instanceof None || (res == null))
514 | return res;
515 | else {
516 | if (parent != null) { // never tomb at root
517 | MainNode n = GCAS_READ (ct);
518 | if (n instanceof TNode)
519 | cleanParent (n, parent, ct, hc, lev, startgen);
520 | }
521 |
522 | return res;
523 | }
524 | }
525 | } else if (m instanceof TNode) {
526 | clean (parent, ct, lev - 5);
527 | return null;
528 | } else if (m instanceof LNode) {
529 | LNode ln = (LNode) m;
530 | if (v == null) {
531 | Option optv = ln.get (k);
532 | MainNode nn = ln.removed (k, ct);
533 | if (GCAS (ln, nn, ct))
534 | return optv;
535 | else
536 | return null;
537 | } else {
538 | Option tmp = ln.get (k);
539 | if (tmp instanceof Some) {
540 | Some tmp1 = (Some) tmp;
541 | if (tmp1.get () == v) {
542 | MainNode nn = ln.removed (k, ct);
543 | if (GCAS (ln, nn, ct))
544 | return tmp;
545 | else
546 | return null;
547 | }
548 | }
549 | }
550 | }
551 | throw new RuntimeException ("Should not happen");
552 | }
553 |
554 | void cleanParent (final Object nonlive, final INode parent, final TrieMap ct, final int hc, final int lev, final Gen startgen) {
555 | while (true) {
556 | MainNode pm = parent.GCAS_READ (ct);
557 | if (pm instanceof CNode) {
558 | CNode cn = (CNode) pm;
559 | int idx = (hc >>> (lev - 5)) & 0x1f;
560 | int bmp = cn.bitmap;
561 | int flag = 1 << idx;
562 | if ((bmp & flag) == 0) {
563 | } // somebody already removed this i-node, we're done
564 | else {
565 | int pos = Integer.bitCount (bmp & (flag - 1));
566 | BasicNode sub = cn.array [pos];
567 | if (sub == this) {
568 | if (nonlive instanceof TNode) {
569 | TNode tn = (TNode) nonlive;
570 | MainNode ncn = cn.updatedAt (pos, tn.copyUntombed (), gen).toContracted (lev - 5);
571 | if (!parent.GCAS (cn, ncn, ct))
572 | if (ct.readRoot ().gen == startgen) {
573 | // cleanParent (nonlive, parent, ct, hc,
574 | // lev, startgen);
575 | // tailrec
576 | continue;
577 | }
578 | }
579 | }
580 | }
581 | } else {
582 | // parent is no longer a cnode, we're done
583 | }
584 | break;
585 | }
586 | }
587 |
588 | private void clean (final INode nd, final TrieMap ct, int lev) {
589 | MainNode m = nd.GCAS_READ (ct);
590 | if (m instanceof CNode) {
591 | CNode cn = (CNode) m;
592 | nd.GCAS (cn, cn.toCompressed (ct, lev, gen), ct);
593 | }
594 | }
595 |
596 | final boolean isNullInode (final TrieMap ct) {
597 | return GCAS_READ (ct) == null;
598 | }
599 |
600 | final int cachedSize (final TrieMap ct) {
601 | MainNode m = GCAS_READ (ct);
602 | return m.cachedSize (ct);
603 | }
604 |
605 | // /* this is a quiescent method! */
606 | // def string(lev: Int) = "%sINode -> %s".format(" " * lev, mainnode
607 | // match {
608 | // case null => ""
609 | // case tn: TNode[_, _] => "TNode(%s, %s, %d, !)".format(tn.k, tn.v,
610 | // tn.hc)
611 | // case cn: CNode[_, _] => cn.string(lev)
612 | // case ln: LNode[_, _] => ln.string(lev)
613 | // case x => "".format(x)
614 | // })
615 |
616 | public String string (int lev) {
617 | return "INode";
618 | }
619 |
620 | }
621 |
622 | private static final class FailedNode extends MainNode {
623 | MainNode p;
624 |
625 | FailedNode (final MainNode p) {
626 | this.p = p;
627 | WRITE_PREV (p);
628 | }
629 |
630 | public String string (int lev) {
631 | throw new UnsupportedOperationException ();
632 | }
633 |
634 | public int cachedSize (Object ct) {
635 | throw new UnsupportedOperationException ();
636 | }
637 |
638 | public String toString () {
639 | return String.format ("FailedNode(%s)", p);
640 | }
641 | }
642 |
643 | private interface KVNode {
644 | Map.Entry kvPair ();
645 | }
646 |
647 | private static final class SNode extends BasicNode implements KVNode {
648 | final K k;
649 | final V v;
650 | final int hc;
651 |
652 | SNode (final K k, final V v, final int hc) {
653 | this.k = k;
654 | this.v = v;
655 | this.hc = hc;
656 | }
657 |
658 | final SNode copy() {
659 | return new SNode (k, v, hc);
660 | }
661 |
662 | final TNode copyTombed () {
663 | return new TNode (k, v, hc);
664 | }
665 |
666 | final SNode copyUntombed () {
667 | return new SNode (k, v, hc);
668 | }
669 |
670 | final public Map.Entry kvPair () {
671 | return new SimpleImmutableEntry (k, v);
672 | }
673 |
674 | final public String string (int lev) {
675 | // (" " * lev) + "SNode(%s, %s, %x)".format(k, v, hc);
676 | return "SNode";
677 | }
678 | }
679 |
680 | private static final class TNode extends MainNode implements KVNode