How to use

getMethodIdentifier

method

in

org.apache.tapestry5.plastic.PlasticMethod

private EventHandlerMethodParameterProvider createQueryParameterProvider(PlasticMethod method, final int parameterIndex, final String parameterName,
                                     final String parameterTypeName, final boolean allowBlank)
  final String methodIdentifier = method.getMethodIdentifier();

  private void validateMethod(PlasticMethod method)
  {
    MethodDescription description = method.getDescription();

    if (description.returnType.equals("void"))
      throw new IllegalArgumentException(String.format(
          "Method %s may not be used with @Cached because it returns void.", method.getMethodIdentifier()));

    if (description.argumentTypes.length != 0)
      throw new IllegalArgumentException(String.format(
          "Method %s may not be used with @Cached because it has parameters.", method.getMethodIdentifier()));
  }
}

  private void validateVoid(PlasticMethod method)
  {
    if (!method.isVoid())
      throw new RuntimeException(String.format(
          "Method %s is not compatible with the @HeartbeatDeferred annotation, as it is not a void method.",
          method.getMethodIdentifier()));
  }
}

  public ComponentIdValidator map(EventHandlerMethod element)
  {
    if (element.componentId.equals(""))
    {
      return null;
    }
    return new ComponentIdValidator(element.componentId, element.method.getMethodIdentifier());
  }
}).removeNulls().toArray(ComponentIdValidator.class);

private void validateNoCheckedExceptions(PlasticMethod method)
{
  if (method.getDescription().checkedExceptionTypes.length > 0)
    throw new RuntimeException(
        String.format(
            "Method %s is not compatible with the @HeartbeatDeferred annotation, as it throws checked exceptions.",
            method.getMethodIdentifier()));
}

  public void work(PlasticMethod method)
  {
    if (!method.isVoid())
      throw new RuntimeException(String.format("Method %s is a lifecycle method and should return void.", method
          .getMethodIdentifier()));
    if (!method.getParameters().isEmpty())
      throw new RuntimeException(String.format("Method %s is a lifecycle method and should take no parameters.",
          method.getMethodIdentifier()));
  }
};

  public void work(PlasticMethod method)
  {
    boolean valid = method.isVoid() && method.getParameters().isEmpty();
    if (!valid)
    {
      throw new RuntimeException(
          String.format(
              "Method %s is invalid: methods with the @PageReset annotation must return void, and have no parameters.",
              method.getMethodIdentifier()));
    }
  }
};

return new EventHandlerMethodParameterSource(method.getMethodIdentifier(), operationTracker, providerArray);

  private void testFailure(MethodDescription description, String messageFragment)
  {
    PlasticMethod method = newMock(PlasticMethod.class);

    boolean isVoid = description.returnType.equals("void");
    expect(method.isVoid()).andReturn(isVoid);

    if (isVoid)
    {
      expect(method.getDescription()).andReturn(description).atLeastOnce();
    }

    expect(method.getMethodIdentifier()).andReturn("<MethodId>");

    replay();

    try
    {
      worker.deferMethodInvocations(method);
      unreachable();
    } catch (RuntimeException ex)
    {
      assertMessageContains(ex, messageFragment);
    }

    verify();
  }
}

private void invokeMethod(InstructionBuilder builder, PlasticMethod method)
{
  // First, tell the Event object what method is being invoked.
  builder.loadArgument(1);
  builder.loadConstant( method.getMethodIdentifier());
  builder.invoke(Event.class, void.class, "setMethodDescription", String.class);
  builder.loadThis();
  // Methods either take no parameters, or take a MarkupWriter parameter.
  if (method.getParameters().size() > 0)
  {
    builder.loadArgument(0);
  }
  builder.invokeVirtual(method);
  // Non-void methods will pass a value to the event.
  if (!method.isVoid())
  {
    builder.boxPrimitive(method.getDescription().returnType);
    builder.loadArgument(1).swap();
    builder.invoke(Event.class, boolean.class, "storeResult", Object.class);
    builder.when(Condition.NON_ZERO, JUST_RETURN);
  }
}

  public void doBuild(InstructionBuilder builder)
  {
    builder.loadArgument(0).loadConstant(method.getMethodIdentifier()).invoke(Event.class, void.class, "setMethodDescription", String.class);
    builder.loadThis();
    int count = description.argumentTypes.length;
    for (int i = 0; i < count; i++)
    {
      builder.loadThis().getField(sourceField).loadArgument(0).loadConstant(i);
      builder.invoke(EventHandlerMethodParameterSource.class, Object.class, "get",
          ComponentEvent.class, int.class);
      builder.castOrUnbox(description.argumentTypes[i]);
    }
    builder.invokeVirtual(method);
    if (!method.isVoid())
    {
      builder.boxPrimitive(description.returnType);
      builder.loadArgument(0).swap();
      builder.invoke(Event.class, boolean.class, "storeResult", Object.class);
      // storeResult() returns true if the method is aborted. Return true since, certainly,
      // a method was invoked.
      builder.when(Condition.NON_ZERO, RETURN_TRUE);
    }
    // Set the result to true, to indicate that some method was invoked.
    builder.loadConstant(true).storeVariable(resultVariable);
  }
});