persistable sclass G22NetworkElement > MetaWithChangeListeners {

  // network element belongs to

  settable G22Network network;

  // position in visual representation

  settable Rect bounds;

  // identifier in network (optional)

  settableWithVar S identifier;

  // script code to adapt element and to create instance

  settableWithVar S code;

  // general properties map depending on element type

  Map properties = syncMap();

  // Is code panel visible in GUI

  settableWithVar bool codeVisible = true;

  {

    onChange(-> { network?.change(); });

  }

  class Port extends MetaWithChangeListeners is IUnstructured {

    // position on element's border (0 to 1, 0 to 1)

    settableWithVar DoublePt position;

    // name of port within element

    settableWithVar S name;

    // cable attached to this port (optional)

    settableWithVar G22NetworkCable cable;

    // is it output or input?

    settableWithVar bool isOutput;

    // type of object sent through port

    settableWithVar Class dataType;

    G22NetworkElement element() { ret G22NetworkElement.this; }

    toString {

      ret (isOutput ? "Output" : "Input") + " port"

        + " " + quote(name) + " of type " + shortClassName(dataType);

    }

    Rect bounds() {

      int size = 10;

      Rect r = element().bounds;

      if (r == null) null;

      r = growRectTopAndLeft(r, size);

      ret rect(r.x+iround(position.x*r.w),

        r.y+iround(position.y*r.h),

        size, size);

    }

    void delete() {

      disconnect();

      ports.remove(this);

      change();

    }

    void disconnect {

      cable?.remove();

    }

    bool isConnected() { ret cable != null; }

    public void _doneLoading {

      onChange(-> element().change());

    }

  }

  L<Port> ports = syncL();

  LASCompileResult newCompileResult() { ret new LASCompileResult; }

  transient LASCompileResult compileResult;

  LASCompileResult compile(G22Utils g22utils) {

    S code = unnull(this.code);

    //if (code == null) null;

    var cr = compileResult;

    if (cr != null && eq(cr.script, code)) ret cr;

    cr = newCompileResult();

    var parser = g22utils.leftArrowParser();

    configureParser(parser);

    cr.script(code).parser(parser).compile();

    ret compileResult = cr;

  }

  void configureParser(GazelleV_LeftArrowScriptParser parser) {

    parser.addVar("blueprint");

    parser.addVar("instance");

  }

  GazelleV_LeftArrowScript.Script compileScript(G22Utils g22utils) {

    var compiled = compile(g22utils);

    if (compiled == null) null;

    if (!compiled.runnable()) null;

    ret compiled!;

  }

  void configureBlueprint(G22Utils g22utils) {  

    var script = compileScript(g22utils);

    if (script == null) ret;

    new FlexibleVarContext ctx;

    var f = script.getFunction("configure");

    if (f != null)

      f.call(ctx, this);

  }

  O makeInstance(G22Utils g22utils, G22NetworkInstance networkInstance) {

    var script = compileScript(g22utils);

    if (script == null) null;

    new FlexibleVarContext ctx;

    for (port : ports)

      if (!port.isOutput() && port.cable != null) {

        var outputPort = port.cable.from;

        if (outputPort != null)

          ctx.set(port.name, networkInstance.getObjectForBlueprint(outputPort.element()));

      }

    ret script.get(ctx);

  }

  // Nodes that we directly depend on

  Set<G22NetworkElement> upstreamNodes() {

    new Set<G22NetworkElement> set;

    for (port : ports)

      if (!port.isOutput() && port.cable != null) {

        var outputPort = port.cable.from;

        if (outputPort != null)

          set.add(outputPort.element());

      }

    ret set;

  }

  // Nodes that directly depend on this one  

  Set<G22NetworkElement> downstreamNodes() {

    new Set<G22NetworkElement> set;

    for (port : ports)

      if (port.isOutput() && port.cable != null) {

        var outputPort = port.cable.to;

        if (outputPort != null)

          set.add(outputPort.element());

      }

    ret set;

  }

  toString { ret or2(identifier(), "Unnamed element"); }

  Port getPort(S name) {

    ret firstThat(ports, p -> eq(p.name, name));

  }

  void addPort(Port port) {

    port.onChange(l0 change);

    ports.add(port);

  }

  void addPort aka addSlot(S name, DoublePt etc position) {

    printFunctionCall("addPort", +name, +position);

    Port p = getPort(name);

    if (p != null) ret;

    addPort(new Port().name(name).position(position));

    change();

  }

  void addInputPort(S name, DoublePt etc position, Class type) {

    Port p = getPort(name);

    if (p != null) ret;

    addPort(new Port().name(name).position(position)

      .isOutput(false).dataType(type));

    change();

  }

  void addOutputPort(S name, DoublePt etc position, Class type) {

    Port p = getPort(name);

    if (p != null) ret;

    p = new Port().name(name).position(position)

      .isOutput(true).dataType(type);

    addPort(p);

    print("Made port " + p);

    change();

  }

  void removePorts aka deletePorts aka removeSlots aka deleteSlots() {

    while (nempty(ports))

      last(ports).delete();

  }

  void removeOutputPorts {

    for (p : filter(ports, p -> p.isOutput()))

      p.delete();

  }

  void removeInputPorts {

    for (p : antiFilter(ports, p -> p.isOutput()))

      p.delete();

  }

  L<Port> ports() { ret cloneList(ports); }

  // key and value must be persistable!

  void setProperty(O key, O value) { properties.put(key, value); change(); }

  O getProperty(O key) { ret properties.get(key); }

  void autoCreateOutputPort(G22NetworkInstance.Value myValue) {

    if (myValue == null) ret;

    removeOutputPorts();

    O o = myValue.object();

    Class type = or(_getClass(o), O);

    addOutputPort("output", 1, 0.5, type);

  }

  void autoCreateInputPorts(G22Utils g22utils) {

    removeInputPorts();

    var script = compile(g22utils)!;

    int n = l(script.params);

    int i = 0;

    fOr (name, valueDescriptor : script.params) {

      double y = doubleRatio(++i, (n+1));

      addInputPort(name, 0, y, or(valueDescriptor.javaClass(), O));

    }

  }

  selfType defaultName(S name) {

    if (empty(identifier()))

      identifier(name);

    this;

  }

}