Annotation Processors

/**
 * The annotation processor for siddhi extension annotation validation.
 * Validates @Extension, @Parameter, @ReturnAttribute, @SystemParameter and @Example annotations.
 * 
 * Extends javax.annotation.processing.AbstractProcessor
 */
public class SiddhiAnnotationProcessor extends AbstractProcessor {
    
    /**
     * Initialize the processor with the processing environment.
     * 
     * @param env - Processing environment providing access to facilities
     */
    public synchronized void init(ProcessingEnvironment env);
    
    /**
     * Process annotations found in the current compilation round.
     * 
     * @param annotations - Set of annotation types to process
     * @param roundEnv - Environment for information about the current round
     * @return false - This processor only validates, doesn't claim annotations
     */
    public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv);
    
    /**
     * Get the set of annotation types supported by this processor.
     * 
     * @return Set of supported annotation type names
     */
    public Set<String> getSupportedAnnotationTypes();
    
    /**
     * Get the latest source version supported by this processor.
     * 
     * @return SourceVersion.RELEASE_8
     */
    public SourceVersion getSupportedSourceVersion();
    
    /**
     * Report a build error with a message and element context.
     * 
     * @param message - Error message to display
     * @param element - Source element where error occurred
     */
    public void showBuildError(String message, Element element);
}

/**
 * Parent class for extension annotation validation processors.
 * Provides common validation patterns and regex-based validation rules.
 */
public abstract class AbstractAnnotationProcessor {
    
    /** Regex pattern for validating core package names */
    protected static final Pattern CORE_PACKAGE_PATTERN; // ^org.wso2.siddhi.core.
    
    /** Regex pattern for validating parameter names in dot notation */
    protected static final Pattern PARAMETER_NAME_PATTERN; // ^[a-z][a-z0-9]*(\\.[a-z][a-z0-9]*)*$
    
    /** Regex pattern for validating camelCase naming convention */
    protected static final Pattern CAMEL_CASE_PATTERN; // ^(([a-z][a-z0-9]+)([A-Z]{0,1}[a-z0-9]*)*)$
    
    /** Full name of the extension class being validated */
    protected String extensionClassFullName;
    
    /**
     * Constructor for annotation processor.
     * 
     * @param extensionClassFullName - Full name of extension class
     */
    public AbstractAnnotationProcessor(String extensionClassFullName);
    
    /**
     * Basic @Extension annotation elements validation.
     * 
     * @param name - Extension name to validate
     * @param description - Extension description to validate  
     * @param namespace - Extension namespace to validate
     * @throws AnnotationValidationException - When validation rules are violated
     */
    public void basicParameterValidation(String name, String description, String namespace) 
            throws AnnotationValidationException;
    
    /**
     * Validate @Extension parameter definitions.
     * 
     * @param parameters - Parameter array to validate
     * @throws AnnotationValidationException - When validation rules are violated
     */
    public void parameterValidation(Parameter[] parameters) throws AnnotationValidationException;
    
    /**
     * Validate @Extension return attribute definitions.
     * 
     * @param returnAttributes - Return attributes array to validate
     * @throws AnnotationValidationException - When validation rules are violated
     */
    public void returnAttributesValidation(ReturnAttribute[] returnAttributes) 
            throws AnnotationValidationException;
    
    /**
     * Validate @Extension system parameter definitions.
     * 
     * @param systemParameters - System parameters array to validate
     * @throws AnnotationValidationException - When validation rules are violated
     */
    public void systemParametersValidation(SystemParameter[] systemParameters) 
            throws AnnotationValidationException;
    
    /**
     * Validate @Extension example definitions.
     * 
     * @param examples - Examples array to validate
     * @throws AnnotationValidationException - When validation rules are violated
     */
    public void examplesValidation(Example[] examples) throws AnnotationValidationException;
}

/**
 * Validation processor for Function Executor extensions.
 * Enforces function-specific rules including single return attribute and no dynamic parameters.
 */
public class FunctionExecutorValidationAnnotationProcessor extends AbstractAnnotationProcessor {
    
    public FunctionExecutorValidationAnnotationProcessor(String extensionClassFullName);
    
    /**
     * Override parameter validation to disallow dynamic parameters.
     * Dynamic parameters are only allowed for Sink and SinkMapper extensions.
     */
    @Override
    public void parameterValidation(Parameter[] parameters) throws AnnotationValidationException;
    
    /**
     * Override return attribute validation to enforce single return attribute with empty name.
     * Function executors must have exactly one return attribute without a name.
     */
    @Override
    public void returnAttributesValidation(ReturnAttribute[] returnAttributes) 
            throws AnnotationValidationException;
}

/**
 * Validation processors for specific extension types, each with custom rules:
 */

// Sink extensions
public class SinkValidationAnnotationProcessor extends AbstractAnnotationProcessor;

// SinkMapper extensions  
public class SinkMapperValidationAnnotationProcessor extends AbstractAnnotationProcessor;

// Source extensions
public class SourceValidationAnnotationProcessor extends AbstractAnnotationProcessor;

// SourceMapper extensions
public class SourceMapperValidationAnnotationProcessor extends AbstractAnnotationProcessor;

// AggregationAttribute extensions
public class AggregationAttributeValidationAnnotationProcessor extends AbstractAnnotationProcessor;

// StreamProcessor extensions
public class StreamProcessorValidationAnnotationProcessor extends AbstractAnnotationProcessor;

// StreamFunctionProcessor extensions
public class StreamFunctionProcessorValidationAnnotationProcessor extends AbstractAnnotationProcessor;

// WindowProcessor extensions
public class WindowProcessorValidationAnnotationProcessor extends AbstractAnnotationProcessor;

// Store extensions
public class StoreValidationAnnotationProcessor extends AbstractAnnotationProcessor;

// DistributionStrategy extensions
public class DistributionStrategyValidationAnnotationProcessor extends AbstractAnnotationProcessor;

// Script extensions
public class ScriptValidationAnnotationProcessor extends AbstractAnnotationProcessor;

// IncrementalAggregationAttribute extensions
public class IncrementalAggregationAttributeValidationAnnotationProcessor extends AbstractAnnotationProcessor;

org.wso2.siddhi.annotation.processor.SiddhiAnnotationProcessor
org.atteo.classindex.processor.ClassIndexProcessor

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-compiler-plugin</artifactId>
    <configuration>
        <!-- Processors run automatically unless disabled -->
        <compilerArgument>-proc:none</compilerArgument> <!-- To disable -->
    </configuration>
</plugin>

The @Extension -> name annotated in class com.example.MyExtension is null or empty.

The @Extension -> @Parameter -> name 'InvalidName' annotated in class com.example.MyExtension is not in proper format 'abc.def.ghi'.

Only one @Extension -> @ReturnAttribute can be annotated in class com.example.MyFunction.

The @Extension -> @Parameter -> name:param -> dynamic property cannot be true annotated in class com.example.MyProcessor. Only classes extending Sink and SinkMapper can have dynamic parameters.