From 09d1e9649441c4c7aefc0f0da5d672ad020f4a39 Mon Sep 17 00:00:00 2001 From: xuwei-k <6b656e6a69@gmail.com> Date: Sun, 21 Sep 2025 20:13:57 +0900 Subject: [PATCH] replace scala.collection.concurrent java files --- .../concurrent/{Gen.java => BasicNode.scala} | 11 +++- .../collection/concurrent/CNodeBase.java | 37 -------------- .../collection/concurrent/CNodeBase.scala | 43 ++++++++++++++++ .../concurrent/{BasicNode.java => Gen.scala} | 9 ++-- .../collection/concurrent/INodeBase.java | 39 --------------- .../collection/concurrent/INodeBase.scala | 36 +++++++++++++ .../scala/collection/concurrent/MainNode.java | 46 ----------------- .../collection/concurrent/MainNode.scala | 50 +++++++++++++++++++ .../scala/collection/concurrent/TrieMap.scala | 2 +- 9 files changed, 143 insertions(+), 130 deletions(-) rename library/src/scala/collection/concurrent/{Gen.java => BasicNode.scala} (63%) delete mode 100644 library/src/scala/collection/concurrent/CNodeBase.java create mode 100644 library/src/scala/collection/concurrent/CNodeBase.scala rename library/src/scala/collection/concurrent/{BasicNode.java => Gen.scala} (66%) delete mode 100644 library/src/scala/collection/concurrent/INodeBase.java create mode 100644 library/src/scala/collection/concurrent/INodeBase.scala delete mode 100644 library/src/scala/collection/concurrent/MainNode.java create mode 100644 library/src/scala/collection/concurrent/MainNode.scala diff --git a/library/src/scala/collection/concurrent/Gen.java b/library/src/scala/collection/concurrent/BasicNode.scala similarity index 63% rename from library/src/scala/collection/concurrent/Gen.java rename to library/src/scala/collection/concurrent/BasicNode.scala index 548c1892321f..22f6947e64de 100644 --- a/library/src/scala/collection/concurrent/Gen.java +++ b/library/src/scala/collection/concurrent/BasicNode.scala @@ -10,6 +10,13 @@ * additional information regarding copyright ownership. */ -package scala.collection.concurrent; +package scala.collection.concurrent -final class Gen {} +import scala.language.`2.13` +import language.experimental.captureChecking + +abstract class BasicNode { + + def string(lev: Int): String + +} diff --git a/library/src/scala/collection/concurrent/CNodeBase.java b/library/src/scala/collection/concurrent/CNodeBase.java deleted file mode 100644 index 4033c12af449..000000000000 --- a/library/src/scala/collection/concurrent/CNodeBase.java +++ /dev/null @@ -1,37 +0,0 @@ -/* - * Scala (https://www.scala-lang.org) - * - * Copyright EPFL and Lightbend, Inc. dba Akka - * - * Licensed under Apache License 2.0 - * (http://www.apache.org/licenses/LICENSE-2.0). - * - * See the NOTICE file distributed with this work for - * additional information regarding copyright ownership. - */ - -package scala.collection.concurrent; - -import java.util.concurrent.atomic.AtomicIntegerFieldUpdater; - -abstract class CNodeBase extends MainNode { - - @SuppressWarnings("unchecked") - public static final AtomicIntegerFieldUpdater> updater = - AtomicIntegerFieldUpdater.newUpdater((Class>) (Class) CNodeBase.class, "csize"); - - public volatile int csize = -1; - - public boolean CAS_SIZE(int oldval, int nval) { - return updater.compareAndSet(this, oldval, nval); - } - - public void WRITE_SIZE(int nval) { - updater.set(this, nval); - } - - public int READ_SIZE() { - return updater.get(this); - } - -} diff --git a/library/src/scala/collection/concurrent/CNodeBase.scala b/library/src/scala/collection/concurrent/CNodeBase.scala new file mode 100644 index 000000000000..3df8802d28b6 --- /dev/null +++ b/library/src/scala/collection/concurrent/CNodeBase.scala @@ -0,0 +1,43 @@ +/* + * Scala (https://www.scala-lang.org) + * + * Copyright EPFL and Lightbend, Inc. dba Akka + * + * Licensed under Apache License 2.0 + * (http://www.apache.org/licenses/LICENSE-2.0). + * + * See the NOTICE file distributed with this work for + * additional information regarding copyright ownership. + */ + +package scala.collection.concurrent + +import scala.language.`2.13` +import language.experimental.captureChecking + +import java.util.concurrent.atomic.AtomicIntegerFieldUpdater +import scala.annotation.static + +private[concurrent] object CNodeBase { + @static + final val updater: AtomicIntegerFieldUpdater[CNodeBase[?, ?]] = + AtomicIntegerFieldUpdater.newUpdater(classOf[CNodeBase[?, ?]], "csize") +} + +private[concurrent] abstract class CNodeBase[K, V] extends MainNode[K, V] { + + @volatile var csize: Int = -1 + + def CAS_SIZE(oldval: Int, nval: Int): Boolean = { + CNodeBase.updater.compareAndSet(this, oldval, nval) + } + + def WRITE_SIZE(nval: Int): Unit = { + CNodeBase.updater.set(this, nval) + } + + def READ_SIZE(): Int = { + CNodeBase.updater.get(this) + } + +} diff --git a/library/src/scala/collection/concurrent/BasicNode.java b/library/src/scala/collection/concurrent/Gen.scala similarity index 66% rename from library/src/scala/collection/concurrent/BasicNode.java rename to library/src/scala/collection/concurrent/Gen.scala index b6a628d1295e..10b309072d06 100644 --- a/library/src/scala/collection/concurrent/BasicNode.java +++ b/library/src/scala/collection/concurrent/Gen.scala @@ -10,10 +10,9 @@ * additional information regarding copyright ownership. */ -package scala.collection.concurrent; +package scala.collection.concurrent -public abstract class BasicNode { +import scala.language.`2.13` +import language.experimental.captureChecking - public abstract String string(int lev); - -} +private[concurrent] final class Gen {} diff --git a/library/src/scala/collection/concurrent/INodeBase.java b/library/src/scala/collection/concurrent/INodeBase.java deleted file mode 100644 index b16265c68ea3..000000000000 --- a/library/src/scala/collection/concurrent/INodeBase.java +++ /dev/null @@ -1,39 +0,0 @@ -/* - * Scala (https://www.scala-lang.org) - * - * Copyright EPFL and Lightbend, Inc. dba Akka - * - * Licensed under Apache License 2.0 - * (http://www.apache.org/licenses/LICENSE-2.0). - * - * See the NOTICE file distributed with this work for - * additional information regarding copyright ownership. - */ - -package scala.collection.concurrent; - -import java.util.concurrent.atomic.AtomicReferenceFieldUpdater; - -abstract class INodeBase extends BasicNode { - - @SuppressWarnings("unchecked") - public static final AtomicReferenceFieldUpdater, MainNode> updater = - AtomicReferenceFieldUpdater.newUpdater((Class>) (Class) INodeBase.class, (Class>) (Class) MainNode.class, "mainnode"); - - static final Object RESTART = new Object(); - - static final Object NO_SUCH_ELEMENT_SENTINEL = new Object(); - - public volatile MainNode mainnode = null; - - public final Gen gen; - - public INodeBase(Gen generation) { - gen = generation; - } - - public BasicNode prev() { - return null; - } - -} diff --git a/library/src/scala/collection/concurrent/INodeBase.scala b/library/src/scala/collection/concurrent/INodeBase.scala new file mode 100644 index 000000000000..7238892da402 --- /dev/null +++ b/library/src/scala/collection/concurrent/INodeBase.scala @@ -0,0 +1,36 @@ +/* + * Scala (https://www.scala-lang.org) + * + * Copyright EPFL and Lightbend, Inc. dba Akka + * + * Licensed under Apache License 2.0 + * (http://www.apache.org/licenses/LICENSE-2.0). + * + * See the NOTICE file distributed with this work for + * additional information regarding copyright ownership. + */ + +package scala.collection.concurrent + +import scala.language.`2.13` +import language.experimental.captureChecking + +import java.util.concurrent.atomic.AtomicReferenceFieldUpdater +import scala.annotation.static + +private[concurrent] object INodeBase { + @static + final val updater: AtomicReferenceFieldUpdater[INodeBase[?, ?], MainNode[?, ?]] = + AtomicReferenceFieldUpdater.newUpdater(classOf[INodeBase[?, ?]], classOf[MainNode[?, ?]], "mainnode") + + @static final val RESTART: Object = new Object() + + @static final val NO_SUCH_ELEMENT_SENTINEL: Object = new Object() +} + +private[concurrent] abstract class INodeBase[K, V](val gen: Gen) extends BasicNode { + + @volatile var mainnode: MainNode[K, V] = null + + def prev(): BasicNode = null +} diff --git a/library/src/scala/collection/concurrent/MainNode.java b/library/src/scala/collection/concurrent/MainNode.java deleted file mode 100644 index 1bfc11594ec9..000000000000 --- a/library/src/scala/collection/concurrent/MainNode.java +++ /dev/null @@ -1,46 +0,0 @@ -/* - * Scala (https://www.scala-lang.org) - * - * Copyright EPFL and Lightbend, Inc. dba Akka - * - * Licensed under Apache License 2.0 - * (http://www.apache.org/licenses/LICENSE-2.0). - * - * See the NOTICE file distributed with this work for - * additional information regarding copyright ownership. - */ - -package scala.collection.concurrent; - -import java.util.concurrent.atomic.AtomicReferenceFieldUpdater; - -abstract class MainNode extends BasicNode { - - @SuppressWarnings("unchecked") - public static final AtomicReferenceFieldUpdater, MainNode> updater = - AtomicReferenceFieldUpdater.newUpdater((Class>) (Class) MainNode.class, (Class>) (Class) MainNode.class, "prev"); - - public volatile MainNode prev = null; - - public abstract int cachedSize(Object ct); - - // standard contract - public abstract int knownSize(); - - public boolean CAS_PREV(MainNode oldval, MainNode nval) { - return updater.compareAndSet(this, oldval, nval); - } - - public void WRITE_PREV(MainNode nval) { - updater.set(this, nval); - } - - // do we need this? unclear in the javadocs... - // apparently not - volatile reads are supposed to be safe - // regardless of whether there are concurrent ARFU updates - @Deprecated @SuppressWarnings("unchecked") - public MainNode READ_PREV() { - return (MainNode) updater.get(this); - } - -} diff --git a/library/src/scala/collection/concurrent/MainNode.scala b/library/src/scala/collection/concurrent/MainNode.scala new file mode 100644 index 000000000000..38c8437365c8 --- /dev/null +++ b/library/src/scala/collection/concurrent/MainNode.scala @@ -0,0 +1,50 @@ +/* + * Scala (https://www.scala-lang.org) + * + * Copyright EPFL and Lightbend, Inc. dba Akka + * + * Licensed under Apache License 2.0 + * (http://www.apache.org/licenses/LICENSE-2.0). + * + * See the NOTICE file distributed with this work for + * additional information regarding copyright ownership. + */ + +package scala.collection.concurrent + +import scala.language.`2.13` +import language.experimental.captureChecking + +import java.util.concurrent.atomic.AtomicReferenceFieldUpdater +import scala.annotation.static + +private[concurrent] object MainNode { + @static val updater: AtomicReferenceFieldUpdater[MainNode[?, ?], MainNode[?, ?]] = + AtomicReferenceFieldUpdater.newUpdater(classOf[MainNode[?, ?]], classOf[MainNode[?, ?]], "prev") +} + +private[concurrent] abstract class MainNode[K, V] extends BasicNode { + + @volatile var prev: MainNode[K, V] = null + + def cachedSize(ct: Object): Int + + // standard contract + def knownSize(): Int + + def CAS_PREV(oldval: MainNode[K, V], nval: MainNode[K, V]): Boolean = { + MainNode.updater.compareAndSet(this, oldval, nval) + } + + def WRITE_PREV(nval: MainNode[K, V]): Unit = { + MainNode.updater.set(this, nval) + } + + // do we need this? unclear in the javadocs... + // apparently not - volatile reads are supposed to be safe + // regardless of whether there are concurrent ARFU updates + @deprecated + def READ_PREV(): MainNode[K, V] = { + MainNode.updater.get(this).asInstanceOf[MainNode[K, V]] + } +} diff --git a/library/src/scala/collection/concurrent/TrieMap.scala b/library/src/scala/collection/concurrent/TrieMap.scala index a29eb902afb4..e49ea07f52ee 100644 --- a/library/src/scala/collection/concurrent/TrieMap.scala +++ b/library/src/scala/collection/concurrent/TrieMap.scala @@ -1049,7 +1049,7 @@ object TrieMap extends MapFactory[TrieMap] { def newBuilder[K, V]: mutable.GrowableBuilder[(K, V), TrieMap[K, V]] = new GrowableBuilder(empty[K, V]) @transient - val inodeupdater: AtomicReferenceFieldUpdater[INodeBase[_, _], MainNode[_, _]] = AtomicReferenceFieldUpdater.newUpdater(classOf[INodeBase[_, _]], classOf[MainNode[_, _]], "mainnode") + val inodeupdater: AtomicReferenceFieldUpdater[INodeBase[_, _], MainNode[_, _]] = INodeBase.updater class MangledHashing[K] extends Hashing[K] { def hash(k: K): Int = scala.util.hashing.byteswap32(k.##)