Formatted

lib/openflow/action.ex

@@ -1,5 +1,4 @@
 defmodule Openflow.Action do
-
   def read(action_bin) do
     do_read([], action_bin)
   end
@@ -7,6 +6,7 @@ defmodule Openflow.Action do
   def to_binary(actions) when is_list(actions) do
     to_binary(<<>>, actions)
   end
+
   def to_binary(action) do
     to_binary([action])
   end
@@ -15,15 +15,17 @@ defmodule Openflow.Action do
 
   defp do_read(acc, <<>>), do: Enum.reverse(acc)
   defp do_read(acc, <<0::32, _::bytes>>), do: Enum.reverse(acc)
+
   defp do_read(acc, <<type::16, length::16, _::bytes>> = binary) do
     <<action_bin::size(length)-bytes, rest::bytes>> = binary
     codec = Openflow.Enums.to_atom(type, :action_type)
-    do_read([codec.read(action_bin)|acc], rest)
+    do_read([codec.read(action_bin) | acc], rest)
   end
 
   defp to_binary(acc, []), do: acc
-  defp to_binary(acc, [action|rest]) do
+
+  defp to_binary(acc, [action | rest]) do
     codec = action.__struct__
-    to_binary(<<acc::bytes, (codec.to_binary(action))::bytes>>, rest)
+    to_binary(<<acc::bytes, codec.to_binary(action)::bytes>>, rest)
   end
 end

lib/openflow/actions/experimenter.ex

@@ -5,7 +5,7 @@ defmodule Openflow.Action.Experimenter do
 
   @experimter_size 8
 
-  def ofpat, do: 0xffff
+  def ofpat, do: 0xFFFF
 
   def new(exp_id, data \\ "") do
     %Experimenter{exp_id: exp_id, data: data}
@@ -13,17 +13,19 @@ defmodule Openflow.Action.Experimenter do
 
   def to_binary(%Experimenter{exp_id: exp_id, data: data}) do
     length = @experimter_size + byte_size(data)
-    <<0xffff::16, length::16, exp_id::32, data::bytes>>
+    <<0xFFFF::16, length::16, exp_id::32, data::bytes>>
   end
 
-  def read(<<0xffff::16, _length::16, exp_id::32, exp_type::16, data::bytes>>) do
+  def read(<<0xFFFF::16, _length::16, exp_id::32, exp_type::16, data::bytes>>) do
     case Openflow.Utils.get_enum(exp_id, :action_vendor) do
       vendor_id when is_integer(vendor_id) ->
         %Experimenter{exp_id: exp_id, data: <<exp_type::16, data::bytes>>}
+
       vendor when is_atom(vendor) ->
         case Openflow.Utils.get_enum(exp_type, vendor) do
           codec when is_atom(codec) ->
             codec.read(<<exp_id::32, exp_type::16, data::bytes>>)
+
           exp_type when is_integer(exp_type) ->
             %Experimenter{exp_id: exp_id, data: <<exp_type::16, data::bytes>>}
         end

lib/openflow/actions/nx_bundle.ex

@@ -1,11 +1,11 @@
 defmodule Openflow.Action.NxBundle do
   defstruct(
-    algorithm:  :active_backup,
+    algorithm: :active_backup,
     hash_field: :eth_src,
-    basis:      0,
+    basis: 0,
     slave_type: :nx_in_port,
-    n_slaves:   0,
-    slaves:     []
+    n_slaves: 0,
+    slaves: []
   )
 
   @experimenter 0x00002320
@@ -15,36 +15,44 @@ defmodule Openflow.Action.NxBundle do
 
   def new(options) do
     slaves = options[:slaves] || []
-    %NxBundle{algorithm:  options[:algorithm]  || :active_backup,
-              hash_field: options[:hash_field] || :eth_src,
-              basis:      options[:basis]      || 0,
-              n_slaves:   length(slaves),
-              slaves:     slaves}
+
+    %NxBundle{
+      algorithm: options[:algorithm] || :active_backup,
+      hash_field: options[:hash_field] || :eth_src,
+      basis: options[:basis] || 0,
+      n_slaves: length(slaves),
+      slaves: slaves
+    }
   end
 
-  def to_binary(%NxBundle{algorithm: alg,
-                          hash_field: hash_field,
-                          basis: basis,
-                          slave_type: slave_type,
-                          n_slaves: n_slaves,
-                          slaves: slaves}) do
+  def to_binary(%NxBundle{
+        algorithm: alg,
+        hash_field: hash_field,
+        basis: basis,
+        slave_type: slave_type,
+        n_slaves: n_slaves,
+        slaves: slaves
+      }) do
     hash_field_int = Openflow.Enums.to_int(hash_field, :nx_hash_fields)
     alg_int = Openflow.Enums.to_int(alg, :nx_bd_algorithm)
     slave_type_bin = Openflow.Match.codec_header(slave_type)
     slaves_bin = codec_slaves(slaves)
-    body = <<alg_int::16, hash_field_int::16, basis::16,
-             slave_type_bin::4-bytes, n_slaves::16, 0::16, 0::size(4)-unit(8), 0::32,
-             slaves_bin::bytes>>
+
+    body =
+      <<alg_int::16, hash_field_int::16, basis::16, slave_type_bin::4-bytes, n_slaves::16, 0::16,
+        0::size(4)-unit(8), 0::32, slaves_bin::bytes>>
+
     exp_body = <<@experimenter::32, @nxast::16, body::bytes>>
-    exp_body_size =  byte_size(exp_body)
+    exp_body_size = byte_size(exp_body)
     padding_length = Openflow.Utils.padding(4 + exp_body_size, 8)
     length = 4 + exp_body_size + padding_length
-    <<0xffff::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
+    <<0xFFFF::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
   end
 
   def read(<<@experimenter::32, @nxast::16, body::bytes>>) do
-    <<alg_int::16, hash_field_int::16, basis::16,
-      slave_type_bin::4-bytes, n_slaves::16, _::16, _::32, _::32, rest::bytes>> = body
+    <<alg_int::16, hash_field_int::16, basis::16, slave_type_bin::4-bytes, n_slaves::16, _::16,
+      _::32, _::32, rest::bytes>> = body
+
     slave_len = n_slaves * 2
     <<slaves_bin::size(slave_len)-bytes, _::bytes>> = rest
     alg = Openflow.Enums.to_atom(alg_int, :nx_bd_algorithm)
@@ -52,23 +60,29 @@ defmodule Openflow.Action.NxBundle do
     slave_type = Openflow.Match.codec_header(slave_type_bin)
     slaves = codec_slaves(slaves_bin)
     n_slaves = length(slaves)
-    %NxBundle{algorithm: alg,
-              hash_field: hash_field,
-              basis: basis,
-              slave_type: slave_type,
-              n_slaves: n_slaves,
-              slaves: slaves}
+
+    %NxBundle{
+      algorithm: alg,
+      hash_field: hash_field,
+      basis: basis,
+      slave_type: slave_type,
+      n_slaves: n_slaves,
+      slaves: slaves
+    }
   end
 
   # private functions
 
   defp codec_slaves(slaves) when is_list(slaves) do
-    slaves1 = for slave <- slaves do
-      slave_int = Openflow.Utils.get_enum(slave, :openflow10_port_no)
-      <<slave_int::16>>
-    end
+    slaves1 =
+      for slave <- slaves do
+        slave_int = Openflow.Utils.get_enum(slave, :openflow10_port_no)
+        <<slave_int::16>>
+      end
+
     Enum.join(slaves1, "")
   end
+
   defp codec_slaves(slaves) when is_binary(slaves) do
     for <<slave_int::16 <- slaves>> do
       Openflow.Utils.get_enum(slave_int, :openflow10_port_no)

lib/openflow/actions/nx_bundle_load.ex

@@ -2,15 +2,15 @@ defmodule Openflow.Action.NxBundleLoad do
   import Bitwise
 
   defstruct(
-    algorithm:  :active_backup,
+    algorithm: :active_backup,
     hash_field: :eth_src,
-    basis:      0,
+    basis: 0,
     slave_type: :nx_in_port,
-    n_slaves:   0,
-    slaves:     [],
-    offset:     0,
-    n_bits:     0,
-    dst_field:  nil
+    n_slaves: 0,
+    slaves: [],
+    offset: 0,
+    n_bits: 0,
+    dst_field: nil
   )
 
   @experimenter 0x00002320
@@ -22,45 +22,52 @@ defmodule Openflow.Action.NxBundleLoad do
     dst_field = options[:dst_field]
     default_n_bits = Openflow.Match.Field.n_bits_of(dst_field)
     slaves = options[:slaves] || []
-    %NxBundleLoad{algorithm:  options[:algorithm]  || :active_backup,
-                  hash_field: options[:hash_field] || :eth_src,
-                  basis:      options[:basis]      || 0,
-                  n_slaves:   length(slaves),
-                  slaves:     slaves,
-                  offset:     options[:offset] || 0,
-                  n_bits:     options[:n_bits] || default_n_bits,
-                  dst_field:  options[:dst_field]}
+
+    %NxBundleLoad{
+      algorithm: options[:algorithm] || :active_backup,
+      hash_field: options[:hash_field] || :eth_src,
+      basis: options[:basis] || 0,
+      n_slaves: length(slaves),
+      slaves: slaves,
+      offset: options[:offset] || 0,
+      n_bits: options[:n_bits] || default_n_bits,
+      dst_field: options[:dst_field]
+    }
   end
 
-  def to_binary(%NxBundleLoad{algorithm: alg,
-                              hash_field: hash_field,
-                              basis: basis,
-                              slave_type: slave_type,
-                              n_slaves: n_slaves,
-                              slaves: slaves,
-                              offset: ofs,
-                              n_bits: n_bits,
-                              dst_field: dst_field}) do
+  def to_binary(%NxBundleLoad{
+        algorithm: alg,
+        hash_field: hash_field,
+        basis: basis,
+        slave_type: slave_type,
+        n_slaves: n_slaves,
+        slaves: slaves,
+        offset: ofs,
+        n_bits: n_bits,
+        dst_field: dst_field
+      }) do
     hash_field_int = Openflow.Enums.to_int(hash_field, :nx_hash_fields)
     alg_int = Openflow.Enums.to_int(alg, :nx_bd_algorithm)
     slave_type_bin = Openflow.Match.codec_header(slave_type)
     slaves_bin = codec_slaves(slaves)
-    ofs_nbits = (ofs <<< 6) ||| (n_bits - 1)
+    ofs_nbits = ofs <<< 6 ||| n_bits - 1
     dst_field_bin = Openflow.Match.codec_header(dst_field)
-    body = <<alg_int::16, hash_field_int::16, basis::16,
-             slave_type_bin::4-bytes, n_slaves::16, ofs_nbits::16,
-             dst_field_bin::4-bytes, 0::32, slaves_bin::bytes>>
+
+    body =
+      <<alg_int::16, hash_field_int::16, basis::16, slave_type_bin::4-bytes, n_slaves::16,
+        ofs_nbits::16, dst_field_bin::4-bytes, 0::32, slaves_bin::bytes>>
+
     exp_body = <<@experimenter::32, @nxast::16, body::bytes>>
-    exp_body_size =  byte_size(exp_body)
+    exp_body_size = byte_size(exp_body)
     padding_length = Openflow.Utils.padding(4 + exp_body_size, 8)
     length = 4 + exp_body_size + padding_length
-    <<0xffff::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
+    <<0xFFFF::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
   end
 
   def read(<<@experimenter::32, @nxast::16, body::bytes>>) do
-    <<alg_int::16, hash_field_int::16, basis::16,
-      slave_type_bin::4-bytes, n_slaves::16, ofs::10, n_bits::6,
-      dst_field_bin::4-bytes, _reserved::32, rest::bytes>> = body
+    <<alg_int::16, hash_field_int::16, basis::16, slave_type_bin::4-bytes, n_slaves::16, ofs::10,
+      n_bits::6, dst_field_bin::4-bytes, _reserved::32, rest::bytes>> = body
+
     slave_len = n_slaves * 2
     <<slaves_bin::size(slave_len)-bytes, _::bytes>> = rest
     alg = Openflow.Enums.to_atom(alg_int, :nx_bd_algorithm)
@@ -69,26 +76,32 @@ defmodule Openflow.Action.NxBundleLoad do
     slaves = codec_slaves(slaves_bin)
     n_slaves = length(slaves)
     dst_field = Openflow.Match.codec_header(dst_field_bin)
-    %NxBundleLoad{algorithm: alg,
-                  hash_field: hash_field,
-                  basis: basis,
-                  slave_type: slave_type,
-                  n_slaves: n_slaves,
-                  slaves: slaves,
-                  offset: ofs,
-                  n_bits: n_bits + 1,
-                  dst_field: dst_field}
+
+    %NxBundleLoad{
+      algorithm: alg,
+      hash_field: hash_field,
+      basis: basis,
+      slave_type: slave_type,
+      n_slaves: n_slaves,
+      slaves: slaves,
+      offset: ofs,
+      n_bits: n_bits + 1,
+      dst_field: dst_field
+    }
   end
 
   # private functions
 
   defp codec_slaves(slaves) when is_list(slaves) do
-    slaves1 = for slave <- slaves do
-      slave_int = Openflow.Utils.get_enum(slave, :openflow10_port_no)
-      <<slave_int::16>>
-    end
+    slaves1 =
+      for slave <- slaves do
+        slave_int = Openflow.Utils.get_enum(slave, :openflow10_port_no)
+        <<slave_int::16>>
+      end
+
     Enum.join(slaves1, "")
   end
+
   defp codec_slaves(slaves) when is_binary(slaves) do
     for <<slave_int::16 <- slaves>> do
       Openflow.Utils.get_enum(slave_int, :openflow10_port_no)

lib/openflow/actions/nx_clone.ex

@@ -1,7 +1,5 @@
 defmodule Openflow.Action.NxClone do
-  defstruct(
-    actions: []
-  )
+  defstruct(actions: [])
 
   @experimenter 0x00002320
   @nxast 42
@@ -15,10 +13,10 @@ defmodule Openflow.Action.NxClone do
   def to_binary(%NxClone{actions: actions}) do
     actions_bin = Openflow.Action.to_binary(actions)
     exp_body = <<@experimenter::32, @nxast::16, 0::size(6)-unit(8), actions_bin::bytes>>
-    exp_body_size =  byte_size(exp_body)
+    exp_body_size = byte_size(exp_body)
     padding_length = Openflow.Utils.padding(4 + exp_body_size, 8)
     length = 4 + exp_body_size + padding_length
-    <<0xffff::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
+    <<0xFFFF::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
   end
 
   def read(<<@experimenter::32, @nxast::16, 0::size(6)-unit(8), actions_bin::bytes>>) do

lib/openflow/actions/nx_conjunction.ex

@@ -1,8 +1,8 @@
 defmodule Openflow.Action.NxConjunction do
   defstruct(
-    clause:    0,
+    clause: 0,
     n_clauses: 0,
-    id:        0
+    id: 0
   )
 
   @experimenter 0x00002320
@@ -11,14 +11,16 @@ defmodule Openflow.Action.NxConjunction do
   alias __MODULE__
 
   def new(options) do
-    %NxConjunction{clause:    options[:clause] || 0,
-                   n_clauses: options[:n_clauses] || 0,
-                   id:        options[:id] || 0}
+    %NxConjunction{
+      clause: options[:clause] || 0,
+      n_clauses: options[:n_clauses] || 0,
+      id: options[:id] || 0
+    }
   end
 
   def to_binary(%NxConjunction{clause: clause, n_clauses: n_clauses, id: id}) do
     exp_body = <<@experimenter::32, @nxast::16, clause::8, n_clauses::8, id::32>>
-    <<0xffff::16, 16::16, exp_body::bytes>>
+    <<0xFFFF::16, 16::16, exp_body::bytes>>
   end
 
   def read(<<@experimenter::32, @nxast::16, clause::8, n_clauses::8, id::32>>) do

lib/openflow/actions/nx_conntrack.ex

@@ -2,14 +2,14 @@ defmodule Openflow.Action.NxConntrack do
   import Bitwise
 
   defstruct(
-    flags:       [],
-    zone_src:     nil,
-    zone_imm:     0,
-    zone_offset:  nil,
-    zone_n_bits:  nil,
+    flags: [],
+    zone_src: nil,
+    zone_imm: 0,
+    zone_offset: nil,
+    zone_n_bits: nil,
     recirc_table: 255,
-    alg:          0,
-    exec:         []
+    alg: 0,
+    exec: []
   )
 
   @experimenter 0x00002320
@@ -18,61 +18,73 @@ defmodule Openflow.Action.NxConntrack do
   alias __MODULE__
 
   def new(options \\ []) do
-    %NxConntrack{flags:        options[:flags] || [],
-                 zone_src:     options[:zone_src],
-                 zone_imm:     options[:zone_imm] || 0,
-                 zone_offset:  options[:zone_offset],
-                 zone_n_bits:  options[:zone_n_bits],
-                 recirc_table: options[:recirc_table] || 255,
-                 alg:          options[:alg]  || 0,
-                 exec:         options[:exec] || []}
+    %NxConntrack{
+      flags: options[:flags] || [],
+      zone_src: options[:zone_src],
+      zone_imm: options[:zone_imm] || 0,
+      zone_offset: options[:zone_offset],
+      zone_n_bits: options[:zone_n_bits],
+      recirc_table: options[:recirc_table] || 255,
+      alg: options[:alg] || 0,
+      exec: options[:exec] || []
+    }
   end
 
   def to_binary(%NxConntrack{
-        flags:        flags,
-        zone_src:     zone_src,
-        zone_offset:  zone_ofs,
-        zone_n_bits:  zone_n_bits,
-        zone_imm:     zone_imm,
+        flags: flags,
+        zone_src: zone_src,
+        zone_offset: zone_ofs,
+        zone_n_bits: zone_n_bits,
+        zone_imm: zone_imm,
         recirc_table: recirc_table,
-        alg:          alg,
-        exec:         exec}) do
+        alg: alg,
+        exec: exec
+      }) do
     flags_int = Openflow.Enums.flags_to_int(flags, :nx_conntrack_flags)
-    {src_bin, ofs_nbits} = if not (is_nil(zone_src)) do
-      zone_src_bin = Openflow.Match.codec_header(zone_src)
-      {zone_src_bin, (zone_ofs <<< 6) ||| (zone_n_bits - 1)}
-    else
-      {<<0::32>>, zone_imm}
-    end
+
+    {src_bin, ofs_nbits} =
+      if not is_nil(zone_src) do
+        zone_src_bin = Openflow.Match.codec_header(zone_src)
+        {zone_src_bin, zone_ofs <<< 6 ||| zone_n_bits - 1}
+      else
+        {<<0::32>>, zone_imm}
+      end
+
     exec_bin = Openflow.Action.to_binary(exec)
-    exp_body = <<@experimenter::32, @nxast::16, flags_int::16,
-                 src_bin::bytes, ofs_nbits::16, recirc_table::8,
-                 0::size(3)-unit(8), alg::16, exec_bin::bytes>>
-    exp_body_size =  byte_size(exp_body)
+
+    exp_body =
+      <<@experimenter::32, @nxast::16, flags_int::16, src_bin::bytes, ofs_nbits::16,
+        recirc_table::8, 0::size(3)-unit(8), alg::16, exec_bin::bytes>>
+
+    exp_body_size = byte_size(exp_body)
     padding_length = Openflow.Utils.padding(4 + exp_body_size, 8)
     length = 4 + exp_body_size + padding_length
-    <<0xffff::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
+    <<0xFFFF::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
   end
 
-  def read(<<@experimenter::32, @nxast::16, flags_int::16,
-             src_bin::4-bytes, ofs_nbits::16-bits, recirc_table::8,
-             _::size(3)-unit(8), alg::16, exec_bin::bytes>>) do
+  def read(
+        <<@experimenter::32, @nxast::16, flags_int::16, src_bin::4-bytes, ofs_nbits::16-bits,
+          recirc_table::8, _::size(3)-unit(8), alg::16, exec_bin::bytes>>
+      ) do
     flags = Openflow.Enums.int_to_flags(flags_int, :nx_conntrack_flags)
     exec = Openflow.Action.read(exec_bin)
+
     ct = %NxConntrack{
-      flags:        flags,
+      flags: flags,
       recirc_table: recirc_table,
-      alg:          alg,
-      exec:         exec
+      alg: alg,
+      exec: exec
     }
+
     case src_bin do
       <<0::32>> ->
         <<zone_imm::16>> = ofs_nbits
-        %{ct|zone_imm: zone_imm}
+        %{ct | zone_imm: zone_imm}
+
       binary when is_binary(binary) ->
         zone_src = Openflow.Match.codec_header(binary)
         <<ofs::10, n_bits::6>> = ofs_nbits
-        %{ct|zone_src: zone_src, zone_offset: ofs, zone_n_bits: n_bits + 1}
+        %{ct | zone_src: zone_src, zone_offset: ofs, zone_n_bits: n_bits + 1}
     end
   end
 end

lib/openflow/actions/nx_controller.ex

@@ -11,19 +11,27 @@ defmodule Openflow.Action.NxController do
   alias __MODULE__
 
   def new(options) do
-    %NxController{max_len: options[:max_len] || :no_buffer,
-                  id:      options[:id]      || 0,
-                  reason:  options[:reason]  || :action}
+    %NxController{
+      max_len: options[:max_len] || :no_buffer,
+      id: options[:id] || 0,
+      reason: options[:reason] || :action
+    }
   end
 
   def to_binary(%NxController{max_len: max_len, id: controller_id, reason: reason}) do
     max_len_int = Openflow.Utils.get_enum(max_len, :controller_max_len)
     reason_int = Openflow.Enums.to_int(reason, :packet_in_reason)
-    exp_body = <<@experimenter::32, @nxast::16, max_len_int::16, controller_id::16, reason_int::8, 0::8>>
-    <<0xffff::16, 16::16, exp_body::bytes>>
+
+    exp_body =
+      <<@experimenter::32, @nxast::16, max_len_int::16, controller_id::16, reason_int::8, 0::8>>
+
+    <<0xFFFF::16, 16::16, exp_body::bytes>>
   end
 
-  def read(<<@experimenter::32, @nxast::16, max_len_int::16, controller_id::16, reason_int::8, _::bytes>>) do
+  def read(
+        <<@experimenter::32, @nxast::16, max_len_int::16, controller_id::16, reason_int::8,
+          _::bytes>>
+      ) do
     max_len = Openflow.Utils.get_enum(max_len_int, :controller_max_len)
     reason = Openflow.Enums.to_atom(reason_int, :packet_in_reason)
     %NxController{max_len: max_len, id: controller_id, reason: reason}

lib/openflow/actions/nx_controller2.ex

@@ -1,10 +1,10 @@
 defmodule Openflow.Action.NxController2 do
   defstruct(
-    max_len:  :no_buffer,
-    id:       0,
-    reason:   :action,
+    max_len: :no_buffer,
+    id: 0,
+    reason: :action,
     userdata: "",
-    pause:    false
+    pause: false
   )
 
   @experimenter 0x00002320
@@ -12,20 +12,22 @@ defmodule Openflow.Action.NxController2 do
 
   @prop_header_size 4
 
-  @prop_max_len  0
-  @prop_ctl_id   1
-  @prop_reason   2
+  @prop_max_len 0
+  @prop_ctl_id 1
+  @prop_reason 2
   @prop_userdata 3
-  @prop_pause    4
+  @prop_pause 4
 
   alias __MODULE__
 
   def new(options) do
-    %NxController2{max_len:  options[:max_len]  || :no_buffer,
-                   id:       options[:id]       || 0,
-                   reason:   options[:reason]   || :action,
-                   userdata: options[:userdata],
-                   pause:    options[:pause]    || false}
+    %NxController2{
+      max_len: options[:max_len] || :no_buffer,
+      id: options[:id] || 0,
+      reason: options[:reason] || :action,
+      userdata: options[:userdata],
+      pause: options[:pause] || false
+    }
   end
 
   def to_binary(%NxController2{} = ctl) do
@@ -33,10 +35,10 @@ defmodule Openflow.Action.NxController2 do
     prop_keys = get_prop_key(ctl)
     props_bin = encode_prop("", prop_keys, ctl)
     exp_body = <<ext_header::bytes, props_bin::bytes>>
-    exp_body_size =  byte_size(exp_body)
+    exp_body_size = byte_size(exp_body)
     padding_length = Openflow.Utils.padding(4 + exp_body_size, 8)
     length = 4 + exp_body_size + padding_length
-    <<0xffff::16, length::16, exp_body::bytes>>
+    <<0xFFFF::16, length::16, exp_body::bytes>>
   end
 
   def read(<<@experimenter::32, @nxast::16, 0::size(6)-unit(8), body::bytes>>) do
@@ -48,64 +50,88 @@ defmodule Openflow.Action.NxController2 do
 
   defp get_prop_key(ctl) do
     ctl
-    |> Map.from_struct
-    |> Enum.map(fn({k, v}) -> if(not is_nil(v), do: k, else: nil) end)
-    |> Enum.filter(fn(v) -> not is_nil(v) end)
+    |> Map.from_struct()
+    |> Enum.map(fn {k, v} -> if(not is_nil(v), do: k, else: nil) end)
+    |> Enum.filter(fn v -> not is_nil(v) end)
   end
 
   defp encode_prop(acc, [], _ctl), do: acc
-  defp encode_prop(acc, [prop|rest], ctl) do
+
+  defp encode_prop(acc, [prop | rest], ctl) do
     value = Map.get(ctl, prop)
-    prop_bin = cond do
-      prop == :max_len and (value != :no_buffer or value < 0xffff) ->
-        padding_length = 2
-        prop_length = @prop_header_size + 2 + padding_length
-        max_len_int = Openflow.Utils.get_enum(value, :controller_max_len)
-        <<@prop_max_len::16, prop_length::16, max_len_int::16, 0::size(padding_length)-unit(8)>>
-      prop == :id ->
-        padding_length = 2
-        prop_length = @prop_header_size + 2 + padding_length
-        <<@prop_ctl_id::16, prop_length::16, value::16, 0::size(padding_length)-unit(8)>>
-      prop == :reason and value != :action ->
-        padding_length = 3
-        prop_length = @prop_header_size + 1 + padding_length
-        reason_int = Openflow.Utils.get_enum(value, :packet_in_reason)
-        <<@prop_reason::16, prop_length::16, reason_int::8, 0::size(padding_length)-unit(8)>>
-      prop == :userdata and byte_size(value) > 0 ->
-        prop_length = @prop_header_size + byte_size(value)
-        padding_length = Openflow.Utils.padding(prop_length, 8)
-        <<@prop_userdata::16, prop_length::16, value::bytes, 0::size(padding_length)-unit(8)>>
-      prop == :pause and value == true ->
-        padding_length = 4
-        prop_length = @prop_header_size + padding_length
-        <<@prop_pause::16, prop_length::16, 0::size(padding_length)-unit(8)>>
-      true ->
-        ""
-    end
+
+    prop_bin =
+      cond do
+        prop == :max_len and (value != :no_buffer or value < 0xFFFF) ->
+          padding_length = 2
+          prop_length = @prop_header_size + 2 + padding_length
+          max_len_int = Openflow.Utils.get_enum(value, :controller_max_len)
+          <<@prop_max_len::16, prop_length::16, max_len_int::16, 0::size(padding_length)-unit(8)>>
+
+        prop == :id ->
+          padding_length = 2
+          prop_length = @prop_header_size + 2 + padding_length
+          <<@prop_ctl_id::16, prop_length::16, value::16, 0::size(padding_length)-unit(8)>>
+
+        prop == :reason and value != :action ->
+          padding_length = 3
+          prop_length = @prop_header_size + 1 + padding_length
+          reason_int = Openflow.Utils.get_enum(value, :packet_in_reason)
+          <<@prop_reason::16, prop_length::16, reason_int::8, 0::size(padding_length)-unit(8)>>
+
+        prop == :userdata and byte_size(value) > 0 ->
+          prop_length = @prop_header_size + byte_size(value)
+          padding_length = Openflow.Utils.padding(prop_length, 8)
+          <<@prop_userdata::16, prop_length::16, value::bytes, 0::size(padding_length)-unit(8)>>
+
+        prop == :pause and value == true ->
+          padding_length = 4
+          prop_length = @prop_header_size + padding_length
+          <<@prop_pause::16, prop_length::16, 0::size(padding_length)-unit(8)>>
+
+        true ->
+          ""
+      end
+
     encode_prop(<<acc::bytes, prop_bin::bytes>>, rest, ctl)
   end
 
   defp decode_prop(ctl, ""), do: ctl
+
   defp decode_prop(ctl, <<prop_type_int::16, _::bytes>> = bin) do
     prop_type = Openflow.Enums.to_atom(prop_type_int, :nx_action_controller2_prop_type)
+
     case prop_type do
       :max_len ->
-        <<@prop_max_len::16, _prop_length::16, max_len_int::16, _::size(2)-unit(8), rest::bytes>> = bin
+        <<@prop_max_len::16, _prop_length::16, max_len_int::16, _::size(2)-unit(8), rest::bytes>> =
+          bin
+
         max_len = Openflow.Utils.get_enum(max_len_int, :controller_max_len)
         decode_prop(struct(ctl, %{max_len: max_len}), rest)
+
       :controller_id ->
-        <<@prop_ctl_id::16, _prop_length::16, controller_id::16, _::size(2)-unit(8), rest::bytes>> = bin
+        <<@prop_ctl_id::16, _prop_length::16, controller_id::16, _::size(2)-unit(8), rest::bytes>> =
+          bin
+
         decode_prop(struct(ctl, %{controller_id: controller_id}), rest)
+
       :reason ->
-        <<@prop_reason::16, _prop_length::16, reason_int::8, _::size(3)-unit(8), rest::bytes>> = bin
+        <<@prop_reason::16, _prop_length::16, reason_int::8, _::size(3)-unit(8), rest::bytes>> =
+          bin
+
         reason = Openflow.Utils.get_enum(reason_int, :packet_in_reason)
         decode_prop(struct(ctl, %{reason: reason}), rest)
+
       :userdata ->
         <<@prop_userdata::16, prop_length::16, remains::bytes>> = bin
         userdata_len = prop_length - 4
         padding_length = Openflow.Utils.padding(prop_length, 8)
-        <<userdata::size(userdata_len)-bytes, _::size(padding_length)-unit(8), rest::bytes>> = remains
+
+        <<userdata::size(userdata_len)-bytes, _::size(padding_length)-unit(8), rest::bytes>> =
+          remains
+
         decode_prop(struct(ctl, %{userdata: userdata}), rest)
+
       :pause ->
         <<@prop_pause::16, _::16, 0::size(4)-unit(8), rest::bytes>> = bin
         decode_prop(struct(ctl, %{pause: true}), rest)

lib/openflow/actions/nx_ct_clear.ex

@@ -12,7 +12,7 @@ defmodule Openflow.Action.NxCtClear do
 
   def to_binary(%NxCtClear{}) do
     exp_body = <<@experimenter::32, @nxast::16, 0::16, 0::size(4)-unit(8)>>
-    <<0xffff::16, 16::16, exp_body::bytes>>
+    <<0xFFFF::16, 16::16, exp_body::bytes>>
   end
 
   def read(<<@experimenter::32, @nxast::16, _::16, _::size(4)-unit(8)>>) do

lib/openflow/actions/nx_dec_mpls_ttl.ex

@@ -12,7 +12,7 @@ defmodule Openflow.Action.NxDecMplsTtl do
 
   def to_binary(%NxDecMplsTtl{}) do
     exp_body = <<@experimenter::32, @nxast::16, 0::size(6)-unit(8)>>
-    <<0xffff::16, 16::16, exp_body::bytes>>
+    <<0xFFFF::16, 16::16, exp_body::bytes>>
   end
 
   def read(<<@experimenter::32, @nxast::16, _::size(6)-unit(8)>>) do

lib/openflow/actions/nx_dec_ttl.ex

@@ -12,7 +12,7 @@ defmodule Openflow.Action.NxDecTtl do
 
   def to_binary(%NxDecTtl{}) do
     exp_body = <<@experimenter::32, @nxast::16, 0::size(6)-unit(8)>>
-    <<0xffff::16, 16::16, exp_body::bytes>>
+    <<0xFFFF::16, 16::16, exp_body::bytes>>
   end
 
   def read(<<@experimenter::32, @nxast::16, _::16, _::size(4)-unit(8)>>) do

lib/openflow/actions/nx_dec_ttl_cnt_ids.ex

@@ -12,14 +12,17 @@ defmodule Openflow.Action.NxDecTtlCntIds do
 
   def to_binary(%NxDecTtlCntIds{ids: ids}) do
     n_controllers = length(ids)
-    ids_bin = Enum.join((for id <- ids, do: <<id::16>>), "")
+    ids_bin = Enum.join(for(id <- ids, do: <<id::16>>), "")
     padding = Openflow.Utils.padding(n_controllers, 8)
-    exp_body = <<@experimenter::32, @nxast::16, n_controllers::16,
-      0::size(4)-unit(8), ids_bin::bytes, 0::size(padding)-unit(8)>>
-    exp_body_size =  byte_size(exp_body)
+
+    exp_body =
+      <<@experimenter::32, @nxast::16, n_controllers::16, 0::size(4)-unit(8), ids_bin::bytes,
+        0::size(padding)-unit(8)>>
+
+    exp_body_size = byte_size(exp_body)
     padding_length = Openflow.Utils.padding(4 + exp_body_size, 8)
     length = 4 + exp_body_size + padding_length
-    <<0xffff::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
+    <<0xFFFF::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
   end
 
   def read(<<@experimenter::32, @nxast::16, n_controllers::16, body::bitstring>>) do

lib/openflow/actions/nx_exit.ex

@@ -12,7 +12,7 @@ defmodule Openflow.Action.NxExit do
 
   def to_binary(%NxExit{}) do
     exp_body = <<@experimenter::32, @nxast::16, 0::48>>
-    <<0xffff::16, 16::16, exp_body::bytes>>
+    <<0xFFFF::16, 16::16, exp_body::bytes>>
   end
 
   def read(<<@experimenter::32, @nxast::16, 0::48>>) do

lib/openflow/actions/nx_fin_timeout.ex

@@ -10,13 +10,15 @@ defmodule Openflow.Action.NxFinTimeout do
   alias __MODULE__
 
   def new(options) do
-    %NxFinTimeout{idle_timeout: options[:idle_timeout] || 0,
-                  hard_timeout: options[:hard_timeout] || 0}
+    %NxFinTimeout{
+      idle_timeout: options[:idle_timeout] || 0,
+      hard_timeout: options[:hard_timeout] || 0
+    }
   end
 
   def to_binary(%NxFinTimeout{idle_timeout: fin_idle, hard_timeout: fin_hard}) do
     exp_body = <<@experimenter::32, @nxast::16, fin_idle::16, fin_hard::16>>
-    <<0xffff::16, 16::16, exp_body::bytes, 0::size(2)-unit(8)>>
+    <<0xFFFF::16, 16::16, exp_body::bytes, 0::size(2)-unit(8)>>
   end
 
   def read(<<@experimenter::32, @nxast::16, fin_idle::16, fin_hard::16, _::size(2)-unit(8)>>) do

lib/openflow/actions/nx_flow_spec.ex

@@ -1,5 +1,4 @@
 defmodule Openflow.Action.NxFlowSpec do
-
   def read(flow_spec_bin) do
     do_read([], flow_spec_bin)
   end
@@ -7,6 +6,7 @@ defmodule Openflow.Action.NxFlowSpec do
   def to_binary(flow_specs) when is_list(flow_specs) do
     to_binary(<<>>, flow_specs)
   end
+
   def to_binary(flow_spec) do
     to_binary([flow_spec])
   end
@@ -15,15 +15,17 @@ defmodule Openflow.Action.NxFlowSpec do
 
   defp do_read(acc, <<>>), do: Enum.reverse(acc)
   defp do_read(acc, <<0::16, _::bitstring>>), do: Enum.reverse(acc)
+
   defp do_read(acc, <<_::2, _::1, type::2, _::bitstring>> = binary) do
     codec = Openflow.Enums.to_atom(type, :nx_flow_spec_type)
     {flow_spec, rest} = codec.read(binary)
-    do_read([flow_spec|acc], rest)
+    do_read([flow_spec | acc], rest)
   end
 
   defp to_binary(acc, []), do: acc
-  defp to_binary(acc, [flow_spec|rest]) do
+
+  defp to_binary(acc, [flow_spec | rest]) do
     codec = flow_spec.__struct__
-    to_binary(<<acc::bytes, (codec.to_binary(flow_spec))::bytes>>, rest)
+    to_binary(<<acc::bytes, codec.to_binary(flow_spec)::bytes>>, rest)
   end
 end

lib/openflow/actions/nx_flow_spec_load.ex

@@ -2,67 +2,80 @@ defmodule Openflow.Action.NxFlowSpecLoad do
   defstruct(
     src: nil,
     dst: nil,
-    n_bits:     0,
+    n_bits: 0,
     src_offset: 0,
     dst_offset: 0
   )
 
-  @learn_src_field     0
+  @learn_src_field 0
   @learn_src_immediate 1
-  @learn_dst           1
+  @learn_dst 1
 
   alias __MODULE__
 
   def new(options) do
     dst = options[:dst]
     n_bits = options[:n_bits] || Openflow.Match.Field.n_bits_of(dst)
-    %NxFlowSpecLoad{src:        options[:src],
-                    dst:        dst,
-                    n_bits:     n_bits,
-                    src_offset: options[:src_offset] || 0,
-                    dst_offset: options[:dst_offset] || 0}
+
+    %NxFlowSpecLoad{
+      src: options[:src],
+      dst: dst,
+      n_bits: n_bits,
+      src_offset: options[:src_offset] || 0,
+      dst_offset: options[:dst_offset] || 0
+    }
   end
 
   def to_binary(%NxFlowSpecLoad{} = fsm) do
     %NxFlowSpecLoad{
-      dst:        dst_field,
-      n_bits:     n_bits,
+      dst: dst_field,
+      n_bits: n_bits,
       src_offset: src_ofs,
       dst_offset: dst_ofs
     } = fsm
+
     {src_code, src_bin} = codec_src(fsm)
     dst_bin = Openflow.Match.codec_header(dst_field)
+
     case src_code do
       @learn_src_immediate ->
-        <<0::2, src_code::1, @learn_dst::2, n_bits::11,
-          src_bin::bytes, dst_bin::4-bytes, dst_ofs::16>>
+        <<0::2, src_code::1, @learn_dst::2, n_bits::11, src_bin::bytes, dst_bin::4-bytes,
+          dst_ofs::16>>
+
       @learn_src_field ->
-        <<0::2, src_code::1, @learn_dst::2, n_bits::11,
-          src_bin::4-bytes, src_ofs::16, dst_bin::4-bytes, dst_ofs::16>>
+        <<0::2, src_code::1, @learn_dst::2, n_bits::11, src_bin::4-bytes, src_ofs::16,
+          dst_bin::4-bytes, dst_ofs::16>>
     end
   end
 
-  def read(<<_::2, @learn_src_field::1, @learn_dst::2, n_bits::11, src_bin::4-bytes,
-             src_ofs::16, dst_bin::4-bytes, dst_ofs::16, rest::bitstring>>) do
+  def read(
+        <<_::2, @learn_src_field::1, @learn_dst::2, n_bits::11, src_bin::4-bytes, src_ofs::16,
+          dst_bin::4-bytes, dst_ofs::16, rest::bitstring>>
+      ) do
     src = Openflow.Match.codec_header(src_bin)
     dst = Openflow.Match.codec_header(dst_bin)
-    flow_spec = %NxFlowSpecLoad{src: src,
-                                dst: dst,
-                                n_bits: n_bits,
-                                src_offset: src_ofs,
-                                dst_offset: dst_ofs}
+
+    flow_spec = %NxFlowSpecLoad{
+      src: src,
+      dst: dst,
+      n_bits: n_bits,
+      src_offset: src_ofs,
+      dst_offset: dst_ofs
+    }
+
     {flow_spec, rest}
   end
+
   def read(<<_::2, @learn_src_immediate::1, @learn_dst::2, n_bits::11, binary::bitstring>>) do
     rounded_up_len = Openflow.Utils.pad_length(n_bits, 8)
     rounded_up_nbits = n_bits + rounded_up_len
-    <<src_bin::size(rounded_up_nbits)-bits, dst_bin::4-bytes, dst_ofs::16, rest::bitstring>> = binary
+
+    <<src_bin::size(rounded_up_nbits)-bits, dst_bin::4-bytes, dst_ofs::16, rest::bitstring>> =
+      binary
+
     dst = Openflow.Match.codec_header(dst_bin)
     src = Openflow.Match.Field.codec(src_bin, dst)
-    flow_spec = %NxFlowSpecLoad{src: src,
-                                dst: dst,
-                                n_bits: n_bits,
-                                dst_offset: dst_ofs}
+    flow_spec = %NxFlowSpecLoad{src: src, dst: dst, n_bits: n_bits, dst_offset: dst_ofs}
     {flow_spec, rest}
   end
 
@@ -72,6 +85,7 @@ defmodule Openflow.Action.NxFlowSpecLoad do
     src_bin = Openflow.Match.codec_header(src_field)
     {@learn_src_field, src_bin}
   end
+
   defp codec_src(%NxFlowSpecLoad{src: src, dst: dst_field}) do
     src_bin = Openflow.Match.Field.codec(src, dst_field)
     {@learn_src_immediate, src_bin}

lib/openflow/actions/nx_flow_spec_match.ex

@@ -2,67 +2,80 @@ defmodule Openflow.Action.NxFlowSpecMatch do
   defstruct(
     src: nil,
     dst: nil,
-    n_bits:     0,
+    n_bits: 0,
     src_offset: 0,
     dst_offset: 0
   )
 
-  @learn_src_field     0
+  @learn_src_field 0
   @learn_src_immediate 1
-  @learn_dst           0
+  @learn_dst 0
 
   alias __MODULE__
 
   def new(options) do
     dst = options[:dst]
     n_bits = options[:n_bits] || Openflow.Match.Field.n_bits_of(dst)
-    %NxFlowSpecMatch{src:        options[:src],
-                     dst:        dst,
-                     n_bits:     n_bits,
-                     src_offset: options[:src_offset] || 0,
-                     dst_offset: options[:dst_offset] || 0}
+
+    %NxFlowSpecMatch{
+      src: options[:src],
+      dst: dst,
+      n_bits: n_bits,
+      src_offset: options[:src_offset] || 0,
+      dst_offset: options[:dst_offset] || 0
+    }
   end
 
   def to_binary(%NxFlowSpecMatch{} = fsm) do
     %NxFlowSpecMatch{
-      dst:        dst_field,
-      n_bits:     n_bits,
+      dst: dst_field,
+      n_bits: n_bits,
       src_offset: src_ofs,
       dst_offset: dst_ofs
     } = fsm
+
     {src_code, src_bin} = codec_src(fsm)
     dst_bin = Openflow.Match.codec_header(dst_field)
+
     case src_code do
       @learn_src_immediate ->
-        <<0::2, src_code::1, @learn_dst::2, n_bits::11,
-          src_bin::bytes, dst_bin::4-bytes, dst_ofs::16>>
+        <<0::2, src_code::1, @learn_dst::2, n_bits::11, src_bin::bytes, dst_bin::4-bytes,
+          dst_ofs::16>>
+
       @learn_src_field ->
-        <<0::2, src_code::1, @learn_dst::2, n_bits::11,
-          src_bin::bytes, src_ofs::16, dst_bin::4-bytes, dst_ofs::16>>
+        <<0::2, src_code::1, @learn_dst::2, n_bits::11, src_bin::bytes, src_ofs::16,
+          dst_bin::4-bytes, dst_ofs::16>>
     end
   end
 
-  def read(<<_::2, @learn_src_field::1, @learn_dst::2, n_bits::11, src_bin::4-bytes,
-             src_ofs::16, dst_bin::4-bytes, dst_ofs::16, rest::bitstring>>) do
+  def read(
+        <<_::2, @learn_src_field::1, @learn_dst::2, n_bits::11, src_bin::4-bytes, src_ofs::16,
+          dst_bin::4-bytes, dst_ofs::16, rest::bitstring>>
+      ) do
     src = Openflow.Match.codec_header(src_bin)
     dst = Openflow.Match.codec_header(dst_bin)
-    flow_spec = %NxFlowSpecMatch{src: src,
-                                 dst: dst,
-                                 n_bits: n_bits,
-                                 src_offset: src_ofs,
-                                 dst_offset: dst_ofs}
+
+    flow_spec = %NxFlowSpecMatch{
+      src: src,
+      dst: dst,
+      n_bits: n_bits,
+      src_offset: src_ofs,
+      dst_offset: dst_ofs
+    }
+
     {flow_spec, rest}
   end
+
   def read(<<_::2, @learn_src_immediate::1, @learn_dst::2, n_bits::11, binary::bitstring>>) do
     rounded_up_len = Openflow.Utils.pad_length(n_bits, 8)
     rounded_up_nbits = n_bits + rounded_up_len
-    <<src_bin::size(rounded_up_nbits)-bits, dst_bin::4-bytes, dst_ofs::16, rest::bitstring>> = binary
+
+    <<src_bin::size(rounded_up_nbits)-bits, dst_bin::4-bytes, dst_ofs::16, rest::bitstring>> =
+      binary
+
     dst = Openflow.Match.codec_header(dst_bin)
     src = Openflow.Match.Field.codec(src_bin, dst)
-    flow_spec = %NxFlowSpecMatch{src: src,
-                                 dst: dst,
-                                 n_bits: n_bits,
-                                 dst_offset: dst_ofs}
+    flow_spec = %NxFlowSpecMatch{src: src, dst: dst, n_bits: n_bits, dst_offset: dst_ofs}
     {flow_spec, rest}
   end
 
@@ -72,6 +85,7 @@ defmodule Openflow.Action.NxFlowSpecMatch do
     src_bin = Openflow.Match.codec_header(src_field)
     {@learn_src_field, src_bin}
   end
+
   defp codec_src(%NxFlowSpecMatch{src: src, dst: dst_field}) do
     src_bin = Openflow.Match.Field.codec(src, dst_field)
     {@learn_src_immediate, src_bin}

lib/openflow/actions/nx_flow_spec_output.ex

@@ -5,32 +5,28 @@ defmodule Openflow.Action.NxFlowSpecOutput do
     src_offset: 0
   )
 
-  @learn_src_field     0
-  @learn_dst           2
+  @learn_src_field 0
+  @learn_dst 2
 
   alias __MODULE__
 
   def new(options) do
     src = options[:src]
     n_bits = options[:n_bits] || Openflow.Match.Field.n_bits_of(src)
-    %NxFlowSpecOutput{n_bits:     n_bits,
-                      src:        src,
-                      src_offset: options[:src_offset] || 0}
+    %NxFlowSpecOutput{n_bits: n_bits, src: src, src_offset: options[:src_offset] || 0}
   end
 
-  def to_binary(%NxFlowSpecOutput{n_bits: n_bits,
-                                  src: src,
-                                  src_offset: src_ofs}) do
+  def to_binary(%NxFlowSpecOutput{n_bits: n_bits, src: src, src_offset: src_ofs}) do
     src_bin = Openflow.Match.codec_header(src)
     <<0::2, @learn_src_field::1, @learn_dst::2, n_bits::11, src_bin::4-bytes, src_ofs::16>>
   end
 
-  def read(<<0::2, @learn_src_field::1, @learn_dst::2,
-             n_bits::11, src_bin::4-bytes, src_ofs::16, rest::bitstring>>) do
+  def read(
+        <<0::2, @learn_src_field::1, @learn_dst::2, n_bits::11, src_bin::4-bytes, src_ofs::16,
+          rest::bitstring>>
+      ) do
     src = Openflow.Match.codec_header(src_bin)
-    flow_spec = %NxFlowSpecOutput{n_bits: n_bits,
-                                  src: src,
-                                  src_offset: src_ofs}
+    flow_spec = %NxFlowSpecOutput{n_bits: n_bits, src: src, src_offset: src_ofs}
     {flow_spec, rest}
   end
 end

lib/openflow/actions/nx_learn.ex

@@ -17,53 +17,60 @@ defmodule Openflow.Action.NxLearn do
   alias __MODULE__
 
   def new(options) do
-    %NxLearn{idle_timeout:     options[:idle_timeout]     || 0,
-             hard_timeout:     options[:hard_timeout]     || 0,
-             priority:         options[:priority]         || 0,
-             cookie:           options[:cookie]           || 0,
-             flags:            options[:flags]            || [],
-             table_id:         options[:table_id]         || 0xff,
-             fin_idle_timeout: options[:fin_idle_timeout] || 0,
-             fin_hard_timeout: options[:fin_hard_timeout] || 0,
-             flow_specs:       options[:flow_specs]       || []}
+    %NxLearn{
+      idle_timeout: options[:idle_timeout] || 0,
+      hard_timeout: options[:hard_timeout] || 0,
+      priority: options[:priority] || 0,
+      cookie: options[:cookie] || 0,
+      flags: options[:flags] || [],
+      table_id: options[:table_id] || 0xFF,
+      fin_idle_timeout: options[:fin_idle_timeout] || 0,
+      fin_hard_timeout: options[:fin_hard_timeout] || 0,
+      flow_specs: options[:flow_specs] || []
+    }
   end
 
-  def to_binary(%NxLearn{idle_timeout: idle,
-                         hard_timeout: hard,
-                         priority: prio,
-                         cookie: cookie,
-                         flags: flags,
-                         table_id: table_id,
-                         fin_idle_timeout: fin_idle,
-                         fin_hard_timeout: fin_hard,
-                         flow_specs: flow_specs}) do
+  def to_binary(%NxLearn{
+        idle_timeout: idle,
+        hard_timeout: hard,
+        priority: prio,
+        cookie: cookie,
+        flags: flags,
+        table_id: table_id,
+        fin_idle_timeout: fin_idle,
+        fin_hard_timeout: fin_hard,
+        flow_specs: flow_specs
+      }) do
     flags_int = Openflow.Enums.flags_to_int(flags, :nx_learn_flag)
     flow_specs_bin = Openflow.Action.NxFlowSpec.to_binary(flow_specs)
-    exp_body = <<@experimenter::32, @nxast::16, idle::16, hard::16,
-      prio::16, cookie::64, flags_int::16, table_id::8,
-      0::size(1)-unit(8), fin_idle::16, fin_hard::16,
-      flow_specs_bin::bitstring>>
-    exp_body_size =  byte_size(exp_body)
+
+    exp_body =
+      <<@experimenter::32, @nxast::16, idle::16, hard::16, prio::16, cookie::64, flags_int::16,
+        table_id::8, 0::size(1)-unit(8), fin_idle::16, fin_hard::16, flow_specs_bin::bitstring>>
+
+    exp_body_size = byte_size(exp_body)
     padding_length = Openflow.Utils.padding(4 + exp_body_size, 8)
     length = 4 + exp_body_size + padding_length
-    <<0xffff::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
+    <<0xFFFF::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
   end
 
   def read(<<@experimenter::32, @nxast::16, body::bitstring>>) do
-    <<idle::16, hard::16,
-      prio::16, cookie::64, flags_int::16, table_id::8,
-      _pad::size(1)-unit(8), fin_idle::16, fin_hard::16,
-      flow_specs_bin::bitstring>> = body
+    <<idle::16, hard::16, prio::16, cookie::64, flags_int::16, table_id::8, _pad::size(1)-unit(8),
+      fin_idle::16, fin_hard::16, flow_specs_bin::bitstring>> = body
+
     flags = Openflow.Enums.int_to_flags(flags_int, :nx_learn_flag)
     flow_specs = Openflow.Action.NxFlowSpec.read(flow_specs_bin)
-    %NxLearn{idle_timeout: idle,
-             hard_timeout: hard,
-             priority: prio,
-             cookie: cookie,
-             flags: flags,
-             table_id: table_id,
-             fin_idle_timeout: fin_idle,
-             fin_hard_timeout: fin_hard,
-             flow_specs: flow_specs}
+
+    %NxLearn{
+      idle_timeout: idle,
+      hard_timeout: hard,
+      priority: prio,
+      cookie: cookie,
+      flags: flags,
+      table_id: table_id,
+      fin_idle_timeout: fin_idle,
+      fin_hard_timeout: fin_hard,
+      flow_specs: flow_specs
+    }
   end
 end

lib/openflow/actions/nx_learn2.ex

@@ -20,65 +20,77 @@ defmodule Openflow.Action.NxLearn2 do
   alias __MODULE__
 
   def new(options) do
-    %NxLearn2{idle_timeout:      options[:idle_timeout]      || 0,
-              hard_timeout:      options[:hard_timeout]      || 0,
-              priority:          options[:priority]          || 0,
-              cookie:            options[:cookie]            || 0,
-              flags:             options[:flags]             || [],
-              table_id:          options[:table_id]          || 0xff,
-              fin_idle_timeout:  options[:fin_idle_timeout]  || 0,
-              fin_hard_timeout:  options[:fin_hard_timeout]  || 0,
-              limit:             options[:limit]             || 0,
-              result_dst_offset: options[:result_dst_offset] || 0,
-              result_dst:        options[:result_dst],
-              flow_specs:        options[:flow_specs]        || []}
+    %NxLearn2{
+      idle_timeout: options[:idle_timeout] || 0,
+      hard_timeout: options[:hard_timeout] || 0,
+      priority: options[:priority] || 0,
+      cookie: options[:cookie] || 0,
+      flags: options[:flags] || [],
+      table_id: options[:table_id] || 0xFF,
+      fin_idle_timeout: options[:fin_idle_timeout] || 0,
+      fin_hard_timeout: options[:fin_hard_timeout] || 0,
+      limit: options[:limit] || 0,
+      result_dst_offset: options[:result_dst_offset] || 0,
+      result_dst: options[:result_dst],
+      flow_specs: options[:flow_specs] || []
+    }
   end
 
-  def to_binary(%NxLearn2{idle_timeout: idle,
-                          hard_timeout: hard,
-                          priority: prio,
-                          cookie: cookie,
-                          flags: flags,
-                          table_id: table_id,
-                          fin_idle_timeout: fin_idle,
-                          fin_hard_timeout: fin_hard,
-                          limit: limit,
-                          result_dst_offset: result_dst_ofs,
-                          result_dst: result_dst,
-                          flow_specs: flow_specs}) do
+  def to_binary(%NxLearn2{
+        idle_timeout: idle,
+        hard_timeout: hard,
+        priority: prio,
+        cookie: cookie,
+        flags: flags,
+        table_id: table_id,
+        fin_idle_timeout: fin_idle,
+        fin_hard_timeout: fin_hard,
+        limit: limit,
+        result_dst_offset: result_dst_ofs,
+        result_dst: result_dst,
+        flow_specs: flow_specs
+      }) do
     flags_int = Openflow.Enums.flags_to_int(flags, :nx_learn_flag)
-    result_dst_bin = if :write_result in flags do
-      Openflow.Match.codec_header(result_dst)
-    else
-      ""
-    end
+
+    result_dst_bin =
+      if :write_result in flags do
+        Openflow.Match.codec_header(result_dst)
+      else
+        ""
+      end
+
     flow_specs_bin = Openflow.Action.NxFlowSpec.to_binary(flow_specs)
-    exp_body = <<@experimenter::32, @nxast::16, idle::16, hard::16,
-      prio::16, cookie::64, flags_int::16, table_id::8,
-      0::size(1)-unit(8), fin_idle::16, fin_hard::16,
-      limit::32, result_dst_ofs::16, 0::size(2)-unit(8),
-      result_dst_bin::bytes, flow_specs_bin::bitstring>>
-    exp_body_size =  byte_size(exp_body)
+
+    exp_body =
+      <<@experimenter::32, @nxast::16, idle::16, hard::16, prio::16, cookie::64, flags_int::16,
+        table_id::8, 0::size(1)-unit(8), fin_idle::16, fin_hard::16, limit::32,
+        result_dst_ofs::16, 0::size(2)-unit(8), result_dst_bin::bytes, flow_specs_bin::bitstring>>
+
+    exp_body_size = byte_size(exp_body)
     padding_length = Openflow.Utils.padding(4 + exp_body_size, 8)
     length = 4 + exp_body_size + padding_length
-    <<0xffff::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
+    <<0xFFFF::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
   end
 
   def read(<<@experimenter::32, @nxast::16, body::bytes>>) do
-    <<idle::16, hard::16, prio::16, cookie::64, flags_int::16, table_id::8,
-      0::8, fin_idle::16, fin_hard::16, limit::32,
-      result_dst_ofs::16, 0::size(2)-unit(8), rest::bytes>> = body
+    <<idle::16, hard::16, prio::16, cookie::64, flags_int::16, table_id::8, 0::8, fin_idle::16,
+      fin_hard::16, limit::32, result_dst_ofs::16, 0::size(2)-unit(8), rest::bytes>> = body
+
     flags = Openflow.Enums.int_to_flags(flags_int, :nx_learn_flag)
-    learn = %NxLearn2{idle_timeout: idle,
-                      hard_timeout: hard,
-                      priority: prio,
-                      cookie: cookie,
-                      flags: flags,
-                      table_id: table_id,
-                      fin_idle_timeout: fin_idle,
-                      fin_hard_timeout: fin_hard,
-                      limit: limit,
-                      result_dst_offset: result_dst_ofs}
+
+    learn = %NxLearn2{
+      idle_timeout: idle,
+      hard_timeout: hard,
+      priority: prio,
+      cookie: cookie,
+      flags: flags,
+      table_id: table_id,
+      fin_idle_timeout: fin_idle,
+      fin_hard_timeout: fin_hard,
+      limit: limit,
+      result_dst_offset: result_dst_ofs
+    }
+
     if :write_result in flags do
       header_size = Openflow.Match.header_size(rest)
       <<result_dst_bin::size(header_size)-bytes, flow_specs_bin::bytes>> = rest

lib/openflow/actions/nx_multipath.ex

@@ -3,13 +3,13 @@ defmodule Openflow.Action.NxMultipath do
 
   defstruct(
     hash_field: :eth_src,
-    basis:      0,
-    algorithm:  :modulo_n,
-    max_link:   0,
-    argument:   0,
-    offset:     0,
-    n_bits:     0,
-    dst_field:  nil
+    basis: 0,
+    algorithm: :modulo_n,
+    max_link: 0,
+    argument: 0,
+    offset: 0,
+    n_bits: 0,
+    dst_field: nil
   )
 
   @experimenter 0x00002320
@@ -27,52 +27,62 @@ defmodule Openflow.Action.NxMultipath do
     default_n_bits = Openflow.Match.Field.n_bits_of(dst_field)
     n_bits = Keyword.get(options, :n_bits, default_n_bits)
     ofs = Keyword.get(options, :offset, 0)
-    %NxMultipath{hash_field: hash_field,
-                 basis:      basis,
-                 algorithm:  alg,
-                 max_link:   max_link,
-                 offset:     ofs,
-                 n_bits:     n_bits,
-                 argument:   arg,
-                 dst_field:  dst_field}
+
+    %NxMultipath{
+      hash_field: hash_field,
+      basis: basis,
+      algorithm: alg,
+      max_link: max_link,
+      offset: ofs,
+      n_bits: n_bits,
+      argument: arg,
+      dst_field: dst_field
+    }
   end
 
-  def to_binary(%NxMultipath{hash_field: hash_field,
-                             basis:      basis,
-                             algorithm:  alg,
-                             max_link:   max_link,
-                             argument:   arg,
-                             offset:     ofs,
-                             n_bits:     n_bits,
-                             dst_field:  dst_field}) do
+  def to_binary(%NxMultipath{
+        hash_field: hash_field,
+        basis: basis,
+        algorithm: alg,
+        max_link: max_link,
+        argument: arg,
+        offset: ofs,
+        n_bits: n_bits,
+        dst_field: dst_field
+      }) do
     hash_field_int = Openflow.Enums.to_int(hash_field, :nx_hash_fields)
     alg_int = Openflow.Enums.to_int(alg, :nx_mp_algorithm)
     dst_field_bin = Openflow.Match.codec_header(dst_field)
-    ofs_nbits = (ofs <<< 6) ||| (n_bits - 1)
-    body = <<hash_field_int::16, basis::16, 0::size(2)-unit(8),
-      alg_int::16, max_link::16, arg::32, 0::size(2)-unit(8),
-      ofs_nbits::16, dst_field_bin::4-bytes>>
+    ofs_nbits = ofs <<< 6 ||| n_bits - 1
+
+    body =
+      <<hash_field_int::16, basis::16, 0::size(2)-unit(8), alg_int::16, max_link::16, arg::32,
+        0::size(2)-unit(8), ofs_nbits::16, dst_field_bin::4-bytes>>
+
     exp_body = <<@experimenter::32, @nxast::16, body::bytes>>
-    exp_body_size =  byte_size(exp_body)
+    exp_body_size = byte_size(exp_body)
     padding_length = Openflow.Utils.padding(4 + exp_body_size, 8)
     length = 4 + exp_body_size + padding_length
-    <<0xffff::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
+    <<0xFFFF::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
   end
 
   def read(<<@experimenter::32, @nxast::16, body::bytes>>) do
-    <<hash_field_int::16, basis::16, _::size(2)-unit(8),
-      alg_int::16, max_link::16, arg::32, _::size(2)-unit(8),
-      ofs::10, n_bits::6, dst_field_bin::4-bytes>> = body
+    <<hash_field_int::16, basis::16, _::size(2)-unit(8), alg_int::16, max_link::16, arg::32,
+      _::size(2)-unit(8), ofs::10, n_bits::6, dst_field_bin::4-bytes>> = body
+
     hash_field = Openflow.Enums.to_atom(hash_field_int, :nx_hash_fields)
     alg = Openflow.Enums.to_atom(alg_int, :nx_mp_algorithm)
     dst_field = Openflow.Match.codec_header(dst_field_bin)
-    %NxMultipath{hash_field: hash_field,
-                 basis:      basis,
-                 algorithm:  alg,
-                 max_link:   max_link,
-                 argument:   arg,
-                 offset:     ofs,
-                 n_bits:     n_bits + 1,
-                 dst_field:  dst_field}
+
+    %NxMultipath{
+      hash_field: hash_field,
+      basis: basis,
+      algorithm: alg,
+      max_link: max_link,
+      argument: arg,
+      offset: ofs,
+      n_bits: n_bits + 1,
+      dst_field: dst_field
+    }
   end
 end

lib/openflow/actions/nx_nat.ex

@@ -1,10 +1,10 @@
 defmodule Openflow.Action.NxNat do
   defstruct(
-    flags:     [],
-    ipv4_min:  nil,
-    ipv4_max:  nil,
-    ipv6_min:  nil,
-    ipv6_max:  nil,
+    flags: [],
+    ipv4_min: nil,
+    ipv4_max: nil,
+    ipv6_min: nil,
+    ipv6_max: nil,
     proto_min: nil,
     proto_max: nil
   )
@@ -22,30 +22,38 @@ defmodule Openflow.Action.NxNat do
     ipv6_max = Keyword.get(options, :ipv6_max)
     proto_min = Keyword.get(options, :proto_min)
     proto_max = Keyword.get(options, :proto_max)
-    %NxNat{flags:     flags,
-           ipv4_min:  ipv4_min,
-           ipv4_max:  ipv4_max,
-           ipv6_min:  ipv6_min,
-           ipv6_max:  ipv6_max,
-           proto_min: proto_min,
-           proto_max: proto_max}
+
+    %NxNat{
+      flags: flags,
+      ipv4_min: ipv4_min,
+      ipv4_max: ipv4_max,
+      ipv6_min: ipv6_min,
+      ipv6_max: ipv6_max,
+      proto_min: proto_min,
+      proto_max: proto_max
+    }
   end
 
   def to_binary(%NxNat{flags: flags} = nat) do
     flags_int = Openflow.Enums.flags_to_int(flags, :nx_nat_flags)
+
     range_flags =
       nat
       |> get_ranges
       |> Openflow.Enums.flags_to_int(:nx_nat_range)
       |> Openflow.Enums.int_to_flags(:nx_nat_range)
+
     ranges_bin = encode_ranges("", range_flags, nat)
     range_flags_int = Openflow.Enums.flags_to_int(range_flags, :nx_nat_range)
-    exp_body = <<@experimenter::32, @nxast::16, 0::size(2)-unit(8),
-                 flags_int::16, range_flags_int::16, ranges_bin::bytes>>
-    exp_body_size =  byte_size(exp_body)
+
+    exp_body =
+      <<@experimenter::32, @nxast::16, 0::size(2)-unit(8), flags_int::16, range_flags_int::16,
+        ranges_bin::bytes>>
+
+    exp_body_size = byte_size(exp_body)
     padding_length = Openflow.Utils.padding(4 + exp_body_size, 8)
     length = 4 + exp_body_size + padding_length
-    <<0xffff::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
+    <<0xFFFF::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
   end
 
   def read(<<@experimenter::32, @nxast::16, body::bytes>>) do
@@ -59,33 +67,43 @@ defmodule Openflow.Action.NxNat do
 
   defp get_ranges(nat) do
     nat
-    |> Map.from_struct
+    |> Map.from_struct()
     |> Map.delete(:flags)
-    |> Enum.map(fn({k, v}) -> if(not is_nil(v), do: k, else: nil) end)
-    |> Enum.filter(fn(v) -> not is_nil(v) end)
+    |> Enum.map(fn {k, v} -> if(not is_nil(v), do: k, else: nil) end)
+    |> Enum.filter(fn v -> not is_nil(v) end)
   end
 
   defp encode_ranges(acc, [], _nat), do: acc
-  defp encode_ranges(acc, [range|rest], nat) do
+
+  defp encode_ranges(acc, [range | rest], nat) do
     cond do
       range == :ipv4_min or range == :ipv4_max ->
         case Map.get(nat, range) do
-          {a1, a2, a3, a4}  ->
+          {a1, a2, a3, a4} ->
             encode_ranges(<<acc::bytes, a1, a2, a3, a4>>, rest, nat)
+
           "" ->
             encode_ranges(<<acc::bytes>>, rest, nat)
         end
+
       range == :ipv6_min or range == :ipv6_max ->
         case Map.get(nat, range) do
           {a1, a2, a3, a4, a5, a6, a7, a8} ->
-            encode_ranges(<<acc::bytes, a1::16, a2::16, a3::16, a4::16, a5::16, a6::16, a7::16, a8::16>>, rest, nat)
+            encode_ranges(
+              <<acc::bytes, a1::16, a2::16, a3::16, a4::16, a5::16, a6::16, a7::16, a8::16>>,
+              rest,
+              nat
+            )
+
           "" ->
             encode_ranges(<<acc::bytes>>, rest, nat)
         end
+
       range == :proto_min or range == :proto_max ->
         case Map.get(nat, range) do
-          proto when is_integer(proto) and proto in (1..0xffff) ->
+          proto when is_integer(proto) and proto in 1..0xFFFF ->
             encode_ranges(<<acc::bytes, proto::16>>, rest, nat)
+
           _ ->
             encode_ranges(<<acc::bytes>>, rest, nat)
         end
@@ -93,26 +111,32 @@ defmodule Openflow.Action.NxNat do
   end
 
   defp decode_ranges(nat, [], _), do: nat
-  defp decode_ranges(nat, [range|ranges], bin) do
+
+  defp decode_ranges(nat, [range | ranges], bin) do
     cond do
       range == :ipv4_min or range == :ipv4_max ->
         case bin do
           <<a1, a2, a3, a4, rest::bytes>> ->
             decode_ranges(struct(nat, %{range => {a1, a2, a3, a4}}), ranges, rest)
+
           rest ->
             decode_ranges(struct(nat, %{range => ""}), ranges, rest)
         end
+
       range == :ipv6_min or range == :ipv6_max ->
         case bin do
           <<a1::16, a2::16, a3::16, a4::16, a5::16, a6::16, a7::16, a8::16, rest::bytes>> ->
             decode_ranges(struct(nat, %{range => {a1, a2, a3, a4, a5, a6, a7, a8}}), ranges, rest)
+
           rest ->
             decode_ranges(struct(nat, %{range => ""}), ranges, rest)
         end
+
       range == :proto_min or range == :proto_max ->
         case bin do
-          <<proto::16, rest::bytes>> when proto in (1..0xffff) ->
+          <<proto::16, rest::bytes>> when proto in 1..0xFFFF ->
             decode_ranges(struct(nat, %{range => proto}), ranges, rest)
+
           rest ->
             decode_ranges(struct(nat, %{range => ""}), ranges, rest)
         end

lib/openflow/actions/nx_note.ex

@@ -13,10 +13,10 @@ defmodule Openflow.Action.NxNote do
   def to_binary(%NxNote{note: note}) do
     padding = Openflow.Utils.padding(byte_size(note) + 2, 8)
     exp_body = <<@experimenter::32, @nxast::16, note::bytes, 0::size(padding)-unit(8)>>
-    exp_body_size =  byte_size(exp_body)
+    exp_body_size = byte_size(exp_body)
     padding_length = Openflow.Utils.padding(4 + exp_body_size, 8)
     length = 4 + exp_body_size + padding_length
-    <<0xffff::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
+    <<0xFFFF::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
   end
 
   def read(<<@experimenter::32, @nxast::16, note_bin::bytes>>) do

lib/openflow/actions/nx_output_reg.ex

@@ -2,10 +2,10 @@ defmodule Openflow.Action.NxOutputReg do
   import Bitwise
 
   defstruct(
-    n_bits:     0,
-    offset:     0,
-    src_field:  nil,
-    max_len:    :no_buffer
+    n_bits: 0,
+    offset: 0,
+    src_field: nil,
+    max_len: :no_buffer
   )
 
   @experimenter 0x00002320
@@ -19,34 +19,25 @@ defmodule Openflow.Action.NxOutputReg do
     n_bits = Keyword.get(options, :n_bits, default_n_bits)
     ofs = Keyword.get(options, :offset, 0)
     max_len = Keyword.get(options, :max_len, :no_buffer)
-    %NxOutputReg{n_bits: n_bits,
-                 offset: ofs,
-                 src_field: src_field,
-                 max_len: max_len}
+    %NxOutputReg{n_bits: n_bits, offset: ofs, src_field: src_field, max_len: max_len}
   end
 
-  def to_binary(%NxOutputReg{n_bits: n_bits,
-                             offset: ofs,
-                             src_field: src_field,
-                             max_len: max_len}) do
+  def to_binary(%NxOutputReg{n_bits: n_bits, offset: ofs, src_field: src_field, max_len: max_len}) do
     src_field_bin = Openflow.Match.codec_header(src_field)
-    ofs_nbits = (ofs <<< 6) ||| (n_bits - 1)
+    ofs_nbits = ofs <<< 6 ||| n_bits - 1
     max_len = Openflow.Utils.get_enum(max_len, :controller_max_len)
     body = <<ofs_nbits::16, src_field_bin::4-bytes, max_len::16, 0::size(6)-unit(8)>>
     exp_body = <<@experimenter::32, @nxast::16, body::bytes>>
-    exp_body_size =  byte_size(exp_body)
+    exp_body_size = byte_size(exp_body)
     padding_length = Openflow.Utils.padding(4 + exp_body_size, 8)
     length = 4 + exp_body_size + padding_length
-    <<0xffff::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
+    <<0xFFFF::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
   end
 
   def read(<<@experimenter::32, @nxast::16, body::bytes>>) do
     <<ofs::10, n_bits::6, src_field_bin::4-bytes, max_len::16, _::size(6)-unit(8)>> = body
     src_field = Openflow.Match.codec_header(src_field_bin)
     max_len = Openflow.Utils.get_enum(max_len, :controller_max_len)
-    %NxOutputReg{n_bits: n_bits + 1,
-                 offset: ofs,
-                 src_field: src_field,
-                 max_len: max_len}
+    %NxOutputReg{n_bits: n_bits + 1, offset: ofs, src_field: src_field, max_len: max_len}
   end
 end

lib/openflow/actions/nx_output_reg2.ex

@@ -2,10 +2,10 @@ defmodule Openflow.Action.NxOutputReg2 do
   import Bitwise
 
   defstruct(
-    n_bits:     0,
-    offset:     0,
-    src_field:  nil,
-    max_len:    :no_buffer
+    n_bits: 0,
+    offset: 0,
+    src_field: nil,
+    max_len: :no_buffer
   )
 
   @experimenter 0x00002320
@@ -24,28 +24,31 @@ defmodule Openflow.Action.NxOutputReg2 do
 
   def to_binary(%NxOutputReg2{n_bits: n_bits, offset: ofs, src_field: src_field, max_len: max_len}) do
     src_field_bin = Openflow.Match.codec_header(src_field)
-    ofs_nbits = (ofs <<< 6) ||| (n_bits - 1)
+    ofs_nbits = ofs <<< 6 ||| n_bits - 1
     max_len = Openflow.Utils.get_enum(max_len, :controller_max_len)
     padding = Openflow.Utils.padding(byte_size(src_field_bin), 10)
     body = <<ofs_nbits::16, max_len::16, src_field_bin::bytes, 0::size(padding)-unit(8)>>
     exp_body = <<@experimenter::32, @nxast::16, body::bytes>>
-    exp_body_size =  byte_size(exp_body)
+    exp_body_size = byte_size(exp_body)
     padding_length = Openflow.Utils.padding(4 + exp_body_size, 8)
     length = 4 + exp_body_size + padding_length
-    <<0xffff::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
+    <<0xFFFF::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
   end
 
   def read(<<@experimenter::32, @nxast::16, body::bytes>>) do
     <<ofs::10, n_bits::6, max_len::16, oxm_header::4-bytes, rest::bitstring>> = body
     exp_size = match_header_size(oxm_header) - 4
     <<experimenter_int::size(exp_size)-unit(8), _padding::bytes>> = rest
-    src_field = Openflow.Match.codec_header(<<oxm_header::bytes, experimenter_int::size(exp_size)-unit(8)>>)
+
+    src_field =
+      Openflow.Match.codec_header(<<oxm_header::bytes, experimenter_int::size(exp_size)-unit(8)>>)
+
     max_len = Openflow.Utils.get_enum(max_len, :controller_max_len)
     %NxOutputReg2{n_bits: n_bits + 1, offset: ofs, src_field: src_field, max_len: max_len}
   end
 
   # private functions
 
-  defp match_header_size(<<0xffff::16, _::bytes>>), do: 8
-  defp match_header_size(<<_::16, _::bytes>>),      do: 4
+  defp match_header_size(<<0xFFFF::16, _::bytes>>), do: 8
+  defp match_header_size(<<_::16, _::bytes>>), do: 4
 end

lib/openflow/actions/nx_output_trunc.ex

@@ -18,10 +18,10 @@ defmodule Openflow.Action.NxOutputTrunc do
   def to_binary(%NxOutputTrunc{port_number: port_no, max_len: max_len}) do
     port_no_int = Openflow.Utils.get_enum(port_no, :openflow10_port_no)
     exp_body = <<@experimenter::32, @nxast::16, port_no_int::16, max_len::32>>
-    exp_body_size =  byte_size(exp_body)
+    exp_body_size = byte_size(exp_body)
     padding_length = Openflow.Utils.padding(4 + exp_body_size, 8)
     length = 4 + exp_body_size + padding_length
-    <<0xffff::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
+    <<0xFFFF::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
   end
 
   def read(<<@experimenter::32, @nxast::16, port_no_int::16, max_len::32>>) do

lib/openflow/actions/nx_pop_mpls.ex

@@ -12,10 +12,10 @@ defmodule Openflow.Action.NxPopMpls do
 
   def to_binary(%NxPopMpls{ethertype: ethertype}) do
     exp_body = <<@experimenter::32, @nxast::16, ethertype::16, 0::size(4)-unit(8)>>
-    exp_body_size =  byte_size(exp_body)
+    exp_body_size = byte_size(exp_body)
     padding_length = Openflow.Utils.padding(4 + exp_body_size, 8)
     length = 4 + exp_body_size + padding_length
-    <<0xffff::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
+    <<0xFFFF::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
   end
 
   def read(<<@experimenter::32, @nxast::16, ethertype::16, _::size(4)-unit(8)>>) do

lib/openflow/actions/nx_pop_queue.ex

@@ -3,7 +3,7 @@ defmodule Openflow.Action.NxPopQueue do
 
   @experimenter 0x00002320
   @nxast 5
- 
+
   alias __MODULE__
 
   def new do
@@ -12,10 +12,10 @@ defmodule Openflow.Action.NxPopQueue do
 
   def to_binary(%NxPopQueue{}) do
     exp_body = <<@experimenter::32, @nxast::16, 0::48>>
-    exp_body_size =  byte_size(exp_body)
+    exp_body_size = byte_size(exp_body)
     padding_length = Openflow.Utils.padding(4 + exp_body_size, 8)
     length = 4 + exp_body_size + padding_length
-    <<0xffff::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
+    <<0xFFFF::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
   end
 
   def read(<<@experimenter::32, @nxast::16, 0::size(6)-unit(8)>>) do

lib/openflow/actions/nx_push_mpls.ex

@@ -12,10 +12,10 @@ defmodule Openflow.Action.NxPushMpls do
 
   def to_binary(%NxPushMpls{ethertype: ethertype}) do
     exp_body = <<@experimenter::32, @nxast::16, ethertype::16, 0::size(4)-unit(8)>>
-    exp_body_size =  byte_size(exp_body)
+    exp_body_size = byte_size(exp_body)
     padding_length = Openflow.Utils.padding(4 + exp_body_size, 8)
     length = 4 + exp_body_size + padding_length
-    <<0xffff::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
+    <<0xFFFF::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
   end
 
   def read(<<@experimenter::32, @nxast::16, ethertype::16, _::size(4)-unit(8)>>) do

lib/openflow/actions/nx_reg_load.ex

@@ -2,10 +2,10 @@ defmodule Openflow.Action.NxRegLoad do
   import Bitwise
 
   defstruct(
-    n_bits:     0,
-    offset:     0,
-    dst_field:  nil,
-    value:      nil
+    n_bits: 0,
+    offset: 0,
+    dst_field: nil,
+    value: nil
   )
 
   @experimenter 0x00002320
@@ -19,36 +19,27 @@ defmodule Openflow.Action.NxRegLoad do
     n_bits = Keyword.get(options, :n_bits, default_n_bits)
     ofs = Keyword.get(options, :offset, 0)
     value = Keyword.get(options, :value)
-    %NxRegLoad{n_bits: n_bits,
-               offset: ofs,
-               dst_field: dst_field,
-               value: value}
+    %NxRegLoad{n_bits: n_bits, offset: ofs, dst_field: dst_field, value: value}
   end
 
-  def to_binary(%NxRegLoad{n_bits: n_bits,
-                           offset: ofs,
-                           dst_field: dst_field,
-                           value: value}) do
+  def to_binary(%NxRegLoad{n_bits: n_bits, offset: ofs, dst_field: dst_field, value: value}) do
     dst_field_bin = Openflow.Match.codec_header(dst_field)
     value_bin0 = Openflow.Match.Field.codec(value, dst_field)
     tmp_value = :binary.decode_unsigned(value_bin0, :big)
     value_bin = <<tmp_value::64>>
-    ofs_nbits = (ofs <<< 6) ||| (n_bits - 1)
+    ofs_nbits = ofs <<< 6 ||| n_bits - 1
     body = <<ofs_nbits::16, dst_field_bin::4-bytes, value_bin::bytes>>
     exp_body = <<@experimenter::32, @nxast::16, body::bytes>>
-    exp_body_size =  byte_size(exp_body)
+    exp_body_size = byte_size(exp_body)
     padding_length = Openflow.Utils.padding(4 + exp_body_size, 8)
     length = 4 + exp_body_size + padding_length
-    <<0xffff::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
+    <<0xFFFF::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
   end
 
   def read(<<@experimenter::32, @nxast::16, body::bytes>>) do
     <<ofs::10, n_bits::6, dst_field_bin::4-bytes, value_bin::bytes>> = body
     dst_field = Openflow.Match.codec_header(dst_field_bin)
     value = Openflow.Match.Field.codec(value_bin, dst_field)
-    %NxRegLoad{n_bits: n_bits + 1,
-               offset: ofs,
-               dst_field: dst_field,
-               value: value}
+    %NxRegLoad{n_bits: n_bits + 1, offset: ofs, dst_field: dst_field, value: value}
   end
 end

lib/openflow/actions/nx_reg_load2.ex

@@ -1,7 +1,7 @@
 defmodule Openflow.Action.NxRegLoad2 do
   defstruct(
-    dst_field:  nil,
-    value:      nil
+    dst_field: nil,
+    value: nil
   )
 
   @experimenter 0x00002320
@@ -18,23 +18,27 @@ defmodule Openflow.Action.NxRegLoad2 do
   def to_binary(%NxRegLoad2{dst_field: dst_field, value: value}) do
     match_bin =
       [{dst_field, value}]
-      |> Openflow.Match.new
-      |> Openflow.Match.to_binary
+      |> Openflow.Match.new()
+      |> Openflow.Match.to_binary()
+
     <<1::16, _length::16, padded_field::bytes>> = match_bin
     patial_len = 4 + 4 + 2 + 6 + byte_size(padded_field)
     padding = Openflow.Utils.padding(patial_len, 8)
-    exp_body = <<@experimenter::32, @nxast::16, 0::48, padded_field::bytes, 0::size(padding)-unit(8)>>
-    exp_body_size =  byte_size(exp_body)
+
+    exp_body =
+      <<@experimenter::32, @nxast::16, 0::48, padded_field::bytes, 0::size(padding)-unit(8)>>
+
+    exp_body_size = byte_size(exp_body)
     padding_length = Openflow.Utils.padding(4 + exp_body_size, 8)
     length = 4 + exp_body_size + padding_length
-    <<0xffff::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
+    <<0xFFFF::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
   end
 
   def read(<<@experimenter::32, @nxast::16, _::48, match_field_bin::bytes>>) do
     <<_class::16, _field::7, _hm::1, flen::8, _rest::bytes>> = match_field_bin
     match_len = 4 + 4 + flen
     match_bin = <<1::16, match_len::16, match_field_bin::bytes, 0::size(4)-unit(8)>>
-    {[{dst_field, value}|_], _rest} = Openflow.Match.read(match_bin)
+    {[{dst_field, value} | _], _rest} = Openflow.Match.read(match_bin)
     %NxRegLoad2{dst_field: dst_field, value: value}
   end
 end

lib/openflow/actions/nx_reg_move.ex

@@ -1,10 +1,10 @@
 defmodule Openflow.Action.NxRegMove do
   defstruct(
-    n_bits:     0,
+    n_bits: 0,
     src_offset: 0,
     dst_offset: 0,
-    src_field:  nil,
-    dst_field:  nil
+    src_field: nil,
+    dst_field: nil
   )
 
   @experimenter 0x00002320
@@ -19,38 +19,49 @@ defmodule Openflow.Action.NxRegMove do
     n_bits = Keyword.get(options, :n_bits, default_n_bits)
     src_ofs = Keyword.get(options, :src_offset, 0)
     dst_ofs = Keyword.get(options, :dst_offset, 0)
-    %NxRegMove{n_bits: n_bits,
-               src_offset: src_ofs,
-               dst_offset: dst_ofs,
-               src_field: src_field,
-               dst_field: dst_field}
+
+    %NxRegMove{
+      n_bits: n_bits,
+      src_offset: src_ofs,
+      dst_offset: dst_ofs,
+      src_field: src_field,
+      dst_field: dst_field
+    }
   end
 
-  def to_binary(%NxRegMove{n_bits: n_bits,
-                           src_offset: src_ofs,
-                           dst_offset: dst_ofs,
-                           src_field: src_field,
-                           dst_field: dst_field}) do
+  def to_binary(%NxRegMove{
+        n_bits: n_bits,
+        src_offset: src_ofs,
+        dst_offset: dst_ofs,
+        src_field: src_field,
+        dst_field: dst_field
+      }) do
     src_field_bin = Openflow.Match.codec_header(src_field)
     dst_field_bin = Openflow.Match.codec_header(dst_field)
-    body = <<n_bits::16, src_ofs::16, dst_ofs::16,
-             src_field_bin::4-bytes, dst_field_bin::4-bytes>>
+
+    body =
+      <<n_bits::16, src_ofs::16, dst_ofs::16, src_field_bin::4-bytes, dst_field_bin::4-bytes>>
+
     exp_body = <<@experimenter::32, @nxast::16, body::bytes>>
-    exp_body_size =  byte_size(exp_body)
+    exp_body_size = byte_size(exp_body)
     padding_length = Openflow.Utils.padding(4 + exp_body_size, 8)
     length = 4 + exp_body_size + padding_length
-    <<0xffff::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
+    <<0xFFFF::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
   end
 
   def read(<<@experimenter::32, @nxast::16, body::bytes>>) do
-    <<n_bits::16, src_ofs::16, dst_ofs::16,
-      src_field_bin::4-bytes, dst_field_bin::4-bytes>> = body
+    <<n_bits::16, src_ofs::16, dst_ofs::16, src_field_bin::4-bytes, dst_field_bin::4-bytes>> =
+      body
+
     src_field = Openflow.Match.codec_header(src_field_bin)
     dst_field = Openflow.Match.codec_header(dst_field_bin)
-    %NxRegMove{n_bits: n_bits,
-               src_offset: src_ofs,
-               dst_offset: dst_ofs,
-               src_field: src_field,
-               dst_field: dst_field}
+
+    %NxRegMove{
+      n_bits: n_bits,
+      src_offset: src_ofs,
+      dst_offset: dst_ofs,
+      src_field: src_field,
+      dst_field: dst_field
+    }
   end
 end

lib/openflow/actions/nx_resubmit.ex

@@ -1,5 +1,5 @@
 defmodule Openflow.Action.NxResubmit do
-  defstruct([in_port: :in_port])
+  defstruct(in_port: :in_port)
 
   @experimenter 0x00002320
   @nxast 1
@@ -13,10 +13,10 @@ defmodule Openflow.Action.NxResubmit do
   def to_binary(%NxResubmit{in_port: in_port}) do
     in_port_int = Openflow.Utils.get_enum(in_port, :openflow10_port_no)
     exp_body = <<@experimenter::32, @nxast::16, in_port_int::16, 0::size(4)-unit(8)>>
-    exp_body_size =  byte_size(exp_body)
+    exp_body_size = byte_size(exp_body)
     padding_length = Openflow.Utils.padding(4 + exp_body_size, 8)
     length = 4 + exp_body_size + padding_length
-    <<0xffff::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
+    <<0xFFFF::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
   end
 
   def read(<<@experimenter::32, @nxast::16, in_port_int::16, _::size(4)-unit(8)>>) do

lib/openflow/actions/nx_resubmit_table.ex

@@ -1,5 +1,5 @@
 defmodule Openflow.Action.NxResubmitTable do
-  defstruct([in_port: :in_port, table_id: :all])
+  defstruct(in_port: :in_port, table_id: :all)
 
   @experimenter 0x00002320
   @nxast 14
@@ -9,6 +9,7 @@ defmodule Openflow.Action.NxResubmitTable do
   def new(table_id) when is_atom(table_id) or is_integer(table_id) do
     new(table_id: table_id)
   end
+
   def new(options) do
     in_port = Keyword.get(options, :in_port, :in_port)
     table_id = Keyword.get(options, :table_id, :all)
@@ -19,13 +20,15 @@ defmodule Openflow.Action.NxResubmitTable do
     in_port_int = Openflow.Utils.get_enum(in_port, :openflow10_port_no)
     table_id_int = Openflow.Utils.get_enum(table_id, :table_id)
     exp_body = <<@experimenter::32, @nxast::16, in_port_int::16, table_id_int::8, 0::24>>
-    exp_body_size =  byte_size(exp_body)
+    exp_body_size = byte_size(exp_body)
     padding_length = Openflow.Utils.padding(4 + exp_body_size, 8)
     length = 4 + exp_body_size + padding_length
-    <<0xffff::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
+    <<0xFFFF::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
   end
 
-  def read(<<@experimenter::32, @nxast::16, in_port_int::16, table_id_int::8, 0::size(3)-unit(8)>>) do
+  def read(
+        <<@experimenter::32, @nxast::16, in_port_int::16, table_id_int::8, 0::size(3)-unit(8)>>
+      ) do
     in_port = Openflow.Utils.get_enum(in_port_int, :openflow10_port_no)
     table_id = Openflow.Utils.get_enum(table_id_int, :table_id)
     %NxResubmitTable{in_port: in_port, table_id: table_id}

lib/openflow/actions/nx_resubmit_table_ct.ex

@@ -16,13 +16,15 @@ defmodule Openflow.Action.NxResubmitTableCt do
     in_port_int = Openflow.Utils.get_enum(in_port, :openflow10_port_no)
     table_id_int = Openflow.Utils.get_enum(table_id, :table_id)
     exp_body = <<@experimenter::32, @nxast::16, in_port_int::16, table_id_int::8, 0::24>>
-    exp_body_size =  byte_size(exp_body)
+    exp_body_size = byte_size(exp_body)
     padding_length = Openflow.Utils.padding(4 + exp_body_size, 8)
     length = 4 + exp_body_size + padding_length
-    <<0xffff::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
-end
+    <<0xFFFF::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
+  end
 
-  def read(<<@experimenter::32, @nxast::16, in_port_int::16, table_id_int::8, 0::size(3)-unit(8)>>) do
+  def read(
+        <<@experimenter::32, @nxast::16, in_port_int::16, table_id_int::8, 0::size(3)-unit(8)>>
+      ) do
     in_port = Openflow.Utils.get_enum(in_port_int, :openflow10_port_no)
     table_id = Openflow.Utils.get_enum(table_id_int, :table_id)
     %NxResubmitTableCt{in_port: in_port, table_id: table_id}

lib/openflow/actions/nx_sample.ex

@@ -1,9 +1,9 @@
 defmodule Openflow.Action.NxSample do
   defstruct(
-    probability:      0,
+    probability: 0,
     collector_set_id: 0,
-    obs_domain_id:    0,
-    obs_point_id:     0
+    obs_domain_id: 0,
+    obs_point_id: 0
   )
 
   @experimenter 0x00002320
@@ -16,29 +16,40 @@ defmodule Openflow.Action.NxSample do
     collector_set_id = Keyword.get(options, :collector_set_id, 0)
     obs_domain_id = Keyword.get(options, :obs_domain_id, 0)
     obs_point_id = Keyword.get(options, :obs_point_id, 0)
-    %NxSample{probability:      probability,
-              collector_set_id: collector_set_id,
-              obs_domain_id:    obs_domain_id,
-              obs_point_id:     obs_point_id}
+
+    %NxSample{
+      probability: probability,
+      collector_set_id: collector_set_id,
+      obs_domain_id: obs_domain_id,
+      obs_point_id: obs_point_id
+    }
   end
 
-  def to_binary(%NxSample{probability:      probability,
-                          collector_set_id: collector_set_id,
-                          obs_domain_id:    obs_domain_id,
-                          obs_point_id:     obs_point_id}) do
-    exp_body = <<@experimenter::32, @nxast::16, probability::16,
-      collector_set_id::32, obs_domain_id::32, obs_point_id::32>>
-    exp_body_size =  byte_size(exp_body)
+  def to_binary(%NxSample{
+        probability: probability,
+        collector_set_id: collector_set_id,
+        obs_domain_id: obs_domain_id,
+        obs_point_id: obs_point_id
+      }) do
+    exp_body =
+      <<@experimenter::32, @nxast::16, probability::16, collector_set_id::32, obs_domain_id::32,
+        obs_point_id::32>>
+
+    exp_body_size = byte_size(exp_body)
     padding_length = Openflow.Utils.padding(4 + exp_body_size, 8)
     length = 4 + exp_body_size + padding_length
-    <<0xffff::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
+    <<0xFFFF::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
   end
 
-  def read(<<@experimenter::32, @nxast::16, probability::16,
-             collector_set_id::32, obs_domain_id::32, obs_point_id::32>>) do
-    %NxSample{probability:      probability,
-              collector_set_id: collector_set_id,
-              obs_domain_id:    obs_domain_id,
-              obs_point_id:     obs_point_id}
+  def read(
+        <<@experimenter::32, @nxast::16, probability::16, collector_set_id::32, obs_domain_id::32,
+          obs_point_id::32>>
+      ) do
+    %NxSample{
+      probability: probability,
+      collector_set_id: collector_set_id,
+      obs_domain_id: obs_domain_id,
+      obs_point_id: obs_point_id
+    }
   end
 end

lib/openflow/actions/nx_sample2.ex

@@ -1,10 +1,10 @@
 defmodule Openflow.Action.NxSample2 do
   defstruct(
-    probability:      0,
+    probability: 0,
     collector_set_id: 0,
-    obs_domain_id:    0,
-    obs_point_id:     0,
-    sampling_port:    0
+    obs_domain_id: 0,
+    obs_point_id: 0,
+    sampling_port: 0
   )
 
   @experimenter 0x00002320
@@ -18,32 +18,43 @@ defmodule Openflow.Action.NxSample2 do
     obs_domain_id = Keyword.get(options, :obs_domain_id, 0)
     obs_point_id = Keyword.get(options, :obs_point_id, 0)
     sampling_port = Keyword.get(options, :sampling_port, 0)
-    %NxSample2{probability:      probability,
-               collector_set_id: collector_set_id,
-               obs_domain_id:    obs_domain_id,
-               obs_point_id:     obs_point_id,
-               sampling_port:    sampling_port}
+
+    %NxSample2{
+      probability: probability,
+      collector_set_id: collector_set_id,
+      obs_domain_id: obs_domain_id,
+      obs_point_id: obs_point_id,
+      sampling_port: sampling_port
+    }
   end
 
-  def to_binary(%NxSample2{probability:      probability,
-                           collector_set_id: collector_set_id,
-                           obs_domain_id:    obs_domain_id,
-                           obs_point_id:     obs_point_id,
-                           sampling_port:    sampling_port}) do
-    exp_body = <<@experimenter::32, @nxast::16, probability::16,
-      collector_set_id::32, obs_domain_id::32, obs_point_id::32, sampling_port::16, 0::size(6)-unit(8)>>
-    exp_body_size =  byte_size(exp_body)
+  def to_binary(%NxSample2{
+        probability: probability,
+        collector_set_id: collector_set_id,
+        obs_domain_id: obs_domain_id,
+        obs_point_id: obs_point_id,
+        sampling_port: sampling_port
+      }) do
+    exp_body =
+      <<@experimenter::32, @nxast::16, probability::16, collector_set_id::32, obs_domain_id::32,
+        obs_point_id::32, sampling_port::16, 0::size(6)-unit(8)>>
+
+    exp_body_size = byte_size(exp_body)
     padding_length = Openflow.Utils.padding(4 + exp_body_size, 8)
     length = 4 + exp_body_size + padding_length
-    <<0xffff::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
+    <<0xFFFF::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
   end
 
-  def read(<<@experimenter::32, @nxast::16, probability::16, collector_set_id::32,
-             obs_domain_id::32, obs_point_id::32, sampling_port::16, 0::size(6)-unit(8)>>) do
-    %NxSample2{probability:      probability,
-               collector_set_id: collector_set_id,
-               obs_domain_id:    obs_domain_id,
-               obs_point_id:     obs_point_id,
-               sampling_port:    sampling_port}
+  def read(
+        <<@experimenter::32, @nxast::16, probability::16, collector_set_id::32, obs_domain_id::32,
+          obs_point_id::32, sampling_port::16, 0::size(6)-unit(8)>>
+      ) do
+    %NxSample2{
+      probability: probability,
+      collector_set_id: collector_set_id,
+      obs_domain_id: obs_domain_id,
+      obs_point_id: obs_point_id,
+      sampling_port: sampling_port
+    }
   end
 end

lib/openflow/actions/nx_sample3.ex

@@ -1,11 +1,11 @@
 defmodule Openflow.Action.NxSample3 do
   defstruct(
-    probability:      0,
+    probability: 0,
     collector_set_id: 0,
-    obs_domain_id:    0,
-    obs_point_id:     0,
-    sampling_port:    0,
-    direction:  :default
+    obs_domain_id: 0,
+    obs_point_id: 0,
+    sampling_port: 0,
+    direction: :default
   )
 
   @experimenter 0x00002320
@@ -20,37 +20,50 @@ defmodule Openflow.Action.NxSample3 do
     obs_point_id = Keyword.get(options, :obs_point_id, 0)
     sampling_port = Keyword.get(options, :sampling_port, 0)
     direction = Keyword.get(options, :direction, :default)
-    %NxSample3{probability:      probability,
-               collector_set_id: collector_set_id,
-               obs_domain_id:    obs_domain_id,
-               obs_point_id:     obs_point_id,
-               sampling_port:    sampling_port,
-               direction:        direction}
+
+    %NxSample3{
+      probability: probability,
+      collector_set_id: collector_set_id,
+      obs_domain_id: obs_domain_id,
+      obs_point_id: obs_point_id,
+      sampling_port: sampling_port,
+      direction: direction
+    }
   end
 
-  def to_binary(%NxSample3{probability:      probability,
-                           collector_set_id: collector_set_id,
-                           obs_domain_id:    obs_domain_id,
-                           obs_point_id:     obs_point_id,
-                           sampling_port:    sampling_port,
-                           direction:        direction}) do
+  def to_binary(%NxSample3{
+        probability: probability,
+        collector_set_id: collector_set_id,
+        obs_domain_id: obs_domain_id,
+        obs_point_id: obs_point_id,
+        sampling_port: sampling_port,
+        direction: direction
+      }) do
     direction_int = Openflow.Enums.to_int(direction, :nx_action_sample_direction)
-    exp_body = <<@experimenter::32, @nxast::16, probability::16, collector_set_id::32,
-      obs_domain_id::32, obs_point_id::32, sampling_port::16, direction_int::8, 0::size(5)-unit(8)>>
-    exp_body_size =  byte_size(exp_body)
+
+    exp_body =
+      <<@experimenter::32, @nxast::16, probability::16, collector_set_id::32, obs_domain_id::32,
+        obs_point_id::32, sampling_port::16, direction_int::8, 0::size(5)-unit(8)>>
+
+    exp_body_size = byte_size(exp_body)
     padding_length = Openflow.Utils.padding(4 + exp_body_size, 8)
     length = 4 + exp_body_size + padding_length
-    <<0xffff::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
+    <<0xFFFF::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
   end
 
-  def read(<<@experimenter::32, @nxast::16, probability::16, collector_set_id::32,
-             obs_domain_id::32, obs_point_id::32, sampling_port::16, direction_int::8, 0::size(5)-unit(8)>>) do
+  def read(
+        <<@experimenter::32, @nxast::16, probability::16, collector_set_id::32, obs_domain_id::32,
+          obs_point_id::32, sampling_port::16, direction_int::8, 0::size(5)-unit(8)>>
+      ) do
     direction = Openflow.Enums.to_atom(direction_int, :nx_action_sample_direction)
-    %NxSample3{probability:      probability,
-               collector_set_id: collector_set_id,
-               obs_domain_id:    obs_domain_id,
-               obs_point_id:     obs_point_id,
-               sampling_port:    sampling_port,
-               direction:        direction}
+
+    %NxSample3{
+      probability: probability,
+      collector_set_id: collector_set_id,
+      obs_domain_id: obs_domain_id,
+      obs_point_id: obs_point_id,
+      sampling_port: sampling_port,
+      direction: direction
+    }
   end
 end

lib/openflow/actions/nx_set_mpls_label.ex

@@ -12,10 +12,10 @@ defmodule Openflow.Action.NxSetMplsLabel do
 
   def to_binary(%NxSetMplsLabel{label: label}) do
     exp_body = <<@experimenter::32, @nxast::16, 0::16, label::32>>
-    exp_body_size =  byte_size(exp_body)
+    exp_body_size = byte_size(exp_body)
     padding_length = Openflow.Utils.padding(4 + exp_body_size, 8)
     length = 4 + exp_body_size + padding_length
-    <<0xffff::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
+    <<0xFFFF::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
   end
 
   def read(<<@experimenter::32, @nxast::16, _::16, label::32>>) do

lib/openflow/actions/nx_set_mpls_tc.ex

@@ -12,10 +12,10 @@ defmodule Openflow.Action.NxSetMplsTc do
 
   def to_binary(%NxSetMplsTc{tc: tc}) do
     exp_body = <<@experimenter::32, @nxast::16, tc::8, 0::size(5)-unit(8)>>
-    exp_body_size =  byte_size(exp_body)
+    exp_body_size = byte_size(exp_body)
     padding_length = Openflow.Utils.padding(4 + exp_body_size, 8)
     length = 4 + exp_body_size + padding_length
-    <<0xffff::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
+    <<0xFFFF::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
   end
 
   def read(<<@experimenter::32, @nxast::16, tc::8, _::size(5)-unit(8)>>) do

lib/openflow/actions/nx_set_mpls_ttl.ex

@@ -12,10 +12,10 @@ defmodule Openflow.Action.NxSetMplsTtl do
 
   def to_binary(%NxSetMplsTtl{ttl: ttl}) do
     exp_body = <<@experimenter::32, @nxast::16, ttl::8, 0::size(5)-unit(8)>>
-    exp_body_size =  byte_size(exp_body)
+    exp_body_size = byte_size(exp_body)
     padding_length = Openflow.Utils.padding(4 + exp_body_size, 8)
     length = 4 + exp_body_size + padding_length
-    <<0xffff::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
+    <<0xFFFF::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
   end
 
   def read(<<@experimenter::32, @nxast::16, ttl::8, _::size(5)-unit(8)>>) do

lib/openflow/actions/nx_set_queue.ex

@@ -1,5 +1,5 @@
 defmodule Openflow.Action.NxSetQueue do
-  defstruct([queue_id: 0])
+  defstruct(queue_id: 0)
 
   @experimenter 0x00002320
   @nxast 4
@@ -12,10 +12,10 @@ defmodule Openflow.Action.NxSetQueue do
 
   def to_binary(%NxSetQueue{queue_id: queue_id}) do
     exp_body = <<@experimenter::32, @nxast::16, 0::16, queue_id::32>>
-    exp_body_size =  byte_size(exp_body)
+    exp_body_size = byte_size(exp_body)
     padding_length = Openflow.Utils.padding(4 + exp_body_size, 8)
     length = 4 + exp_body_size + padding_length
-    <<0xffff::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
+    <<0xFFFF::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
   end
 
   def read(<<@experimenter::32, @nxast::16, 0::size(2)-unit(8), queue_id::32>>) do

lib/openflow/actions/nx_set_tunnel.ex

@@ -12,10 +12,10 @@ defmodule Openflow.Action.NxSetTunnel do
 
   def to_binary(%NxSetTunnel{tunnel_id: tunnel_id}) do
     exp_body = <<@experimenter::32, @nxast::16, 0::16, tunnel_id::32>>
-    exp_body_size =  byte_size(exp_body)
+    exp_body_size = byte_size(exp_body)
     padding_length = Openflow.Utils.padding(4 + exp_body_size, 8)
     length = 4 + exp_body_size + padding_length
-    <<0xffff::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
+    <<0xFFFF::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
   end
 
   def read(<<@experimenter::32, @nxast::16, _::16, tunnel_id::32>>) do

lib/openflow/actions/nx_set_tunnel64.ex

@@ -1,5 +1,5 @@
 defmodule Openflow.Action.NxSetTunnel64 do
-  defstruct([tunnel_id: 0])
+  defstruct(tunnel_id: 0)
 
   @experimenter 0x00002320
   @nxast 9
@@ -12,10 +12,10 @@ defmodule Openflow.Action.NxSetTunnel64 do
 
   def to_binary(%NxSetTunnel64{tunnel_id: tunnel_id}) do
     exp_body = <<@experimenter::32, @nxast::16, 0::size(6)-unit(8), tunnel_id::64>>
-    exp_body_size =  byte_size(exp_body)
+    exp_body_size = byte_size(exp_body)
     padding_length = Openflow.Utils.padding(4 + exp_body_size, 8)
     length = 4 + exp_body_size + padding_length
-    <<0xffff::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
+    <<0xFFFF::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
   end
 
   def read(<<@experimenter::32, @nxast::16, 0::size(6)-unit(8), tunnel_id::64>>) do

lib/openflow/actions/nx_stack_pop.ex

@@ -1,8 +1,8 @@
 defmodule Openflow.Action.NxStackPop do
   defstruct(
-    n_bits:   0,
-    offset:   0,
-    field:  nil
+    n_bits: 0,
+    offset: 0,
+    field: nil
   )
 
   @experimenter 0x00002320
@@ -20,16 +20,21 @@ defmodule Openflow.Action.NxStackPop do
 
   def to_binary(%NxStackPop{n_bits: n_bits, offset: ofs, field: field}) do
     field_bin = Openflow.Match.codec_header(field)
-    exp_body = <<@experimenter::32, @nxast::16, ofs::16,
-                 field_bin::4-bytes, n_bits::16, 0::size(6)-unit(8)>>
-    exp_body_size =  byte_size(exp_body)
+
+    exp_body =
+      <<@experimenter::32, @nxast::16, ofs::16, field_bin::4-bytes, n_bits::16,
+        0::size(6)-unit(8)>>
+
+    exp_body_size = byte_size(exp_body)
     padding_length = Openflow.Utils.padding(4 + exp_body_size, 8)
     length = 4 + exp_body_size + padding_length
-    <<0xffff::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
+    <<0xFFFF::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
   end
 
-  def read(<<@experimenter::32, @nxast::16, ofs::16,
-             field_bin::4-bytes, n_bits::16, _::size(6)-unit(8)>>) do
+  def read(
+        <<@experimenter::32, @nxast::16, ofs::16, field_bin::4-bytes, n_bits::16,
+          _::size(6)-unit(8)>>
+      ) do
     field = Openflow.Match.codec_header(field_bin)
     %NxStackPop{n_bits: n_bits, offset: ofs, field: field}
   end

lib/openflow/actions/nx_stack_push.ex

@@ -1,8 +1,8 @@
 defmodule Openflow.Action.NxStackPush do
   defstruct(
-    n_bits:   0,
-    offset:   0,
-    field:  nil
+    n_bits: 0,
+    offset: 0,
+    field: nil
   )
 
   @experimenter 0x00002320
@@ -20,16 +20,21 @@ defmodule Openflow.Action.NxStackPush do
 
   def to_binary(%NxStackPush{n_bits: n_bits, offset: ofs, field: field}) do
     field_bin = Openflow.Match.codec_header(field)
-    exp_body = <<@experimenter::32, @nxast::16, ofs::16,
-      field_bin::4-bytes, n_bits::16, 0::size(6)-unit(8)>>
-    exp_body_size =  byte_size(exp_body)
+
+    exp_body =
+      <<@experimenter::32, @nxast::16, ofs::16, field_bin::4-bytes, n_bits::16,
+        0::size(6)-unit(8)>>
+
+    exp_body_size = byte_size(exp_body)
     padding_length = Openflow.Utils.padding(4 + exp_body_size, 8)
     length = 4 + exp_body_size + padding_length
-    <<0xffff::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
+    <<0xFFFF::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
   end
 
-  def read(<<@experimenter::32, @nxast::16, ofs::16,
-             field_bin::4-bytes, n_bits::16, _::size(6)-unit(8)>>) do
+  def read(
+        <<@experimenter::32, @nxast::16, ofs::16, field_bin::4-bytes, n_bits::16,
+          _::size(6)-unit(8)>>
+      ) do
     field = Openflow.Match.codec_header(field_bin)
     %NxStackPush{n_bits: n_bits, offset: ofs, field: field}
   end

lib/openflow/actions/nx_write_metadata.ex

@@ -1,7 +1,7 @@
 defmodule Openflow.Action.NxWriteMetadata do
   defstruct(
     metadata: 0,
-    metadata_mask: 0xffffffffffffffff
+    metadata_mask: 0xFFFFFFFFFFFFFFFF
   )
 
   @experimenter 0x00002320
@@ -12,18 +12,21 @@ defmodule Openflow.Action.NxWriteMetadata do
   def new(metadata) when is_integer(metadata) do
     new(metadata: metadata)
   end
+
   def new(options) when is_list(options) do
     metadata = Keyword.get(options, :metadata, 0)
-    metadata_mask = Keyword.get(options, :metadata_mask, 0xffffffffffffffff)
+    metadata_mask = Keyword.get(options, :metadata_mask, 0xFFFFFFFFFFFFFFFF)
     %NxWriteMetadata{metadata: metadata, metadata_mask: metadata_mask}
   end
 
   def to_binary(%NxWriteMetadata{metadata: metadata, metadata_mask: metadata_mask}) do
-    exp_body = <<@experimenter::32, @nxast::16, 0::size(6)-unit(8), metadata::64, metadata_mask::64>>
-    exp_body_size =  byte_size(exp_body)
+    exp_body =
+      <<@experimenter::32, @nxast::16, 0::size(6)-unit(8), metadata::64, metadata_mask::64>>
+
+    exp_body_size = byte_size(exp_body)
     padding_length = Openflow.Utils.padding(4 + exp_body_size, 8)
     length = 4 + exp_body_size + padding_length
-    <<0xffff::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
+    <<0xFFFF::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
   end
 
   def read(<<@experimenter::32, @nxast::16, _::size(6)-unit(8), metadata::64, metadata_mask::64>>) do

lib/openflow/actions/output.ex

@@ -11,6 +11,7 @@ defmodule Openflow.Action.Output do
   def new(port) when not is_list(port) do
     new(port_number: port)
   end
+
   def new(options) when is_list(options) do
     port_no = Keyword.get(options, :port_number)
     max_len = Keyword.get(options, :max_len, :no_buffer)

lib/openflow/actions/push_pbb.ex

@@ -1,5 +1,5 @@
 defmodule Openflow.Action.PushPbb do
-  defstruct(ethertype: 0x88e7)
+  defstruct(ethertype: 0x88E7)
 
   alias __MODULE__
 

lib/openflow/actions/set_field.ex

@@ -14,8 +14,8 @@ defmodule Openflow.Action.SetField do
   def to_binary(%SetField{field: {field, value}}) do
     match_bin =
       [{field, value}]
-      |> Openflow.Match.new
-      |> Openflow.Match.to_binary
+      |> Openflow.Match.new()
+      |> Openflow.Match.to_binary()
 
     <<1::16, _length::16, padded_field::bytes>> = match_bin
     patial_len = @set_field_size - 4 + byte_size(padded_field)
@@ -28,7 +28,7 @@ defmodule Openflow.Action.SetField do
     <<_class::16, _field::7, _hm::1, flen::8, _rest::bytes>> = match_field_bin
     match_len = 4 + 4 + flen
     match_bin = <<1::16, match_len::16, match_field_bin::bytes>>
-    {[field|_], _rest} = Openflow.Match.read(match_bin)
+    {[field | _], _rest} = Openflow.Match.read(match_bin)
     %SetField{field: field}
   end
 end

lib/openflow/barrier/reply.ex

@@ -1,9 +1,11 @@
 defmodule Openflow.Barrier.Reply do
   defstruct(
-    version:        4,
-    xid:            0,
-    datapath_id:  nil, # virtual field
-    aux_id:         0  # virtual field
+    version: 4,
+    xid: 0,
+    # virtual field
+    datapath_id: nil,
+    # virtual field
+    aux_id: 0
   )
 
   alias __MODULE__

lib/openflow/barrier/request.ex

@@ -1,9 +1,11 @@
 defmodule Openflow.Barrier.Request do
   defstruct(
-    version:        4,
-    xid:            0,
-    datapath_id:  nil, # virtual field
-    aux_id:         0  # virtual field
+    version: 4,
+    xid: 0,
+    # virtual field
+    datapath_id: nil,
+    # virtual field
+    aux_id: 0
   )
 
   alias __MODULE__

lib/openflow/buckets.ex

@@ -1,9 +1,9 @@
 defmodule Openflow.Bucket do
   defstruct(
-    weight:      0,
-    watch_port:  0,
+    weight: 0,
+    watch_port: 0,
     watch_group: 0,
-    actions:     []
+    actions: []
   )
 
   alias __MODULE__
@@ -29,26 +29,43 @@ defmodule Openflow.Bucket do
   # private functions
 
   defp do_read(acc, ""), do: Enum.reverse(acc)
-  defp do_read(acc, <<length::16, weight::16, watch_port_int::32,
-                      watch_group_int::32, _::size(4)-unit(8), binary::bytes>>) do
+
+  defp do_read(
+         acc,
+         <<length::16, weight::16, watch_port_int::32, watch_group_int::32, _::size(4)-unit(8),
+           binary::bytes>>
+       ) do
     actions_len = length - @header_size
     <<actions_bin::size(actions_len)-bytes, rest::bytes>> = binary
     watch_port = Openflow.Utils.get_enum(watch_port_int, :openflow13_port_no)
     watch_group = Openflow.Utils.get_enum(watch_group_int, :group_id)
     actions = Openflow.Action.read(actions_bin)
-    bucket = %Bucket{weight: weight, watch_port: watch_port, watch_group: watch_group, actions: actions}
-    do_read([bucket|acc], rest)
+
+    bucket = %Bucket{
+      weight: weight,
+      watch_port: watch_port,
+      watch_group: watch_group,
+      actions: actions
+    }
+
+    do_read([bucket | acc], rest)
   end
 
   defp to_binary(acc, []), do: acc
-  defp to_binary(acc, [bucket|rest]) do
-    %Bucket{weight: weight, watch_port: watch_port, watch_group: watch_group, actions: actions} = bucket
+
+  defp to_binary(acc, [bucket | rest]) do
+    %Bucket{weight: weight, watch_port: watch_port, watch_group: watch_group, actions: actions} =
+      bucket
+
     watch_port_int = Openflow.Utils.get_enum(watch_port, :openflow13_port_no)
     watch_group_int = Openflow.Utils.get_enum(watch_group, :group_id)
     actions_bin = Openflow.Action.to_binary(actions)
     length = byte_size(actions_bin) + @header_size
-    bucket_bin = <<length::16, weight::16, watch_port_int::32,
-    watch_group_int::32, 0::size(4)-unit(8), actions_bin::bytes>>
+
+    bucket_bin =
+      <<length::16, weight::16, watch_port_int::32, watch_group_int::32, 0::size(4)-unit(8),
+        actions_bin::bytes>>
+
     to_binary(<<acc::bytes, bucket_bin::bytes>>, rest)
   end
 end

lib/openflow/echo/reply.ex

@@ -1,10 +1,12 @@
 defmodule Openflow.Echo.Reply do
   defstruct(
-    version:        4,
-    xid:            0,
-    data:          "",
-    datapath_id:  nil, # virtual field
-    aux_id:         0  # virtual field
+    version: 4,
+    xid: 0,
+    data: "",
+    # virtual field
+    datapath_id: nil,
+    # virtual field
+    aux_id: 0
   )
 
   alias __MODULE__

lib/openflow/echo/request.ex

@@ -1,10 +1,12 @@
 defmodule Openflow.Echo.Request do
   defstruct(
-    version:        4,
-    xid:            0,
-    data:          "",
-    datapath_id:  nil, # virtual field
-    aux_id:         0  # virtual field
+    version: 4,
+    xid: 0,
+    data: "",
+    # virtual field
+    datapath_id: nil,
+    # virtual field
+    aux_id: 0
   )
 
   alias __MODULE__
@@ -23,4 +25,3 @@ defmodule Openflow.Echo.Request do
     data
   end
 end
-

lib/openflow/error_msg.ex

@@ -2,33 +2,38 @@ defmodule Openflow.ErrorMsg do
   @moduledoc "OpenFlow Error codec module"
 
   defstruct(
-    version:        4,
-    xid:            0,
-    type:         nil,
-    code:         nil,
-    data:          "",
-    exp_type:     nil,
+    version: 4,
+    xid: 0,
+    type: nil,
+    code: nil,
+    data: "",
+    exp_type: nil,
     experimenter: nil,
-    datapath_id:  nil, # virtual field
-    aux_id:         0  # virtual field
+    # virtual field
+    datapath_id: nil,
+    # virtual field
+    aux_id: 0
   )
 
   alias __MODULE__
 
   def ofp_type, do: 1
 
-  def read(<<0xffff::16, exp_type::16, experimenter::32, data::bytes>>) do
-    error_type = Openflow.Enums.to_atom(0xffff, :error_type)
+  def read(<<0xFFFF::16, exp_type::16, experimenter::32, data::bytes>>) do
+    error_type = Openflow.Enums.to_atom(0xFFFF, :error_type)
+
     %ErrorMsg{
-      type:         error_type,
-      exp_type:     exp_type,
+      type: error_type,
+      exp_type: exp_type,
       experimenter: experimenter,
-      data:         data
+      data: data
     }
   end
+
   def read(<<type::16, code::16, data::bytes>>) do
     error_type = Openflow.Enums.to_atom(type, :error_type)
     error_code = Openflow.Enums.to_atom(code, error_type)
+
     %ErrorMsg{
       type: error_type,
       code: error_code,
@@ -36,16 +41,17 @@ defmodule Openflow.ErrorMsg do
     }
   end
 
-  def to_binary(%ErrorMsg{type: :experimenter,
-                          exp_type: exp_type,
-                          experimenter: experimenter,
-                          data: data}) do
+  def to_binary(%ErrorMsg{
+        type: :experimenter,
+        exp_type: exp_type,
+        experimenter: experimenter,
+        data: data
+      }) do
     error_type = Openflow.Enums.to_int(:experimenter, :error_type)
     <<error_type::16, exp_type::16, experimenter::32, data::bytes>>
   end
-  def to_binary(%ErrorMsg{type: type,
-                          code: code,
-                          data: data}) do
+
+  def to_binary(%ErrorMsg{type: type, code: code, data: data}) do
     error_type = Openflow.Enums.to_int(type, :error_type)
     error_code = Openflow.Enums.to_int(code, type)
     <<error_type::16, error_code::16, data::bytes>>

lib/openflow/experimenter.ex

@@ -1,12 +1,12 @@
 defmodule Openflow.Experimenter do
   defstruct(
-    version:      4,
-    xid:          0,
+    version: 4,
+    xid: 0,
     datapath_id: "",
-    aux_id:       0,
-    exp_id:       0,
-    exp_type:     0,
-    data:        ""
+    aux_id: 0,
+    exp_id: 0,
+    exp_type: 0,
+    data: ""
   )
 
   alias __MODULE__
@@ -14,9 +14,11 @@ defmodule Openflow.Experimenter do
   def ofp_type, do: 4
 
   def new(options) do
-    %Experimenter{exp_id:   Keyword.get(options, :exp_id, 0),
-                  exp_type: Keyword.get(options, :exp_type, 0),
-                  data:     Keyword.get(options, :data, "")}
+    %Experimenter{
+      exp_id: Keyword.get(options, :exp_id, 0),
+      exp_type: Keyword.get(options, :exp_type, 0),
+      data: Keyword.get(options, :data, "")
+    }
   end
 
   def to_binary(%Experimenter{exp_id: exp_id, exp_type: exp_type, data: data}) do
@@ -27,10 +29,12 @@ defmodule Openflow.Experimenter do
     case Openflow.Utils.get_enum(exp_id, :experimenter_id) do
       ^exp_id ->
         %Experimenter{exp_id: exp_id, exp_type: exp_type, data: data}
-       experimenter when is_atom(experimenter) ->
+
+      experimenter when is_atom(experimenter) ->
         case Openflow.Utils.get_enum(exp_type, experimenter) do
           ^exp_type ->
             %Experimenter{exp_id: exp_id, exp_type: exp_type, data: data}
+
           codec when is_atom(codec) ->
             codec.read(<<exp_id::32, exp_type::32, data::bytes>>)
         end

lib/openflow/features/reply.ex

@@ -1,22 +1,24 @@
 defmodule Openflow.Features.Reply do
   defstruct(
-    version:        4,
-    xid:            0,
-    datapath_id:   "",
-    n_buffers:      0,
-    n_tables:       0,
-    aux_id:         0,
-    capabilities:   []
+    version: 4,
+    xid: 0,
+    datapath_id: "",
+    n_buffers: 0,
+    n_tables: 0,
+    aux_id: 0,
+    capabilities: []
   )
 
   alias __MODULE__
 
   def ofp_type, do: 6
 
-  def read(<<datapath_id::64-bits, n_buf::32, n_tab::8,
-    aux_id::8, _pad::16, caps_int::32, _rsv::32>>) do
+  def read(
+        <<datapath_id::64-bits, n_buf::32, n_tab::8, aux_id::8, _pad::16, caps_int::32, _rsv::32>>
+      ) do
     dpid = Openflow.Utils.to_hex_string(datapath_id)
     flags = Openflow.Enums.int_to_flags(caps_int, :switch_capabilities)
+
     %Reply{
       datapath_id: dpid,
       n_buffers: n_buf,
@@ -31,7 +33,8 @@ defmodule Openflow.Features.Reply do
         n_buffers: n_buf,
         n_tables: n_tab,
         aux_id: aux_id,
-        capabilities: flags}) do
+        capabilities: flags
+      }) do
     dpid_int = String.to_integer(datapath_id, 16)
     flags_int = Openflow.Enums.flags_to_int(flags, :switch_capabilities)
     <<dpid_int::64, n_buf::32, n_tab::8, aux_id::8, 0::16, flags_int::32, 0::32>>

lib/openflow/features/request.ex

@@ -1,9 +1,11 @@
 defmodule Openflow.Features.Request do
   defstruct(
-    version:        4,
-    xid:            0,
-    datapath_id:  nil, # virtual field
-    aux_id:         0  # virtual field
+    version: 4,
+    xid: 0,
+    # virtual field
+    datapath_id: nil,
+    # virtual field
+    aux_id: 0
   )
 
   alias __MODULE__

lib/openflow/flow_mod.ex

@@ -3,7 +3,7 @@ defmodule Openflow.FlowMod do
     version: 4,
     xid: 0,
     datapath_id: "",
-    aux_id:      0,
+    aux_id: 0,
     cookie: 0,
     cookie_mask: 0,
     table_id: 0,
@@ -35,26 +35,31 @@ defmodule Openflow.FlowMod do
     out_port = Keyword.get(options, :out_port, :any)
     out_group = Keyword.get(options, :out_group, :any)
     flags = Keyword.get(options, :flags, [])
-    match = Keyword.get(options, :match, Openflow.Match.new)
+    match = Keyword.get(options, :match, Openflow.Match.new())
     instructions = Keyword.get(options, :instructions, [])
-    %FlowMod{cookie: cookie,
-             cookie_mask: cookie_mask,
-             priority: priority,
-             table_id: table_id,
-             command: command,
-             idle_timeout: idle,
-             hard_timeout: hard,
-             buffer_id: buffer_id,
-             out_port: out_port,
-             out_group: out_group,
-             flags: flags,
-             match: match,
-             instructions: instructions}
+
+    %FlowMod{
+      cookie: cookie,
+      cookie_mask: cookie_mask,
+      priority: priority,
+      table_id: table_id,
+      command: command,
+      idle_timeout: idle,
+      hard_timeout: hard,
+      buffer_id: buffer_id,
+      out_port: out_port,
+      out_group: out_group,
+      flags: flags,
+      match: match,
+      instructions: instructions
+    }
   end
 
-  def read(<<cookie::64, cookie_mask::64, table_id_int::8, command_int::8,
-             idle::16, hard::16, prio::16, buffer_id_int::32, out_port_int::32,
-             out_group_int::32, flags_int::16, _::size(2)-unit(8), rest::bytes>>) do
+  def read(
+        <<cookie::64, cookie_mask::64, table_id_int::8, command_int::8, idle::16, hard::16,
+          prio::16, buffer_id_int::32, out_port_int::32, out_group_int::32, flags_int::16,
+          _::size(2)-unit(8), rest::bytes>>
+      ) do
     table_id = Openflow.Utils.get_enum(table_id_int, :table_id)
     command = Openflow.Utils.get_enum(command_int, :flow_mod_command)
     buffer_id = Openflow.Utils.get_enum(buffer_id_int, :buffer_id)
@@ -64,35 +69,41 @@ defmodule Openflow.FlowMod do
     {match_fields, instructions_bin} = Openflow.Match.read(rest)
     match = Openflow.Match.new(match_fields)
     instructions = Openflow.Instruction.read(instructions_bin)
-    %FlowMod{cookie: cookie,
-             cookie_mask: cookie_mask,
-             priority: prio,
-             table_id: table_id,
-             command: command,
-             idle_timeout: idle,
-             hard_timeout: hard,
-             buffer_id: buffer_id,
-             out_port: out_port,
-             out_group: out_group,
-             flags: flags,
-             match: match,
-             instructions: instructions}
+
+    %FlowMod{
+      cookie: cookie,
+      cookie_mask: cookie_mask,
+      priority: prio,
+      table_id: table_id,
+      command: command,
+      idle_timeout: idle,
+      hard_timeout: hard,
+      buffer_id: buffer_id,
+      out_port: out_port,
+      out_group: out_group,
+      flags: flags,
+      match: match,
+      instructions: instructions
+    }
   end
 
   def to_binary(flow_mod) do
-    %FlowMod{cookie: cookie,
-             cookie_mask: cookie_mask,
-             priority: prio,
-             table_id: table_id,
-             command: command,
-             idle_timeout: idle,
-             hard_timeout: hard,
-             buffer_id: buffer_id,
-             out_port: out_port,
-             out_group: out_group,
-             flags: flags,
-             match: match_fields,
-             instructions: instructions} = flow_mod
+    %FlowMod{
+      cookie: cookie,
+      cookie_mask: cookie_mask,
+      priority: prio,
+      table_id: table_id,
+      command: command,
+      idle_timeout: idle,
+      hard_timeout: hard,
+      buffer_id: buffer_id,
+      out_port: out_port,
+      out_group: out_group,
+      flags: flags,
+      match: match_fields,
+      instructions: instructions
+    } = flow_mod
+
     table_id_int = Openflow.Utils.get_enum(table_id, :table_id)
     command_int = Openflow.Utils.get_enum(command, :flow_mod_command)
     buffer_id_int = Openflow.Utils.get_enum(buffer_id, :buffer_id)
@@ -101,9 +112,9 @@ defmodule Openflow.FlowMod do
     flags_int = Openflow.Enums.flags_to_int(flags, :flow_mod_flags)
     match_fields_bin = Openflow.Match.to_binary(match_fields)
     instructions_bin = Openflow.Instruction.to_binary(instructions)
-    <<cookie::64, cookie_mask::64, table_id_int::8, command_int::8,
-      idle::16, hard::16, prio::16, buffer_id_int::32, out_port_int::32,
-      out_group_int::32, flags_int::16, 0::size(2)-unit(8),
+
+    <<cookie::64, cookie_mask::64, table_id_int::8, command_int::8, idle::16, hard::16, prio::16,
+      buffer_id_int::32, out_port_int::32, out_group_int::32, flags_int::16, 0::size(2)-unit(8),
       match_fields_bin::bytes, instructions_bin::bytes>>
   end
 end

lib/openflow/flow_removed.ex

@@ -1,42 +1,46 @@
 defmodule Openflow.FlowRemoved do
   defstruct(
-    version:       4,
-    xid:           0,
-    datapath_id:   "",
-    aux_id:        0,
-    cookie:        0,
-    priority:      0,
-    reason:        :idle_timeout,
-    table_id:      0,
-    duration_sec:  0,
+    version: 4,
+    xid: 0,
+    datapath_id: "",
+    aux_id: 0,
+    cookie: 0,
+    priority: 0,
+    reason: :idle_timeout,
+    table_id: 0,
+    duration_sec: 0,
     duration_nsec: 0,
-    idle_timeout:  0,
-    hard_timeout:  0,
-    packet_count:  0,
-    byte_count:    0,
-    match:         []
+    idle_timeout: 0,
+    hard_timeout: 0,
+    packet_count: 0,
+    byte_count: 0,
+    match: []
   )
 
   alias __MODULE__
 
   def ofp_type, do: 11
 
-  def read(<<cookie::64, priority::16, reason_int::8,
-             table_id_int::8, dsec::32, dnsec::32,
-             idle::16, hard::16, pkt::64, byt::64, rest::bytes>>) do
+  def read(
+        <<cookie::64, priority::16, reason_int::8, table_id_int::8, dsec::32, dnsec::32, idle::16,
+          hard::16, pkt::64, byt::64, rest::bytes>>
+      ) do
     reason = Openflow.Enums.to_atom(reason_int, :flow_removed_reason)
     table_id = Openflow.Utils.get_enum(table_id_int, :table_id)
     {match_fields, _rest} = Openflow.Match.read(rest)
-    %FlowRemoved{cookie:        cookie,
-                 priority:      priority,
-                 reason:        reason,
-                 table_id:      table_id,
-                 duration_sec:  dsec,
-                 duration_nsec: dnsec,
-                 idle_timeout:  idle,
-                 hard_timeout:  hard,
-                 packet_count:  pkt,
-                 byte_count:    byt,
-                 match:         match_fields}
+
+    %FlowRemoved{
+      cookie: cookie,
+      priority: priority,
+      reason: reason,
+      table_id: table_id,
+      duration_sec: dsec,
+      duration_nsec: dnsec,
+      idle_timeout: idle,
+      hard_timeout: hard,
+      packet_count: pkt,
+      byte_count: byt,
+      match: match_fields
+    }
   end
 end

lib/openflow/get_async/reply.ex

@@ -1,40 +1,46 @@
 defmodule Openflow.GetAsync.Reply do
   defstruct(
-    version:        4,
-    xid:            0,
-    datapath_id:  nil,  # virtual field
-    aux_id:         0,  # virtual field
-    packet_in_mask_master:    0,
-    packet_in_mask_slave:     0,
-    port_status_mask_master:  0,
-    port_status_mask_slave:   0,
+    version: 4,
+    xid: 0,
+    # virtual field
+    datapath_id: nil,
+    # virtual field
+    aux_id: 0,
+    packet_in_mask_master: 0,
+    packet_in_mask_slave: 0,
+    port_status_mask_master: 0,
+    port_status_mask_slave: 0,
     flow_removed_mask_master: 0,
-    flow_removed_mask_slave:  0
+    flow_removed_mask_slave: 0
   )
 
   alias __MODULE__
 
   def ofp_type, do: 27
 
-  def read(<<packet_in_mask_master::32, packet_in_mask_slave::32,
-             port_status_mask_master::32, port_status_mask_slave::32,
-             flow_removed_mask_master::32, flow_removed_mask_slave::32>>) do
-    %Reply{packet_in_mask_master: packet_in_mask_master,
-           packet_in_mask_slave: packet_in_mask_slave,
-           port_status_mask_master: port_status_mask_master,
-           port_status_mask_slave: port_status_mask_slave,
-           flow_removed_mask_master: flow_removed_mask_master,
-           flow_removed_mask_slave: flow_removed_mask_slave}
+  def read(
+        <<packet_in_mask_master::32, packet_in_mask_slave::32, port_status_mask_master::32,
+          port_status_mask_slave::32, flow_removed_mask_master::32, flow_removed_mask_slave::32>>
+      ) do
+    %Reply{
+      packet_in_mask_master: packet_in_mask_master,
+      packet_in_mask_slave: packet_in_mask_slave,
+      port_status_mask_master: port_status_mask_master,
+      port_status_mask_slave: port_status_mask_slave,
+      flow_removed_mask_master: flow_removed_mask_master,
+      flow_removed_mask_slave: flow_removed_mask_slave
+    }
   end
 
-  def to_binary(%Reply{packet_in_mask_master: packet_in_mask_master,
-                       packet_in_mask_slave: packet_in_mask_slave,
-                       port_status_mask_master: port_status_mask_master,
-                       port_status_mask_slave: port_status_mask_slave,
-                       flow_removed_mask_master: flow_removed_mask_master,
-                       flow_removed_mask_slave: flow_removed_mask_slave}) do
-    <<packet_in_mask_master::32, packet_in_mask_slave::32,
-      port_status_mask_master::32, port_status_mask_slave::32,
-      flow_removed_mask_master::32, flow_removed_mask_slave::32>>
+  def to_binary(%Reply{
+        packet_in_mask_master: packet_in_mask_master,
+        packet_in_mask_slave: packet_in_mask_slave,
+        port_status_mask_master: port_status_mask_master,
+        port_status_mask_slave: port_status_mask_slave,
+        flow_removed_mask_master: flow_removed_mask_master,
+        flow_removed_mask_slave: flow_removed_mask_slave
+      }) do
+    <<packet_in_mask_master::32, packet_in_mask_slave::32, port_status_mask_master::32,
+      port_status_mask_slave::32, flow_removed_mask_master::32, flow_removed_mask_slave::32>>
   end
 end

lib/openflow/get_async/request.ex

@@ -1,9 +1,11 @@
 defmodule Openflow.GetAsync.Request do
   defstruct(
-    version:        4,
-    xid:            0,
-    datapath_id:  nil, # virtual field
-    aux_id:         0  # virtual field
+    version: 4,
+    xid: 0,
+    # virtual field
+    datapath_id: nil,
+    # virtual field
+    aux_id: 0
   )
 
   alias __MODULE__

lib/openflow/get_config/reply.ex

@@ -1,10 +1,11 @@
 defmodule Openflow.GetConfig.Reply do
   defstruct(
-    version:        4,
-    xid:            0,
-    datapath_id:   "",
-    aux_id:         0,
-    flags:          [], # default = "normal" is no special handling
+    version: 4,
+    xid: 0,
+    datapath_id: "",
+    aux_id: 0,
+    # default = "normal" is no special handling
+    flags: [],
     miss_send_len: 128
   )
 

lib/openflow/get_config/request.ex

@@ -1,9 +1,11 @@
 defmodule Openflow.GetConfig.Request do
   defstruct(
-    version:        4,
-    xid:            0,
-    datapath_id:  nil, # virtual field
-    aux_id:         0  # virtual field
+    version: 4,
+    xid: 0,
+    # virtual field
+    datapath_id: nil,
+    # virtual field
+    aux_id: 0
   )
 
   alias __MODULE__

lib/openflow/group_mod.ex

@@ -3,7 +3,7 @@ defmodule Openflow.GroupMod do
     version: 4,
     xid: 0,
     datapath_id: "",
-    aux_id:      0,
+    aux_id: 0,
     command: :add,
     type: :all,
     group_id: 0,
@@ -19,10 +19,7 @@ defmodule Openflow.GroupMod do
     type = Keyword.get(options, :type, :all)
     group_id = Keyword.get(options, :group_id, 0)
     buckets = Keyword.get(options, :buckets, [])
-    %GroupMod{command:  command,
-              type:     type,
-              group_id: group_id,
-              buckets:  buckets}
+    %GroupMod{command: command, type: type, group_id: group_id, buckets: buckets}
   end
 
   def read(<<command_int::16, type_int::8, _::8, group_id_int::32, buckets_bin::bytes>>) do
@@ -30,16 +27,10 @@ defmodule Openflow.GroupMod do
     type = Openflow.Utils.get_enum(type_int, :group_type)
     group_id = Openflow.Utils.get_enum(group_id_int, :group_id)
     buckets = Openflow.Bucket.read(buckets_bin)
-    %GroupMod{command:  command,
-              type:     type,
-              group_id: group_id,
-              buckets:  buckets}
+    %GroupMod{command: command, type: type, group_id: group_id, buckets: buckets}
   end
 
-  def to_binary(%GroupMod{command:  command,
-                          type:     type,
-                          group_id: group_id,
-                          buckets:  buckets}) do
+  def to_binary(%GroupMod{command: command, type: type, group_id: group_id, buckets: buckets}) do
     command_int = Openflow.Utils.get_enum(command, :group_mod_command)
     type_int = Openflow.Utils.get_enum(type, :group_type)
     group_id_int = Openflow.Utils.get_enum(group_id, :group_id)

lib/openflow/hello.ex

@@ -9,32 +9,32 @@ defmodule Openflow.Hello do
 
   alias __MODULE__
 
-  def ofp_type,
-    do: 0
+  def ofp_type, do: 0
 
   def new(version) when is_integer(version) do
     %Hello{elements: [versionbitmap: [version]]}
   end
+
   def new(versions) when is_list(versions) do
     %Hello{elements: [versionbitmap: versions]}
   end
 
   def supported_version?(%Hello{version: 4, elements: []}), do: true
   def supported_version?(%Hello{elements: []}), do: false
+
   def supported_version?(%Hello{elements: elements}) do
     versionbitmaps = for {:versionbitmap, versions} <- elements, do: versions
-    Enum.any?(versionbitmaps, fn(versions) -> 4 in versions end)
+    Enum.any?(versionbitmaps, fn versions -> 4 in versions end)
   end
 
-  def read(binary),
-    do: %Hello{elements: decode([], binary)}
+  def read(binary), do: %Hello{elements: decode([], binary)}
 
-  def to_binary(%Hello{elements: elements}),
-    do: encode([], elements)
+  def to_binary(%Hello{elements: elements}), do: encode([], elements)
 
   # private functions
 
   defp decode(acc, <<>>), do: acc
+
   defp decode(acc, <<typeint::16, length::16, rest::bytes>>) do
     data_len = length - @ofp_hello_size
     <<data::bytes-size(data_len), rest2::bytes>> = rest
@@ -50,15 +50,13 @@ defmodule Openflow.Hello do
     end
   end
 
-  defp encode(acc, []),
-    do: to_string(acc)
-  defp encode(acc, [h|rest]),
-    do: encode([encode_hello_elem(h)|acc], rest)
+  defp encode(acc, []), do: to_string(acc)
+  defp encode(acc, [h | rest]), do: encode([encode_hello_elem(h) | acc], rest)
 
   defp decode_hello_elem(:versionbitmap, acc, binary),
-    do: [{:versionbitmap, decode_bitmap([], binary, 0)}|acc]
-  defp decode_hello_elem(_, acc, _binary),
-    do: acc
+    do: [{:versionbitmap, decode_bitmap([], binary, 0)} | acc]
+
+  defp decode_hello_elem(_, acc, _binary), do: acc
 
   defp encode_hello_elem({:versionbitmap, versions}) do
     bitmap_bin = encode_bitmap(versions)
@@ -66,11 +64,13 @@ defmodule Openflow.Hello do
     size_int = @ofp_hello_size + byte_size(bitmap_bin)
     <<type_int::16, size_int::16, bitmap_bin::bytes>>
   end
+
   defp encode_hello_elem(_) do
     <<>>
   end
 
   defp decode_bitmap(acc, "", _), do: acc
+
   defp decode_bitmap(acc, <<int::32, rest::bytes>>, base) do
     acc
     |> decode_bitmap(int, 0, base)
@@ -80,24 +80,27 @@ defmodule Openflow.Hello do
   defp encode_bitmap(list) do
     size =
       list
-      |> Enum.max
+      |> Enum.max()
       |> div(32)
+
     encode_bitmap(0, list, size)
   end
 
-  defp decode_bitmap(acc, _, index, _) when index >= 32,
-    do: acc
-  defp decode_bitmap(acc, int, index, base) when (int &&& (1 <<< index)) == 0,
+  defp decode_bitmap(acc, _, index, _) when index >= 32, do: acc
+
+  defp decode_bitmap(acc, int, index, base) when (int &&& 1 <<< index) == 0,
     do: decode_bitmap(acc, int, index + 1, base)
+
   defp decode_bitmap(acc, int, index, base),
-    do: decode_bitmap([base + index|acc], int, index + 1, base)
+    do: decode_bitmap([base + index | acc], int, index + 1, base)
 
   defp encode_bitmap(acc, [], size) do
     bytes = (size + 1) * 32
     <<acc::size(bytes)>>
   end
-  defp encode_bitmap(acc, [h|rest], size) do
-    index = (size - div(h, 32) * 32 + rem(h, 32))
-    encode_bitmap(acc ||| (1 <<< index), rest, size)
+
+  defp encode_bitmap(acc, [h | rest], size) do
+    index = size - div(h, 32) * 32 + rem(h, 32)
+    encode_bitmap(acc ||| 1 <<< index, rest, size)
   end
 end

lib/openflow/instruction.ex

@@ -1,5 +1,4 @@
 defmodule Openflow.Instruction do
-
   def read(instruction_bin) do
     do_read([], instruction_bin)
   end
@@ -7,6 +6,7 @@ defmodule Openflow.Instruction do
   def to_binary(instructions) when is_list(instructions) do
     to_binary(<<>>, instructions)
   end
+
   def to_binary(instruction) do
     to_binary([instruction])
   end
@@ -14,15 +14,17 @@ defmodule Openflow.Instruction do
   # private functions
 
   defp do_read(acc, <<>>), do: Enum.reverse(acc)
+
   defp do_read(acc, <<type::16, length::16, _::bytes>> = binary) do
     <<instruction_bin::size(length)-bytes, rest::bytes>> = binary
     codec = Openflow.Enums.to_atom(type, :instruction_type)
-    do_read([codec.read(instruction_bin)|acc], rest)
+    do_read([codec.read(instruction_bin) | acc], rest)
   end
 
   defp to_binary(acc, []), do: acc
-  defp to_binary(acc, [instruction|rest]) do
+
+  defp to_binary(acc, [instruction | rest]) do
     codec = instruction.__struct__
-    to_binary(<<acc::bytes, (codec.to_binary(instruction))::bytes>>, rest)
+    to_binary(<<acc::bytes, codec.to_binary(instruction)::bytes>>, rest)
   end
 end

lib/openflow/instructions/experimenter.ex

@@ -9,10 +9,10 @@ defmodule Openflow.Instruction.Experimenter do
 
   def to_binary(%Experimenter{exp_id: exp_id, data: data}) do
     length = 8 + byte_size(data)
-    <<0xffff::16, length::16, exp_id::32, data::bytes>>
+    <<0xFFFF::16, length::16, exp_id::32, data::bytes>>
   end
 
-  def read(<<0xffff::16, _::16, exp_id::32, data::bytes>>) do
+  def read(<<0xFFFF::16, _::16, exp_id::32, data::bytes>>) do
     %Experimenter{exp_id: exp_id, data: data}
   end
 end

lib/openflow/instructions/write_metadata.ex

@@ -1,11 +1,11 @@
 defmodule Openflow.Instruction.WriteMetadata do
-  defstruct(metadata: 0, metadata_mask: 0xffffffffffffffff)
+  defstruct(metadata: 0, metadata_mask: 0xFFFFFFFFFFFFFFFF)
 
   alias __MODULE__
 
   def new(options) do
     metadata = Keyword.get(options, :metadata, 0)
-    metadata_mask = Keyword.get(options, :metadata_mask, 0xffffffffffffffff)
+    metadata_mask = Keyword.get(options, :metadata_mask, 0xFFFFFFFFFFFFFFFF)
     %WriteMetadata{metadata: metadata, metadata_mask: metadata_mask}
   end
 

lib/openflow/match.ex

@@ -1,11 +1,11 @@
 defmodule Openflow.Match do
-  @match_size  8
+  @match_size 8
   @header_size 4
 
-  defstruct([
-    type:   :oxm,
+  defstruct(
+    type: :oxm,
     fields: []
-  ])
+  )
 
   alias __MODULE__
 
@@ -13,6 +13,7 @@ defmodule Openflow.Match do
     oxm_fields =
       fields
       |> keyword_to_oxm_fields([])
+
     %Match{type: :oxm, fields: oxm_fields}
   end
 
@@ -20,7 +21,10 @@ defmodule Openflow.Match do
     <<1::16, no_pad_len::16, binary1::binary>> = binary
     padding_length = Openflow.Utils.pad_length(no_pad_len, 8)
     match_field_len = no_pad_len - @header_size
-    <<match_fields::size(match_field_len)-binary, _::size(padding_length)-unit(8), rest::bitstring>> = binary1
+
+    <<match_fields::size(match_field_len)-binary, _::size(padding_length)-unit(8),
+      rest::bitstring>> = binary1
+
     {decode_fields(match_fields, []), rest}
   end
 
@@ -33,14 +37,17 @@ defmodule Openflow.Match do
   end
 
   def codec_header(oxm_field0) when is_atom(oxm_field0) do
-    oxm_field = case has_mask(oxm_field0) do
-                  1 ->
-                    string = to_string(oxm_field0)
-                    "masked_" <> field = string
-                    String.to_atom(field)
-                  0 ->
-                    oxm_field0
-                end
+    oxm_field =
+      case has_mask(oxm_field0) do
+        1 ->
+          string = to_string(oxm_field0)
+          "masked_" <> field = string
+          String.to_atom(field)
+
+        0 ->
+          oxm_field0
+      end
+
     case Openflow.Match.Field.vendor_of(oxm_field) do
       oxm_class when oxm_class in [:nxm_0, :nxm_1, :openflow_basic, :packet_register] ->
         oxm_class_int = Openflow.Enums.to_int(oxm_class, :oxm_class)
@@ -48,8 +55,9 @@ defmodule Openflow.Match do
         oxm_length = div(Openflow.Match.Field.n_bits_of(oxm_field), 8)
         has_mask = has_mask(oxm_field0)
         <<oxm_class_int::16, oxm_field_int::7, has_mask::1, oxm_length::8>>
+
       experimenter when experimenter in [:nicira_ext_match, :onf_ext_match, :hp_ext_match] ->
-        oxm_class_int = 0xffff
+        oxm_class_int = 0xFFFF
         experimenter_int = Openflow.Enums.to_int(experimenter, :experimenter_oxm_vendors)
         oxm_field_int = Openflow.Enums.to_int(oxm_field, experimenter)
         oxm_length = div(Openflow.Match.Field.n_bits_of(oxm_field) + 4, 8)
@@ -57,41 +65,63 @@ defmodule Openflow.Match do
         <<oxm_class_int::16, oxm_field_int::7, has_mask::1, oxm_length::8, experimenter_int::32>>
     end
   end
+
   def codec_header(<<oxm_class_int::16, oxm_field_int::7, oxm_has_mask::1, _oxm_length::8>>) do
     oxm_class = Openflow.Enums.to_atom(oxm_class_int, :oxm_class)
+
     case oxm_has_mask do
-      0 -> Openflow.Enums.to_atom(oxm_field_int, oxm_class)
+      0 ->
+        Openflow.Enums.to_atom(oxm_field_int, oxm_class)
+
       1 ->
         field_str =
           oxm_field_int
           |> Openflow.Enums.to_atom(oxm_class)
           |> to_string
+
         String.to_atom("masked_" <> field_str)
     end
   end
-  def codec_header(<<0xffff::16, oxm_field_int::7, oxm_has_mask::1, _oxm_length::8, experimenter_int::32>>) do
+
+  def codec_header(
+        <<0xFFFF::16, oxm_field_int::7, oxm_has_mask::1, _oxm_length::8, experimenter_int::32>>
+      ) do
     experimenter = Openflow.Enums.to_atom(experimenter_int, :experimenter_oxm_vendors)
     Openflow.Enums.to_atom(oxm_field_int, experimenter)
+
     case oxm_has_mask do
-      0 -> Openflow.Enums.to_atom(oxm_field_int, experimenter)
+      0 ->
+        Openflow.Enums.to_atom(oxm_field_int, experimenter)
+
       1 ->
         field_str =
           oxm_field_int
           |> Openflow.Enums.to_atom(experimenter)
           |> to_string
+
         String.to_atom("masked_" <> field_str)
     end
   end
 
-  def header_size(<<_oxm_class_int::16, _oxm_field_int::7, _oxm_has_mask::1, _oxm_length::8, _::bytes>>),
-    do: 4
-  def header_size(<<0xffff::16, _oxm_field_int::7, _oxm_has_mask::1, _oxm_length::8, _exp_int::32, _::bytes>>),
-    do: 8
+  def header_size(
+        <<_oxm_class_int::16, _oxm_field_int::7, _oxm_has_mask::1, _oxm_length::8, _::bytes>>
+      ),
+      do: 4
+
+  def header_size(
+        <<0xFFFF::16, _oxm_field_int::7, _oxm_has_mask::1, _oxm_length::8, _exp_int::32,
+          _::bytes>>
+      ),
+      do: 8
 
   # private functions
 
   defp decode_fields(<<>>, acc), do: Enum.reverse(acc)
-  defp decode_fields(<<0xffff::16, _::7, 1::1, length::8, vendor_int::32, field_int::16, binary::bytes>>, acc) do
+
+  defp decode_fields(
+         <<0xFFFF::16, _::7, 1::1, length::8, vendor_int::32, field_int::16, binary::bytes>>,
+         acc
+       ) do
     length = length - 6
     field_len = div(length, 2)
     <<value_bin::size(field_len)-bytes, mask_bin::size(field_len)-bytes, rest::bytes>> = binary
@@ -99,16 +129,21 @@ defmodule Openflow.Match do
     field_name = Openflow.Enums.to_atom(field_int, experimenter)
     value = Openflow.Match.Field.codec(value_bin, field_name)
     mask = Openflow.Match.Field.codec(mask_bin, field_name)
-    decode_fields(rest, [{field_name, {value, mask}}|acc])
+    decode_fields(rest, [{field_name, {value, mask}} | acc])
   end
-  defp decode_fields(<<0xffff::16, _::7, 0::1, length::8, vendor_int::32, field_int::16, binary::bytes>>, acc) do
+
+  defp decode_fields(
+         <<0xFFFF::16, _::7, 0::1, length::8, vendor_int::32, field_int::16, binary::bytes>>,
+         acc
+       ) do
     length = length - 6
     <<value_bin::size(length)-bytes, rest::bytes>> = binary
     experimenter = Openflow.Enums.to_atom(vendor_int, :experimenter_oxm_vendors)
     field_name = Openflow.Enums.to_atom(field_int, experimenter)
     value = Openflow.Match.Field.codec(value_bin, field_name)
-    decode_fields(rest, [{field_name, value}|acc])
+    decode_fields(rest, [{field_name, value} | acc])
   end
+
   defp decode_fields(<<class_int::16, field_int::7, 1::1, length::8, binary::bytes>>, acc) do
     field_len = div(length, 2)
     <<value_bin::size(field_len)-bytes, mask_bin::size(field_len)-bytes, rest::bytes>> = binary
@@ -116,37 +151,43 @@ defmodule Openflow.Match do
     field_name = Openflow.Enums.to_atom(field_int, class)
     value = Openflow.Match.Field.codec(value_bin, field_name)
     mask = Openflow.Match.Field.codec(mask_bin, field_name)
-    decode_fields(rest, [{field_name, {value, mask}}|acc])
+    decode_fields(rest, [{field_name, {value, mask}} | acc])
   end
+
   defp decode_fields(<<class_int::16, field_int::7, 0::1, length::8, binary::bytes>>, acc) do
     <<value_bin::size(length)-bytes, rest::bytes>> = binary
     class = Openflow.Enums.to_atom(class_int, :oxm_class)
     field_name = Openflow.Enums.to_atom(field_int, class)
     value = Openflow.Match.Field.codec(value_bin, field_name)
-    decode_fields(rest, [{field_name, value}|acc])
+    decode_fields(rest, [{field_name, value} | acc])
   end
 
   defp encode_fields([], acc), do: acc
-  defp encode_fields([field|fields], acc) do
-    encode_fields(fields, <<acc::bytes, (encode_field(field))::bytes>>)
+
+  defp encode_fields([field | fields], acc) do
+    encode_fields(fields, <<acc::bytes, encode_field(field)::bytes>>)
   end
 
   defp encode_field(%{class: class, field: field, has_mask: true, value: value, mask: mask})
-  when class == :nicira_ext_match or class == :onf_ext_match do
+       when class == :nicira_ext_match or class == :onf_ext_match do
     vendor_int = Openflow.Enums.to_int(class, :experimenter_oxm_vendors)
     field_int = Openflow.Enums.to_int(field, class)
     has_mask_int = 1
-    length = (byte_size(value) * 2) + 6
-    <<0xffff::16, 0::7, has_mask_int::1, length::8, vendor_int::32, field_int::16, value::bytes, mask::bytes>>
+    length = byte_size(value) * 2 + 6
+
+    <<0xFFFF::16, 0::7, has_mask_int::1, length::8, vendor_int::32, field_int::16, value::bytes,
+      mask::bytes>>
   end
+
   defp encode_field(%{class: class, field: field, has_mask: false, value: value})
-  when class == :nicira_ext_match or class == :onf_ext_match do
+       when class == :nicira_ext_match or class == :onf_ext_match do
     vendor_int = Openflow.Enums.to_int(class, :experimenter_oxm_vendors)
     field_int = Openflow.Enums.to_int(field, class)
     has_mask_int = 0
     length = byte_size(value) + 6
-    <<0xffff::16, 0::7, has_mask_int::1, length::8, vendor_int::32, field_int::16, value::bytes>>
+    <<0xFFFF::16, 0::7, has_mask_int::1, length::8, vendor_int::32, field_int::16, value::bytes>>
   end
+
   defp encode_field(%{class: class, field: field, has_mask: true, value: value, mask: mask}) do
     class_int = Openflow.Enums.to_int(class, :oxm_class)
     field_int = Openflow.Enums.to_int(field, class)
@@ -154,6 +195,7 @@ defmodule Openflow.Match do
     length = byte_size(value) * 2
     <<class_int::16, field_int::7, has_mask_int::1, length::8, value::bytes, mask::bytes>>
   end
+
   defp encode_field(%{class: class, field: field, has_mask: false, value: value}) do
     class_int = Openflow.Enums.to_int(class, :oxm_class)
     field_int = Openflow.Enums.to_int(field, class)
@@ -163,8 +205,9 @@ defmodule Openflow.Match do
   end
 
   defp keyword_to_oxm_fields([], acc), do: Enum.reverse(acc)
-  defp keyword_to_oxm_fields([{field_name, field_value}|fields], acc) do
-    keyword_to_oxm_fields(fields, [oxm_field(field_name, field_value)|acc])
+
+  defp keyword_to_oxm_fields([{field_name, field_value} | fields], acc) do
+    keyword_to_oxm_fields(fields, [oxm_field(field_name, field_value) | acc])
   end
 
   defp oxm_field(field_name, {value, mask}) do
@@ -173,6 +216,7 @@ defmodule Openflow.Match do
     match_class = Openflow.Match.Field.vendor_of(field_name)
     %{class: match_class, field: field_name, has_mask: true, value: value_bin, mask: mask_bin}
   end
+
   defp oxm_field(field_name, value) do
     value_bin = Openflow.Match.Field.codec(value, field_name)
     match_class = Openflow.Match.Field.vendor_of(field_name)
@@ -184,6 +228,7 @@ defmodule Openflow.Match do
       oxm_field
       |> to_string
       |> String.match?(~r/^masked_/)
+
     if has_mask? do
       1
     else

lib/openflow/meter_band.ex

@@ -1,5 +1,4 @@
 defmodule Openflow.MeterBand do
-
   def read(meter_band_bin) do
     do_read([], meter_band_bin)
   end
@@ -7,6 +6,7 @@ defmodule Openflow.MeterBand do
   def to_binary(meter_bands) when is_list(meter_bands) do
     to_binary(<<>>, meter_bands)
   end
+
   def to_binary(meter_band) do
     to_binary([meter_band])
   end
@@ -14,15 +14,17 @@ defmodule Openflow.MeterBand do
   # private functions
 
   defp do_read(acc, <<>>), do: Enum.reverse(acc)
+
   defp do_read(acc, <<type::16, length::16, _::bytes>> = binary) do
     <<meter_band_bin::size(length)-bytes, rest::bytes>> = binary
     codec = Openflow.Enums.to_atom(type, :meter_band_type)
-    do_read([codec.read(meter_band_bin)|acc], rest)
+    do_read([codec.read(meter_band_bin) | acc], rest)
   end
 
   defp to_binary(acc, []), do: acc
-  defp to_binary(acc, [meter_band|rest]) do
+
+  defp to_binary(acc, [meter_band | rest]) do
     codec = meter_band.__struct__
-    to_binary(<<acc::bytes, (codec.to_binary(meter_band))::bytes>>, rest)
+    to_binary(<<acc::bytes, codec.to_binary(meter_band)::bytes>>, rest)
   end
 end

lib/openflow/meter_band/drop.ex

@@ -1,6 +1,6 @@
 defmodule Openflow.MeterBand.Drop do
   defstruct(
-    rate:       0,
+    rate: 0,
     burst_size: 0
   )
 

lib/openflow/meter_band/experimenter.ex

@@ -1,7 +1,7 @@
 defmodule Openflow.MeterBand.Experimenter do
   defstruct(
-    rate:         0,
-    burst_size:   0,
+    rate: 0,
+    burst_size: 0,
     experimenter: 0
   )
 
@@ -14,11 +14,11 @@ defmodule Openflow.MeterBand.Experimenter do
     %Experimenter{rate: rate, burst_size: burst_size, experimenter: experimenter}
   end
 
-  def read(<<0xffff::16, _::16, rate::32, burst_size::32, experimenter::32>>) do
+  def read(<<0xFFFF::16, _::16, rate::32, burst_size::32, experimenter::32>>) do
     %Experimenter{rate: rate, burst_size: burst_size, experimenter: experimenter}
   end
 
   def to_binary(%Experimenter{rate: rate, burst_size: burst_size, experimenter: experimenter}) do
-    <<0xffff::16, 16::16, rate::32, burst_size::32, experimenter::32>>
+    <<0xFFFF::16, 16::16, rate::32, burst_size::32, experimenter::32>>
   end
 end

lib/openflow/meter_band/remark.ex

@@ -1,6 +1,6 @@
 defmodule Openflow.MeterBand.Remark do
   defstruct(
-    rate:       0,
+    rate: 0,
     burst_size: 0,
     prec_level: 0
   )

lib/openflow/meter_mod.ex

@@ -3,7 +3,7 @@ defmodule Openflow.MeterMod do
     version: 4,
     xid: 0,
     datapath_id: "",
-    aux_id:      0,
+    aux_id: 0,
     command: :add,
     flags: [],
     meter_id: 0,

lib/openflow/multipart/aggregate/reply.ex

@@ -1,13 +1,14 @@
 defmodule Openflow.Multipart.Aggregate.Reply do
   defstruct(
-    version:      4,
-    xid:          0,
-    datapath_id:  nil, # virtual field
-    aux_id:       nil,
-    flags:        [],
+    version: 4,
+    xid: 0,
+    # virtual field
+    datapath_id: nil,
+    aux_id: nil,
+    flags: [],
     packet_count: 0,
-    byte_count:   0,
-    flow_count:   0
+    byte_count: 0,
+    flow_count: 0
   )
 
   alias __MODULE__

lib/openflow/multipart/aggregate/request.ex

@@ -1,15 +1,16 @@
 defmodule Openflow.Multipart.Aggregate.Request do
   defstruct(
-    version:      4,
-    xid:          0,
-    datapath_id:  nil, # virtual field
-    flags:        [],
-    table_id:     :all,
-    out_port:     :any,
-    out_group:    :any,
-    cookie:       0,
-    cookie_mask:  0,
-    match:        []
+    version: 4,
+    xid: 0,
+    # virtual field
+    datapath_id: nil,
+    flags: [],
+    table_id: :all,
+    out_port: :any,
+    out_group: :any,
+    cookie: 0,
+    cookie_mask: 0,
+    match: []
   )
 
   alias __MODULE__
@@ -23,44 +24,55 @@ defmodule Openflow.Multipart.Aggregate.Request do
     cookie = Keyword.get(options, :cookie, 0)
     cookie_mask = Keyword.get(options, :cookie, 0)
     match = Keyword.get(options, :match, [])
-    %Request{table_id: table_id,
-             out_port: out_port,
-             out_group: out_group,
-             cookie: cookie,
-             cookie_mask: cookie_mask,
-             match: match}
+
+    %Request{
+      table_id: table_id,
+      out_port: out_port,
+      out_group: out_group,
+      cookie: cookie,
+      cookie_mask: cookie_mask,
+      match: match
+    }
   end
 
-  def read(<<table_id_int::8, _::size(3)-unit(8),
-             out_port_int::32, out_group_int::32,
-             _::size(4)-unit(8), cookie::64,
-             cookie_mask::64, match_bin::bytes>>) do
+  def read(
+        <<table_id_int::8, _::size(3)-unit(8), out_port_int::32, out_group_int::32,
+          _::size(4)-unit(8), cookie::64, cookie_mask::64, match_bin::bytes>>
+      ) do
     table_id = Openflow.Utils.get_enum(table_id_int, :table_id)
     out_port = Openflow.Utils.get_enum(out_port_int, :openflow13_port_no)
     out_group = Openflow.Utils.get_enum(out_group_int, :group_id)
     {match, _rest} = Openflow.Match.read(match_bin)
-    %Request{table_id: table_id,
-             out_port: out_port,
-             out_group: out_group,
-             cookie: cookie,
-             cookie_mask: cookie_mask,
-             match: match}
+
+    %Request{
+      table_id: table_id,
+      out_port: out_port,
+      out_group: out_group,
+      cookie: cookie,
+      cookie_mask: cookie_mask,
+      match: match
+    }
   end
 
-  def to_binary(%Request{table_id: table_id,
-                         out_port: out_port,
-                         out_group: out_group,
-                         cookie: cookie,
-                         cookie_mask: cookie_mask,
-                         match: match} = msg) do
+  def to_binary(
+        %Request{
+          table_id: table_id,
+          out_port: out_port,
+          out_group: out_group,
+          cookie: cookie,
+          cookie_mask: cookie_mask,
+          match: match
+        } = msg
+      ) do
     table_id_int = Openflow.Utils.get_enum(table_id, :table_id)
     out_port_int = Openflow.Utils.get_enum(out_port, :openflow13_port_no)
     out_group_int = Openflow.Utils.get_enum(out_group, :group_id)
     match_bin = Openflow.Match.to_binary(match)
-    body_bin = <<table_id_int::8, 0::size(3)-unit(8),
-                 out_port_int::32, out_group_int::32,
-                 0::size(4)-unit(8), cookie::64,
-                 cookie_mask::64, match_bin::bytes>>
+
+    body_bin =
+      <<table_id_int::8, 0::size(3)-unit(8), out_port_int::32, out_group_int::32,
+        0::size(4)-unit(8), cookie::64, cookie_mask::64, match_bin::bytes>>
+
     header_bin = Openflow.Multipart.Request.header(msg)
     <<header_bin::bytes, body_bin::bytes>>
   end

lib/openflow/multipart/desc/reply.ex

@@ -1,31 +1,36 @@
 defmodule Openflow.Multipart.Desc.Reply do
   defstruct(
-    version:        4,
-    xid:            0,
-    datapath_id:  nil, # virtual field
-    aux_id:       nil,
-    flags:        [],
-    mfr_desc:     "",
-    hw_desc:      "",
-    sw_desc:      "",
-    serial_num:   "",
-    dp_desc:      ""
+    version: 4,
+    xid: 0,
+    # virtual field
+    datapath_id: nil,
+    aux_id: nil,
+    flags: [],
+    mfr_desc: "",
+    hw_desc: "",
+    sw_desc: "",
+    serial_num: "",
+    dp_desc: ""
   )
 
   alias __MODULE__
 
-  @desc_str_len   256
+  @desc_str_len 256
   @serial_num_len 32
 
   def ofp_type, do: 19
 
-  def read(<<mfr_desc::size(@desc_str_len)-bytes, hw_desc::size(@desc_str_len)-bytes,
-             sw_desc::size(@desc_str_len)-bytes, serial_num::size(@serial_num_len)-bytes,
-             dp_desc::size(@desc_str_len)-bytes>>) do
-    %Reply{mfr_desc:   Openflow.Utils.decode_string(mfr_desc),
-           hw_desc:    Openflow.Utils.decode_string(hw_desc),
-           sw_desc:    Openflow.Utils.decode_string(sw_desc),
-           serial_num: Openflow.Utils.decode_string(serial_num),
-           dp_desc:    Openflow.Utils.decode_string(dp_desc)}
+  def read(
+        <<mfr_desc::size(@desc_str_len)-bytes, hw_desc::size(@desc_str_len)-bytes,
+          sw_desc::size(@desc_str_len)-bytes, serial_num::size(@serial_num_len)-bytes,
+          dp_desc::size(@desc_str_len)-bytes>>
+      ) do
+    %Reply{
+      mfr_desc: Openflow.Utils.decode_string(mfr_desc),
+      hw_desc: Openflow.Utils.decode_string(hw_desc),
+      sw_desc: Openflow.Utils.decode_string(sw_desc),
+      serial_num: Openflow.Utils.decode_string(serial_num),
+      dp_desc: Openflow.Utils.decode_string(dp_desc)
+    }
   end
 end

lib/openflow/multipart/desc/request.ex

@@ -1,8 +1,9 @@
 defmodule Openflow.Multipart.Desc.Request do
   defstruct(
-    version:      4,
-    xid:          0,
-    datapath_id:  nil, # virtual field
+    version: 4,
+    xid: 0,
+    # virtual field
+    datapath_id: nil,
     flags: []
   )
 

lib/openflow/multipart/flow/reply.ex

@@ -1,11 +1,12 @@
 defmodule Openflow.Multipart.Flow.Reply do
   defstruct(
-    version:      4,
-    xid:          0,
-    datapath_id:  nil, # virtual field
-    aux_id:       nil,
-    flags:        [],
-    flows:        []
+    version: 4,
+    xid: 0,
+    # virtual field
+    datapath_id: nil,
+    aux_id: nil,
+    flags: [],
+    flows: []
   )
 
   alias __MODULE__
@@ -22,29 +23,32 @@ defmodule Openflow.Multipart.Flow.Reply do
   end
 
   def append_body(%Reply{flows: flows} = message, %Reply{flags: [:more], flows: continue}) do
-    %{message|flows: [continue|flows]}
+    %{message | flows: [continue | flows]}
   end
+
   def append_body(%Reply{flows: flows} = message, %Reply{flags: [], flows: continue}) do
-    new_flows = [continue|flows]
-    |> Enum.reverse
-    |> List.flatten
-    %{message|flows: new_flows}
+    new_flows =
+      [continue | flows]
+      |> Enum.reverse()
+      |> List.flatten()
+
+    %{message | flows: new_flows}
   end
 end
 
 defmodule Openflow.Multipart.FlowStats do
   defstruct(
-    table_id:      0,
-    duration_sec:  0,
+    table_id: 0,
+    duration_sec: 0,
     duration_nsec: 0,
-    priority:      0,
-    idle_timeout:  0,
-    hard_timeout:  0,
-    flags:         0,
-    cookie:        0,
-    packet_count:  0,
-    byte_count:    0,
-    match:        [],
+    priority: 0,
+    idle_timeout: 0,
+    hard_timeout: 0,
+    flags: 0,
+    cookie: 0,
+    packet_count: 0,
+    byte_count: 0,
+    match: [],
     instructions: []
   )
 
@@ -57,30 +61,35 @@ defmodule Openflow.Multipart.FlowStats do
   # private functions
 
   defp do_read(acc, ""), do: Enum.reverse(acc)
+
   defp do_read(acc, <<length::16, _tail::bytes>> = binary) do
     <<flow_stats_bin::size(length)-bytes, rest::bytes>> = binary
-    do_read([codec(flow_stats_bin)|acc], rest)
+    do_read([codec(flow_stats_bin) | acc], rest)
   end
 
-  defp codec(<<_length::16, table_id_int::8, 0::8, duration_sec::32,
-               duration_nsec::32, priority::16, idle::16, hard::16,
-               flags_int::16, _::size(4)-unit(8), cookie::64,
-               packet_count::64, byte_count::64, tail::bytes>>) do
+  defp codec(
+         <<_length::16, table_id_int::8, 0::8, duration_sec::32, duration_nsec::32, priority::16,
+           idle::16, hard::16, flags_int::16, _::size(4)-unit(8), cookie::64, packet_count::64,
+           byte_count::64, tail::bytes>>
+       ) do
     {match, instructions_bin} = Openflow.Match.read(tail)
     table_id = Openflow.Utils.get_enum(table_id_int, :table_id)
     flags = Openflow.Enums.int_to_flags(flags_int, :flow_mod_flags)
     instructions = Openflow.Instruction.read(instructions_bin)
-    %FlowStats{table_id: table_id,
-               duration_sec: duration_sec,
-               duration_nsec: duration_nsec,
-               priority: priority,
-               idle_timeout: idle,
-               hard_timeout: hard,
-               flags: flags,
-               cookie: cookie,
-               packet_count: packet_count,
-               byte_count: byte_count,
-               match: match,
-               instructions: instructions}
+
+    %FlowStats{
+      table_id: table_id,
+      duration_sec: duration_sec,
+      duration_nsec: duration_nsec,
+      priority: priority,
+      idle_timeout: idle,
+      hard_timeout: hard,
+      flags: flags,
+      cookie: cookie,
+      packet_count: packet_count,
+      byte_count: byte_count,
+      match: match,
+      instructions: instructions
+    }
   end
 end

lib/openflow/multipart/flow/request.ex

@@ -1,15 +1,16 @@
 defmodule Openflow.Multipart.Flow.Request do
   defstruct(
-    version:      4,
-    xid:          0,
-    datapath_id:  nil, # virtual field
-    flags:        [],
-    table_id:     :all,
-    out_port:     :any,
-    out_group:    :any,
-    cookie:       0,
-    cookie_mask:  0,
-    match:        []
+    version: 4,
+    xid: 0,
+    # virtual field
+    datapath_id: nil,
+    flags: [],
+    table_id: :all,
+    out_port: :any,
+    out_group: :any,
+    cookie: 0,
+    cookie_mask: 0,
+    match: []
   )
 
   alias __MODULE__
@@ -22,45 +23,56 @@ defmodule Openflow.Multipart.Flow.Request do
     out_group = Keyword.get(options, :out_group, :any)
     cookie = Keyword.get(options, :cookie, 0)
     cookie_mask = Keyword.get(options, :cookie, 0)
-    match = Keyword.get(options, :match, Openflow.Match.new)
-    %Request{table_id: table_id,
-             out_port: out_port,
-             out_group: out_group,
-             cookie: cookie,
-             cookie_mask: cookie_mask,
-             match: match}
+    match = Keyword.get(options, :match, Openflow.Match.new())
+
+    %Request{
+      table_id: table_id,
+      out_port: out_port,
+      out_group: out_group,
+      cookie: cookie,
+      cookie_mask: cookie_mask,
+      match: match
+    }
   end
 
-  def read(<<table_id_int::8, _::size(3)-unit(8),
-             out_port_int::32, out_group_int::32,
-             _::size(4)-unit(8), cookie::64,
-             cookie_mask::64, match_bin::bytes>>) do
+  def read(
+        <<table_id_int::8, _::size(3)-unit(8), out_port_int::32, out_group_int::32,
+          _::size(4)-unit(8), cookie::64, cookie_mask::64, match_bin::bytes>>
+      ) do
     table_id = Openflow.Utils.get_enum(table_id_int, :table_id)
     out_port = Openflow.Utils.get_enum(out_port_int, :openflow13_port_no)
     out_group = Openflow.Utils.get_enum(out_group_int, :group_id)
     {match, _rest} = Openflow.Match.read(match_bin)
-    %Request{table_id: table_id,
-             out_port: out_port,
-             out_group: out_group,
-             cookie: cookie,
-             cookie_mask: cookie_mask,
-             match: match}
+
+    %Request{
+      table_id: table_id,
+      out_port: out_port,
+      out_group: out_group,
+      cookie: cookie,
+      cookie_mask: cookie_mask,
+      match: match
+    }
   end
 
-  def to_binary(%Request{table_id: table_id,
-                         out_port: out_port,
-                         out_group: out_group,
-                         cookie: cookie,
-                         cookie_mask: cookie_mask,
-                         match: match} = msg) do
+  def to_binary(
+        %Request{
+          table_id: table_id,
+          out_port: out_port,
+          out_group: out_group,
+          cookie: cookie,
+          cookie_mask: cookie_mask,
+          match: match
+        } = msg
+      ) do
     table_id_int = Openflow.Utils.get_enum(table_id, :table_id)
     out_port_int = Openflow.Utils.get_enum(out_port, :openflow13_port_no)
     out_group_int = Openflow.Utils.get_enum(out_group, :group_id)
     match_bin = Openflow.Match.to_binary(match)
-    body_bin = <<table_id_int::8, 0::size(3)-unit(8),
-                 out_port_int::32, out_group_int::32,
-                 0::size(4)-unit(8), cookie::64,
-                 cookie_mask::64, match_bin::bytes>>
+
+    body_bin =
+      <<table_id_int::8, 0::size(3)-unit(8), out_port_int::32, out_group_int::32,
+        0::size(4)-unit(8), cookie::64, cookie_mask::64, match_bin::bytes>>
+
     header_bin = Openflow.Multipart.Request.header(msg)
     <<header_bin::bytes, body_bin::bytes>>
   end

lib/openflow/multipart/group/reply.ex

@@ -1,11 +1,12 @@
 defmodule Openflow.Multipart.Group.Reply do
   defstruct(
-    version:      4,
-    xid:          0,
-    datapath_id:  nil, # virtual field
-    aux_id:       nil,
-    flags:        [],
-    groups:       []
+    version: 4,
+    xid: 0,
+    # virtual field
+    datapath_id: nil,
+    aux_id: nil,
+    flags: [],
+    groups: []
   )
 
   alias __MODULE__
@@ -22,25 +23,28 @@ defmodule Openflow.Multipart.Group.Reply do
   end
 
   def append_body(%Reply{groups: groups} = message, %Reply{flags: [:more], groups: continue}) do
-    %{message|groups: [continue|groups]}
+    %{message | groups: [continue | groups]}
   end
+
   def append_body(%Reply{groups: groups} = message, %Reply{flags: [], groups: continue}) do
-    new_groups = [continue|groups]
-    |> Enum.reverse
-    |> List.flatten
-    %{message|groups: new_groups}
+    new_groups =
+      [continue | groups]
+      |> Enum.reverse()
+      |> List.flatten()
+
+    %{message | groups: new_groups}
   end
 end
 
 defmodule Openflow.Multipart.Group do
   defstruct(
-    group_id:      0,
-    ref_count:     0,
-    packet_count:  0,
-    byte_count:    0,
-    duration_sec:  0,
+    group_id: 0,
+    ref_count: 0,
+    packet_count: 0,
+    byte_count: 0,
+    duration_sec: 0,
     duration_nsec: 0,
-    bucket_stats:  []
+    bucket_stats: []
   )
 
   @ofp_group_stats_size 40
@@ -54,27 +58,32 @@ defmodule Openflow.Multipart.Group do
   # private functions
 
   defp do_read(acc, ""), do: Enum.reverse(acc)
+
   defp do_read(acc, <<length::16, _binary::bytes>> = binary) do
     <<group_bin::size(length)-bytes, rest::bytes>> = binary
-    do_read([codec(group_bin)|acc], rest)
+    do_read([codec(group_bin) | acc], rest)
   end
 
-  defp codec(<<length::16, _::size(2)-unit(8),
-               group_id::32, ref_count::32,
-               _::size(4)-unit(8), packet_count::64,
-               byte_count::64, duration_sec::32,
-               duration_nsec::32, tail::bytes>>) do
+  defp codec(
+         <<length::16, _::size(2)-unit(8), group_id::32, ref_count::32, _::size(4)-unit(8),
+           packet_count::64, byte_count::64, duration_sec::32, duration_nsec::32, tail::bytes>>
+       ) do
     bucket_stats_size = length - @ofp_group_stats_size
     <<bucket_stats_bin::size(bucket_stats_size)-bytes, _rest::bytes>> = tail
-    bucket_stats = for <<packet_count::64, byte_count::64 <- bucket_stats_bin>> do
-      %{packet_count: packet_count, byte_count: byte_count}
-    end
-    %Group{group_id: group_id,
-           ref_count: ref_count,
-           packet_count: packet_count,
-           byte_count: byte_count,
-           duration_sec: duration_sec,
-           duration_nsec: duration_nsec,
-           bucket_stats: bucket_stats}
+
+    bucket_stats =
+      for <<packet_count::64, byte_count::64 <- bucket_stats_bin>> do
+        %{packet_count: packet_count, byte_count: byte_count}
+      end
+
+    %Group{
+      group_id: group_id,
+      ref_count: ref_count,
+      packet_count: packet_count,
+      byte_count: byte_count,
+      duration_sec: duration_sec,
+      duration_nsec: duration_nsec,
+      bucket_stats: bucket_stats
+    }
   end
 end

lib/openflow/multipart/group/request.ex

@@ -1,10 +1,11 @@
 defmodule Openflow.Multipart.Group.Request do
   defstruct(
-    version:      4,
-    xid:          0,
-    datapath_id:  nil, # virtual field
+    version: 4,
+    xid: 0,
+    # virtual field
+    datapath_id: nil,
     flags: [],
-    group_id:    :all
+    group_id: :all
   )
 
   alias __MODULE__

lib/openflow/multipart/group_desc/reply.ex

@@ -1,10 +1,11 @@
 defmodule Openflow.Multipart.GroupDesc.Reply do
   defstruct(
-    version:      4,
-    xid:          0,
-    datapath_id:  nil, # virtual field
-    flags:        [],
-    groups:       []
+    version: 4,
+    xid: 0,
+    # virtual field
+    datapath_id: nil,
+    flags: [],
+    groups: []
   )
 
   alias __MODULE__
@@ -21,21 +22,24 @@ defmodule Openflow.Multipart.GroupDesc.Reply do
   end
 
   def append_body(%Reply{groups: groups} = message, %Reply{flags: [:more], groups: continue}) do
-    %{message|groups: [continue|groups]}
+    %{message | groups: [continue | groups]}
   end
+
   def append_body(%Reply{groups: groups} = message, %Reply{flags: [], groups: continue}) do
-    new_groups = [continue|groups]
-    |> Enum.reverse
-    |> List.flatten
-    %{message|groups: new_groups}
+    new_groups =
+      [continue | groups]
+      |> Enum.reverse()
+      |> List.flatten()
+
+    %{message | groups: new_groups}
   end
 end
 
 defmodule Openflow.Multipart.GroupDescStats do
   defstruct(
-    type:     :all,
-    group_id:    0,
-    buckets:    []
+    type: :all,
+    group_id: 0,
+    buckets: []
   )
 
   alias __MODULE__
@@ -49,9 +53,10 @@ defmodule Openflow.Multipart.GroupDescStats do
   # private functions
 
   defp do_read(acc, ""), do: Enum.reverse(acc)
+
   defp do_read(acc, <<length::16, _tail::bytes>> = binary) do
     <<group_stats_bin::size(length)-bytes, rest::bytes>> = binary
-    do_read([codec(group_stats_bin)|acc], rest)
+    do_read([codec(group_stats_bin) | acc], rest)
   end
 
   defp codec(<<length::16, type_int::8, _::8, group_id::32, tail::bytes>>) do

lib/openflow/multipart/group_desc/request.ex

@@ -1,8 +1,9 @@
 defmodule Openflow.Multipart.GroupDesc.Request do
   defstruct(
-    version:      4,
-    xid:          0,
-    datapath_id:  nil, # virtual field
+    version: 4,
+    xid: 0,
+    # virtual field
+    datapath_id: nil,
     flags: []
   )
 

lib/openflow/multipart/group_features/reply.ex

@@ -1,45 +1,47 @@
 defmodule Openflow.Multipart.GroupFeatures.Reply do
   defstruct(
-    version:      4,
-    xid:          0,
-    datapath_id:  nil, # virtual field
-    aux_id:       nil,
-    flags:        [],
-    types:        0,
+    version: 4,
+    xid: 0,
+    # virtual field
+    datapath_id: nil,
+    aux_id: nil,
+    flags: [],
+    types: 0,
     capabilities: [],
-    max_groups_for_all:           0,
-    max_groups_for_select:        0,
-    max_groups_for_indirect:      0,
+    max_groups_for_all: 0,
+    max_groups_for_select: 0,
+    max_groups_for_indirect: 0,
     max_groups_for_fast_failover: 0,
-    actions_for_all:              0,
-    actions_for_select:           0,
-    actions_for_indirect:         0,
-    actions_for_fast_failover:    0
+    actions_for_all: 0,
+    actions_for_select: 0,
+    actions_for_indirect: 0,
+    actions_for_fast_failover: 0
   )
 
   alias __MODULE__
 
   def ofp_type, do: 18
 
-  def read(<<types_int::32, capabilities_int::32,
-             max_groups_for_all_int::32,
-             max_groups_for_select_int::32,
-             max_groups_for_indirect_int::32,
-             max_groups_for_fast_failover_int::32,
-             actions_for_all_int::32,
-             actions_for_select_int::32,
-             actions_for_indirect_int::32,
-             actions_for_fast_failover_int::32>>) do
+  def read(
+        <<types_int::32, capabilities_int::32, max_groups_for_all_int::32,
+          max_groups_for_select_int::32, max_groups_for_indirect_int::32,
+          max_groups_for_fast_failover_int::32, actions_for_all_int::32,
+          actions_for_select_int::32, actions_for_indirect_int::32,
+          actions_for_fast_failover_int::32>>
+      ) do
     capabilities = Openflow.Enums.int_to_flags(capabilities_int, :group_capabilities)
-    %Reply{types: types_int,
-           capabilities: capabilities,
-           max_groups_for_all: max_groups_for_all_int,
-           max_groups_for_select: max_groups_for_select_int,
-           max_groups_for_indirect: max_groups_for_indirect_int,
-           max_groups_for_fast_failover: max_groups_for_fast_failover_int,
-           actions_for_all: actions_for_all_int,
-           actions_for_select: actions_for_select_int,
-           actions_for_indirect: actions_for_indirect_int,
-           actions_for_fast_failover: actions_for_fast_failover_int}
+
+    %Reply{
+      types: types_int,
+      capabilities: capabilities,
+      max_groups_for_all: max_groups_for_all_int,
+      max_groups_for_select: max_groups_for_select_int,
+      max_groups_for_indirect: max_groups_for_indirect_int,
+      max_groups_for_fast_failover: max_groups_for_fast_failover_int,
+      actions_for_all: actions_for_all_int,
+      actions_for_select: actions_for_select_int,
+      actions_for_indirect: actions_for_indirect_int,
+      actions_for_fast_failover: actions_for_fast_failover_int
+    }
   end
 end

lib/openflow/multipart/group_features/request.ex

@@ -1,8 +1,9 @@
 defmodule Openflow.Multipart.GroupFeatures.Request do
   defstruct(
-    version:      4,
-    xid:          0,
-    datapath_id:  nil, # virtual field
+    version: 4,
+    xid: 0,
+    # virtual field
+    datapath_id: nil,
     flags: []
   )
 

lib/openflow/multipart/meter/reply.ex

@@ -1,11 +1,12 @@
 defmodule Openflow.Multipart.Meter.Reply do
   defstruct(
-    version:      4,
-    xid:          0,
-    datapath_id:  nil, # virtual field
-    aux_id:       nil,
-    flags:        [],
-    meters:       []
+    version: 4,
+    xid: 0,
+    # virtual field
+    datapath_id: nil,
+    aux_id: nil,
+    flags: [],
+    meters: []
   )
 
   alias __MODULE__
@@ -18,25 +19,28 @@ defmodule Openflow.Multipart.Meter.Reply do
   end
 
   def append_body(%Reply{meters: meters} = message, %Reply{flags: [:more], meters: continue}) do
-    %{message|meters: [continue|meters]}
+    %{message | meters: [continue | meters]}
   end
+
   def append_body(%Reply{meters: meters} = message, %Reply{flags: [], meters: continue}) do
-    new_meters = [continue|meters]
-    |> Enum.reverse
-    |> List.flatten
-    %{message|meters: new_meters}
+    new_meters =
+      [continue | meters]
+      |> Enum.reverse()
+      |> List.flatten()
+
+    %{message | meters: new_meters}
   end
 end
 
 defmodule Openflow.Multipart.Meter do
   defstruct(
-    meter_id:        0,
-    flow_count:      0,
+    meter_id: 0,
+    flow_count: 0,
     packet_in_count: 0,
-    byte_in_count:   0,
-    duration_sec:    0,
-    duration_nsec:   0,
-    band_stats:     []
+    byte_in_count: 0,
+    duration_sec: 0,
+    duration_nsec: 0,
+    band_stats: []
   )
 
   @ofp_meter_stats_size 40
@@ -50,25 +54,32 @@ defmodule Openflow.Multipart.Meter do
   # private functions
 
   defp do_read(acc, ""), do: Enum.reverse(acc)
+
   defp do_read(acc, <<_::32, length::16, _binary::bytes>> = binary) do
     <<meter_bin::size(length)-bytes, rest::bytes>> = binary
-    do_read([codec(meter_bin)|acc], rest)
+    do_read([codec(meter_bin) | acc], rest)
   end
 
-  defp codec(<<meter_id::32, length::16, _::size(6)-unit(8),
-               flow_count::32, packet_in_count::64, byte_in_count::64,
-               duration_sec::32, duration_nsec::32, tail::bytes>>) do
+  defp codec(
+         <<meter_id::32, length::16, _::size(6)-unit(8), flow_count::32, packet_in_count::64,
+           byte_in_count::64, duration_sec::32, duration_nsec::32, tail::bytes>>
+       ) do
     band_stats_size = length - @ofp_meter_stats_size
     <<band_stats_bin::size(band_stats_size)-bytes, _rest::bytes>> = tail
-    band_stats = for <<packet_band_count::64, byte_band_count::64 <- band_stats_bin>> do
-      %{packet_band_count: packet_band_count,byte_band_count: byte_band_count}
-    end
-    %Meter{meter_id: meter_id,
-           flow_count: flow_count,
-           packet_in_count: packet_in_count,
-           byte_in_count: byte_in_count,
-           duration_sec: duration_sec,
-           duration_nsec: duration_nsec,
-           band_stats: band_stats}
+
+    band_stats =
+      for <<packet_band_count::64, byte_band_count::64 <- band_stats_bin>> do
+        %{packet_band_count: packet_band_count, byte_band_count: byte_band_count}
+      end
+
+    %Meter{
+      meter_id: meter_id,
+      flow_count: flow_count,
+      packet_in_count: packet_in_count,
+      byte_in_count: byte_in_count,
+      duration_sec: duration_sec,
+      duration_nsec: duration_nsec,
+      band_stats: band_stats
+    }
   end
 end

lib/openflow/multipart/meter/request.ex

@@ -1,10 +1,11 @@
 defmodule Openflow.Multipart.Meter.Request do
   defstruct(
-    version:      4,
-    xid:          0,
-    datapath_id:  nil, # virtual field
+    version: 4,
+    xid: 0,
+    # virtual field
+    datapath_id: nil,
     flags: [],
-    meter_id:    :all
+    meter_id: :all
   )
 
   alias __MODULE__

lib/openflow/multipart/meter_config/request.ex

@@ -1,10 +1,11 @@
 defmodule Openflow.Multipart.MeterConfig.Request do
   defstruct(
-    version:      4,
-    xid:          0,
-    datapath_id:  nil, # virtual field
+    version: 4,
+    xid: 0,
+    # virtual field
+    datapath_id: nil,
     flags: [],
-    meter_id:    :all
+    meter_id: :all
   )
 
   alias __MODULE__

lib/openflow/multipart/port_desc/reply.ex

@@ -1,11 +1,12 @@
 defmodule Openflow.Multipart.PortDesc.Reply do
   defstruct(
-    version:      4,
-    xid:          0,
-    datapath_id:  nil, # virtual field
-    aux_id:       nil,
-    flags:        [],
-    ports:        []
+    version: 4,
+    xid: 0,
+    # virtual field
+    datapath_id: nil,
+    aux_id: nil,
+    flags: [],
+    ports: []
   )
 
   alias __MODULE__
@@ -17,17 +18,20 @@ defmodule Openflow.Multipart.PortDesc.Reply do
   end
 
   def read(<<ports_bin::bytes>>) do
-    ports = for (<<port_bin::64-bytes <- ports_bin>>), do: Openflow.Port.read(port_bin)
+    ports = for <<port_bin::64-bytes <- ports_bin>>, do: Openflow.Port.read(port_bin)
     %Reply{ports: Enum.reverse(ports)}
   end
 
   def append_body(%Reply{ports: ports} = message, %Reply{flags: [:more], ports: continue}) do
-    %{message|ports: [continue|ports]}
+    %{message | ports: [continue | ports]}
   end
+
   def append_body(%Reply{ports: ports} = message, %Reply{flags: [], ports: continue}) do
-    new_ports = [continue|ports]
-    |> Enum.reverse
-    |> List.flatten
-    %{message|ports: new_ports}
+    new_ports =
+      [continue | ports]
+      |> Enum.reverse()
+      |> List.flatten()
+
+    %{message | ports: new_ports}
   end
 end

lib/openflow/multipart/port_desc/request.ex

@@ -1,8 +1,9 @@
 defmodule Openflow.Multipart.PortDesc.Request do
   defstruct(
-    version:      4,
-    xid:          0,
-    datapath_id:  nil, # virtual field
+    version: 4,
+    xid: 0,
+    # virtual field
+    datapath_id: nil,
     flags: []
   )
 

lib/openflow/multipart/port_stats/reply.ex

@@ -1,11 +1,12 @@
 defmodule Openflow.Multipart.PortStats.Reply do
   defstruct(
-    version:      4,
-    xid:          0,
-    datapath_id:  nil, # virtual field
-    aux_id:       nil,
-    flags:        [],
-    ports:        []
+    version: 4,
+    xid: 0,
+    # virtual field
+    datapath_id: nil,
+    aux_id: nil,
+    flags: [],
+    ports: []
   )
 
   alias __MODULE__
@@ -22,32 +23,35 @@ defmodule Openflow.Multipart.PortStats.Reply do
   end
 
   def append_body(%Reply{ports: ports} = message, %Reply{flags: [:more], ports: continue}) do
-    %{message|ports: [continue|ports]}
+    %{message | ports: [continue | ports]}
   end
+
   def append_body(%Reply{ports: ports} = message, %Reply{flags: [], ports: continue}) do
-    new_ports = [continue|ports]
-    |> Enum.reverse
-    |> List.flatten
-    %{message|ports: new_ports}
+    new_ports =
+      [continue | ports]
+      |> Enum.reverse()
+      |> List.flatten()
+
+    %{message | ports: new_ports}
   end
 end
 
 defmodule Openflow.Multipart.PortStats do
   defstruct(
-    port_number:   0,
-    rx_packets:    0,
-    tx_packets:    0,
-    rx_bytes:      0,
-    tx_bytes:      0,
-    rx_dropped:    0,
-    tx_dropped:    0,
-    rx_errors:     0,
-    tx_errors:     0,
-    rx_frame_err:  0,
-    rx_over_err:   0,
-    rx_crc_err:    0,
-    collisions:    0,
-    duration_sec:  0,
+    port_number: 0,
+    rx_packets: 0,
+    tx_packets: 0,
+    rx_bytes: 0,
+    tx_bytes: 0,
+    rx_dropped: 0,
+    tx_dropped: 0,
+    rx_errors: 0,
+    tx_errors: 0,
+    rx_frame_err: 0,
+    rx_over_err: 0,
+    rx_crc_err: 0,
+    collisions: 0,
+    duration_sec: 0,
     duration_nsec: 0
   )
 
@@ -60,30 +64,33 @@ defmodule Openflow.Multipart.PortStats do
   # private functions
 
   defp do_read(acc, ""), do: Enum.reverse(acc)
+
   defp do_read(acc, <<port_stats_bin::112-bytes, rest::bytes>>) do
-    do_read([codec(port_stats_bin)|acc], rest)
+    do_read([codec(port_stats_bin) | acc], rest)
   end
 
-  defp codec(<<port_no::32, _::size(4)-unit(8), rx_packets::64,
-               tx_packets::64, rx_bytes::64, tx_bytes::64,
-               rx_dropped::64, tx_dropped::64, rx_errors::64,
-               tx_errors::64, rx_frame_err::64, rx_over_err::64,
-               rx_crc_err::64, collisions::64,
-               duration_sec::32, duration_nsec::32>>) do
-    %PortStats{port_number:   port_no,
-               rx_packets:    rx_packets,
-               tx_packets:    tx_packets,
-               rx_bytes:      rx_bytes,
-               tx_bytes:      tx_bytes,
-               rx_dropped:    rx_dropped,
-               tx_dropped:    tx_dropped,
-               rx_errors:     rx_errors,
-               tx_errors:     tx_errors,
-               rx_frame_err:  rx_frame_err,
-               rx_over_err:   rx_over_err,
-               rx_crc_err:    rx_crc_err,
-               collisions:    collisions,
-               duration_sec:  duration_sec,
-               duration_nsec: duration_nsec}
+  defp codec(
+         <<port_no::32, _::size(4)-unit(8), rx_packets::64, tx_packets::64, rx_bytes::64,
+           tx_bytes::64, rx_dropped::64, tx_dropped::64, rx_errors::64, tx_errors::64,
+           rx_frame_err::64, rx_over_err::64, rx_crc_err::64, collisions::64, duration_sec::32,
+           duration_nsec::32>>
+       ) do
+    %PortStats{
+      port_number: port_no,
+      rx_packets: rx_packets,
+      tx_packets: tx_packets,
+      rx_bytes: rx_bytes,
+      tx_bytes: tx_bytes,
+      rx_dropped: rx_dropped,
+      tx_dropped: tx_dropped,
+      rx_errors: rx_errors,
+      tx_errors: tx_errors,
+      rx_frame_err: rx_frame_err,
+      rx_over_err: rx_over_err,
+      rx_crc_err: rx_crc_err,
+      collisions: collisions,
+      duration_sec: duration_sec,
+      duration_nsec: duration_nsec
+    }
   end
 end

lib/openflow/multipart/port_stats/request.ex

@@ -1,8 +1,9 @@
 defmodule Openflow.Multipart.PortStats.Request do
   defstruct(
-    version:      4,
-    xid:          0,
-    datapath_id:  nil, # virtual field
+    version: 4,
+    xid: 0,
+    # virtual field
+    datapath_id: nil,
     flags: [],
     port_number: :any
   )

lib/openflow/multipart/queue/reply.ex

@@ -1,11 +1,12 @@
 defmodule Openflow.Multipart.Queue.Reply do
   defstruct(
-    version:      4,
-    xid:          0,
-    datapath_id:  nil, # virtual field
-    aux_id:       nil,
-    flags:        [],
-    queues:       []
+    version: 4,
+    xid: 0,
+    # virtual field
+    datapath_id: nil,
+    aux_id: nil,
+    flags: [],
+    queues: []
   )
 
   alias __MODULE__
@@ -22,24 +23,27 @@ defmodule Openflow.Multipart.Queue.Reply do
   end
 
   def append_body(%Reply{queues: queues} = message, %Reply{flags: [:more], queues: continue}) do
-    %{message|queues: [continue|queues]}
+    %{message | queues: [continue | queues]}
   end
+
   def append_body(%Reply{queues: queues} = message, %Reply{flags: [], queues: continue}) do
-    new_queues = [continue|queues]
-    |> Enum.reverse
-    |> List.flatten
-    %{message|queues: new_queues}
+    new_queues =
+      [continue | queues]
+      |> Enum.reverse()
+      |> List.flatten()
+
+    %{message | queues: new_queues}
   end
 end
 
 defmodule Openflow.Multipart.Queue do
   defstruct(
-    port_number:   0,
-    queue_id:      0,
-    tx_bytes:      0,
-    tx_packets:    0,
-    tx_errors:     0,
-    duration_sec:  0,
+    port_number: 0,
+    queue_id: 0,
+    tx_bytes: 0,
+    tx_packets: 0,
+    tx_errors: 0,
+    duration_sec: 0,
     duration_nsec: 0
   )
 
@@ -52,19 +56,23 @@ defmodule Openflow.Multipart.Queue do
   # private functions
 
   defp do_read(acc, ""), do: Enum.reverse(acc)
+
   defp do_read(acc, <<queue_bin::40-bytes, rest::bytes>>) do
-    do_read([codec(queue_bin)|acc], rest)
+    do_read([codec(queue_bin) | acc], rest)
   end
 
-  defp codec(<<port_no::32, queue_id::32, tx_bytes::64,
-               tx_packets::64, tx_errors::64,
-               duration_sec::32, duration_nsec::32>>) do
-    %Queue{port_number:   port_no,
-           queue_id:      queue_id,
-           tx_bytes:      tx_bytes,
-           tx_packets:    tx_packets,
-           tx_errors:     tx_errors,
-           duration_sec:  duration_sec,
-           duration_nsec: duration_nsec}
+  defp codec(
+         <<port_no::32, queue_id::32, tx_bytes::64, tx_packets::64, tx_errors::64,
+           duration_sec::32, duration_nsec::32>>
+       ) do
+    %Queue{
+      port_number: port_no,
+      queue_id: queue_id,
+      tx_bytes: tx_bytes,
+      tx_packets: tx_packets,
+      tx_errors: tx_errors,
+      duration_sec: duration_sec,
+      duration_nsec: duration_nsec
+    }
   end
 end

lib/openflow/multipart/queue/request.ex

@@ -1,11 +1,12 @@
 defmodule Openflow.Multipart.Queue.Request do
   defstruct(
-    version:      4,
-    xid:          0,
-    datapath_id:  nil, # virtual field
+    version: 4,
+    xid: 0,
+    # virtual field
+    datapath_id: nil,
     flags: [],
     port_number: :any,
-    queue_id:    :all
+    queue_id: :all
   )
 
   alias __MODULE__