asn1_db: Remove unused functions

Also replace unused code with assertions.

While at it, also let reply/2 return 'ok' to silence Dialyzer
warnings for unmatched returns.

1 files changed, 8 insertions, 44 deletions

diff --git a/lib/asn1/src/asn1_db.erl b/lib/asn1/src/asn1_db.erl
index 843fc66c9c..7ea29b7021 100644
--- a/lib/asn1/src/asn1_db.erl
+++ b/lib/asn1/src/asn1_db.erl
@@ -19,31 +19,22 @@
 %%
 -module(asn1_db).
 
--export([dbstart/1,dbnew/1,dbsave/2,dbload/1,dbput/3,dbget/2,dbget_all/1]).
--export([dbget_all_mod/1,dbclear/0,dberase_module/1,dbstop/0]).
+-export([dbstart/1,dbnew/1,dbsave/2,dbput/3,dbget/2]).
+-export([dbstop/0]).
 
 -record(state, {parent, monitor, includes, table}).
 
 %% Interface
 dbstart(Includes) ->
     Parent = self(),
-    case get(?MODULE) of
-        undefined ->
-            put(?MODULE, spawn_link(fun() -> init(Parent, Includes) end)),
-            true;
-        _Pid ->
-            req({new_includes, Includes})
-    end.
+    undefined = get(?MODULE),			%Assertion.
+    put(?MODULE, spawn_link(fun() -> init(Parent, Includes) end)),
+    ok.
 
 dbnew(Module)              -> req({new, Module}).
 dbsave(OutFile, Module)    -> req({save, OutFile, Module}).
-dbload(Module)             -> req({load, Module}).
 dbput(Module, K, V)        -> req({set, Module, K, V}).
 dbget(Module, K)           -> req({get, Module, K}).
-dbget_all(K)               -> req({get_all, K}).
-dbget_all_mod(Mod)         -> req({all_mod, Mod}).
-dbclear()                  -> req(clear).
-dberase_module({module,M}) -> req({delete_mod, M}).
 dbstop()                   -> Resp = req(stop), erase(?MODULE), Resp.
 
 %% Internal functions
@@ -60,7 +51,8 @@ req(Request) ->
     end.
 
 reply({Ref,From}, Response) ->
-    From ! {{Ref,?MODULE}, Response}.
+    From ! {{Ref,?MODULE}, Response},
+    ok.
 
 init(Parent, Includes) ->
     MRef = erlang:monitor(process, Parent),
@@ -85,44 +77,16 @@ loop(#state{parent = Parent, monitor = MRef, table = Table,
                 _Error       -> reply(From, undefined)
             end,
             loop(State);
-        {From, {all_mod, Mod}} ->
-            [{_, Modtab}] = ets:lookup(Table, Mod),
-            reply(From, ets:tab2list(Modtab)),
-            loop(State);
-        {From, {delete_mod, Mod}} ->
-            [{_, Modtab}] = ets:lookup(Table, Mod),
-            ets:delete(Modtab),
-            ets:delete(Table, Mod),
-            reply(From, ok),
-            loop(State);
         {From, {save, OutFile, Mod}} ->
             [{_,Mtab}] = ets:lookup(Table, Mod),
             reply(From, ets:tab2file(Mtab, OutFile)),
             loop(State);
-        {From, {load, Mod}} ->
-            Result = case ets:lookup(Table, Mod) of
-                         []            -> opentab(Table, Mod, Includes);
-                         [{_, Modtab}] -> {ok, Modtab}
-                     end,
-            reply(From, Result),
-            loop(State);
         {From, {new, Mod}} ->
-            case ets:lookup(Table, Mod) of
-                [{_, Modtab}] -> ets:delete(Modtab);
-                _             -> true
-            end,
+            [] = ets:lookup(Table, Mod),	%Assertion.
             ModTableId = ets:new(list_to_atom(lists:concat(["asn1_",Mod])), []),
             ets:insert(Table, {Mod, ModTableId}),
             reply(From, ok),
             loop(State);
-        {From, clear} ->
-            [ets:delete(Mt) || {_, Mt} <- ets:tab2list(Table)],
-            ets:delete(Table),
-            reply(From, cleared),
-            loop(State#state{table = ets:new(asn1, [set])});
-        {From, {new_includes, NewIncludes}} ->
-            reply(From, true),
-            loop(State#state{includes = NewIncludes});
         {From, stop} ->
             reply(From, stopped); %% Nothing to store
         {'DOWN', MRef, process, Parent, Reason} ->