ORSet

这段代码实现了OR-Set，是一种基于版本向量的CRDT，用于实现集合的合并。OR-Set由两个集合add和remove组成，add集合存储添加的元素，remove集合存储删除的元素。每个元素都有一个版本向量，用于标识该元素的添加和删除操作。其中，add集合中的元素版本向量的值大于remove集合中的元素版本向量的值，表示该元素是存在的。OR-Set支持添加和删除元素，以及合并两个OR-Set。其中，添加元素时，会将该元素的版本向量加1，删除元素时，会将该元素的版本向量加1并放入remove集合中。合并两个OR-Set时，会将两个OR-Set的add集合和remove集合分别合并，然后将remove集合中版本向量小于add集合中版本向量的元素从remove集合中删除，最后返回合并后的OR-Set。

import VClock

def ORSet():
    return (dict(), dict())

def zero():
    return ORSet()

def value(s: ORSet):
    add, rem = s
    return {key for key in set(add.keys()) | set(rem.keys()) 
        if VClock.compare(add.get(key, VClock.zero()), rem.get(key, VClock.zero())) != VClock.Ord.Lt}

def add(s: ORSet, replica_id, value):
    add, rem = s
    add[value] = VClock.inc(add.get(value, VClock.zero()), replica_id)
    print(add[value])

def rem(s: ORSet, replica_id, value):
    add, rem = s
    rem[value] = VClock.inc(rem.get(value, VClock.zero()), replica_id)

def merge(s1: ORSet, s2: ORSet):
    add_1, rem_1 = s1
    add_2, rem_2 = s2

    merged_add = { key: VClock.merge(add_1.get(key, VClock.zero()), add_2.get(key, VClock.zero())) 
        for key in set(add_1.keys()) | set(add_2.keys()) }

    merged_rem = { key: VClock.merge(rem_1.get(key, VClock.zero()), rem_2.get(key, VClock.zero())) 
        for key in set(rem_1.keys()) | set(rem_2.keys()) }

    cleared_merged_rem = { key: merged_rem[key] for key in set(merged_rem.keys())
        if VClock.compare(merged_add.get(key, VClock.zero()), merged_rem[key]) == VClock.Ord.Lt or 
            VClock.compare(merged_add.get(key, VClock.zero()), merged_rem[key]) == VClock.Ord.Cc }

    return (merged_add, cleared_merged_rem)

import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

public class ORSet {
    private Map<String, Map<Integer, Integer>> add;
    private Map<String, Map<Integer, Integer>> rem;

    public ORSet() {
        add = new HashMap<>();
        rem = new HashMap<>();
    }

    public static ORSet zero() {
        return new ORSet();
    }

    public Set<String> value() {
        Set<String> res = new HashSet<>();
        for (String key : add.keySet()) {
            if (!rem.containsKey(key) || !compare(add.get(key), rem.get(key)).equals(Ord.Lt)) {
                res.add(key);
            }
        }
        for (String key : rem.keySet()) {
            if (!add.containsKey(key)) {
                res.add(key);
            }
        }
        return res;
    }

    public void add(int replica_id, String value) {
        if (!add.containsKey(value)) {
            add.put(value, new HashMap<>());
        }
        Map<Integer, Integer> clock = add.get(value);
        clock.put(replica_id, clock.getOrDefault(replica_id, 0) + 1);
    }

    public void rem(int replica_id, String value) {
        if (!rem.containsKey(value)) {
            rem.put(value, new HashMap<>());
        }
        Map<Integer, Integer> clock = rem.get(value);
        clock.put(replica_id, clock.getOrDefault(replica_id, 0) + 1);
    }

    public void merge(ORSet other) {
        for (String key : other.add.keySet()) {
            if (!add.containsKey(key)) {
                add.put(key, new HashMap<>());
            }
            Map<Integer, Integer> clock = add.get(key);
            for (Map.Entry<Integer, Integer> entry : other.add.get(key).entrySet()) {
                int replica_id = entry.getKey();
                int timestamp = entry.getValue();
                clock.put(replica_id, Math.max(clock.getOrDefault(replica_id, 0), timestamp));
            }
        }
        for (String key : other.rem.keySet()) {
            if (!rem.containsKey(key)) {
                rem.put(key, new HashMap<>());
            }
            Map<Integer, Integer> clock = rem.get(key);
            for (Map.Entry<Integer, Integer> entry : other.rem.get(key).entrySet()) {
                int replica_id = entry.getKey();
                int timestamp =