raboof/pekko
1
0
Fork 0
Code Issues Pull requests Projects Releases 6 Packages Wiki Activity Actions 11

replace unicode arrows

Browse source 
* ⇒, →, ←
* 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 2019-02-09 15:25:39 +01:00
parent e4d38f92a4
commit 5c96a5f556
1521 changed files with 18846 additions and 18786 deletions
Download patch file Download diff file Expand all files Collapse all files

320
akka-distributed-data/src/main/scala/akka/cluster/ddata/protobuf/ReplicatedDataSerializer.scala
View file

@ -4,7 +4,7 @@
package akka.cluster.ddata.protobuf
import java.{ util, lang ⇒ jl }
import java.{ util, lang => jl }
import java.util.ArrayList
import java.util.Collections
import java.util.Comparator
@ -17,8 +17,8 @@ import scala.collection.immutable
import akka.actor.ExtendedActorSystem
import akka.cluster.ddata._
import akka.cluster.ddata.Replicator.Internal._
import akka.cluster.ddata.protobuf.msg.{ ReplicatedDataMessages ⇒ rd }
import akka.cluster.ddata.protobuf.msg.{ ReplicatorMessages ⇒ dm }
import akka.cluster.ddata.protobuf.msg.{ ReplicatedDataMessages => rd }
import akka.cluster.ddata.protobuf.msg.{ ReplicatorMessages => dm }
import akka.serialization.SerializerWithStringManifest
import akka.serialization.BaseSerializer
import akka.protobuf.{ ByteString, GeneratedMessage }
@ -43,16 +43,16 @@ private object ReplicatedDataSerializer {
def getKey(entry: A): Any
final def compare(x: A, y: A): Int = compareKeys(getKey(x), getKey(y))
private final def compareKeys(t1: Any, t2: Any): Int = (t1, t2) match {
case (k1: String, k2: String) ⇒ k1.compareTo(k2)
case (k1: String, k2) ⇒ -1
case (k1, k2: String) ⇒ 1
case (k1: Int, k2: Int) ⇒ k1.compareTo(k2)
case (k1: Int, k2) ⇒ -1
case (k1, k2: Int) ⇒ 1
case (k1: Long, k2: Long) ⇒ k1.compareTo(k2)
case (k1: Long, k2) ⇒ -1
case (k1, k2: Long) ⇒ 1
case (k1: OtherMessage, k2: OtherMessage) ⇒ OtherMessageComparator.compare(k1, k2)
case (k1: String, k2: String) => k1.compareTo(k2)
case (k1: String, k2) => -1
case (k1, k2: String) => 1
case (k1: Int, k2: Int) => k1.compareTo(k2)
case (k1: Int, k2) => -1
case (k1, k2: Int) => 1
case (k1: Long, k2: Long) => k1.compareTo(k2)
case (k1: Long, k2) => -1
case (k1, k2: Long) => 1
case (k1: OtherMessage, k2: OtherMessage) => OtherMessageComparator.compare(k1, k2)
}
}
@ -210,110 +210,110 @@ class ReplicatedDataSerializer(val system: ExtendedActorSystem)
private val ORMultiMapKeyManifest = "k"
private val VersionVectorManifest = "L"
private val fromBinaryMap = collection.immutable.HashMap[String, Array[Byte] ⇒ AnyRef](
GSetManifest → gsetFromBinary,
ORSetManifest → orsetFromBinary,
ORSetAddManifest → orsetAddFromBinary,
ORSetRemoveManifest → orsetRemoveFromBinary,
ORSetFullManifest → orsetFullFromBinary,
ORSetDeltaGroupManifest → orsetDeltaGroupFromBinary,
FlagManifest → flagFromBinary,
LWWRegisterManifest → lwwRegisterFromBinary,
GCounterManifest → gcounterFromBinary,
PNCounterManifest → pncounterFromBinary,
ORMapManifest → ormapFromBinary,
ORMapPutManifest → ormapPutFromBinary,
ORMapRemoveManifest → ormapRemoveFromBinary,
ORMapRemoveKeyManifest → ormapRemoveKeyFromBinary,
ORMapUpdateManifest → ormapUpdateFromBinary,
ORMapDeltaGroupManifest → ormapDeltaGroupFromBinary,
LWWMapManifest → lwwmapFromBinary,
PNCounterMapManifest → pncountermapFromBinary,
ORMultiMapManifest → multimapFromBinary,
DeletedDataManifest → (_ ⇒ DeletedData),
VersionVectorManifest → versionVectorFromBinary,
private val fromBinaryMap = collection.immutable.HashMap[String, Array[Byte] => AnyRef](
GSetManifest -> gsetFromBinary,
ORSetManifest -> orsetFromBinary,
ORSetAddManifest -> orsetAddFromBinary,
ORSetRemoveManifest -> orsetRemoveFromBinary,
ORSetFullManifest -> orsetFullFromBinary,
ORSetDeltaGroupManifest -> orsetDeltaGroupFromBinary,
FlagManifest -> flagFromBinary,
LWWRegisterManifest -> lwwRegisterFromBinary,
GCounterManifest -> gcounterFromBinary,
PNCounterManifest -> pncounterFromBinary,
ORMapManifest -> ormapFromBinary,
ORMapPutManifest -> ormapPutFromBinary,
ORMapRemoveManifest -> ormapRemoveFromBinary,
ORMapRemoveKeyManifest -> ormapRemoveKeyFromBinary,
ORMapUpdateManifest -> ormapUpdateFromBinary,
ORMapDeltaGroupManifest -> ormapDeltaGroupFromBinary,
LWWMapManifest -> lwwmapFromBinary,
PNCounterMapManifest -> pncountermapFromBinary,
ORMultiMapManifest -> multimapFromBinary,
DeletedDataManifest -> (_ => DeletedData),
VersionVectorManifest -> versionVectorFromBinary,
GSetKeyManifest → (bytes ⇒ GSetKey(keyIdFromBinary(bytes))),
ORSetKeyManifest → (bytes ⇒ ORSetKey(keyIdFromBinary(bytes))),
FlagKeyManifest → (bytes ⇒ FlagKey(keyIdFromBinary(bytes))),
LWWRegisterKeyManifest → (bytes ⇒ LWWRegisterKey(keyIdFromBinary(bytes))),
GCounterKeyManifest → (bytes ⇒ GCounterKey(keyIdFromBinary(bytes))),
PNCounterKeyManifest → (bytes ⇒ PNCounterKey(keyIdFromBinary(bytes))),
ORMapKeyManifest → (bytes ⇒ ORMapKey(keyIdFromBinary(bytes))),
LWWMapKeyManifest → (bytes ⇒ LWWMapKey(keyIdFromBinary(bytes))),
PNCounterMapKeyManifest → (bytes ⇒ PNCounterMapKey(keyIdFromBinary(bytes))),
ORMultiMapKeyManifest → (bytes ⇒ ORMultiMapKey(keyIdFromBinary(bytes))))
GSetKeyManifest -> (bytes => GSetKey(keyIdFromBinary(bytes))),
ORSetKeyManifest -> (bytes => ORSetKey(keyIdFromBinary(bytes))),
FlagKeyManifest -> (bytes => FlagKey(keyIdFromBinary(bytes))),
LWWRegisterKeyManifest -> (bytes => LWWRegisterKey(keyIdFromBinary(bytes))),
GCounterKeyManifest -> (bytes => GCounterKey(keyIdFromBinary(bytes))),
PNCounterKeyManifest -> (bytes => PNCounterKey(keyIdFromBinary(bytes))),
ORMapKeyManifest -> (bytes => ORMapKey(keyIdFromBinary(bytes))),
LWWMapKeyManifest -> (bytes => LWWMapKey(keyIdFromBinary(bytes))),
PNCounterMapKeyManifest -> (bytes => PNCounterMapKey(keyIdFromBinary(bytes))),
ORMultiMapKeyManifest -> (bytes => ORMultiMapKey(keyIdFromBinary(bytes))))
override def manifest(obj: AnyRef): String = obj match {
case _: ORSet[_] ⇒ ORSetManifest
case _: ORSet.AddDeltaOp[_] ⇒ ORSetAddManifest
case _: ORSet.RemoveDeltaOp[_] ⇒ ORSetRemoveManifest
case _: GSet[_] ⇒ GSetManifest
case _: GCounter ⇒ GCounterManifest
case _: PNCounter ⇒ PNCounterManifest
case _: Flag ⇒ FlagManifest
case _: LWWRegister[_] ⇒ LWWRegisterManifest
case _: ORMap[_, _] ⇒ ORMapManifest
case _: ORMap.PutDeltaOp[_, _] ⇒ ORMapPutManifest
case _: ORMap.RemoveDeltaOp[_, _] ⇒ ORMapRemoveManifest
case _: ORMap.RemoveKeyDeltaOp[_, _] ⇒ ORMapRemoveKeyManifest
case _: ORMap.UpdateDeltaOp[_, _] ⇒ ORMapUpdateManifest
case _: LWWMap[_, _] ⇒ LWWMapManifest
case _: PNCounterMap[_] ⇒ PNCounterMapManifest
case _: ORMultiMap[_, _] ⇒ ORMultiMapManifest
case DeletedData ⇒ DeletedDataManifest
case _: VersionVector ⇒ VersionVectorManifest
case _: ORSet[_] => ORSetManifest
case _: ORSet.AddDeltaOp[_] => ORSetAddManifest
case _: ORSet.RemoveDeltaOp[_] => ORSetRemoveManifest
case _: GSet[_] => GSetManifest
case _: GCounter => GCounterManifest
case _: PNCounter => PNCounterManifest
case _: Flag => FlagManifest
case _: LWWRegister[_] => LWWRegisterManifest
case _: ORMap[_, _] => ORMapManifest
case _: ORMap.PutDeltaOp[_, _] => ORMapPutManifest
case _: ORMap.RemoveDeltaOp[_, _] => ORMapRemoveManifest
case _: ORMap.RemoveKeyDeltaOp[_, _] => ORMapRemoveKeyManifest
case _: ORMap.UpdateDeltaOp[_, _] => ORMapUpdateManifest
case _: LWWMap[_, _] => LWWMapManifest
case _: PNCounterMap[_] => PNCounterMapManifest
case _: ORMultiMap[_, _] => ORMultiMapManifest
case DeletedData => DeletedDataManifest
case _: VersionVector => VersionVectorManifest
case _: ORSetKey[_] ⇒ ORSetKeyManifest
case _: GSetKey[_] ⇒ GSetKeyManifest
case _: GCounterKey ⇒ GCounterKeyManifest
case _: PNCounterKey ⇒ PNCounterKeyManifest
case _: FlagKey ⇒ FlagKeyManifest
case _: LWWRegisterKey[_] ⇒ LWWRegisterKeyManifest
case _: ORMapKey[_, _] ⇒ ORMapKeyManifest
case _: LWWMapKey[_, _] ⇒ LWWMapKeyManifest
case _: PNCounterMapKey[_] ⇒ PNCounterMapKeyManifest
case _: ORMultiMapKey[_, _] ⇒ ORMultiMapKeyManifest
case _: ORSetKey[_] => ORSetKeyManifest
case _: GSetKey[_] => GSetKeyManifest
case _: GCounterKey => GCounterKeyManifest
case _: PNCounterKey => PNCounterKeyManifest
case _: FlagKey => FlagKeyManifest
case _: LWWRegisterKey[_] => LWWRegisterKeyManifest
case _: ORMapKey[_, _] => ORMapKeyManifest
case _: LWWMapKey[_, _] => LWWMapKeyManifest
case _: PNCounterMapKey[_] => PNCounterMapKeyManifest
case _: ORMultiMapKey[_, _] => ORMultiMapKeyManifest
case _: ORSet.DeltaGroup[_] ⇒ ORSetDeltaGroupManifest
case _: ORMap.DeltaGroup[_, _] ⇒ ORMapDeltaGroupManifest
case _: ORSet.FullStateDeltaOp[_] ⇒ ORSetFullManifest
case _: ORSet.DeltaGroup[_] => ORSetDeltaGroupManifest
case _: ORMap.DeltaGroup[_, _] => ORMapDeltaGroupManifest
case _: ORSet.FullStateDeltaOp[_] => ORSetFullManifest
case _ ⇒
case _ =>
throw new IllegalArgumentException(s"Can't serialize object of type ${obj.getClass} in [${getClass.getName}]")
}
def toBinary(obj: AnyRef): Array[Byte] = obj match {
case m: ORSet[_] ⇒ compress(orsetToProto(m))
case m: ORSet.AddDeltaOp[_] ⇒ orsetToProto(m.underlying).toByteArray
case m: ORSet.RemoveDeltaOp[_] ⇒ orsetToProto(m.underlying).toByteArray
case m: GSet[_] ⇒ gsetToProto(m).toByteArray
case m: GCounter ⇒ gcounterToProto(m).toByteArray
case m: PNCounter ⇒ pncounterToProto(m).toByteArray
case m: Flag ⇒ flagToProto(m).toByteArray
case m: LWWRegister[_] ⇒ lwwRegisterToProto(m).toByteArray
case m: ORMap[_, _] ⇒ compress(ormapToProto(m))
case m: ORMap.PutDeltaOp[_, _] ⇒ ormapPutToProto(m).toByteArray
case m: ORMap.RemoveDeltaOp[_, _] ⇒ ormapRemoveToProto(m).toByteArray
case m: ORMap.RemoveKeyDeltaOp[_, _] ⇒ ormapRemoveKeyToProto(m).toByteArray
case m: ORMap.UpdateDeltaOp[_, _] ⇒ ormapUpdateToProto(m).toByteArray
case m: LWWMap[_, _] ⇒ compress(lwwmapToProto(m))
case m: PNCounterMap[_] ⇒ compress(pncountermapToProto(m))
case m: ORMultiMap[_, _] ⇒ compress(multimapToProto(m))
case DeletedData ⇒ dm.Empty.getDefaultInstance.toByteArray
case m: VersionVector ⇒ versionVectorToProto(m).toByteArray
case Key(id) ⇒ keyIdToBinary(id)
case m: ORSet.DeltaGroup[_] ⇒ orsetDeltaGroupToProto(m).toByteArray
case m: ORMap.DeltaGroup[_, _] ⇒ ormapDeltaGroupToProto(m).toByteArray
case m: ORSet.FullStateDeltaOp[_] ⇒ orsetToProto(m.underlying).toByteArray
case _ ⇒
case m: ORSet[_] => compress(orsetToProto(m))
case m: ORSet.AddDeltaOp[_] => orsetToProto(m.underlying).toByteArray
case m: ORSet.RemoveDeltaOp[_] => orsetToProto(m.underlying).toByteArray
case m: GSet[_] => gsetToProto(m).toByteArray
case m: GCounter => gcounterToProto(m).toByteArray
case m: PNCounter => pncounterToProto(m).toByteArray
case m: Flag => flagToProto(m).toByteArray
case m: LWWRegister[_] => lwwRegisterToProto(m).toByteArray
case m: ORMap[_, _] => compress(ormapToProto(m))
case m: ORMap.PutDeltaOp[_, _] => ormapPutToProto(m).toByteArray
case m: ORMap.RemoveDeltaOp[_, _] => ormapRemoveToProto(m).toByteArray
case m: ORMap.RemoveKeyDeltaOp[_, _] => ormapRemoveKeyToProto(m).toByteArray
case m: ORMap.UpdateDeltaOp[_, _] => ormapUpdateToProto(m).toByteArray
case m: LWWMap[_, _] => compress(lwwmapToProto(m))
case m: PNCounterMap[_] => compress(pncountermapToProto(m))
case m: ORMultiMap[_, _] => compress(multimapToProto(m))
case DeletedData => dm.Empty.getDefaultInstance.toByteArray
case m: VersionVector => versionVectorToProto(m).toByteArray
case Key(id) => keyIdToBinary(id)
case m: ORSet.DeltaGroup[_] => orsetDeltaGroupToProto(m).toByteArray
case m: ORMap.DeltaGroup[_, _] => ormapDeltaGroupToProto(m).toByteArray
case m: ORSet.FullStateDeltaOp[_] => orsetToProto(m.underlying).toByteArray
case _ =>
throw new IllegalArgumentException(s"Can't serialize object of type ${obj.getClass} in [${getClass.getName}]")
}
override def fromBinary(bytes: Array[Byte], manifest: String): AnyRef =
fromBinaryMap.get(manifest) match {
case Some(f) ⇒ f(bytes)
case None ⇒ throw new NotSerializableException(
case Some(f) => f(bytes)
case None => throw new NotSerializableException(
s"Unimplemented deserialization of message with manifest [$manifest] in [${getClass.getName}]")
}
@ -326,11 +326,11 @@ class ReplicatedDataSerializer(val system: ExtendedActorSystem)
val otherElements = new ArrayList[dm.OtherMessage]
val actorRefElements = new ArrayList[String]
gset.elements.foreach {
case s: String ⇒ stringElements.add(s)
case i: Int ⇒ intElements.add(i)
case l: Long ⇒ longElements.add(l)
case ref: ActorRef ⇒ actorRefElements.add(Serialization.serializedActorPath(ref))
case other ⇒ otherElements.add(otherMessageToProto(other))
case s: String => stringElements.add(s)
case i: Int => intElements.add(i)
case l: Long => longElements.add(l)
case ref: ActorRef => actorRefElements.add(Serialization.serializedActorPath(ref))
case other => otherElements.add(otherMessageToProto(other))
}
if (!stringElements.isEmpty) {
Collections.sort(stringElements)
@ -382,11 +382,11 @@ class ReplicatedDataSerializer(val system: ExtendedActorSystem)
var otherElementsMap = Map.empty[dm.OtherMessage, Any]
val actorRefElements = new ArrayList[ActorRef]
orset.elementsMap.keysIterator.foreach {
case s: String ⇒ stringElements.add(s)
case i: Int ⇒ intElements.add(i)
case l: Long ⇒ longElements.add(l)
case ref: ActorRef ⇒ actorRefElements.add(ref)
case other ⇒
case s: String => stringElements.add(s)
case i: Int => intElements.add(i)
case l: Long => longElements.add(l)
case ref: ActorRef => actorRefElements.add(ref)
case other =>
val enclosedMsg = otherMessageToProto(other)
otherElements.add(enclosedMsg)
// need the mapping back to the `other` when adding dots
@ -398,8 +398,8 @@ class ReplicatedDataSerializer(val system: ExtendedActorSystem)
val iter = elements.iterator
while (iter.hasNext) {
val element = iter.next() match {
case enclosedMsg: dm.OtherMessage ⇒ otherElementsMap(enclosedMsg)
case e ⇒ e
case enclosedMsg: dm.OtherMessage => otherElementsMap(enclosedMsg)
case e => e
}
b.addDots(versionVectorToProto(orset.elementsMap(element)))
}
@ -458,13 +458,13 @@ class ReplicatedDataSerializer(val system: ExtendedActorSystem)
val b = rd.ORSetDeltaGroup.newBuilder()
deltaGroup.ops.foreach {
case ORSet.AddDeltaOp(u) ⇒
case ORSet.AddDeltaOp(u) =>
b.addEntries(createEntry(rd.ORSetDeltaOp.Add, u))
case ORSet.RemoveDeltaOp(u) ⇒
case ORSet.RemoveDeltaOp(u) =>
b.addEntries(createEntry(rd.ORSetDeltaOp.Remove, u))
case ORSet.FullStateDeltaOp(u) ⇒
case ORSet.FullStateDeltaOp(u) =>
b.addEntries(createEntry(rd.ORSetDeltaOp.Full, u))
case ORSet.DeltaGroup(u) ⇒
case ORSet.DeltaGroup(u) =>
throw new IllegalArgumentException("ORSet.DeltaGroup should not be nested")
}
b.build()
@ -473,7 +473,7 @@ class ReplicatedDataSerializer(val system: ExtendedActorSystem)
private def orsetDeltaGroupFromBinary(bytes: Array[Byte]): ORSet.DeltaGroup[Any] = {
val deltaGroup = rd.ORSetDeltaGroup.parseFrom(bytes)
val ops: Vector[ORSet.DeltaOp] =
deltaGroup.getEntriesList.asScala.iterator.map { entry ⇒
deltaGroup.getEntriesList.asScala.iterator.map { entry =>
if (entry.getOperation == rd.ORSetDeltaOp.Add)
ORSet.AddDeltaOp(orsetFromProto(entry.getUnderlying))
else if (entry.getOperation == rd.ORSetDeltaOp.Remove)
@ -528,8 +528,8 @@ class ReplicatedDataSerializer(val system: ExtendedActorSystem)
def gcounterToProto(gcounter: GCounter): rd.GCounter = {
val b = rd.GCounter.newBuilder()
gcounter.state.toVector.sortBy { case (address, _) ⇒ address }.foreach {
case (address, value) ⇒ b.addEntries(rd.GCounter.Entry.newBuilder().
gcounter.state.toVector.sortBy { case (address, _) => address }.foreach {
case (address, value) => b.addEntries(rd.GCounter.Entry.newBuilder().
setNode(uniqueAddressToProto(address)).setValue(ByteString.copyFrom(value.toByteArray)))
}
b.build()
@ -539,8 +539,8 @@ class ReplicatedDataSerializer(val system: ExtendedActorSystem)
gcounterFromProto(rd.GCounter.parseFrom(bytes))
def gcounterFromProto(gcounter: rd.GCounter): GCounter = {
new GCounter(state = gcounter.getEntriesList.asScala.iterator.map(entry ⇒
uniqueAddressFromProto(entry.getNode) → BigInt(entry.getValue.toByteArray)).toMap)
new GCounter(state = gcounter.getEntriesList.asScala.iterator.map(entry =>
uniqueAddressFromProto(entry.getNode) -> BigInt(entry.getValue.toByteArray)).toMap)
}
def pncounterToProto(pncounter: PNCounter): rd.PNCounter =
@ -561,14 +561,14 @@ class ReplicatedDataSerializer(val system: ExtendedActorSystem)
/*
* Convert a Map[A, B] to an Iterable[Entry] where Entry is the protobuf map entry.
*/
private def getEntries[IKey, IValue, EntryBuilder <: GeneratedMessage.Builder[EntryBuilder], PEntry <: GeneratedMessage, PValue <: GeneratedMessage](input: Map[IKey, IValue], createBuilder: () ⇒ EntryBuilder, valueConverter: IValue ⇒ PValue)(implicit comparator: Comparator[PEntry], eh: ProtoMapEntryWriter[PEntry, EntryBuilder, PValue]): java.lang.Iterable[PEntry] = {
private def getEntries[IKey, IValue, EntryBuilder <: GeneratedMessage.Builder[EntryBuilder], PEntry <: GeneratedMessage, PValue <: GeneratedMessage](input: Map[IKey, IValue], createBuilder: () => EntryBuilder, valueConverter: IValue => PValue)(implicit comparator: Comparator[PEntry], eh: ProtoMapEntryWriter[PEntry, EntryBuilder, PValue]): java.lang.Iterable[PEntry] = {
// The resulting Iterable needs to be ordered deterministically in order to create same signature upon serializing same data
val protoEntries = new TreeSet[PEntry](comparator)
input.foreach {
case (key: String, value) ⇒ protoEntries.add(eh.setStringKey(createBuilder(), key, valueConverter(value)))
case (key: Int, value) ⇒ protoEntries.add(eh.setIntKey(createBuilder(), key, valueConverter(value)))
case (key: Long, value) ⇒ protoEntries.add(eh.setLongKey(createBuilder(), key, valueConverter(value)))
case (key, value) ⇒ protoEntries.add(eh.setOtherKey(createBuilder(), otherMessageToProto(key), valueConverter(value)))
case (key: String, value) => protoEntries.add(eh.setStringKey(createBuilder(), key, valueConverter(value)))
case (key: Int, value) => protoEntries.add(eh.setIntKey(createBuilder(), key, valueConverter(value)))
case (key: Long, value) => protoEntries.add(eh.setLongKey(createBuilder(), key, valueConverter(value)))
case (key, value) => protoEntries.add(eh.setOtherKey(createBuilder(), otherMessageToProto(key), valueConverter(value)))
}
protoEntries
}
@ -582,25 +582,25 @@ class ReplicatedDataSerializer(val system: ExtendedActorSystem)
def ormapFromBinary(bytes: Array[Byte]): ORMap[Any, ReplicatedData] =
ormapFromProto(rd.ORMap.parseFrom(decompress(bytes)))
def mapTypeFromProto[PEntry <: GeneratedMessage, A <: GeneratedMessage, B <: ReplicatedData](input: util.List[PEntry], valueCreator: A ⇒ B)(implicit eh: ProtoMapEntryReader[PEntry, A]): Map[Any, B] = {
input.asScala.map { entry ⇒
if (eh.hasStringKey(entry)) eh.getStringKey(entry) → valueCreator(eh.getValue(entry))
else if (eh.hasIntKey(entry)) eh.getIntKey(entry) → valueCreator(eh.getValue(entry))
else if (eh.hasLongKey(entry)) eh.getLongKey(entry) → valueCreator(eh.getValue(entry))
else if (eh.hasOtherKey(entry)) otherMessageFromProto(eh.getOtherKey(entry)) → valueCreator(eh.getValue(entry))
def mapTypeFromProto[PEntry <: GeneratedMessage, A <: GeneratedMessage, B <: ReplicatedData](input: util.List[PEntry], valueCreator: A => B)(implicit eh: ProtoMapEntryReader[PEntry, A]): Map[Any, B] = {
input.asScala.map { entry =>
if (eh.hasStringKey(entry)) eh.getStringKey(entry) -> valueCreator(eh.getValue(entry))
else if (eh.hasIntKey(entry)) eh.getIntKey(entry) -> valueCreator(eh.getValue(entry))
else if (eh.hasLongKey(entry)) eh.getLongKey(entry) -> valueCreator(eh.getValue(entry))
else if (eh.hasOtherKey(entry)) otherMessageFromProto(eh.getOtherKey(entry)) -> valueCreator(eh.getValue(entry))
else throw new IllegalArgumentException(s"Can't deserialize ${entry.getClass} because it does not have any key in the serialized message.")
}.toMap
}
def ormapFromProto(ormap: rd.ORMap): ORMap[Any, ReplicatedData] = {
val entries = mapTypeFromProto(ormap.getEntriesList, (v: dm.OtherMessage) ⇒ otherMessageFromProto(v).asInstanceOf[ReplicatedData])
val entries = mapTypeFromProto(ormap.getEntriesList, (v: dm.OtherMessage) => otherMessageFromProto(v).asInstanceOf[ReplicatedData])
new ORMap(
keys = orsetFromProto(ormap.getKeys),
entries,
ORMap.VanillaORMapTag)
}
def singleMapEntryFromProto[PEntry <: GeneratedMessage, A <: GeneratedMessage, B <: ReplicatedData](input: util.List[PEntry], valueCreator: A ⇒ B)(implicit eh: ProtoMapEntryReader[PEntry, A]): Map[Any, B] = {
def singleMapEntryFromProto[PEntry <: GeneratedMessage, A <: GeneratedMessage, B <: ReplicatedData](input: util.List[PEntry], valueCreator: A => B)(implicit eh: ProtoMapEntryReader[PEntry, A]): Map[Any, B] = {
val map = mapTypeFromProto(input, valueCreator)
if (map.size > 1)
throw new IllegalArgumentException(s"Can't deserialize the key/value pair in the ORMap delta - too many pairs on the wire")
@ -610,12 +610,12 @@ class ReplicatedDataSerializer(val system: ExtendedActorSystem)
def singleKeyEntryFromProto[PEntry <: GeneratedMessage, A <: GeneratedMessage](entryOption: Option[PEntry])(implicit eh: ProtoMapEntryReader[PEntry, A]): Any =
entryOption match {
case Some(entry) ⇒ if (eh.hasStringKey(entry)) eh.getStringKey(entry)
case Some(entry) => if (eh.hasStringKey(entry)) eh.getStringKey(entry)
else if (eh.hasIntKey(entry)) eh.getIntKey(entry)
else if (eh.hasLongKey(entry)) eh.getLongKey(entry)
else if (eh.hasOtherKey(entry)) otherMessageFromProto(eh.getOtherKey(entry))
else throw new IllegalArgumentException(s"Can't deserialize the key in the ORMap delta")
case _ ⇒ throw new IllegalArgumentException(s"Can't deserialize the key in the ORMap delta")
case _ => throw new IllegalArgumentException(s"Can't deserialize the key in the ORMap delta")
}
// wire protocol is always DeltaGroup
@ -656,12 +656,12 @@ class ReplicatedDataSerializer(val system: ExtendedActorSystem)
// this can be made client-extendable in the same way as Http codes in Spray are
private def zeroTagFromCode(code: Int) = code match {
case ORMap.VanillaORMapTag.value ⇒ ORMap.VanillaORMapTag
case PNCounterMap.PNCounterMapTag.value ⇒ PNCounterMap.PNCounterMapTag
case ORMultiMap.ORMultiMapTag.value ⇒ ORMultiMap.ORMultiMapTag
case ORMultiMap.ORMultiMapWithValueDeltasTag.value ⇒ ORMultiMap.ORMultiMapWithValueDeltasTag
case LWWMap.LWWMapTag.value ⇒ LWWMap.LWWMapTag
case _ ⇒ throw new IllegalArgumentException("Invalid ZeroTag code")
case ORMap.VanillaORMapTag.value => ORMap.VanillaORMapTag
case PNCounterMap.PNCounterMapTag.value => PNCounterMap.PNCounterMapTag
case ORMultiMap.ORMultiMapTag.value => ORMultiMap.ORMultiMapTag
case ORMultiMap.ORMultiMapWithValueDeltasTag.value => ORMultiMap.ORMultiMapWithValueDeltasTag
case LWWMap.LWWMapTag.value => LWWMap.LWWMapTag
case _ => throw new IllegalArgumentException("Invalid ZeroTag code")
}
private def ormapDeltaGroupFromBinary(bytes: Array[Byte]): ORMap.DeltaGroup[Any, ReplicatedData] = {
@ -671,9 +671,9 @@ class ReplicatedDataSerializer(val system: ExtendedActorSystem)
private def ormapDeltaGroupOpsFromBinary(bytes: Array[Byte]): scala.collection.immutable.IndexedSeq[ORMap.DeltaOp] = {
val deltaGroup = rd.ORMapDeltaGroup.parseFrom(bytes)
val ops: Vector[ORMap.DeltaOp] =
deltaGroup.getEntriesList.asScala.iterator.map { entry ⇒
deltaGroup.getEntriesList.asScala.iterator.map { entry =>
if (entry.getOperation == rd.ORMapDeltaOp.ORMapPut) {
val map = singleMapEntryFromProto(entry.getEntryDataList, (v: dm.OtherMessage) ⇒ otherMessageFromProto(v).asInstanceOf[ReplicatedData])
val map = singleMapEntryFromProto(entry.getEntryDataList, (v: dm.OtherMessage) => otherMessageFromProto(v).asInstanceOf[ReplicatedData])
ORMap.PutDeltaOp(ORSet.AddDeltaOp(orsetFromProto(entry.getUnderlying)), map.head, zeroTagFromCode(entry.getZeroTag))
} else if (entry.getOperation == rd.ORMapDeltaOp.ORMapRemove) {
ORMap.RemoveDeltaOp(ORSet.RemoveDeltaOp(orsetFromProto(entry.getUnderlying)), zeroTagFromCode(entry.getZeroTag))
@ -681,7 +681,7 @@ class ReplicatedDataSerializer(val system: ExtendedActorSystem)
val elem = singleKeyEntryFromProto(entry.getEntryDataList.asScala.headOption)
ORMap.RemoveKeyDeltaOp(ORSet.RemoveDeltaOp(orsetFromProto(entry.getUnderlying)), elem, zeroTagFromCode(entry.getZeroTag))
} else if (entry.getOperation == rd.ORMapDeltaOp.ORMapUpdate) {
val map = mapTypeFromProto(entry.getEntryDataList, (v: dm.OtherMessage) ⇒ otherMessageFromProto(v).asInstanceOf[ReplicatedDelta])
val map = mapTypeFromProto(entry.getEntryDataList, (v: dm.OtherMessage) => otherMessageFromProto(v).asInstanceOf[ReplicatedDelta])
ORMap.UpdateDeltaOp(ORSet.AddDeltaOp(orsetFromProto(entry.getUnderlying)), map, zeroTagFromCode(entry.getZeroTag))
} else
throw new NotSerializableException(s"Unknown ORMap delta operation ${entry.getOperation}")
@ -719,10 +719,10 @@ class ReplicatedDataSerializer(val system: ExtendedActorSystem)
.setUnderlying(orsetToProto(u))
.setZeroTag(zt)
m.foreach {
case (key: String, value) ⇒ builder.addEntryData(rd.ORMapDeltaGroup.MapEntry.newBuilder().setStringKey(key).setValue(otherMessageToProto(value)).build())
case (key: Int, value) ⇒ builder.addEntryData(rd.ORMapDeltaGroup.MapEntry.newBuilder().setIntKey(key).setValue(otherMessageToProto(value)).build())
case (key: Long, value) ⇒ builder.addEntryData(rd.ORMapDeltaGroup.MapEntry.newBuilder().setLongKey(key).setValue(otherMessageToProto(value)).build())
case (key, value) ⇒ builder.addEntryData(rd.ORMapDeltaGroup.MapEntry.newBuilder().setOtherKey(otherMessageToProto(key)).setValue(otherMessageToProto(value)).build())
case (key: String, value) => builder.addEntryData(rd.ORMapDeltaGroup.MapEntry.newBuilder().setStringKey(key).setValue(otherMessageToProto(value)).build())
case (key: Int, value) => builder.addEntryData(rd.ORMapDeltaGroup.MapEntry.newBuilder().setIntKey(key).setValue(otherMessageToProto(value)).build())
case (key: Long, value) => builder.addEntryData(rd.ORMapDeltaGroup.MapEntry.newBuilder().setLongKey(key).setValue(otherMessageToProto(value)).build())
case (key, value) => builder.addEntryData(rd.ORMapDeltaGroup.MapEntry.newBuilder().setOtherKey(otherMessageToProto(key)).setValue(otherMessageToProto(value)).build())
}
builder
}
@ -731,10 +731,10 @@ class ReplicatedDataSerializer(val system: ExtendedActorSystem)
def createEntryWithKey(opType: rd.ORMapDeltaOp, u: ORSet[_], k: Any, zt: Int) = {
val entryDataBuilder = rd.ORMapDeltaGroup.MapEntry.newBuilder()
k match {
case key: String ⇒ entryDataBuilder.setStringKey(key)
case key: Int ⇒ entryDataBuilder.setIntKey(key)
case key: Long ⇒ entryDataBuilder.setLongKey(key)
case key ⇒ entryDataBuilder.setOtherKey(otherMessageToProto(key))
case key: String => entryDataBuilder.setStringKey(key)
case key: Int => entryDataBuilder.setIntKey(key)
case key: Long => entryDataBuilder.setLongKey(key)
case key => entryDataBuilder.setOtherKey(otherMessageToProto(key))
}
val builder = rd.ORMapDeltaGroup.Entry.newBuilder()
.setOperation(opType)
@ -746,15 +746,15 @@ class ReplicatedDataSerializer(val system: ExtendedActorSystem)
val b = rd.ORMapDeltaGroup.newBuilder()
deltaGroupOps.foreach {
case ORMap.PutDeltaOp(op, pair, zt) ⇒
case ORMap.PutDeltaOp(op, pair, zt) =>
b.addEntries(createEntry(rd.ORMapDeltaOp.ORMapPut, op.asInstanceOf[ORSet.AddDeltaOp[_]].underlying, Map(pair), zt.value))
case ORMap.RemoveDeltaOp(op, zt) ⇒
case ORMap.RemoveDeltaOp(op, zt) =>
b.addEntries(createEntry(rd.ORMapDeltaOp.ORMapRemove, op.asInstanceOf[ORSet.RemoveDeltaOp[_]].underlying, Map.empty, zt.value))
case ORMap.RemoveKeyDeltaOp(op, k, zt) ⇒
case ORMap.RemoveKeyDeltaOp(op, k, zt) =>
b.addEntries(createEntryWithKey(rd.ORMapDeltaOp.ORMapRemoveKey, op.asInstanceOf[ORSet.RemoveDeltaOp[_]].underlying, k, zt.value))
case ORMap.UpdateDeltaOp(op, m, zt) ⇒
case ORMap.UpdateDeltaOp(op, m, zt) =>
b.addEntries(createEntry(rd.ORMapDeltaOp.ORMapUpdate, op.asInstanceOf[ORSet.AddDeltaOp[_]].underlying, m, zt.value))
case ORMap.DeltaGroup(u) ⇒
case ORMap.DeltaGroup(u) =>
throw new IllegalArgumentException("ORMap.DeltaGroup should not be nested")
}
b.build()