handle functions return structs instead of tuples

diff --git a/lib/roles/broker.ex b/lib/roles/broker.ex
index 89036b4a857022d8d8de4768d8d506bd4fbf7940..27beb2b6f895af5a34c4ab50098ced9cd67231a7 100644 (file)
--- a/lib/roles/broker.ex
+++ b/lib/roles/broker.ex
@@ -3,6 +3,8 @@ defmodule Wampex.Roles.Broker do
   Handles requests and responses for a Broker
   """
   alias Wampex.Role
+  alias Wampex.Roles.Publisher.Publish
+  alias Wampex.Roles.Subscriber.{Subscribe, Unsubscribe}
   @behaviour Role
 
   @publish 16
@@ -16,14 +18,14 @@ defmodule Wampex.Roles.Broker do
   defmodule Event do
     @moduledoc false
     @enforce_keys [:subscription_id, :publication_id]
-    defstruct [:subscription_id, :publication_id, arg_list: [], arg_kw: %{}, options: %{}]
+    defstruct [:subscription_id, :publication_id, arg_list: [], arg_kw: %{}, details: %{}]
 
     @type t :: %__MODULE__{
             subscription_id: integer(),
             publication_id: integer(),
             arg_list: list(any()),
             arg_kw: map(),
-            options: map()
+            details: map()
           }
   end
 
@@ -70,7 +72,7 @@ defmodule Wampex.Roles.Broker do
         publication_id: pi,
         arg_list: al,
         arg_kw: akw,
-        options: opts
+        details: opts
       }) do
     [@event, si, pi, opts, al, akw]
   end
@@ -93,13 +95,13 @@ defmodule Wampex.Roles.Broker do
   @impl true
   def handle([@subscribe, request_id, opts, topic]) do
     {[{:next_event, :internal, :subscribe}], request_id,
-     {:update, :subscribe, {:subscribe, request_id, opts, topic}}}
+     {:update, :subscribe, %Subscribe{request_id: request_id, options: opts, topic: topic}}}
   end
 
   @impl true
   def handle([@unsubscribe, request_id, id]) do
     {[{:next_event, :internal, :unsubscribe}], request_id,
-     {:update, :unsubscribe, {:unsubscribe, request_id, id}}}
+     {:update, :unsubscribe, %Unsubscribe{request_id: request_id, subscription_id: id}}}
   end
 
   @impl true
@@ -115,6 +117,7 @@ defmodule Wampex.Roles.Broker do
   @impl true
   def handle([@publish, id, opts, topic, arg_l, arg_kw]) do
     {[{:next_event, :internal, :publish}], id,
-     {:update, :publish, {:publish, id, opts, topic, arg_l, arg_kw}}}
+     {:update, :publish,
+      %Publish{request_id: id, options: opts, topic: topic, arg_list: arg_l, arg_kw: arg_kw}}}
   end
 end

diff --git a/lib/roles/callee.ex b/lib/roles/callee.ex
index 8b34613f45a9693b163e709a9e9899f1dca44f90..1df27416defd04930d994af917a84cb575957b1a 100644 (file)
--- a/lib/roles/callee.ex
+++ b/lib/roles/callee.ex
@@ -4,6 +4,7 @@ defmodule Wampex.Roles.Callee do
   """
 
   alias Wampex.Role
+  alias Wampex.Roles.Dealer.{Invocation, Result}
   @behaviour Role
 
   @register 64
@@ -17,9 +18,11 @@ defmodule Wampex.Roles.Callee do
   defmodule Register do
     @moduledoc false
     @enforce_keys [:procedure]
-    defstruct [:procedure, options: %{}]
+    defstruct [:request_id, :registration_id, :procedure, options: %{}]
 
     @type t :: %__MODULE__{
+            registration_id: integer() | nil,
+            request_id: integer() | nil,
             procedure: binary(),
             options: map()
           }
@@ -28,9 +31,10 @@ defmodule Wampex.Roles.Callee do
   defmodule Unregister do
     @moduledoc false
     @enforce_keys [:registration_id]
-    defstruct [:registration_id]
+    defstruct [:request_id, :registration_id]
 
     @type t :: %__MODULE__{
+            request_id: integer() | nil,
             registration_id: integer()
           }
   end
@@ -68,6 +72,11 @@ defmodule Wampex.Roles.Callee do
     [@yield, ri, opts, al, akw]
   end
 
+  @impl true
+  def handle(<<@unregistered, request_id>>) do
+    {[{:next_event, :internal, :established}], request_id, {:ok, request_id}}
+  end
+
   @impl true
   def handle([@unregistered, request_id]) do
     {[{:next_event, :internal, :established}], request_id, {:ok, request_id}}
@@ -91,7 +100,14 @@ defmodule Wampex.Roles.Callee do
   @impl true
   def handle([@invocation, id, reg_id, dets, arg_l, arg_kw]) do
     {[{:next_event, :internal, :invocation}], id,
-     {:update, :invocation, {:invocation, id, reg_id, dets, arg_l, arg_kw}}}
+     {:update, :invocation,
+      %Invocation{
+        request_id: id,
+        registration_id: reg_id,
+        details: dets,
+        arg_list: arg_l,
+        arg_kw: arg_kw
+      }}}
   end
 
   @impl true

diff --git a/lib/roles/caller.ex b/lib/roles/caller.ex
index 068eb2885852c734f72c44a207d3527ce90191b0..e28a44f9b092d4c7213a451bfa29c8973755c2ad 100644 (file)
--- a/lib/roles/caller.ex
+++ b/lib/roles/caller.ex
@@ -4,6 +4,7 @@ defmodule Wampex.Roles.Caller do
   """
 
   alias Wampex.Role
+  alias Wampex.Roles.Dealer.Result
   alias Wampex.Roles.Peer.Error
   @behaviour Role
 
@@ -16,9 +17,10 @@ defmodule Wampex.Roles.Caller do
     @moduledoc false
     @enforce_keys [:procedure]
 
-    defstruct [:procedure, arg_list: [], arg_kw: %{}, options: %{}]
+    defstruct [:request_id, :procedure, arg_list: [], arg_kw: %{}, options: %{}]
 
     @type t :: %__MODULE__{
+            request_id: integer() | nil,
             procedure: binary(),
             arg_list: list(any()),
             arg_kw: map(),
@@ -69,6 +71,7 @@ defmodule Wampex.Roles.Caller do
 
   @impl true
   def handle([@result, id, dets, arg_l, arg_kw]) do
-    {[{:next_event, :internal, :established}], id, {:ok, dets, arg_l, arg_kw}}
+    {[{:next_event, :internal, :established}], id,
+     %Result{request_id: id, details: dets, arg_list: arg_l, arg_kw: arg_kw}}
   end
 end

diff --git a/lib/roles/dealer.ex b/lib/roles/dealer.ex
index d8e9ae032cde927a3c24d1424831e904723b99ac..fe94d226b2aef900d6f064e1ca754df1fd38449c 100644 (file)
--- a/lib/roles/dealer.ex
+++ b/lib/roles/dealer.ex
@@ -3,6 +3,8 @@ defmodule Wampex.Roles.Dealer do
   Handles requests and responses for a Dealer
   """
   alias Wampex.Role
+  alias Wampex.Roles.Callee.{Unregister, Yield, Register}
+  alias Wampex.Roles.Caller.{Call, Cancel}
   @behaviour Role
 
   @call 48
@@ -38,27 +40,27 @@ defmodule Wampex.Roles.Dealer do
   defmodule Result do
     @moduledoc false
     @enforce_keys [:request_id]
-    defstruct [:request_id, arg_list: [], arg_kw: %{}, options: %{}]
+    defstruct [:request_id, arg_list: [], arg_kw: %{}, details: %{}]
 
     @type t :: %__MODULE__{
             request_id: integer(),
             arg_list: list(any()),
             arg_kw: map(),
-            options: map()
+            details: map()
           }
   end
 
   defmodule Invocation do
     @moduledoc false
     @enforce_keys [:request_id, :registration_id]
-    defstruct [:request_id, :registration_id, arg_list: [], arg_kw: %{}, options: %{}]
+    defstruct [:request_id, :registration_id, arg_list: [], arg_kw: %{}, details: %{}]
 
     @type t :: %__MODULE__{
             request_id: integer(),
             registration_id: integer(),
             arg_list: list(any()),
             arg_kw: map(),
-            options: map()
+            details: map()
           }
   end
 
@@ -81,7 +83,7 @@ defmodule Wampex.Roles.Dealer do
   def invocation(%Invocation{
         request_id: ri,
         registration_id: reg_id,
-        options: opts,
+        details: opts,
         arg_list: al,
         arg_kw: akw
       }) do
@@ -93,51 +95,53 @@ defmodule Wampex.Roles.Dealer do
         request_id: ri,
         arg_list: al,
         arg_kw: akw,
-        options: opts
+        details: dets
       }) do
-    [@result, ri, opts, al, akw]
+    [@result, ri, dets, al, akw]
   end
 
   @impl true
   def handle([@unregister, request_id, registration_id]) do
     {[{:next_event, :internal, :unregister}], request_id,
-     {:update, :unregister, {:unregister, request_id, registration_id}}}
+     {:update, :unregister, %Unregister{request_id: request_id, registration_id: registration_id}}}
   end
 
   @impl true
   def handle([@register, request_id, opts, procedure]) do
     {[{:next_event, :internal, :register}], request_id,
-     {:update, :register, {:register, request_id, opts, procedure}}}
+     {:update, :register, %Register{request_id: request_id, options: opts, procedure: procedure}}}
   end
 
   @impl true
-  def handle([@call, id, dets, proc]) do
-    handle([@call, id, dets, proc, [], %{}])
+  def handle([@call, id, opts, proc]) do
+    handle([@call, id, opts, proc, [], %{}])
   end
 
   @impl true
-  def handle([@call, id, dets, proc, arg_l]) do
-    handle([@call, id, dets, proc, arg_l, %{}])
+  def handle([@call, id, opts, proc, arg_l]) do
+    handle([@call, id, opts, proc, arg_l, %{}])
   end
 
   @impl true
-  def handle([@call, id, dets, proc, arg_l, arg_kw]) do
+  def handle([@call, id, opts, proc, arg_l, arg_kw]) do
     {[{:next_event, :internal, :call}], id,
-     {:update, :call, {:call, id, dets, proc, arg_l, arg_kw}}}
+     {:update, :call,
+      %Call{request_id: id, options: opts, procedure: proc, arg_list: arg_l, arg_kw: arg_kw}}}
   end
 
   @impl true
-  def handle([@yield, id, dets]) do
-    handle([@yield, id, dets, [], %{}])
+  def handle([@yield, id, opts]) do
+    handle([@yield, id, opts, [], %{}])
   end
 
   @impl true
-  def handle([@yield, id, dets, arg_l]) do
-    handle([@yield, id, dets, arg_l, %{}])
+  def handle([@yield, id, opts, arg_l]) do
+    handle([@yield, id, opts, arg_l, %{}])
   end
 
   @impl true
-  def handle([@yield, id, dets, arg_l, arg_kw]) do
-    {[{:next_event, :internal, :yield}], id, {:update, :yield, {:yield, id, dets, arg_l, arg_kw}}}
+  def handle([@yield, id, opts, arg_l, arg_kw]) do
+    {[{:next_event, :internal, :yield}], id,
+     {:update, :yield, %Yield{request_id: id, options: opts, arg_list: arg_l, arg_kw: arg_kw}}}
   end
 end

diff --git a/lib/roles/peer.ex b/lib/roles/peer.ex
index 23552fe66eaece1a9278e4f87b3a8dc3ca53eb56..ed33e8b245234e9984f46bd3dac7854fd035d399 100644 (file)
--- a/lib/roles/peer.ex
+++ b/lib/roles/peer.ex
@@ -40,11 +40,11 @@ defmodule Wampex.Roles.Peer do
   defmodule Challenge do
     @moduledoc false
     @enforce_keys [:auth_method]
-    defstruct [:auth_method, options: %{}]
+    defstruct [:auth_method, extra: %{}]
 
     @type t :: %__MODULE__{
             auth_method: String.t(),
-            options: %{}
+            extra: %{}
           }
   end
 
@@ -117,8 +117,8 @@ defmodule Wampex.Roles.Peer do
   end
 
   @spec challenge(Challenge.t()) :: Wampex.message()
-  def challenge(%Challenge{auth_method: am, options: opts}) do
-    [@challenge, am, opts]
+  def challenge(%Challenge{auth_method: am, extra: ext}) do
+    [@challenge, am, ext]
   end
 
   @spec goodbye(Goodbye.t()) :: Wampex.message()
@@ -132,14 +132,21 @@ defmodule Wampex.Roles.Peer do
   end
 
   @impl true
-  def handle([@hello, realm, dets]) do
-    {[{:next_event, :internal, :hello}], nil, {:update, :hello, {:hello, realm, dets}}}
+  def handle([@hello, realm, opts]) do
+    {[{:next_event, :internal, :hello}], nil,
+     {:update, :hello,
+      %Hello{
+        realm: realm,
+        options: opts,
+        roles: get_in(opts, ["roles"]),
+        agent: get_in(opts, ["agent"])
+      }}}
   end
 
   @impl true
-  def handle([@authenticate, sig, dets]) do
+  def handle([@authenticate, sig, extra]) do
     {[{:next_event, :internal, :authenticate}], nil,
-     {:update, :authenticate, {:authenticate, sig, dets}}}
+     {:update, :authenticate, %Authenticate{signature: sig, extra: extra}}}
   end
 
   @impl true
@@ -159,7 +166,8 @@ defmodule Wampex.Roles.Peer do
 
   @impl true
   def handle([@challenge, auth_method, extra]) do
-    {[{:next_event, :internal, :challenge}], nil, {:update, :challenge, {auth_method, extra}}}
+    {[{:next_event, :internal, :challenge}], nil,
+     {:update, :challenge, %Challenge{auth_method: auth_method, extra: extra}}}
   end
 
   @impl true

diff --git a/lib/roles/publisher.ex b/lib/roles/publisher.ex
index d31d7cac3d4711b95bb28eb81da24b408d1e1848..3f0d71b09d2c4f36518f3d71478dd62f1c2b4366 100644 (file)
--- a/lib/roles/publisher.ex
+++ b/lib/roles/publisher.ex
@@ -12,9 +12,10 @@ defmodule Wampex.Roles.Publisher do
   defmodule Publish do
     @moduledoc false
     @enforce_keys [:topic]
-    defstruct [:topic, arg_list: [], arg_kw: %{}, options: %{}]
+    defstruct [:request_id, :topic, arg_list: [], arg_kw: %{}, options: %{}]
 
     @type t :: %__MODULE__{
+            request_id: integer() | nil,
             topic: binary(),
             arg_list: list(any()),
             arg_kw: map(),

diff --git a/lib/roles/subscriber.ex b/lib/roles/subscriber.ex
index db3e86f74158d0f7823a3cf10e70359c6baad29f..8bda15470371ee912b844b3465b4fc354f781591 100644 (file)
--- a/lib/roles/subscriber.ex
+++ b/lib/roles/subscriber.ex
@@ -4,6 +4,7 @@ defmodule Wampex.Roles.Subscriber do
   """
 
   alias Wampex.Role
+  alias Wampex.Roles.Broker.Event
   @behaviour Role
 
   @subscribe 32
@@ -15,9 +16,10 @@ defmodule Wampex.Roles.Subscriber do
   defmodule Subscribe do
     @moduledoc false
     @enforce_keys [:topic]
-    defstruct [:topic, options: %{}]
+    defstruct [:request_id, :topic, options: %{}]
 
     @type t :: %__MODULE__{
+            request_id: integer() | nil,
             topic: binary(),
             options: map()
           }
@@ -26,9 +28,10 @@ defmodule Wampex.Roles.Subscriber do
   defmodule Unsubscribe do
     @moduledoc false
     @enforce_keys [:subscription_id]
-    defstruct [:subscription_id]
+    defstruct [:request_id, :subscription_id]
 
     @type t :: %__MODULE__{
+            request_id: integer() | nil,
             subscription_id: integer()
           }
   end
@@ -76,6 +79,13 @@ defmodule Wampex.Roles.Subscriber do
   @impl true
   def handle([@event, sub_id, pub_id, dets, arg_l, arg_kw]) do
     {[{:next_event, :internal, :event}], nil,
-     {:update, :event, {:event, sub_id, pub_id, dets, arg_l, arg_kw}}}
+     {:update, :event,
+      %Event{
+        subscription_id: sub_id,
+        publication_id: pub_id,
+        details: dets,
+        arg_list: arg_l,
+        arg_kw: arg_kw
+      }}}
   end
 end

diff --git a/lib/wampex.ex b/lib/wampex.ex
index bdf7f14e3e3edc218d41d52c87aef106ee0bab2b..ce0bab5702526a7139829a62f93cb5baf4123cc6 100644 (file)
--- a/lib/wampex.ex
+++ b/lib/wampex.ex
@@ -2,63 +2,38 @@ defmodule Wampex do
   @moduledoc """
   Types for wampex
   """
+  alias Wampex.Roles
+  alias Roles.{Broker, Callee, Caller, Dealer, Peer, Publisher, Subscriber}
+  alias Broker.{Event, Subscribed, Unsubscribed, Published}
+  alias Callee.{Register, Unregister, Yield}
+  alias Caller.{Call, Cancel}
+  alias Dealer.{Registered, Unregistered, Result, Invocation}
+  alias Peer.{Hello, Welcome, Challenge, Goodbye, Authenticate, Abort, Error}
+
   @type message_part :: integer() | binary() | map() | list()
   @type message :: nonempty_list(message_part())
   @type arg_list :: [] | nonempty_list(any())
   @type arg_keyword :: map()
 
-  @type hello :: {:hello, realm :: String.t(), details :: map()}
-
-  @type authenticate :: {:authenticate, signature :: binary(), details :: map()}
-
-  @type call ::
-          {:call, request_id :: integer(), details :: map(), procedure :: String.t(),
-           arg_list :: arg_list(), arg_keywords :: arg_keyword()}
-
-  @type yield ::
-          {:yield, request_id :: integer(), details :: map(), arg_list :: arg_list(),
-           arg_keywords :: arg_keyword()}
-
-  @type publish ::
-          {:publish, request_id :: integer(), details :: map(), topic :: String.t(),
-           arg_list :: arg_list(), arg_keywords :: arg_keyword()}
-
-  @type register ::
-          {:register, request_id :: integer(), details :: map(), procedure :: String.t()}
-
-  @type unregister :: {:unregister, request_id :: integer(), registration_id :: integer()}
-
-  @type unsubscribe ::
-          {:unsubscribe, request_id :: integer(), id :: integer()}
-
-  @type subscribe ::
-          {:subscribe, request_id :: integer(), details :: map(), topic :: String.t()}
-  @type invocation ::
-          {:invocation, request_id :: integer(), registration_id :: integer(), details :: map(),
-           arg_list :: arg_list(), arg_keywords :: arg_keyword()}
-  @type event ::
-          {:event, subscription_id :: integer(), publication_id :: integer(), details :: map(),
-           arg_list :: arg_list(), arg_keyword :: arg_keyword()}
   @type error ::
           {:error, reason :: binary()}
-          | {:error, type :: integer(), error :: binary(), details :: map(),
-             arg_list :: arg_list(), arg_keyword :: arg_keyword()}
+          | Error.t()
   @type messages ::
-          publish()
-          | hello()
-          | authenticate()
-          | unsubscribe()
-          | subscribe()
-          | invocation()
-          | register()
-          | unregister()
-          | call()
-          | yield()
-          | error()
-          | event()
+          Publish.t()
+          | Hello.t()
+          | Authenticate.t()
+          | Unsubscribe.t()
+          | Subscribe.t()
+          | Invocation.t()
+          | Register.t()
+          | Unregister.t()
+          | Call.t()
+          | Yield.t()
+          | Error.t()
+          | Event.t()
 
   @type handle_response ::
           {:ok, integer()}
-          | {:ok, details :: map(), arg_list :: arg_list(), arg_keyword :: arg_keyword()}
+          | {:ok, details :: map(), arg_list :: arg_list(), arg_kw :: arg_keyword()}
           | {:update, atom(), messages()}
 end