Package io.quarkus.qute

Annotation Type TemplateExtension

  • @Retention(RUNTIME)
@Target({METHOD,TYPE})
public @interface TemplateExtension
    Instructs a fully integrated environment 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 Detail

      • METHOD_NAME

        static final String METHOD_NAME
        Constant value for matchName() indicating that the method name should be used.

      • ANY

        static final String ANY
        Constant value for matchName() indicating that any name matches.

      • DEFAULT_PRIORITY

        static final int DEFAULT_PRIORITY
        Constant value for {priority().

    • Element Detail

      • 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:
        NamespaceResolver.getNamespace()
        Default:
        ""