replace unicode arrows
* ⇒, →, ← * because we don't want to show them in documentation snippets and then it's complicated to avoid that when snippets are located in src/test/scala in individual modules * dont replace object `→` in FSM.scala and PersistentFSM.scala
This commit is contained in:
Patrik Nordwall
parent
e4d38f92a4
commit
5c96a5f556
1521 changed files with 18846 additions and 18786 deletions
|
|
@ -30,8 +30,8 @@ object ORSet {
|
|||
* Extract the [[ORSet#elements]] of an `ORSet`.
|
||||
*/
|
||||
def unapply(a: ReplicatedData): Option[Set[Any]] = a match {
|
||||
case s: ORSet[Any] @unchecked ⇒ Some(s.elements)
|
||||
case _ ⇒ None
|
||||
case s: ORSet[Any] @unchecked => Some(s.elements)
|
||||
case _ => None
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -56,13 +56,13 @@ object ORSet {
|
|||
@InternalApi private[akka] final case class AddDeltaOp[A](underlying: ORSet[A]) extends AtomicDeltaOp[A] {
|
||||
|
||||
override def merge(that: DeltaOp): DeltaOp = that match {
|
||||
case AddDeltaOp(u) ⇒
|
||||
case AddDeltaOp(u) =>
|
||||
// Note that we only merge deltas originating from the same node
|
||||
AddDeltaOp(new ORSet(
|
||||
concatElementsMap(u.elementsMap.asInstanceOf[Map[A, Dot]]),
|
||||
underlying.vvector.merge(u.vvector)))
|
||||
case _: AtomicDeltaOp[A] ⇒ DeltaGroup(Vector(this, that))
|
||||
case DeltaGroup(ops) ⇒ DeltaGroup(this +: ops)
|
||||
case _: AtomicDeltaOp[A] => DeltaGroup(Vector(this, that))
|
||||
case DeltaGroup(ops) => DeltaGroup(this +: ops)
|
||||
}
|
||||
|
||||
private def concatElementsMap(thatMap: Map[A, Dot]): Map[A, Dot] = {
|
||||
|
|
@ -80,16 +80,16 @@ object ORSet {
|
|||
throw new IllegalArgumentException(s"RemoveDeltaOp should contain one removed element, but was $underlying")
|
||||
|
||||
override def merge(that: DeltaOp): DeltaOp = that match {
|
||||
case _: AtomicDeltaOp[A] ⇒ DeltaGroup(Vector(this, that)) // keep it simple for removals
|
||||
case DeltaGroup(ops) ⇒ DeltaGroup(this +: ops)
|
||||
case _: AtomicDeltaOp[A] => DeltaGroup(Vector(this, that)) // keep it simple for removals
|
||||
case DeltaGroup(ops) => DeltaGroup(this +: ops)
|
||||
}
|
||||
}
|
||||
|
||||
/** INTERNAL API: Used for `clear` but could be used for other cases also */
|
||||
@InternalApi private[akka] final case class FullStateDeltaOp[A](underlying: ORSet[A]) extends AtomicDeltaOp[A] {
|
||||
override def merge(that: DeltaOp): DeltaOp = that match {
|
||||
case _: AtomicDeltaOp[A] ⇒ DeltaGroup(Vector(this, that))
|
||||
case DeltaGroup(ops) ⇒ DeltaGroup(this +: ops)
|
||||
case _: AtomicDeltaOp[A] => DeltaGroup(Vector(this, that))
|
||||
case DeltaGroup(ops) => DeltaGroup(this +: ops)
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -99,14 +99,14 @@ object ORSet {
|
|||
@InternalApi private[akka] final case class DeltaGroup[A](ops: immutable.IndexedSeq[DeltaOp])
|
||||
extends DeltaOp with ReplicatedDeltaSize {
|
||||
override def merge(that: DeltaOp): DeltaOp = that match {
|
||||
case thatAdd: AddDeltaOp[A] ⇒
|
||||
case thatAdd: AddDeltaOp[A] =>
|
||||
// merge AddDeltaOp into last AddDeltaOp in the group, if possible
|
||||
ops.last match {
|
||||
case thisAdd: AddDeltaOp[A] ⇒ DeltaGroup(ops.dropRight(1) :+ thisAdd.merge(thatAdd))
|
||||
case _ ⇒ DeltaGroup(ops :+ thatAdd)
|
||||
case thisAdd: AddDeltaOp[A] => DeltaGroup(ops.dropRight(1) :+ thisAdd.merge(thatAdd))
|
||||
case _ => DeltaGroup(ops :+ thatAdd)
|
||||
}
|
||||
case DeltaGroup(thatOps) ⇒ DeltaGroup(ops ++ thatOps)
|
||||
case _ ⇒ DeltaGroup(ops :+ that)
|
||||
case DeltaGroup(thatOps) => DeltaGroup(ops ++ thatOps)
|
||||
case _ => DeltaGroup(ops :+ that)
|
||||
}
|
||||
|
||||
override def zero: ORSet[A] = ORSet.empty
|
||||
|
|
@ -127,8 +127,8 @@ object ORSet {
|
|||
|
||||
@tailrec def dropDots(remaining: List[(UniqueAddress, Long)], acc: List[(UniqueAddress, Long)]): List[(UniqueAddress, Long)] =
|
||||
remaining match {
|
||||
case Nil ⇒ acc
|
||||
case (d @ (node, v1)) :: rest ⇒
|
||||
case Nil => acc
|
||||
case (d @ (node, v1)) :: rest =>
|
||||
val v2 = vvector.versionAt(node)
|
||||
if (v2 >= v1)
|
||||
// dot is dominated by version vector, drop it
|
||||
|
|
@ -141,12 +141,12 @@ object ORSet {
|
|||
VersionVector.empty
|
||||
else {
|
||||
dot match {
|
||||
case OneVersionVector(node, v1) ⇒
|
||||
case OneVersionVector(node, v1) =>
|
||||
// if dot is dominated by version vector, drop it
|
||||
if (vvector.versionAt(node) >= v1) VersionVector.empty
|
||||
else dot
|
||||
|
||||
case ManyVersionVector(vs) ⇒
|
||||
case ManyVersionVector(vs) =>
|
||||
val remaining = vs.toList
|
||||
val newDots = dropDots(remaining, Nil)
|
||||
VersionVector(newDots)
|
||||
|
|
@ -163,11 +163,11 @@ object ORSet {
|
|||
|
||||
private def mergeCommonKeys[A](commonKeys: Iterator[A], lhs: ORSet[A], rhs: ORSet[A]): Map[A, ORSet.Dot] = {
|
||||
commonKeys.foldLeft(Map.empty[A, ORSet.Dot]) {
|
||||
case (acc, k) ⇒
|
||||
case (acc, k) =>
|
||||
val lhsDots = lhs.elementsMap(k)
|
||||
val rhsDots = rhs.elementsMap(k)
|
||||
(lhsDots, rhsDots) match {
|
||||
case (OneVersionVector(n1, v1), OneVersionVector(n2, v2)) ⇒
|
||||
case (OneVersionVector(n1, v1), OneVersionVector(n2, v2)) =>
|
||||
if (n1 == n2 && v1 == v2)
|
||||
// one single common dot
|
||||
acc.updated(k, lhsDots)
|
||||
|
|
@ -180,9 +180,9 @@ object ORSet {
|
|||
if (merged.isEmpty) acc
|
||||
else acc.updated(k, merged)
|
||||
}
|
||||
case (ManyVersionVector(lhsVs), ManyVersionVector(rhsVs)) ⇒
|
||||
case (ManyVersionVector(lhsVs), ManyVersionVector(rhsVs)) =>
|
||||
val commonDots = lhsVs.filter {
|
||||
case (thisDotNode, v) ⇒ rhsVs.get(thisDotNode).exists(_ == v)
|
||||
case (thisDotNode, v) => rhsVs.get(thisDotNode).exists(_ == v)
|
||||
}
|
||||
val commonDotsKeys = commonDots.keys
|
||||
val lhsUniqueDots = lhsVs -- commonDotsKeys
|
||||
|
|
@ -193,9 +193,9 @@ object ORSet {
|
|||
// Perfectly possible that an item in both sets should be dropped
|
||||
if (merged.isEmpty) acc
|
||||
else acc.updated(k, merged)
|
||||
case (ManyVersionVector(lhsVs), OneVersionVector(n2, v2)) ⇒
|
||||
case (ManyVersionVector(lhsVs), OneVersionVector(n2, v2)) =>
|
||||
val commonDots = lhsVs.filter {
|
||||
case (n1, v1) ⇒ v1 == v2 && n1 == n2
|
||||
case (n1, v1) => v1 == v2 && n1 == n2
|
||||
}
|
||||
val commonDotsKeys = commonDots.keys
|
||||
val lhsUniqueDots = lhsVs -- commonDotsKeys
|
||||
|
|
@ -206,9 +206,9 @@ object ORSet {
|
|||
// Perfectly possible that an item in both sets should be dropped
|
||||
if (merged.isEmpty) acc
|
||||
else acc.updated(k, merged)
|
||||
case (OneVersionVector(n1, v1), ManyVersionVector(rhsVs)) ⇒
|
||||
case (OneVersionVector(n1, v1), ManyVersionVector(rhsVs)) =>
|
||||
val commonDots = rhsVs.filter {
|
||||
case (n2, v2) ⇒ v1 == v2 && n1 == n2
|
||||
case (n2, v2) => v1 == v2 && n1 == n2
|
||||
}
|
||||
val commonDotsKeys = commonDots.keys
|
||||
val lhsUnique = if (commonDotsKeys.isEmpty) lhsDots else VersionVector.empty
|
||||
|
|
@ -235,7 +235,7 @@ object ORSet {
|
|||
private def mergeDisjointKeys[A](keys: Iterator[A], elementsMap: Map[A, ORSet.Dot], vvector: VersionVector,
|
||||
accumulator: Map[A, ORSet.Dot]): Map[A, ORSet.Dot] = {
|
||||
keys.foldLeft(accumulator) {
|
||||
case (acc, k) ⇒
|
||||
case (acc, k) =>
|
||||
val dots = elementsMap(k)
|
||||
if (vvector > dots || vvector == dots)
|
||||
acc
|
||||
|
|
@ -327,12 +327,12 @@ final class ORSet[A] private[akka] (
|
|||
val newVvector = vvector + node
|
||||
val newDot = VersionVector(node, newVvector.versionAt(node))
|
||||
val newDelta = delta match {
|
||||
case None ⇒
|
||||
ORSet.AddDeltaOp(new ORSet(Map(element → newDot), newDot))
|
||||
case Some(existing: ORSet.AddDeltaOp[A]) ⇒
|
||||
existing.merge(ORSet.AddDeltaOp(new ORSet(Map(element → newDot), newDot)))
|
||||
case Some(d) ⇒
|
||||
d.merge(ORSet.AddDeltaOp(new ORSet(Map(element → newDot), newDot)))
|
||||
case None =>
|
||||
ORSet.AddDeltaOp(new ORSet(Map(element -> newDot), newDot))
|
||||
case Some(existing: ORSet.AddDeltaOp[A]) =>
|
||||
existing.merge(ORSet.AddDeltaOp(new ORSet(Map(element -> newDot), newDot)))
|
||||
case Some(d) =>
|
||||
d.merge(ORSet.AddDeltaOp(new ORSet(Map(element -> newDot), newDot)))
|
||||
}
|
||||
assignAncestor(new ORSet(elementsMap.updated(element, newDot), newVvector, Some(newDelta)))
|
||||
}
|
||||
|
|
@ -366,10 +366,10 @@ final class ORSet[A] private[akka] (
|
|||
*/
|
||||
@InternalApi private[akka] def remove(node: UniqueAddress, element: A): ORSet[A] = {
|
||||
val deltaDot = VersionVector(node, vvector.versionAt(node))
|
||||
val rmOp = ORSet.RemoveDeltaOp(new ORSet(Map(element → deltaDot), vvector))
|
||||
val rmOp = ORSet.RemoveDeltaOp(new ORSet(Map(element -> deltaDot), vvector))
|
||||
val newDelta = delta match {
|
||||
case None ⇒ rmOp
|
||||
case Some(d) ⇒ d.merge(rmOp)
|
||||
case None => rmOp
|
||||
case Some(d) => d.merge(rmOp)
|
||||
}
|
||||
assignAncestor(copy(elementsMap = elementsMap - element, delta = Some(newDelta)))
|
||||
}
|
||||
|
|
@ -391,8 +391,8 @@ final class ORSet[A] private[akka] (
|
|||
val newFullState = new ORSet[A](elementsMap = Map.empty, vvector)
|
||||
val clearOp = ORSet.FullStateDeltaOp(newFullState)
|
||||
val newDelta = delta match {
|
||||
case None ⇒ clearOp
|
||||
case Some(d) ⇒ d.merge(clearOp)
|
||||
case None => clearOp
|
||||
case Some(d) => d.merge(clearOp)
|
||||
}
|
||||
assignAncestor(newFullState.copy(delta = Some(newDelta)))
|
||||
}
|
||||
|
|
@ -426,7 +426,7 @@ final class ORSet[A] private[akka] (
|
|||
val entries00 = ORSet.mergeCommonKeys(commonKeys, this, that)
|
||||
val entries0 =
|
||||
if (addDeltaOp)
|
||||
entries00 ++ this.elementsMap.filter { case (elem, _) ⇒ !that.elementsMap.contains(elem) }
|
||||
entries00 ++ this.elementsMap.filter { case (elem, _) => !that.elementsMap.contains(elem) }
|
||||
else {
|
||||
val thisUniqueKeys = this.elementsMap.keysIterator.filterNot(that.elementsMap.contains)
|
||||
ORSet.mergeDisjointKeys(thisUniqueKeys, this.elementsMap, that.vvector, entries00)
|
||||
|
|
@ -441,15 +441,15 @@ final class ORSet[A] private[akka] (
|
|||
|
||||
override def mergeDelta(thatDelta: ORSet.DeltaOp): ORSet[A] = {
|
||||
thatDelta match {
|
||||
case d: ORSet.AddDeltaOp[A] ⇒ dryMerge(d.underlying, addDeltaOp = true)
|
||||
case d: ORSet.RemoveDeltaOp[A] ⇒ mergeRemoveDelta(d)
|
||||
case d: ORSet.FullStateDeltaOp[A] ⇒ dryMerge(d.underlying, addDeltaOp = false)
|
||||
case ORSet.DeltaGroup(ops) ⇒
|
||||
case d: ORSet.AddDeltaOp[A] => dryMerge(d.underlying, addDeltaOp = true)
|
||||
case d: ORSet.RemoveDeltaOp[A] => mergeRemoveDelta(d)
|
||||
case d: ORSet.FullStateDeltaOp[A] => dryMerge(d.underlying, addDeltaOp = false)
|
||||
case ORSet.DeltaGroup(ops) =>
|
||||
ops.foldLeft(this) {
|
||||
case (acc, op: ORSet.AddDeltaOp[A]) ⇒ acc.dryMerge(op.underlying, addDeltaOp = true)
|
||||
case (acc, op: ORSet.RemoveDeltaOp[A]) ⇒ acc.mergeRemoveDelta(op)
|
||||
case (acc, op: ORSet.FullStateDeltaOp[A]) ⇒ acc.dryMerge(op.underlying, addDeltaOp = false)
|
||||
case (acc, op: ORSet.DeltaGroup[A]) ⇒
|
||||
case (acc, op: ORSet.AddDeltaOp[A]) => acc.dryMerge(op.underlying, addDeltaOp = true)
|
||||
case (acc, op: ORSet.RemoveDeltaOp[A]) => acc.mergeRemoveDelta(op)
|
||||
case (acc, op: ORSet.FullStateDeltaOp[A]) => acc.dryMerge(op.underlying, addDeltaOp = false)
|
||||
case (acc, op: ORSet.DeltaGroup[A]) =>
|
||||
throw new IllegalArgumentException("ORSet.DeltaGroup should not be nested")
|
||||
}
|
||||
}
|
||||
|
|
@ -459,23 +459,23 @@ final class ORSet[A] private[akka] (
|
|||
val that = thatDelta.underlying
|
||||
val (elem, thatDot) = that.elementsMap.head
|
||||
def deleteDots = that.vvector.versionsIterator
|
||||
def deleteDotsNodes = deleteDots.map { case (dotNode, _) ⇒ dotNode }
|
||||
def deleteDotsNodes = deleteDots.map { case (dotNode, _) => dotNode }
|
||||
val newElementsMap = {
|
||||
val thisDotOption = this.elementsMap.get(elem)
|
||||
val deleteDotsAreGreater = deleteDots.forall {
|
||||
case (dotNode, dotV) ⇒
|
||||
case (dotNode, dotV) =>
|
||||
thisDotOption match {
|
||||
case Some(thisDot) ⇒ thisDot.versionAt(dotNode) <= dotV
|
||||
case None ⇒ false
|
||||
case Some(thisDot) => thisDot.versionAt(dotNode) <= dotV
|
||||
case None => false
|
||||
}
|
||||
}
|
||||
if (deleteDotsAreGreater) {
|
||||
thisDotOption match {
|
||||
case Some(thisDot) ⇒
|
||||
if (thisDot.versionsIterator.forall { case (thisDotNode, _) ⇒ deleteDotsNodes.contains(thisDotNode) })
|
||||
case Some(thisDot) =>
|
||||
if (thisDot.versionsIterator.forall { case (thisDotNode, _) => deleteDotsNodes.contains(thisDotNode) })
|
||||
elementsMap - elem
|
||||
else elementsMap
|
||||
case None ⇒
|
||||
case None =>
|
||||
elementsMap
|
||||
}
|
||||
} else
|
||||
|
|
@ -499,7 +499,7 @@ final class ORSet[A] private[akka] (
|
|||
|
||||
override def prune(removedNode: UniqueAddress, collapseInto: UniqueAddress): ORSet[A] = {
|
||||
val pruned = elementsMap.foldLeft(Map.empty[A, ORSet.Dot]) {
|
||||
case (acc, (elem, dot)) ⇒
|
||||
case (acc, (elem, dot)) =>
|
||||
if (dot.needPruningFrom(removedNode)) acc.updated(elem, dot.prune(removedNode, collapseInto))
|
||||
else acc
|
||||
}
|
||||
|
|
@ -509,14 +509,14 @@ final class ORSet[A] private[akka] (
|
|||
// re-add elements that were pruned, to bump dots to right vvector
|
||||
val newSet = new ORSet(elementsMap = elementsMap ++ pruned, vvector = vvector.prune(removedNode, collapseInto))
|
||||
pruned.keys.foldLeft(newSet) {
|
||||
case (s, elem) ⇒ s.add(collapseInto, elem)
|
||||
case (s, elem) => s.add(collapseInto, elem)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
override def pruningCleanup(removedNode: UniqueAddress): ORSet[A] = {
|
||||
val updated = elementsMap.foldLeft(elementsMap) {
|
||||
case (acc, (elem, dot)) ⇒
|
||||
case (acc, (elem, dot)) =>
|
||||
if (dot.needPruningFrom(removedNode)) acc.updated(elem, dot.pruningCleanup(removedNode))
|
||||
else acc
|
||||
}
|
||||
|
|
@ -532,8 +532,8 @@ final class ORSet[A] private[akka] (
|
|||
override def toString: String = s"OR$elements"
|
||||
|
||||
override def equals(o: Any): Boolean = o match {
|
||||
case other: ORSet[_] ⇒ vvector == other.vvector && elementsMap == other.elementsMap
|
||||
case _ ⇒ false
|
||||
case other: ORSet[_] => vvector == other.vvector && elementsMap == other.elementsMap
|
||||
case _ => false
|
||||
}
|
||||
|
||||
override def hashCode: Int = {
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue