anchor.diff:      ?CORE:wait_needed(Id, Threshold, Store, From, ReplyFun, ?BLOCKING);
   
   %% Attempt to read a value.
  -handle_call({read, Id, Threshold}, From, #state{store=Store, actor=Actor}=State) ->
  +handle_call({read, Id, Threshold}, From, #state{store=Store}=State) ->
       ReplyFun = fun({_Id, Type, Metadata, Value}) ->
                       {reply, {ok, {_Id, Type, Metadata, Value}}, State};
                     ({error, Error}) ->
  
positive.code:     {_Time, Value} = timer:tc(?CORE,
                                read,
                                [Id, Threshold, Store, From, ReplyFun, ?BLOCKING]),
      case Value of
          {error, not_found} ->
              case Id of
                  {StorageId, TypeId} ->
                      {ok, {Id, _, _, _}} = ?CORE:declare(StorageId, TypeId,
                                                          ?CLOCK_INIT, Store),
                      {_NewTime, NewValue} = timer:tc(?CORE, read,
                                                [Id, Threshold, Store, From,
                                                 ReplyFun, ?BLOCKING]),
                      NewValue;
                  _ ->
                      {reply, {error, not_found}, State}
              end;
          X ->
              X
      end;
  
  %% Spawn a process to perform a filter.
  
negative.code: %% clock to be incremented again and a subsequent broadcast.  However,
  %% this could change if the other module is later refactored.
  handle_call({bind, Id, Metadata0, Value}, _From,
              #state{store=Store, counter=Counter}=State) ->
      {_Time, Result0} = timer:tc(?CORE,
                                  bind,
                                  [Id, Value, ?CLOCK_MERG, Store]),
      Result1 = not_found_handling(Result0, Id, State, timer, tc,
                                   [?CORE, bind, [Id, Value, ?CLOCK_MERG, Store]]),
      Result = case Result1 of
                   {error, not_found} ->
                       {error, not_found};
                   {found, Result2} ->
                       Result2;
                   {_NewTime, Result2} ->
                       Result2
               end,
      {reply, Result, State#state{counter=increment_counter(Counter)}};
  
  %% Bind two variables together.
  handle_call({bind_to, Id, DVId}, _From, #state{store=Store}=State) ->
  