View Source ExTimer (ex_timer v1.5.2)

ExTimer module.

Summary

Functions

add new timer to send msg after time milliseconds.

delete all the registerd timers.

delete all the registerd timers.

return true if found the timer at the given msg, otherwise return false

get the minimum time(milliseconds) for the timer to expired.

delete the previous registerd timer.

call the callback handler (handle_timer) for the timer that has elapsed.

Types

state()

@type state() :: term()

t()

@type t() :: %ExTimer{now_ms: (-> integer()), timers: [timer_node()]}

time_ms()

@type time_ms() :: ExTimer.Node.time_ms()

timer_node()

@type timer_node() :: ExTimer.Node.t()

timer_node_msg()

@type timer_node_msg() :: ExTimer.Node.msg()

Functions

add(timer, msg, delta_ms)

@spec add(t(), timer_node_msg(), time_ms()) :: t()

add new timer to send msg after time milliseconds.

Examples

iex> now_ref = fn -> 500 end
iex> timer = ExTimer.new(now_ms: now_ref)
%ExTimer{now_ms: now_ref, timers: []}
iex> timer = ExTimer.add(timer, {:handler, :name, "uhaha"}, 2000)
%ExTimer{now_ms: now_ref, timers: [%ExTimer.Node{due_ms: 2500, msg: {:handler, :name, "uhaha"}}]}
iex> [timer_node] = timer.timers
[%ExTimer.Node{due_ms: 2500, msg: {:handler, :name, "uhaha"}}]
iex> timer_node.msg == {:handler, :name, "uhaha"}
true
iex> timer_node.due_ms == 2500
true

clear(timer)

@spec clear(t()) :: t()

delete all the registerd timers.

Examples

iex> now_ref = fn -> 500 end
iex> timer = ExTimer.new(now_ms: now_ref)
iex> timer = ExTimer.add(timer, {:handler, :name1, "a1"}, 1000)
iex> timer = ExTimer.add(timer, {:handler, :name2, "a2"}, 2000)
%ExTimer{
timers: [
  %ExTimer.Node{due_ms: 1500, msg: {:handler, :name1, "a1"}},
  %ExTimer.Node{due_ms: 2500, msg: {:handler, :name2, "a2"}}
],
now_ms: now_ref
}
iex> ExTimer.clear(timer)
%ExTimer{timers: [], now_ms: now_ref}

clear(state, timer, callback?)

(macro)

delete all the registerd timers.

Examples

iex> state = %{}
iex> now_ref = fn -> 500 end
iex> timer = ExTimer.new(now_ms: now_ref)
iex> timer = ExTimer.add(timer, {:handler, :name, "uhaha"}, 2000)
%ExTimer{timers: [%ExTimer.Node{due_ms: 2500, msg: {:handler, :name, "uhaha"}}], now_ms: now_ref}
iex> {_state, _timer} = ExTimer.clear(state, timer, false)
{%{}, %ExTimer{timers: [], now_ms: now_ref}}

exist?(timer, msg)

@spec exist?(t(), timer_node_msg()) :: boolean()

return true if found the timer at the given msg, otherwise return false

Examples

iex> timer = %ExTimer{timers: [%ExTimer.Node{msg: {:handler, :name, "uhaha"}, due_ms: 2000}]}
iex> ExTimer.exist?(timer, {:handler, :name, "uhaha"})
true

get_next_expiration(timer, min_time)

@spec get_next_expiration(t(), time_ms()) :: time_ms()

get the minimum time(milliseconds) for the timer to expired.

Examples


def handle_info({:tick}, state) do
  ...
  {state, timer} = ExTimer.update(state, state.timer)
  state = put_in(state.timer, timer)
  ...
  Process.send_after(self(), {:tick}, ExTimer.get_next_expiration(state.timer, 1000))
  {:noreply, state}
end

new(opts \\ [])

remove(timer, msg)

@spec remove(t(), timer_node_msg()) :: t()

delete the previous registerd timer.

Examples

iex> timer = %{timers: [%ExTimer.Node{msg: {:handler, :name, "uhaha"}, due_ms: 2000}]}
iex> ExTimer.remove(timer, {:handler, :name, "uhaha"})
%{timers: []}

update(state, timer)

(macro)

call the callback handler (handle_timer) for the timer that has elapsed.

Examples

def handle_timer({:tick}, state) do
  ...
  {state, timer} = ExTimer.update(state, state.timer)
  state = put_in(state.timer, timer)
  ...
  {state, timer}
end