/**这是你实现的类；这里的架构来自OC的API。*/
@Architecture.Name("Pseudolang")
public class PseudoArchitecture implements Architecture {
  private final Machine machine;

  private PseudoVM vm;

  /**构造函数的签名必须与此处完全一致。*/
  public PseudoArchitecture(Machine machine) {
    this.machine = machine;
  }

  public boolean isInitialized() { return true; }

  public void recomputeMemory() {}

  public boolean initialize() {
    //在此处新建虚拟机，并在里面注册你想要的所有API回调函数。
    vm = new PseudoVM();
    vm.setApiFunction("invoke", new PseudoNativeFunction() {
      public Object invoke(Object[] args) {
        final String address = (String)args[0];
        final String method = (String)args[1];
        final Object[] params = (Object[])args[2];
        try {
          return new Object[]{true, machine.invoke(address, method, params)};
        }
        catch (e LimitReachedException) {
          //这里的执行逻辑也可用于休眠/执行同步调用。
          //在此样例中我们遵循这样的协议：
          //成功时返回(true,某物)，到达上限时返回(false)。
          //此后虚拟机中运行的脚本需要将控制权交还给
          //初始化了当前执行的任务的调用者（例如，若支持的话
          //可以yield，或者在事件驱动的系统中直接return）
          return new Object[]{false};
        }
      }
    });
    vm.setApiFunction("isDirect", new PseudoNativeFunction() {
      public Object invoke(Object[] args) {
        final String address = (String)args[0];
        final String method = (String)args[1];
        final Node node = machine.node().network().node(address);
        if (node instanceof Component) {
          final Component component = (Component) node;
          if (component.canBeSeenFrom(machine.node())) {
            final Callback callback = machine.methods(node.host()).get(method);
            if (callback != null) {
              return callback.direct();
            }
          }
        }
        return false;
      }
    });
    // ... 更多回调。
    return true;
  }

  void close() {
    vm = null;
  }

  ExecutionResult runThreaded(boolean isSynchronizedReturn) {
    //在此处执行所需步骤。通常你会希望通过将队列中下一个信号传递给
    //虚拟机的方式来唤醒它，但你也可能会选择让你的虚拟机手动拉取信号。
    try {
      final Signal signal;
      if (isSynchronizedReturn) {
        //正在从同步调用中返回时不要拉取信号！因为我们正在执行其他事情。
        signal = null;
      }
      else {
        signal = machine.popSignal();
      }
      final Object[] result;
      if (signal != null) {
        result = vm.run(new Object[]{signal.name(), signal.args()});
      }
      else {
        result = vm.run(null);
      }

      //你可能会想定义一些内部协议，用以决定何时执行同步调用。
      //假设我们希望虚拟机在出现待决定的同步调用时返回数字值，代表休眠
      //或者返回布尔值，代表关机/重启或其他东西。
      if (result != null) {
        if (result[0] instanceof Boolean) {
          return new ExecutionResult.Shutdown((Boolean)result[0]);
        }
        if (result[0] instanceof Integer) {
          return new ExecutionResult.Sleep((Integer)result[0]);
        }
      }
      //若返回此值，下次'resume'时会调用runSynchronized。
      //此次调用后的下次对runThreaded函数的调用中
      //isSynchronizedReturn参数将会设定为true。
      return new ExecutionResult.SynchronizedCall();
    }
    catch (Throwable t) {
      return new ExecutionResult.Error(t.toString);
    }
  }

  void runSynchronized() {
    //同步调用在MC的服务端线程中执行，让回调与世界交互更方便
    //（因为它们之间的同步由执行机/架构完成）
    //这意味着若虚拟机中的代码开始了一次同步调用，就需要*暂停*
    //并且放弃对主机的控制，然后我们切换到同步调用模式（参看runThreaded），
    //并等待MC服务端线程，接着再进行实际的调用。
    //可以在runThread中传递调用所需的信息，将其存储在架构中，
    //然后在此处直接进行调用。
    //对此样例而言，让我们假定状态信息存储于虚拟机内部，并且
    //下次resume使其进行*实际*调用。下面给出了处理它们的伪代码。
    vm.run(null);
  }

  void onConnect() {}

  //用这行代码加载虚拟机状态，假如虚拟机可持续。
  void load(NBTTagCompound nbt) {}

  //用这行代码保存虚拟机状态，假如虚拟机可持续。
  void save(NBTTagCompound nbt) {}
}