68 lines
1.9 KiB
Elixir
68 lines
1.9 KiB
Elixir
defmodule Scopes.CSys.Environ do
|
|
|
|
alias Scopes.CSys
|
|
alias Scopes.Shape
|
|
|
|
defmodule State do
|
|
defstruct [neurons: [], cells: %{}, init_seq: []]
|
|
end
|
|
|
|
def setup({state, proc}, seq \\ []) do
|
|
scope = {%State{init_seq: seq}, &proc_env/2, [], self()}
|
|
env = CSys.neuron(scope)
|
|
CSys.create(Shape.create([:csys, :zero], data: %{addr: [:csys, :c00, {0, 0}]}),
|
|
{state, proc, [], env})
|
|
env
|
|
end
|
|
|
|
def proc_env(msg, scope = {state, _proc, _syns, env}) do
|
|
case Shape.head(msg) do
|
|
{:exec, func} -> func.(state)
|
|
[:csys, :created | _rest] ->
|
|
process_creation(msg, scope)
|
|
send(env, msg)
|
|
[dom, :for, cat, item] ->
|
|
#IO.inspect(CSys.state(scope).cells)
|
|
cell = get_in(state.cells, [{dom, cat}, item])
|
|
CSys.send_message(cell, [dom, :data], Shape.data(msg))
|
|
_ -> send(env, msg) # forward message to application
|
|
end
|
|
end
|
|
|
|
def process_creation(msg, {state, proc, syns, env}) do
|
|
data = Shape.data(msg)
|
|
new = data.new
|
|
addr = data[:addr]
|
|
cells = if addr do
|
|
[dom, cat, item] = addr
|
|
Map.update(state.cells, {dom, cat}, %{item => new},
|
|
fn x -> Map.put(x, item, new) end)
|
|
else
|
|
state.cells
|
|
end
|
|
neurons = [new | state.neurons]
|
|
{step, seq} = List.pop_at(state.init_seq, 0)
|
|
state1 = %State{neurons: neurons, cells: cells, init_seq: seq}
|
|
CSys.update({state1, proc, syns, env})
|
|
if step do
|
|
Process.sleep(1)
|
|
step.(state1)
|
|
end
|
|
end
|
|
|
|
def send_message(state, [dom, cat, item], head, data) do
|
|
cell = get_in(state.cells, [{dom, cat}, item])
|
|
CSys.send_message(cell, head, data)
|
|
end
|
|
|
|
# delegating tasks to env
|
|
|
|
def delegate(env, func) do
|
|
CSys.send_message(env, {:exec, func})
|
|
end
|
|
|
|
def forward_value(env, addr, value) do
|
|
delegate(env, &send_message(&1, addr, ~w(csys data)a, %{value: value}))
|
|
#CSys.send_message(env, [dom, :for, cat, item], %{value: value})
|
|
end
|
|
end
|