How to use

Reflection$Arg

in

php.runtime.annotation

@Override
@Signature({@Arg("offset"), @Arg("value")})
synchronized public Memory offsetSet(Environment env, Memory... args) {
  userEnv.put(args[0].toString(), args[1].toString());
  return Memory.NULL;
}

if (!arg.value().isEmpty()) {
  param.setName(arg.value());
param.setType(arg.type());
param.setReference(arg.reference());
if (arg.nativeType() != IObject.class) {
  param.setTypeNativeClass(arg.nativeType());
if (!arg.typeClass().isEmpty()) {
  param.setTypeClass(arg.typeClass());
if (arg.optional().exists()
    || !arg.optional().value().isEmpty()
    || (arg.type() != HintType.STRING && !arg.optional().value().isEmpty())){
  param.setDefaultValue(MemoryUtils.valueOf(arg.optional().value(), arg.optional().type()));

@Signature
public static void setOut(Environment env, @Arg(typeClass = "php\\io\\Stream", nullable = true) Memory stream)
    throws UnsupportedEncodingException {
  setOut(env, stream, Memory.NULL);
}

@Signature
public PMarkdownOptions addSuperscriptExtension(@Arg(type = HintType.ARRAY) @Optional("null") Memory options) {
  parserExtensions.add(SuperscriptExtension.create());
  Memory htmlOpen = options.valueOfIndex("htmlOpen");
  if (htmlOpen.isNotNull()) {
    this.options.set(SuperscriptExtension.SUPERSCRIPT_STYLE_HTML_OPEN, htmlOpen.toString());
  }
  Memory htmlClose = options.valueOfIndex("htmlClose");
  if (htmlOpen.isNotNull()) {
    this.options.set(SuperscriptExtension.SUPERSCRIPT_STYLE_HTML_CLOSE, htmlClose.toString());
  }
  return this;
}

@Signature(@Arg("name"))
public Memory addFunction(Environment env, Memory... args) {
  return pkg.addFunction(args[0].toString()) ? Memory.TRUE : Memory.FALSE;
}

@Signature(@Arg("name"))
public Memory addConstant(Environment env, Memory... args) {
  return pkg.addConstant(args[0].toString()) ? Memory.TRUE : Memory.FALSE;
}

@Override
@Signature(value = @Arg("offset"), result = @Arg(type = HintType.BOOLEAN))
synchronized public Memory offsetExists(Environment env, Memory... args) {
  return userEnv.containsKey(args[0].toString()) ? Memory.TRUE : Memory.FALSE;
}

@Signature({
    @Arg("name"),
    @Arg(value = "def", optional = @Optional(""))
})
public static Memory getProperty(Environment env, Memory... args) {
  return StringMemory.valueOf(System.getProperty(args[0].toString(), args[1].toString()));
}

@Signature(@Arg("moduleName"))
public Memory __construct(Environment env, Memory... args) {
  __wrappedObject = new SourceMap(args[0].toString());
  return Memory.NULL;
}

@Override
@Signature({@Arg("offset"), @Arg("value")})
public Memory offsetSet(Environment environment, Memory... memories) {
  throw new UnsupportedOperationException();
}

@Signature({
    @Arg("sourceLine"),
})
public Memory getCompiledLine(Environment env, Memory... args) {
  int sourceLine = getWrappedObject().getCompiledLine(args[0].toInteger());
  return LongMemory.valueOf(sourceLine);
}

@Signature
private void makeReject(Environment env, @Arg(typeClass = "Throwable") Memory error) throws Exception {
  if (this.state != State.PENDING) {
    throw new IllegalStateException("This promise is already resolved, and you\'re not allowed to resolve a promise more than once");
  }
  this.state = State.REJECTED;
  this.value = error;
  for (Subscriber subscriber : subscribers) {
    this.invokeCallback(env, subscriber.subPromise, subscriber.onRejected);
  }
}

@Signature(@Arg(value = "names", type = HintType.ARRAY))
public Memory addClasses(Environment env, Memory... args) {
  for (Memory one : args[0].toValue(ArrayMemory.class)) {
    pkg.addClass(one.toString());
  }
  return Memory.NULL;
}

  @Signature
  public void __construct(Environment env, OutputStream outputStream, @Nullable @Arg(type = ARRAY) Memory parameters)
      throws IOException {
    if (parameters.isNull()) {
      this.outputStream = new GzipCompressorOutputStream(outputStream);
    } else {
      this.outputStream = new GzipCompressorOutputStream(
          outputStream, parameters.toValue(ArrayMemory.class).toBean(env, GzipParameters.class)
      );
    }
  }
}

  @Signature(@Arg(value = "names", type = HintType.ARRAY))
  public Memory addConstants(Environment env, Memory... args) {
    for (Memory one : args[0].toValue(ArrayMemory.class)) {
      pkg.addConstant(one.toString());
    }

    return Memory.NULL;
  }
}

@Signature
public PMarkdownOptions addSubscriptExtension(@Arg(type = HintType.ARRAY) @Optional("null") Memory options) {
  parserExtensions.add(SubscriptExtension.create());
  Memory htmlOpen = options.valueOfIndex("htmlOpen");
  if (htmlOpen.isNotNull()) {
    this.options.set(SubscriptExtension.SUBSCRIPT_STYLE_HTML_OPEN, htmlOpen.toString());
  }
  Memory htmlClose = options.valueOfIndex("htmlClose");
  if (htmlOpen.isNotNull()) {
    this.options.set(SubscriptExtension.SUBSCRIPT_STYLE_HTML_CLOSE, htmlClose.toString());
  }
  return this;
}

@Signature({
    @Arg("sourceLine"),
    @Arg("compiledLine")
})
public Memory addLine(Environment env, Memory... args) {
  getWrappedObject().addLine(args[0].toInteger(), args[1].toInteger());
  return Memory.NULL;
}

@Signature(@Arg(value = "flags", optional = @Optional("0")))
public Memory __construct(Environment env, Memory... args) {
  DumperOptions options = new DumperOptions();
  int flags = args[0].toInteger();
  options.setPrettyFlow((flags & SERIALIZE_PRETTY_FLOW) == SERIALIZE_PRETTY_FLOW);
  options.setDefaultFlowStyle((flags & SERIALIZE_PRETTY_FLOW) == SERIALIZE_PRETTY_FLOW ? DumperOptions.FlowStyle.BLOCK : DumperOptions.FlowStyle.AUTO);
  options.setCanonical((flags & SERIALIZE_CANONICAL) == SERIALIZE_CANONICAL);
  options.setExplicitStart((flags & SERIALIZE_EXPLICIT_START) == SERIALIZE_EXPLICIT_START);
  options.setExplicitEnd((flags & SERIALIZE_EXPLICIT_END) == SERIALIZE_EXPLICIT_END);
  options.setSplitLines(!((flags & SERIALIZE_NOT_SPLIT_LINES) == SERIALIZE_NOT_SPLIT_LINES));
  yaml = new Yaml(options);
  return Memory.NULL;
}

@Signature(@Arg(value = "value", optional = @Reflection.Optional("null")))
public Memory __construct(Environment env, Memory... args) {
  this.local = new ThreadLocal<Memory>() {
    @Override
    protected Memory initialValue() {
      return args[0];
    }
  };
  return Memory.NULL;
}

@Signature(@Arg("name"))
public Memory hasConstant(Environment env, Memory... args) {
  return pkg.hasConstant(args[0].toString()) ? Memory.TRUE : Memory.FALSE;
}