def serialize(self):
mkcv = MultiKeyCausalValue()
# Serialize the vector clock for this particular lattice by adding each
# key-counter pair.
self.vector_clock.serialize(mkcv.vector_clock)
# Serialize the vector clocks for each of the keys this lattice depends
# on.
for key in self.dependencies:
kv = mkcv.add_dependences()
kv.key = key
self.dependencies[key].serialize(kv.vector_clock)
# Add the value(s) stored by this lattice.
for v in self.value:
mkcv.values.add(v)
return mkcv, MULTI_CAUSAL
def _deserialize(self, tup):
if tup.lattice_type == LWW:
# Deserialize last-writer-wins lattices
val = LWWValue()
val.ParseFromString(tup.payload)
return LWWPairLattice(val.timestamp, val.value)
elif tup.lattice_type == SET:
# Deserialize unordered-set lattices
s = SetValue()
s.ParseFromString(tup.payload)
result = set()
for k in s.values:
result.add(k)
return SetLattice(result)
elif tup.lattice_type == ORDERED_SET:
# Deserialize ordered-set lattices
res = ListBasedOrderedSet()
val = SetValue()
val.ParseFromString(tup.payload)
for v in val.values:
res.insert(v)
return OrderedSetLattice(res)
elif tup.lattice_type == SINGLE_CAUSAL:
# Deserialize single-key causal lattices
val = SingleKeyCausalValue()
# Deserialize the vector_clock stored in the Protobuf into a
# MapLattice, where each value is a MaxIntLattice of the VC
# counter.
vc = VectorClock(val.vector_clock, True)
# Create a SetLattice with the value(s) stored by this lattice.
values = set()
for v in val.values():
values.add(v)
return SingleKeyCasaulLattice(vc, SetLattice(values))
elif tup.lattice_type == MULTI_CAUSAL:
# Deserialize multi-key causal lattices
val = MultiKeyCausalValue()
# Deserialize the vector_clock stored in the Protobuf into a
# MapLattice, where each value is a MaxIntLattice of the VC
# counter.
vc = VectorClock(val.vector_clock, True)
# Deserialize the set of dependencies of this key into a MapLattice
# where the keys are names of other KVS keys and the values are
# MapLattices that have the vector clocks for those keys.
dep_map = {}
for kv in val.dependencies:
key = kv.key
dep_map[key] = VectorClock(kv.vector_clock, True)
# Create a SetLattice with the value(s) stored by this lattice.
values = set()
for v in val.values():
values.add(v)
dependencies = MapLattice(dep_map)
value = SetLattice(values)
return MultiKeyCausalLattice(vc, dependencies, value)
else:
raise ValueError('Unsupported type cannot be serialized: ' +
str(tup.lattice_type))