anchor.diff:            src_target           :: {non_neg_integer(), non_neg_integer()},
             stats                :: #ho_stats{},
             tcp_mod              :: module(),
  -          total                :: non_neg_integer(),
  +
  +          total_objects        :: non_neg_integer(),
             total_bytes          :: non_neg_integer(),
  +
             item_queue           :: [binary()],
  +          item_queue_length    :: non_neg_integer(),
             item_queue_byte_size :: non_neg_integer()
           }).
   
  
positive.code:             BinObj = Module:encode_handoff_item(K, V),
  
              ItemQueue2 = [BinObj | ItemQueue],
              ItemQueueByteSize2 = ItemQueueByteSize + byte_size(BinObj),
  
              %% Unit size is bytes:
              HandoffBatchThreshold = app_helper:get_env(riak_core, handoff_batch_threshold, 1024*1024),
  
              case ItemQueueByteSize2 =< HandoffBatchThreshold of
                  true -> 
                           Acc#ho_acc{item_queue=ItemQueue2,
                                      item_queue_byte_size=ItemQueueByteSize2};
  
                  false -> send_objects(ItemQueue2, Acc)
              end;
  
          false ->
              Acc#ho_acc{error=ok, total=Total+1}
      end.
  
  send_objects([], Acc) ->
  
negative.code:                                       src_target={SrcPartition, TargetPartition},
                                        stats=Stats,                                
                                        tcp_mod=TcpMod,
  
                                        total_bytes=0,
                                        total_objects=0,
  
                                        item_queue=[],
                                        item_queue_length=0,
                                        item_queue_byte_size=0}},                             
  
           %% IFF the vnode is using an async worker to perform the fold
  