anchor.diff:      BinKey = list_to_binary(Key),
       ok = case riakc_pb_socket:get(Conn, Bucket, BinKey) of
           {ok, O} ->
  -            O2 = riakc_obj:update_value(O, ConvertedPropList),
  +            O2 = riakc_obj:update_value(O, PropList),
               riakc_pb_socket:put(Conn, O2);
           {error, _} ->
  -            O = riakc_obj:new(Bucket, BinKey, ConvertedPropList, <<"application/x-erlang-term">>),
  +            O = riakc_obj:new(Bucket, BinKey, PropList, <<"application/x-erlang-term">>),
               riakc_pb_socket:put(Conn, O)
       end,
       {ok, Record:set(id, lists:concat([Type, "-", Key]))}.
  
positive.code: escape_value([H|T], Acc) ->
      escape_value(T, [H|Acc]).
  
  encode_data_for_riak(Data) ->
      lists:map(fun({K, V}) ->
          BinaryKey = list_to_binary(atom_to_list(K)),
          ConvertedValue = try
                             list_to_binary(V)
                           catch
                             error:_ -> V
                           end,
          {BinaryKey, ConvertedValue}
      end, Data).
  
  decode_data_from_riak(Data, AttributeTypes) ->
      lists:map(fun({K, V}) ->
          AtomKey = list_to_atom(binary_to_list(K)),
          AttributeType = proplists:get_value(AtomKey, AttributeTypes),
          ConvertedValue = case AttributeType of
              string -> binary_to_list(V);
              _ -> V
          end,
          {AtomKey, boss_record_lib:convert_value_to_type(ConvertedValue, AttributeType)}
      end, Data).
  
negative.code:         {ok, Res} ->
              Value = riakc_obj:get_value(Res),
              Data = binary_to_term(Value),
              ConvertedData = riak_search_decode_data(Data),
              AttributeTypes = boss_record_lib:attribute_types(Type),
              Record = apply(Type, new, lists:map(fun (AttrName) ->
                              Val = proplists:get_value(AttrName, ConvertedData),
                              AttrType = proplists:get_value(AttrName, AttributeTypes),
  