anchor.diff:      end.
   
   %% @private
  +schedule_delta_synchronization() ->
  +    case lasp_config:get(mode, state_based) of
  +        delta_based ->
  +            erlang:send_after(?DELTA_INTERVAL, self(), delta_sync);
  +        state_based ->
  +            ok
  +    end.
  +
  +%% @private
  +schedule_delta_garbage_collection() ->
  +    case lasp_config:get(mode, state_based) of
  +        delta_based ->
  +            erlang:send_after(?DELTA_GC_INTERVAL, self(), delta_gc);
  +        state_based ->
  +            ok
  +    end.
  +
  +%% @private
   send(Msg, Peer) ->
       PeerServiceManager = lasp_config:get(peer_service_manager,
                                            partisan_peer_service),
       PeerServiceManager:forward_message(Peer, ?MODULE, Msg).
  +
  +%% @private
  +init_delta_sync(Peer) ->
  +    lager:info("Initializing delta synchronization with peer: ~p", [Peer]),
  +    gen_server:cast(?MODULE, {exchange, Peer}).
  
positive.code:                 erlang:monotonic_time(),
                  erlang:unique_integer()),
  
      {ok, Actor} = lasp_unique:unique(),
  
      Counter = 0,
  
negative.code:                         end
                  end
          end,
      GCCounter = case GCCounter0 == MaxGCCounter of
          false ->
              GCCounter0;
          true ->
              spawn(
                  fun() ->
                          {ok, Results} = do(fold, [Store, Function, []]),
                          lists:foreach(
                            fun({ok, Id, DeltaMap, RemovedAckMap}) ->
                                    case do(get, [Store, Id]) of
                                        {ok, Object} ->
                                            _ = do(put,
                                                   [Store, Id,
                                                    Object#dv{delta_map=DeltaMap,
                                                              delta_ack_map=RemovedAckMap}]),
                                            ok;
                                        _ ->
                                            ok
                                    end
                            end, Results)
                  end),
              0
      end,
  
      %% Schedule next GC and reset counter.
      schedule_delta_garbage_collection(),
  
      {noreply, State#state{gc_counter=GCCounter}};
  
  handle_info(Msg, State) ->
      _ = lager:warning("Unhandled messages: ~p", [Msg]),
      {noreply, State}.
  