anchor.diff:  db_delete(Destination, State) ->
     EdisItem = (State#state.backend_mod):get(State#state.backend_ref, Destination),
     case EdisItem of
  -    #edis_item{vclock = _} ->
  +    #edis_item{} ->
         NewEdisItem = EdisItem#edis_item{
                                             vclock = edis_vclock:increment(process(State#state.index), EdisItem#edis_item.vclock), 
                                             timestamp = edis_vclock:timestamp()},
         (State#state.backend_mod):delete(State#state.backend_ref, Destination),
         abcast = gen_server:abcast(nodes(), process(State#state.index), {db_delete, Destination, NewEdisItem});
  -    #edis_item{} ->
  -    %% It has to be resolved what to do in respect of vector clocks for this case
  -      {error, bad_item_type};
       not_found ->
  +    %% Assumption: All nodes have agreed once that the item should be deleted.
         not_found;
       {error, Reason} ->
         lager:error("~p~n", [Reason])
  
positive.code: 
  %% @hidden
  -spec handle_cast({write|put|delete, term()}, state()) -> {noreply, state()}.
  handle_cast({db_write, Actions}, State) ->
    (State#state.backend_mod):write(State#state.backend_ref, Actions),
    {noreply, State};
  
  handle_cast({db_put, Destination, EdisItem}, State) ->
    EdisItemLocal = (State#state.backend_mod):get(State#state.backend_ref, EdisItem),
    case edis_vclock:descends(EdisItemLocal#edis_item.vclock, EdisItem#edis_item.vclock) of
      true -> 
        %% The case of when the incoming EdisItem vclock is MORE advanced than the local one
        db_put(Destination, EdisItem, State)
    end,
  
    case edis_vclock:descends(EdisItem#edis_item.vclock, EdisItemLocal#edis_item.vclock) of
  
negative.code: 
  
  
  db_write(Actions, IncomingState) ->
    SortActions = 
    fun({put, Key, EdisItem}, [{local, LocalActions},{broadcast, AbcastActions}, State]) -> 
          PutItem = {put, Key, EdisItem#edis_item{
                                                vclock = edis_vclock:increment(process(State#state.index), EdisItem#edis_item.vclock), 
                                                timestamp = edis_vclock:timestamp()}},
          [{local, [PutItem | LocalActions]},{broadcast, [PutItem | AbcastActions]}, State];
        ({delete, Key}, [{local, LocalActions},{broadcast, AbcastActions}, State]) -> 
          EdisItem = (State#state.backend_mod):get(State#state.backend_ref, Key),
          case EdisItem of 
            #edis_item{} -> 
              [{local, [{delete, Key} | LocalActions]},
              {broadcast, [{delete, Key, EdisItem#edis_item{
                              vclock = edis_vclock:increment(process(State#state.index), EdisItem#edis_item.vclock), 
                              timestamp = edis_vclock:timestamp()}} | AbcastActions]}, State];
            %% Below means that the value did not exist, assume that it has already been deleted. Adding nothing to actionlists
            not_found -> [{local, LocalActions},{broadcast, AbcastActions}, State];
            {error, Reason} ->
              lager:error("~p~n", [Reason])
          end
    end,
  
    NewActions = lists:foldr(SortActions, [{local, []},{broadcast, []}, IncomingState], Actions),
    MatchMe = fun([{local, LocalActions},{broadcast, AbcastActions}, MatchState]) -> 
      (MatchState#state.backend_mod):write(MatchState#state.backend_ref, LocalActions),
      abcast = gen_server:abcast(nodes(), process(MatchState#state.index), {db_write, AbcastActions})
    end,
    MatchMe(NewActions),
    ok.
  
  
  db_put(Destination, EdisItem, State) ->
    IncrementedVClock = EdisItem#edis_item{
  