anchor.diff:  -behaviour(gen_server).
   
   -define(FIRST_RECONNECT_INTERVAL, 100).
  +-define(TIMEOUT, 1000).
   
   -type address() :: string() | atom() | inet:ip_address(). %% The TCP/IP host name or address of the Riak node
   -type portnum() :: non_neg_integer(). %% The TCP port number of the Riak node's Protocol Buffers interface
  
positive.code:          terminate/2]).
  
  -export([
           get/1
          ]).
  
  get(Pid) ->
      Req = #fpbincrementreq{key="key", amount=2},
      call_infinity(Pid, {req, Req}).
  
  %% Callback functions
  
  %% @private
  init([Address, Port, _Options]) ->
      State = #state{address = Address, port = Port, queue = queue:new()},
      case connect(State) of
          {error, Reason} ->
              {stop, {tcp, Reason}};
  
negative.code: stop(Pid) ->
      call_infinity(Pid, stop).
  
  %% @private Like `gen_server:call/3', but with the timeout hardcoded
  %% to `infinity'.
  call_infinity(Pid, Msg) ->
     gen_server:call(Pid, Msg, infinity).
  
  %% @private
  handle_call({req, Msg, Timeout}, From, State) ->
      {noreply, send_request(new_request(Msg, From, Timeout), State)}.
  
  %% @private
  handle_info({_Proto, Sock, Data}, State=#state{active = Active}) ->
      <<MsgCode:8, MsgData/binary>> = Data,
      Resp = riak_pb_codec:decode(MsgCode, MsgData),
      NewState = case Resp of
          %Must improve message handling
          #fpboperationresp{success = true} ->
              cancel_req_timer(Active#request.tref),
               _ = send_caller(Resp, Active),
              State#state{ active = undefined };
          _ ->
              lager:warning("Unexpected Message ~p",[Resp]),
              State#state{ active = undefined }
      end,
      ok = inet:setopts(Sock, [{active, once}]),
     {noreply, NewState};
  
  handle_info(Msg, State) ->
      State.
  
  %% @private
  handle_cast(_Msg, State) ->
  