anchor.diff:                                      NewReplies#rr_replies.read_value),
                       ?PDB:delete(ReqId, tablename(State)),
                       State;
  -                true ->
  +                inconsistent ->
                       %% majority replied, but we do not have a consistent quorum ->
                       %% do a qread with highest received read round + 1
                       ?PDB:delete(ReqId, tablename(State)),
  
positive.code:             {RF, _, _}   -> RF;
              RF           -> RF
          end,
  
      %% If enough replicas have replied, decide on the next action
      %% to take.
      {Result, R4} =
          case ?REDUNDANCY:quorum_accepted(ReplyCount) of
              true ->
                  case ReplyCount =:= R3#rr_replies.highest_write_count andalso
                       %% If this round request is part of a read, then it does not matter if
                       %% there is a write in progress which has not yet written the majority.
                       %% Since the read and write are concurrent, the read can return the older value.
                       (OpType =:= read orelse ReplyCount =:= R3#rr_replies.highest_read_count) of
                      true ->
                          %% consistent quorum
                          Collected = R3#rr_replies.read_value,
                          ReadValue = ?REDUNDANCY:get_read_value(Collected, ReadFilter),
                          T1 = R3#rr_replies{read_value=ReadValue},
                          {consistent, T1};
                      false ->
                          %% not a consistent quorum
                          %% we do not have to calculate the final value since a
                          %% new read request will be started anyway.
                          {true, R3}
                  end;
              false ->
                  %% no majority yet
  
negative.code:                                            entry_datatype(NewEntry),
                                             entry_filters(NewEntry),
                                             entry_retrigger(NewEntry),
                                             1+pr:get_r(entry_my_round(NewEntry))}, State);
                  write_through ->
                      %% majority replied, we have not a consistent quorum, but we can
                      %% skip qread phase and go directly to write through
  
                      % transform reply record to r_replies since that is what WT expects
                      RReplies = #r_replies{highest_write_count=NewReplies#rr_replies.highest_write_count,
                                           highest_write_round=NewReplies#rr_replies.highest_write_round,
                                           read_value=NewReplies#rr_replies.read_value},
                      NewEntry2 = entry_set_replies(NewEntry, RReplies),
                      ?PDB:delete(ReqId, tablename(State)),
                      gen_component:post_op({qread_initiate_write_through, NewEntry2},
                                             State)
              end
      end;
  
  