anchor.diff:                               end
                        end, {PendingOperations, LastCommitTime}, Sorted_ops),
       DcId = dc_utilities:get_my_dc_id(),
  -    lager:info("Updating vector clock ~p",[Stable_time]),
  -    Result = vectorclock:update_clock(Partition, DcId, Stable_time),
  -    lager:info("Updated vc ~p",[Result]),
  -
  +    vectorclock:update_clock(Partition, DcId, Stable_time),
       {reply, ok, State#dstate{last_commit_time = Last_processed_time,
                                pending_operations = Remaining_operations}};
   
  
positive.code: 
  %% @doc Read client update operations,
  %%      generate downstream operations and store it to persistent log.
  handle_command({trigger, WriteSet, From}, _Sender,
                 State=#dstate{partition = Partition,
                               last_commit_time = LastCommitTime,
                               pending_operations = Pending}) ->
      PendingOperations = add_to_pending_operations(Pending, WriteSet),
      lager:info("PendingOperations: ~p", [PendingOperations]),
  
      From ! {ok, trigger_received},
      Node = {Partition, node()}, %% Send ack to caller and continue processing
      Stable_time = get_stable_time(Node, LastCommitTime),
      %% Send a message to itself to process operations
  
negative.code:     IndexNode = hd(Preflist),
      riak_core_vnode_master:command([IndexNode],
                                     {trigger, Writeset, self()},
                                     ?CLOCKSI_GENERATOR_MASTER).
  
  start_vnode(I) ->
      riak_core_vnode_master:get_vnode_pid(I, ?MODULE).
  