Add Registry.values/3

Author: josevalim

lib/elixir/lib/registry.ex

@@ -731,6 +731,64 @@ defmodule Registry do
     acc
   end
 
+  @doc """
+  Reads the values for the given `key` for `pid` in `registry`.
+
+  For unique registries, it is either an empty list or a list
+  with a single element. For duplicate registries, it is a list
+  with zero, one, or multiple elements.
+
+  ## Examples
+
+  In the example below we register the current process and look it up
+  both from itself and other processes:
+
+      iex> Registry.start_link(keys: :unique, name: Registry.UniqueLookupTest)
+      iex> Registry.values(Registry.UniqueLookupTest, "hello", self())
+      []
+      iex> {:ok, _} = Registry.register(Registry.UniqueLookupTest, "hello", :world)
+      iex> Registry.values(Registry.UniqueLookupTest, "hello", self())
+      [:world]
+      iex> Task.async(fn -> Registry.values(Registry.UniqueLookupTest, "hello", self()) end) |> Task.await()
+      []
+      iex> parent = self()
+      iex> Task.async(fn -> Registry.values(Registry.UniqueLookupTest, "hello", parent) end) |> Task.await()
+      [:world]
+
+  The same applies to duplicate registries:
+
+      iex> Registry.start_link(keys: :duplicate, name: Registry.DuplicateLookupTest)
+      iex> Registry.values(Registry.DuplicateLookupTest, "hello", self())
+      []
+      iex> {:ok, _} = Registry.register(Registry.DuplicateLookupTest, "hello", :world)
+      iex> Registry.values(Registry.DuplicateLookupTest, "hello", self())
+      [:world]
+      iex> {:ok, _} = Registry.register(Registry.DuplicateLookupTest, "hello", :another)
+      iex> Enum.sort(Registry.values(Registry.DuplicateLookupTest, "hello", self()))
+      [:another, :world]
+
+  """
+  @doc since: "1.12.0"
+  @spec values(registry, key, pid) :: [value]
+  def values(registry, key, pid) when is_atom(registry) do
+    case key_info!(registry) do
+      {:unique, partitions, key_ets} ->
+        key_ets = key_ets || key_ets!(registry, key, partitions)
+
+        case safe_lookup_second(key_ets, key) do
+          {^pid, value} ->
+            [value]
+
+          _ ->
+            []
+        end
+
+      {:duplicate, partitions, key_ets} ->
+        key_ets = key_ets || key_ets!(registry, pid, partitions)
+        for {^pid, value} <- safe_lookup_second(key_ets, key), do: value
+    end
+  end
+
   @doc """
   Unregisters all entries for the given `key` associated to the current
   process in `registry`.

lib/elixir/test/elixir/registry_test.exs

@@ -36,10 +36,12 @@ defmodule RegistryTest do
         {:ok, pid} = Registry.register(registry, "hello", :value)
         assert is_pid(pid)
         assert Registry.keys(registry, self()) == ["hello"]
+        assert Registry.values(registry, "hello", self()) == [:value]
 
         assert {:error, {:already_registered, pid}} = Registry.register(registry, "hello", :value)
         assert pid == self()
         assert Registry.keys(registry, self()) == ["hello"]
+        assert Registry.values(registry, "hello", self()) == [:value]
 
         {:ok, pid} = Registry.register(registry, "world", :value)
         assert is_pid(pid)
@@ -49,11 +51,15 @@ defmodule RegistryTest do
       test "has unique registrations across processes", %{registry: registry} do
         {_, task} = register_task(registry, "hello", :value)
         Process.link(Process.whereis(registry))
+        assert Registry.keys(registry, task) == ["hello"]
+        assert Registry.values(registry, "hello", task) == [:value]
 
         assert {:error, {:already_registered, ^task}} =
                  Registry.register(registry, "hello", :recent)
 
         assert Registry.keys(registry, self()) == []
+        assert Registry.values(registry, "hello", self()) == []
+
         {:links, links} = Process.info(self(), :links)
         assert Process.whereis(registry) in links
       end
@@ -433,16 +439,30 @@ defmodule RegistryTest do
         {:ok, pid} = Registry.register(registry, "hello", :value)
         assert is_pid(pid)
         assert Registry.keys(registry, self()) == ["hello"]
+        assert Registry.values(registry, "hello", self()) == [:value]
 
         assert {:ok, pid} = Registry.register(registry, "hello", :value)
         assert is_pid(pid)
         assert Registry.keys(registry, self()) == ["hello", "hello"]
+        assert Registry.values(registry, "hello", self()) == [:value, :value]
 
         {:ok, pid} = Registry.register(registry, "world", :value)
         assert is_pid(pid)
         assert Registry.keys(registry, self()) |> Enum.sort() == ["hello", "hello", "world"]
       end
 
+      test "has duplicate registrations across processes", %{registry: registry} do
+        {_, task} = register_task(registry, "hello", :world)
+        assert Registry.keys(registry, self()) == []
+        assert Registry.keys(registry, task) == ["hello"]
+        assert Registry.values(registry, "hello", self()) == []
+        assert Registry.values(registry, "hello", task) == [:world]
+
+        assert {:ok, _pid} = Registry.register(registry, "hello", :value)
+        assert Registry.keys(registry, self()) == ["hello"]
+        assert Registry.values(registry, "hello", self()) == [:value]
+      end
+
       test "compares using matches", %{registry: registry} do
         {:ok, _} = Registry.register(registry, 1.0, :value)
         {:ok, _} = Registry.register(registry, 1, :value)