这样仅仅会丢掉一些向量时钟的信息，即数据更新过程的信息，可是不会丢掉实实在在的数据。仅仅有当一种情况会有问题，就是一个client保持了一个非常久之前的向量时钟，然后继承于这个向量时钟提交了一个数据，此时就会有冲突。由于服务器这边已经没有这个非常久之前的向量时钟信息了，已经被剪枝掉了可能，所以client提交的此次数据，在服务端无法找到一个祖先。此时就会创建一个sibling。所以这个剪枝的策略是一个权衡tradeoff，一方面是无限增长的向量时钟的空间。还有一方面是偶尔的会有"false merge"。对，但肯定的是，不会悄无声息的丢数据。综上。为了防止向量时钟空间的无限增长，剪枝还是比用server标识向量时钟工作的更好。

defmodule VClock do@moduledoc """this is !!!!!!!!"""@vsn 0.1@spec fresh() :: []def fresh do[]end# return true if va is a direct descendant of vb, else false -- remember, a vclock is its own descendant!@spec descends(any, []) :: (true|false)def descends(_, []) dotrueend@type va :: list()@spec descends(any, any) :: (false|true)def descends(va, vb) do[{nodeb, {ctrb, _}} | resetb] = vbcase :lists.keyfind(nodeb, 1, va) dofalse ->false;{_, {ctra, _tsa}} ->(ctra >= ctrb) && descends(va, resetb)endend@doc """Combine all VClock in the input list into their least possible common descendant"""@spec merge(list, list) :: listdef merge([]), do: []def merge([singevclock]), do: singevclock## first is a list, eg [:a, {1, 1234}]# rest is list of list, eg [[{:a, {1, 233}}, {:b, {3, 124}}]]def merge([first|rest])  domerge(rest, :lists.keysort(1, first))enddef merge([], nclock), do: nclockdef merge([aclock|vclocks], nclock)  domerge(vclocks, merge(:lists.keysort(1, aclock), nclock, []))enddef merge([], [], accclock), do: :lists.reverse(accclock)def merge([], left, accclock), do: :lists.reverse(accclock, left)def merge(left, [], accclock), do: :lists.reverse(accclock, left)def merge(v = [{node1, {ctr1, ts1} = ct1} = nct1 | vclock],n = [{node2, {ctr2, ts2} = ct2} = nct2 | nclock], accclock) docond donode1 < node2 ->merge(vclock, n, [nct1|accclock]);node1 > node2 ->merge(v, nclock, [nct2|accclock]);true ->({_ctr, _ts} = ct) = cond doctr1 > ctr2 ->ct1;ctr1 < ctr2 ->ct2;true ->{ctr1, :erlang.max(ts1, ts2)}endmerge(vclock, nclock, [{node1, ct}|accclock])endend@doc """get the counter value in vclock set from node"""@spec get_counter(node :: atom, vclock::list) :: (integer|:undefined)def get_counter(node, vclock) docase :lists.keytake(node, 1, vclock) do{_, {c, _}} -> c;false -> :undefinedendend@doc """Get the timestamp value in a VClock set from node"""@spec get_timestamp(node :: atom, vclock :: list) :: (integer | :undefined)def get_timestamp(node, vclock) docase :lists.keytake(node, 1, vclock) do{_, {_, ts}} -> ts;false -> :undefinedendend@doc """increment VClock at node"""@spec increment(atom, list) :: integerdef increment(node, vclock) doincrement(node, timestamp(), vclock)end@spec increment(atom, integer, list) :: listdef increment(node, incts, vclock) doIO.puts "#{inspect node}, #{inspect incts}, #{inspect vclock}"{{_ctr, _ts} = c1, newv} = case :lists.keytake(node, 1, vclock) dofalse ->{{1, incts}, vclock};{:value, {_n, {c, _t}}, modv} ->{{c + 1, incts}, modv}end[{node, c1} | newv]end# retrun the list of all nodes that have ever incremented VClock@spec all_nodes(vclock :: list) :: (list)def all_nodes(vclock) dovclock |> Enum.map(fn({x, {_, _}}) -> x end)end@days_from_gergorian_base_to_epoch (1978 * 365 + 478)@seconds_from_gergorian_base_to_epoch (@days_from_gergorian_base_to_epoch * 24 * 60 * 60)@spec timestamp() :: integerdef timestamp do{megaseconds, seconds, _} = :os.timestamp()@days_from_gergorian_base_to_epoch + megaseconds * 1000000 + secondsend@doc """Compares two VClock for equality"""@spec equal(va :: list, vb :: list) :: (true | false)def equal(va, vb) doEnum.sort(va) === Enum.sort(vb)end@doc """Possibly shrink the size of a vclock, depending on current age and size"""@spec prune(v :: list, now :: integer, bucketprops :: any) :: listdef prune(v, now, bucketprops) do## This sort need to be deterministic, to avoid spurious merge conflicts later,# We achieve this by using the node ID as secondary keysortv = :lists.sort(fn({n1, {_, t1}}, {n2, {_, t2}}) -> {t1, n1} < {t2, n2} end, v)prune_vclock1(sortv, now, bucketprops)enddef prune_vclock1(v, now, bprops) docase get_property(:small_vclock, bprops) >= :erlang.length(v) dotrue -> v;false ->{_, {_, headtime}} = hd(v)case (now - headtime) < get_property(:young_vclock, bprops) dotrue -> v;false -> prune_vclock1(v, now, bprops, headtime)endendenddef prune_vclock1(v, now, bprops, headtime) do# has a precondition that v is longer than small and older than youngcase (:erlang.length(v) > get_property(:big_vclock, bprops)) or ((now - headtime) > get_property(:old_vclock, bprops)) dotrue -> prune_vclock1(tl(v), now, bprops);false -> vendenddef get_property(key, pairlist) docase :lists.keyfind(key, 1, pairlist) do{_key, value} ->value;false ->:undefinedendendend