110 lines
2.6 KiB
Elixir
110 lines
2.6 KiB
Elixir
defmodule Scopes.CSys.Program do
|
|
alias Scopes.CSys
|
|
alias Scopes.Shape
|
|
|
|
defmodule State do
|
|
defstruct [:value, :threshold, :stage, :prog]
|
|
end
|
|
|
|
def prepare(prog, args) do
|
|
state = %State{
|
|
value: args[:value],
|
|
threshold: args[:threshold],
|
|
stage: :initial,
|
|
prog: prog
|
|
}
|
|
{state, get_proc(state)}
|
|
end
|
|
|
|
def get_proc(state) do
|
|
get_proc(elem(state.prog, 0), state.stage)
|
|
end
|
|
|
|
defp get_proc(stages, stage) do
|
|
stages[stage] || stages[:default]
|
|
end
|
|
|
|
# basic program
|
|
|
|
def basic_prog() do
|
|
default = &basic_active/2
|
|
stages = %{
|
|
default: default,
|
|
initial: &basic_initial/2,
|
|
active: default,
|
|
retired: default
|
|
}
|
|
transitions = %{
|
|
restart: :initial,
|
|
retire: :retired,
|
|
next: [initial: :active, active: :retired]
|
|
}
|
|
{stages, transitions}
|
|
end
|
|
|
|
def prepare_basic(args \\ [value: 0, threshold: 0]) do
|
|
prepare(basic_prog(), args)
|
|
end
|
|
|
|
# basic processors
|
|
|
|
def basic_initial(msg, scope) do
|
|
basic(msg, scope)
|
|
end
|
|
|
|
def basic_active(msg, scope) do
|
|
basic(msg, scope)
|
|
end
|
|
|
|
def basic(msg, scope) do
|
|
case Shape.head(msg) do
|
|
[:csys, :set | _rest] -> set(msg, scope)
|
|
#[:csys, :data | rest] -> process_data(rest, Shape.data(msg), scope)
|
|
[:csys, :connect | _rest] -> CSys.connect(msg, scope)
|
|
[:csys, :create, :succ | _rest] -> create_succ(msg, scope)
|
|
[:csys, :create, :pred | _rest] -> create_pred(msg, scope)
|
|
#[:csys, :next | _rest] -> next(scope, meta)
|
|
#[:csys, action | rest] -> transition(action, scope)
|
|
_ -> CSys.forward(msg, scope) || CSys.notify(msg, scope)
|
|
end
|
|
end
|
|
|
|
# message handlers // proc steps
|
|
|
|
def set(msg, scope) do
|
|
data = Shape.data(msg)
|
|
state = CSys.state(scope)
|
|
value = data[:value] || state.value
|
|
threshold = data[:threshold] || state.threshold
|
|
state_n = %{state | value: value, threshold: threshold}
|
|
CSys.update(put_elem(scope, 0, state_n))
|
|
end
|
|
|
|
def create_succ(msg, scope) do
|
|
new = CSys.create(msg, restart(scope))
|
|
data = Shape.data(msg)
|
|
CSys.send_message(self(), [:csys, :connect], Map.put(data, :target, new))
|
|
end
|
|
|
|
def create_pred(msg, scope) do
|
|
new = CSys.create(msg, restart(scope))
|
|
data = Shape.data(msg)
|
|
CSys.send_message(new, [:csys, :connect], Map.put(data, :target, self()))
|
|
end
|
|
|
|
# synapse operations
|
|
|
|
def negate() do
|
|
fn msg ->
|
|
value = Shape.data(msg)[:value] || 0
|
|
Shape.create(Shape.head(msg), data: %{Shape.data(msg) | value: -value})
|
|
end
|
|
end
|
|
|
|
# helper functions
|
|
|
|
def restart({state, _proc, syns, env}) do
|
|
state_n = %{state | stage: :initial}
|
|
{state_n, get_proc(state_n), syns, env}
|
|
end
|
|
end
|