anchor.diff:  
   
   recv_from_socket(Length, Timeout, Wrapper) ->
  -	Mod = Wrapper#sbw.mod,
  -	Req = Wrapper#sbw.req,
  +    Mod = Wrapper#sbw.mod,
  +    Req = Wrapper#sbw.req,
       case erlang:function_exported(Mod, recv_from_socket, 3) of
           true ->  Mod:recv_from_socket(Length, Timeout, Req);
           false -> throw({not_supported, Mod, recv_from_socket})
  
positive.code: %% RESPONSE WRAPPERS
  
  set_status_code(StatusCode, Wrapper) ->
  	update_response(fun(Res) ->
  		Res#response{status_code=StatusCode}
  	end, Wrapper).
  
  set_header(Name0, Value, Wrapper) ->
  	Name = simple_bridge_util:binarize_header(Name0),
  	update_response(fun(Res) ->
  		Header = #header { name=Name, value=Value },
  		Headers = Res#response.headers,
  		Headers1 = [X || X <- Headers, X#header.name /= Name orelse X#header.name =:= <<"set-cookie">>],
  		Headers2 = [Header|Headers1],
  		Res#response{headers=Headers2}
  	end, Wrapper).
  
  get_response_header(Name0, Wrapper) ->
  	Name = simple_bridge_util:binarize_header(Name0),
  	Res = Wrapper#sbw.response,
  	Headers = [H#header.value || H <- Res#response.headers, H#header.name == Name],
  	case Headers of
  		[] -> undefined;
  		[V] -> V
  	end.
  
  clear_headers(Wrapper) ->
  	update_response(fun(Res) ->
  		Res#response{headers=[]}
  	end, Wrapper).
  
  set_cookie(Name, Value, Wrapper) ->
      set_cookie(Name, Value, "/", 20, Wrapper).
  
  set_cookie(Name, Value, Path, MinutesToLive, Wrapper) ->
  	update_response(fun(Res) ->
  		Cookie = #cookie { name=Name, value=Value, path=Path, minutes_to_live=MinutesToLive },
  		Cookies = Res#response.cookies,
  		Cookies1 = [X || X <- Cookies, X#cookie.name /= Name],
  		Cookies2 = [Cookie|Cookies1],
  		Res#response{cookies=Cookies2}
  	end, Wrapper).
  
  clear_cookies(Wrapper) ->
  	update_response(fun(Res) ->
  		Res#response{cookies=[]}
  	end, Wrapper).
  
  set_response_data(Data, Wrapper) ->
  	update_response(fun(Res) ->
  		Res#response{data={data, Data}}
  	end, Wrapper).
  
  set_response_file(Path, Wrapper) ->
  	update_response(fun(Res) ->
  		Res#response{data={file,Path}}
  	end, Wrapper).
  
  build_response(Wrapper) ->
  	Mod = Wrapper#sbw.mod,
  	Req = Wrapper#sbw.req,
  	Res = Wrapper#sbw.response,
  	Mod:build_response(Req,Res).
  
  update_response(Fun, Wrapper) ->
  	NewRes = Fun(Wrapper#sbw.response),
  	Wrapper#sbw{response=NewRes}.
  
  
  %% DEPRECATED RESPONSE WRAPPERS
  
  status_code(StatusCode, Wrapper) ->
  	set_status_code(StatusCode, Wrapper).
  
  header(Name, Value, Wrapper) ->
  	set_header(Name, Value, Wrapper).
  
  cookie(Name, Value, Wrapper) ->
  	set_cookie(Name, Value, Wrapper).
  
  cookie(Name, Value, Path, MinutesToLive, Wrapper) ->
  	set_cookie(Name, Value, Path, MinutesToLive, Wrapper).
  
  data(Data, Wrapper) ->
  	set_response_data(Data, Wrapper).
  
  file(File, Wrapper) ->
  	set_response_file(File, Wrapper).
  
negative.code:     post_param_group(Param, [], Wrapper).
  
  post_param_group(Param, DefaultValue, Wrapper) ->
      find_param_group(Param, DefaultValue, post_params(Wrapper)).
  
  %% QUERY PARAMS
  
  query_params(Wrapper) ->
      Wrapper#sbw.query_params.
  
  query_param(Param, Wrapper) ->
      query_param(Param, undefined, Wrapper).
  
  query_param(Param, DefaultValue, Wrapper) ->
      find_param(Param, DefaultValue, query_params(Wrapper)).
  
  %% POST PARAMS
  
  post_params(Wrapper) ->
      Wrapper#sbw.post_params.
  
  post_param(Param, Wrapper) ->
      post_param(Param, undefined, Wrapper).
  
  post_param(Param, DefaultValue, Wrapper) ->
      find_param(Param, DefaultValue, post_params(Wrapper)).
  
  %% AGNOSTIC PARAMS
  
  params(Wrapper) ->
      post_params(Wrapper) ++ query_params(Wrapper).
  
  param(Param, Wrapper) ->
      param(Param, undefined, Wrapper).
  
  param(Param, DefaultValue, Wrapper) ->
      case post_param(Param, Wrapper) of
          undefined -> query_param(Param, DefaultValue, Wrapper);
          V -> V
      end.
  
  %% FIND PARAM
  
  find_param(Param, Default, ParamList) when is_binary(Param) ->
      case lists:keyfind(Param, 1, ParamList) of
          {_, Val} -> Val;
          false -> Default
      end;
  find_param(Param, Default, ParamList) when is_atom(Param); is_list(Param) ->
      Param1 = simple_bridge_util:to_binary(Param),
      simple_bridge_util:to_list(find_param(Param1, Default, ParamList)).
  
  
  find_param_group(Param, Default, ParamList) when is_binary(Param) ->
      case [V || {K,V} <- ParamList, K=:=Param] of
          [] -> Default;
          L -> L
      end;
  find_param_group(Param, Default, ParamList) when is_list(Param); is_atom(Param) ->
      Param1 = simple_bridge_util:to_list(Param),
      ResultList = find_param_group(Param1, Default, ParamList),
      [simple_bridge_util:to_list(V) || V <- ResultList].
  
  %% DEEP PARAM STUFF
  
  deep_params(Wrapper) ->
      Params = params(Wrapper),
      parse_deep_post_params(Params, []).
  
  deep_param(Path, Wrapper) ->
      find_deep_post_param(Path, deep_params(Wrapper)).
  
  deep_query_params(Wrapper) ->
      Params = query_params(Wrapper),
      parse_deep_post_params(Params, []).
  
  deep_query_param(Path, Wrapper) ->
      find_deep_post_param(Path, deep_query_params(Wrapper)).
  
  deep_post_params(Wrapper) ->
      Params = post_params(Wrapper),
  