misc:table_map -> misc:table_filter.

3 files changed, 35 insertions, 40 deletions

diff --git a/src/rabbit_binding.erl b/src/rabbit_binding.erl
index 8633ed1338..ec64c47476 100644
--- a/src/rabbit_binding.erl
+++ b/src/rabbit_binding.erl
@@ -97,29 +97,24 @@
 recover(XNames, QNames) ->
     XNameSet = sets:from_list(XNames),
     QNameSet = sets:from_list(QNames),
-    rabbit_misc:table_map(
-      fun (Route = #route{binding = B =
-                              #binding{destination = Dst =
-                                           #resource{kind = Kind}}}) ->
+    rabbit_misc:table_filter(
+      fun (#route{binding = B = #binding{destination = Dst =
+                                             #resource{kind = Kind}}}) ->
               %% The check against rabbit_durable_route is in case it
               %% disappeared between getting the list and here
-              case mnesia:read({rabbit_durable_route, B}) =/= [] andalso
+              mnesia:read({rabbit_durable_route, B}) =/= [] andalso
                   sets:is_element(Dst, case Kind of
                                            exchange -> XNameSet;
                                            queue    -> QNameSet
-                                       end) of
-                  true  -> ok = sync_transient_binding(
-                                  Route, fun mnesia:write/3),
-                           B;
-                  false -> none
-              end
+                                       end)
       end,
-      fun (none, _Tx) ->
-              none;
-          (B = #binding{source = Src}, Tx) ->
+      fun (R = #route{binding = B = #binding{source = Src}}, Tx) ->
               {ok, X} = rabbit_exchange:lookup(Src),
               rabbit_exchange:callback(X, add_bindings, [Tx, X, [B]]),
-              B
+              case Tx of
+                  true  -> ok = sync_transient_binding(R, fun mnesia:write/3);
+                  false -> ok
+              end
       end,
       rabbit_durable_route),
     ok.
diff --git a/src/rabbit_exchange.erl b/src/rabbit_exchange.erl
index 623adf0b6e..3e4edba437 100644
--- a/src/rabbit_exchange.erl
+++ b/src/rabbit_exchange.erl
@@ -83,17 +83,16 @@
 -define(INFO_KEYS, [name, type, durable, auto_delete, internal, arguments]).
 
 recover() ->
-    Xs = rabbit_misc:table_map(
-           fun (X = #exchange{name = XName}) ->
-                   case mnesia:read({rabbit_exchange, XName}) of
-                       []  -> ok = mnesia:write(rabbit_exchange, X, write),
-                              X;
-                       [_] -> none
-                   end
+    Xs = rabbit_misc:table_filter(
+           fun (#exchange{name = XName}) ->
+                   mnesia:read({rabbit_exchange, XName}) =:= []
            end,
-           fun (none, _Tx) -> none;
-               (X,     Tx) -> rabbit_exchange:callback(X, create, [Tx, X]),
-                              X
+           fun (X, Tx) -> rabbit_exchange:callback(X, create, [Tx, X]),
+                          case Tx of
+                              true  -> ok = mnesia:write(rabbit_exchange,
+                                                         X, write);
+                              false -> ok
+                          end
            end,
            rabbit_durable_exchange),
     [XName || #exchange{name = XName} <- Xs].
diff --git a/src/rabbit_misc.erl b/src/rabbit_misc.erl
index 6bebf005ac..adc3ae6601 100644
--- a/src/rabbit_misc.erl
+++ b/src/rabbit_misc.erl
@@ -38,7 +38,7 @@
 -export([ensure_ok/2]).
 -export([makenode/1, nodeparts/1, cookie_hash/0, tcp_name/3]).
 -export([upmap/2, map_in_order/2]).
--export([table_map/3]).
+-export([table_filter/3]).
 -export([dirty_read_all/1, dirty_foreach_key/2, dirty_dump_log/1]).
 -export([read_term_file/1, write_term_file/2]).
 -export([append_file/2, ensure_parent_dirs_exist/1]).
@@ -146,7 +146,8 @@
         -> atom()).
 -spec(upmap/2 :: (fun ((A) -> B), [A]) -> [B]).
 -spec(map_in_order/2 :: (fun ((A) -> B), [A]) -> [B]).
--spec(table_map/3 :: (fun ((A) -> A), fun ((A, boolean()) -> A), atom()) -> A).
+-spec(table_filter/3:: (fun ((A) -> boolean()), fun ((A, boolean()) -> 'ok'),
+                                                    atom()) -> [A]).
 -spec(dirty_read_all/1 :: (atom()) -> [any()]).
 -spec(dirty_foreach_key/2 :: (fun ((any()) -> any()), atom())
                              -> 'ok' | 'aborted').
@@ -461,24 +462,24 @@ map_in_order(F, L) ->
     lists:reverse(
       lists:foldl(fun (E, Acc) -> [F(E) | Acc] end, [], L)).
 
-%% Fold over each entry in a table, executing the cons function in a
+%% Fold over each entry in a table, executing the pre-post-commit function in a
 %% transaction.  This is often far more efficient than wrapping a tx
 %% around the lot.
 %%
 %% We ignore entries that have been modified or removed.
-table_map(Fun, PrePostCommitFun, TableName) ->
+table_filter(Pred, PrePostCommitFun, TableName) ->
     lists:foldl(
-      fun (E, Acc) -> case execute_mnesia_transaction(
-                             fun () -> case mnesia:match_object(TableName, E,
-                                                                read) of
-                                           [] -> Acc;
-                                           _  -> Fun(E)
-                                       end
-                             end,
-                             PrePostCommitFun) of
-                          none -> Acc;
-                          Res  -> [Res | Acc]
-                      end
+      fun (E, Acc) -> execute_mnesia_transaction(
+                        fun () -> case mnesia:match_object(TableName, E,
+                                                           read) of
+                                      [] -> false;
+                                      _  -> Pred(E)
+                                  end
+                        end,
+                        fun (false, _Tx) -> Acc;
+                            (true,   Tx) -> PrePostCommitFun(E, Tx),
+                                            [E | Acc]
+                        end)
       end, [], dirty_read_all(TableName)).
 
 dirty_read_all(TableName) ->