%%
%% %CopyrightBegin%
%%
%% Copyright Ericsson AB 2010-2011. All Rights Reserved.
%%
%% The contents of this file are subject to the Erlang Public License,
%% Version 1.1, (the "License"); you may not use this file except in
%% compliance with the License. You should have received a copy of the
%% Erlang Public License along with this software. If not, it can be
%% retrieved online at http://www.erlang.org/.
%%
%% Software distributed under the License is distributed on an "AS IS"
%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
%% the License for the specific language governing rights and limitations
%% under the License.
%%
%% %CopyrightEnd%
%%

%%
%% This module provide OTP's dict interface built on top of ets.
%%
%% Note that while the interface is the same as dict the semantics
%% aren't quite. A Dict here is just a table identifier (although
%% this fact can't be used if you want dict/ets-based implementations
%% to be interchangeable) so changes made to the Dict modify the
%% underlying table. For merge/3, the first argument table is modified.
%%
%% The underlying ets table implementing a dict is deleted when the
%% process from which new() was invoked exits and the dict is only
%% writable from this process.
%%
%% The reason for this is to be able to swap dict/ets-based
%% implementations: the former is easier to debug, the latter is
%% faster for larger tables. It's also just a nice interface even
%% when there's no need for swapability.
%%

-module(diameter_dict).

-export([append/3,
         append_list/3,
         erase/2,
         fetch/2,
         fetch_keys/1,
         filter/2,
         find/2,
         fold/3,
         from_list/1,
         is_key/2,
         map/2,
         merge/3,
         new/0,
         store/3,
         to_list/1,
         update/3,
         update/4,
         update_counter/3]).

%%% ----------------------------------------------------------
%%% EXPORTED INTERNAL FUNCTIONS
%%% ----------------------------------------------------------

append(Key, Value, Dict) ->
    append_list(Key, [Value], Dict).

append_list(Key, ValueList, Dict)
  when is_list(ValueList) ->
    update(Key, fun(V) -> V ++ ValueList end, ValueList, Dict).

erase(Key, Dict) ->
    ets:delete(Dict, Key),
    Dict.

fetch(Key, Dict) ->
    {ok, V} = find(Key, Dict),
    V.

fetch_keys(Dict) ->
    ets:foldl(fun({K,_}, Acc) -> [K | Acc] end, [], Dict).

filter(Pred, Dict) ->
    lists:foreach(fun({K,V}) -> filter(Pred(K,V), K, Dict) end, to_list(Dict)),
    Dict.

find(Key, Dict) ->
    case ets:lookup(Dict, Key) of
        [{Key, V}] ->
            {ok, V};
        [] ->
            error
    end.

fold(Fun, Acc0, Dict) ->
    ets:foldl(fun({K,V}, Acc) -> Fun(K, V, Acc) end, Acc0, Dict).

from_list(List) ->
    lists:foldl(fun store/2, new(), List).

is_key(Key, Dict) ->
    ets:member(Dict, Key).

map(Fun, Dict) ->
    lists:foreach(fun({K,V}) -> store(K, Fun(K,V), Dict) end, to_list(Dict)),
    Dict.

merge(Fun, Dict1, Dict2) ->
    fold(fun(K2,V2,_) ->
                 update(K2, fun(V1) -> Fun(K2, V1, V2) end, V2, Dict1)
         end,
         Dict1,
         Dict2).

new() ->
    ets:new(?MODULE, [set]).

store(Key, Value, Dict) ->
    store({Key, Value}, Dict).

to_list(Dict) ->
    ets:tab2list(Dict).

update(Key, Fun, Dict) ->
    store(Key, Fun(fetch(Key, Dict)), Dict).

update(Key, Fun, Initial, Dict) ->
    store(Key, map(Key, Fun, Dict, Initial), Dict).

update_counter(Key, Increment, Dict)
  when is_integer(Increment) ->
    update(Key, fun(V) -> V + Increment end, Increment, Dict).

%%% ---------------------------------------------------------
%%% INTERNAL FUNCTIONS
%%% ---------------------------------------------------------

store({_,_} = T, Dict) ->
    ets:insert(Dict, T),
    Dict.

filter(true, _, _) ->
    ok;
filter(false, K, Dict) ->
    erase(K, Dict).

map(Key, Fun, Dict, Error) ->
    case find(Key, Dict) of
        {ok, V} ->
            Fun(V);
        error ->
            Error
    end.