First commit

Author: lok0613

.formatter.exs

@@ -0,0 +1,4 @@
+# Used by "mix format"
+[
+  inputs: ["{mix,.formatter}.exs", "{config,lib,test}/**/*.{ex,exs}"]
+]

.gitignore

@@ -0,0 +1,24 @@
+# The directory Mix will write compiled artifacts to.
+/_build/
+
+# If you run "mix test --cover", coverage assets end up here.
+/cover/
+
+# The directory Mix downloads your dependencies sources to.
+/deps/
+
+# Where third-party dependencies like ExDoc output generated docs.
+/doc/
+
+# Ignore .fetch files in case you like to edit your project deps locally.
+/.fetch
+
+# If the VM crashes, it generates a dump, let's ignore it too.
+erl_crash.dump
+
+# Also ignore archive artifacts (built via "mix archive.build").
+*.ez
+
+# Ignore package tarball (built via "mix hex.build").
+binary_reader-*.tar
+

README.md

@@ -0,0 +1,47 @@
+# BinaryReader
+
+A Elixir Binary Reader that running with side effects.
+
+## Installation
+
+If [available in Hex](https://hex.pm/docs/publish), the package can be installed
+by adding `binary_reader` to your list of dependencies in `mix.exs`:
+
+```elixir
+def deps do
+  [
+    {:binary_reader, "~> 0.1.0"}
+  ]
+end
+```
+
+## Usage
+
+### Normal Usage
+```elixir
+iex> {:ok, pid} = BinaryReader.start_link(<<65, 66, 67, 68, 2, 0, 0, 0>>)
+{:ok, #PID<0.0.0>}
+iex> BinaryReader.read_string(pid)
+"ABCD"
+iex> BinaryReader.remains_byte_size(pid)
+4
+iex> BinaryReader.read_int32(pid)
+2
+iex> BinaryReader.stop(pid)
+:ok
+```
+
+### Extend BinaryReader
+```elixir
+defmodule SpecialBinaryReader do
+  use BinaryReader
+
+  def special_read(pid) do
+    length = read_int32(pid)
+    read_bytes(pid, length)
+  end
+end
+
+iex> {:ok, pid} = SpecialBinaryReader.start_link(<<.....>>)
+iex> SpecialBinaryReader.special_read(pid)
+```

lib/binary_reader.ex

@@ -0,0 +1,84 @@
+defmodule BinaryReader do
+  @moduledoc """
+  Warning: This module has side effects.
+
+  a_int = BinaryReader.read_int32(pid)
+
+  Each action like this will cost a side effect, chaging the binary content that inputed initailly.
+  Be careful to use it according to your needs.
+  """
+  alias BinaryReader.Server
+
+  defmacro __using__(_opt) do
+    quote do
+      import BinaryReader
+    end
+  end
+
+  @doc """
+  Start the GenServer
+  """
+  @spec start_link(binary()) :: {:ok, pid()}
+  def start_link(content) do
+    GenServer.start_link(Server, content)
+  end
+
+  @doc """
+  Stop the GenServer
+  """
+  @spec stop(pid()) :: :ok
+  def stop(pid), do: GenServer.stop(pid, :normal)
+
+  @doc """
+  Read one byte
+  """
+  @spec read_byte(pid()) :: binary()
+  def read_byte(pid), do: read_bytes(pid, 1)
+
+  @doc """
+  Read number of bytes
+  """
+  @spec read_bytes(pid(), integer()) :: binary()
+  def read_bytes(pid, size) when is_integer(size) do
+    GenServer.call(pid, {:read_bytes, size})
+  end
+
+  @doc """
+  Read 8 bytes for int64
+  """
+  @spec read_int64(pid()) :: integer()
+  def read_int64(pid), do: GenServer.call(pid, :read_int64)
+
+  @doc """
+  Read 4 bytes for int32
+  """
+  @spec read_int32(pid()) :: integer()
+  def read_int32(pid), do: GenServer.call(pid, :read_int32)
+
+  @doc """
+  Read 2 bytes for int16
+  """
+  @spec read_int16(pid()) :: integer()
+  def read_int16(pid), do: GenServer.call(pid, :read_int16)
+
+  @doc """
+  Read 4 bytes for string
+  """
+  @spec read_string(pid()) :: String.t()
+  def read_string(pid), do: GenServer.call(pid, :read_string)
+
+  @doc """
+  Return remains size of bytes
+  """
+  @spec remains_byte_size(pid()) :: binary()
+  def remains_byte_size(pid), do: GenServer.call(pid, :remains)
+
+  @doc """
+  Move the reading pivot to certain index
+  """
+  @spec move_pivot_to(pid(), integer()) :: :ok
+  def move_pivot_to(pid, index) when is_integer(index) do
+    GenServer.call(pid, {:move_pivot_to, index})
+  end
+
+end

lib/binary_reader/server.ex

@@ -0,0 +1,61 @@
+defmodule BinaryReader.Server do
+  use GenServer
+
+  @impl true
+  def init(content) do
+    {:ok, content}
+  end
+
+  @impl true
+  def handle_call({:read_bytes, size}, _from, content) do
+    <<head::binary-size(size), rest::binary>> = content
+    {:reply, head, rest}
+  end
+
+  @impl true
+  def handle_call(:read_int64, _from, content) do
+    <<head::binary-size(8), rest::binary>> = content
+    <<int64::little-signed-integer-size(64)>> = head
+
+    {:reply, int64, rest}
+  end
+
+  @impl true
+  def handle_call(:read_int32, _from, content) do
+    <<head::binary-size(4), rest::binary>> = content
+    <<int32::little-signed-integer-size(32)>> = head
+
+    {:reply, int32, rest}
+  end
+
+  @impl true
+  def handle_call(:read_int16, _from, content) do
+    <<head::binary-size(2), rest::binary>> = content
+    <<int32::little-signed-integer-size(16)>> = head
+
+    {:reply, int32, rest}
+  end
+
+  @impl true
+  def handle_call(:read_string, _from, content) do
+    <<head::binary-size(4), rest::binary>> = content
+
+    string = head
+    |> :binary.bin_to_list()
+    |> to_string()
+
+    {:reply, string, rest}
+  end
+
+  @impl true
+  def handle_call({:move_pivot_to, index}, _from, content) do
+    <<_head::binary-size(index), rest::binary>> = content
+    {:reply, :ok, rest}
+  end
+
+  @impl true
+  def handle_call(:remains_byte_size, _from, content) do
+    {:reply, byte_size(content), content}
+  end
+
+end

mix.exs

@@ -0,0 +1,28 @@
+defmodule BinaryReader.MixProject do
+  use Mix.Project
+
+  def project do
+    [
+      app: :binary_reader,
+      version: "0.1.0",
+      elixir: "~> 1.10",
+      start_permanent: Mix.env() == :prod,
+      deps: deps()
+    ]
+  end
+
+  # Run "mix help compile.app" to learn about applications.
+  def application do
+    [
+      extra_applications: [:logger]
+    ]
+  end
+
+  # Run "mix help deps" to learn about dependencies.
+  defp deps do
+    [
+      # {:dep_from_hexpm, "~> 0.3.0"},
+      # {:dep_from_git, git: "https://github.com/elixir-lang/my_dep.git", tag: "0.1.0"}
+    ]
+  end
+end

test/binary_reader_test.exs

@@ -0,0 +1,44 @@
+defmodule BinaryReaderTest do
+  use ExUnit.Case, async: true
+  @moduledoc"""
+  <<
+  71, 86, 65, 83, # string
+  2, 0, 0, 0, # int32
+  5, 2, 0, 0, # int32
+  4, 0, # int16
+  22, 0, # int16
+  3, 0,
+  0, 0, 0, 0,
+  19, 0, 0, 0,
+  43, 43, 85, 69, 52, 43, 82, 101, 108, 101, 97, 115, 101, 45, 52, 46, 50....
+  """
+
+  setup_all do
+    file = Path.relative("test/fixtures/test.binary")
+    {:ok, content} = File.read(file)
+    {:ok, pid} = BinaryReader.start_link(content)
+    {:ok, pid: pid}
+  end
+
+  test "read string", %{pid: pid} do
+    assert "GVAS" == BinaryReader.read_string(pid)
+  end
+
+  test "read int32", %{pid: pid} do
+    assert 2 == BinaryReader.read_int32(pid)
+    assert 517 == BinaryReader.read_int32(pid)
+  end
+
+  test "read int16", %{pid: pid} do
+    assert 4 == BinaryReader.read_int16(pid)
+  end
+
+  test "read bytes", %{pid: pid} do
+    assert <<22, 0>> == BinaryReader.read_bytes(pid, 2)
+  end
+
+  test "stop", %{pid: pid} do
+    assert :ok == BinaryReader.stop(pid)
+  end
+
+end

test/fixtures/test.binary

@@ -0,0 +1,2 @@
+ExUnit.configure seed: 0
+ExUnit.start()