or run

npx @tessl/cli init
Log in

Version

Tile

Overview

Evals

Files

docs

annotation-processors.mdcore-annotations.mdindex.mdutility-classes.md
tile.json

tessl/maven-org-wso2-siddhi--siddhi-annotations

Annotation support for the Siddhi Complex Event Processing Engine, providing extension definitions and validation for stream processors, functions, aggregations, and other extension types.

Workspace
tessl
Visibility
Public
Created
Last updated
Describes
mavenpkg:maven/org.wso2.siddhi/siddhi-annotations@4.5.x

To install, run

npx @tessl/cli install tessl/maven-org-wso2-siddhi--siddhi-annotations@4.5.0

index.mddocs/

Siddhi Annotations

Siddhi Annotations provides comprehensive annotation support for the Siddhi Complex Event Processing Engine, enabling developers to define and validate custom extensions through a standardized annotation framework. It includes core annotations for marking Siddhi extensions, compile-time validation processors, and runtime discovery mechanisms through ClassIndex integration.

Package Information

  • Package Name: siddhi-annotations
  • Package Type: maven
  • Language: Java
  • Installation: 
    <dependency>
  <groupId>org.wso2.siddhi</groupId>
  <artifactId>siddhi-annotations</artifactId>
  <version>4.5.11</version>
</dependency>

Core Imports

import org.wso2.siddhi.annotation.Extension;
import org.wso2.siddhi.annotation.Parameter;
import org.wso2.siddhi.annotation.ReturnAttribute;
import org.wso2.siddhi.annotation.SystemParameter;
import org.wso2.siddhi.annotation.Example;
import org.wso2.siddhi.annotation.util.DataType;

Basic Usage

import org.wso2.siddhi.annotation.*;
import org.wso2.siddhi.annotation.util.DataType;

@Extension(
    name = "sum",
    namespace = "math",
    description = "Calculates the sum of numeric values.",
    parameters = {
        @Parameter(name = "value", 
                  type = {DataType.INT, DataType.LONG, DataType.DOUBLE}, 
                  description = "Numeric value to be summed")
    },
    returnAttributes = @ReturnAttribute(
        name = "sum", 
        type = {DataType.LONG, DataType.DOUBLE}, 
        description = "Sum of the numeric values"
    ),
    examples = @Example(
        syntax = "from inputStream#math:sum(value) select sum insert into outputStream;",
        description = "This calculates the sum of 'value' from inputStream."
    )
)
public class SumFunction extends FunctionExecutor {
    // Implementation details
}

Architecture

The Siddhi Annotations framework is built around several key components:

  • Core Annotations: Five primary annotations (@Extension, @Parameter, @ReturnAttribute, @SystemParameter, @Example) that define extension metadata
  • Validation Framework: Compile-time annotation processors that validate extension definitions against Siddhi's requirements
  • Type System: DataType enum providing standardized type definitions for parameters and return values
  • Runtime Discovery: ClassIndex integration enabling automatic discovery of annotated extensions
  • Extension Types: Support for 11+ different Siddhi extension types with specific validation rules

Capabilities

Core Annotations

Primary annotations for marking and describing Siddhi extensions, including the main @Extension annotation and supporting annotations for parameters, return attributes, system parameters, and usage examples.

@interface Extension {
    String name() default "";
    String namespace() default "";
    String description() default "";
    Parameter[] parameters() default {};
    SystemParameter[] systemParameter() default {};
    ReturnAttribute[] returnAttributes() default {};
    Example[] examples() default {};
}

Core Annotations

Annotation Processors

Compile-time validation framework that ensures extension annotations comply with Siddhi's requirements, with specialized processors for different extension types and comprehensive validation rules.

public class SiddhiAnnotationProcessor extends AbstractProcessor {
    public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv);
}

public abstract class AbstractAnnotationProcessor {
    protected void basicParameterValidation(String name, String description, String namespace) throws AnnotationValidationException;
    protected void parameterValidation(Parameter[] parameters) throws AnnotationValidationException;
    protected void returnAttributesValidation(ReturnAttribute[] returnAttributes) throws AnnotationValidationException;
}

Annotation Processors

Utility Classes

Supporting classes including data type definitions, validation exceptions, and constants for extension superclasses and namespaces.

public enum DataType {
    STRING, INT, LONG, FLOAT, DOUBLE, BOOL, OBJECT, TIME
}

public class AnnotationValidationException extends Exception {
    public AnnotationValidationException(String message);
    public AnnotationValidationException(String message, Throwable throwable);
    public AnnotationValidationException(Throwable throwable);
}

Utility Classes

Types

Core Annotation Types

@interface Parameter {
    String name() default "";
    DataType[] type() default {};
    String description() default "";
    boolean optional() default false;
    boolean dynamic() default false;
    String defaultValue() default "";
}

@interface ReturnAttribute {
    String name() default "";
    DataType[] type() default {};
    String description() default "";
}

@interface SystemParameter {
    String name() default "";
    String description() default "";
    String defaultValue() default "";
    String[] possibleParameters() default {};
}

@interface Example {
    String syntax() default "";
    String description() default "";
}