Package io.quarkus.qute

Annotation Interface TemplateExtension

@Retention(RUNTIME) @Target({METHOD,TYPE}) public @interface TemplateExtension

IMPORTANT: This annotation only works in a fully integrated environment; such as a Quarkus application.

Instructs to generate a ValueResolver for a method annotated with this annotation.

If declared on a class a value resolver is generated for every non-private static method declared on the class. Method-level annotations override the behavior defined on the class. Methods that do not meet the following requirements are ignored.

A template extension method:

  • must not be private,
  • must be static,
  • must not return void.
If there is no namespace defined the class of the first parameter that is not annotated with TemplateExtension.TemplateAttribute is used to match the base object. Otherwise the namespace is used to match an expression. 
 @TemplateExtension
 static BigDecimal discountedPrice(Item item) {
    // this method matches {item.discountedPrice} if "item" resolves to an object assignable to "Item"
    return item.getPrice().multiply(new BigDecimal("0.9"));
 }

Matching by name

By default, the method name is used to match the expression property/method name. However, it is possible to specify the matching name with matchName(). 
 @TemplateExtension(matchName = "discounted")
 static BigDecimal discountedPrice(Item item) {
    // this method matches {item.discounted} if "item" resolves to an object assignable to "Item"
    return item.getPrice().multiply(new BigDecimal("0.9"));
 }
A special constant - ANY - can be used to specify that the extension method matches any name. In this case, an additional string method parameter must be used to pass the property name. 
 @TemplateExtension(matchName = "*")
 static String itemProperty(Item item, String name) {
    // this method matches {item.foo} if "item" resolves to an object assignable to "Item"
    // the value of the "name" argument is "foo"
 }
It is also possible to match the name against a regular expression specified in matchRegex(). Again, an additional string method parameter must be used to pass the property name. 
 @TemplateExtension(matchRegex = "foo|bar")
 static String itemProperty(Item item, String name) {
    // this method matches {item.foo} and {item.bar} if "item" resolves to an object assignable to "Item"
    // the value of the "name" argument is "foo" or "bar"
 }
Finally, matchNames() can be used to specify a collection of matching names. An additional string method parameter is mandatory as well. 
 @TemplateExtension(matchNames = {"foo", "bar"})
 static String itemProperty(Item item, String name) {
    // this method matches {item.foo} and {item.bar} if "item" resolves to an object assignable to "Item"
    // the value of the "name" argument is "foo" or "bar"
 }
Superfluous matching conditions are ignored. The conditions sorted by priority in descending order are: matchRegex(), matchNames() and matchName().

  • Field Details

  • Element Details

    • matchName

      String matchName
      Returns:
      the name is used to match the property name
      Default:
      "<<method name>>"

    • matchNames

      String[] matchNames
      Returns:
      the list of names used to match the property name
      Default:
      {}

    • matchRegex

      String matchRegex
      Returns:
      the regex is used to match the property name
      Default:
      ""

    • priority

      int priority
      Returns:
      the priority used by the generated value resolver
      Default:
      5

    • namespace

      String namespace
      If not empty a namespace resolver is generated instead.

      Template extension methods that share the same namespace and are declared on the same class are grouped in one resolver and ordered by priority(). The first matching extension method is used to resolve an expression. Template extension methods declared on different classes cannot share the same namespace.

      Returns:
      the namespace
      See Also:
      Default:
      ""