How to use

getElements

method

in

org.wso2.siddhi.query.api.annotation.Annotation

if (annotation != null) {
  Element element = null;
  for (Element aElement : annotation.getElements()) {
    if (elementName == null) {
      if (aElement.getKey() == null) {

/**
 * Traverse annotations and returns the name
 *
 * @param annotations
 * @return
 */
private static String getName(List<Annotation> annotations) {
  String name = UUID.randomUUID().toString();
  if (annotations != null) {
    for (Annotation annotation : annotations) {
      if (annotation.getName().equals(EventProcessorConstants.NAME)) {
        name = annotation.getElements().get(0).getValue();
      }
    }
  }
  return name;
}

/**
 * Generates AnnotationConfig String for the given Siddhi Annotation
 * @param annotation    Siddhi Annotation
 * @return              String representing the Annotation
 */
public String generateAnnotationConfig(Annotation annotation) {
  StringBuilder annotationConfig = new StringBuilder();
  annotationConfig.append("@");
  annotationConfig.append(annotation.getName());
  annotationConfig.append("(");
  List<String> annotationMembers = new ArrayList<>();
  for (Element element : annotation.getElements()) {
    annotationMembers.add(element.toString());
  }
  for (Annotation innerAnnotation : annotation.getAnnotations()) {
    annotationMembers.add(generateAnnotationConfig(innerAnnotation));
  }
  annotationConfig.append(String.join(", ", annotationMembers));
  annotationConfig.append(")");
  preserveCodeSegment(annotation);
  return annotationConfig.toString();
}

protected void init(StreamDefinition streamDefinition, OptionHolder optionHolder,
          ConfigReader configReader, SiddhiAppContext siddhiAppContext) {
  this.siddhiAppContext = siddhiAppContext;
  uriOption = optionHolder.validateAndGetOption(Constants.FILE_URI);
  String append = optionHolder.validateAndGetStaticValue(Constants.APPEND, Constants.TRUE);
  properties = new HashMap<>();
  properties.put(Constants.ACTION, Constants.WRITE);
  if (Constants.TRUE.equalsIgnoreCase(append)) {
    properties.put(Constants.APPEND, append);
  }
  String mapType = streamDefinition.getAnnotations().get(0).getAnnotations().get(0).getElements().get(0)
      .getValue();
  addEventSeparator = optionHolder.isOptionExists(Constants.ADD_EVENT_SEPARATOR) ?
      Boolean.parseBoolean(optionHolder.validateAndGetStaticValue(Constants.ADD_EVENT_SEPARATOR)) :
      !mapType.equalsIgnoreCase("csv");
}

return indices.getElements().stream().map(index -> {
  Matcher matcher = indexBy.matcher(index.getValue());
  if (matcher.matches() && attributeNames.contains(matcher.group(1))) {

for (Annotation annotation : sourceStream.getValue().getAnnotations()) {
  if (annotation.getName().equalsIgnoreCase(Constants.KAFKA_SOURCE)) {
    for (Element sourceElement : annotation.getElements()) {
      if (sourceElement.getKey().equalsIgnoreCase(Constants.KAFKA_SOURCE_TOPIC_LIST)) {
        sourceList.add(sourceElement.getValue());
    for (Element sinkElement : annotation.getElements()) {
      if (sinkElement.getKey().equalsIgnoreCase(Constants.KAFKA_SINK_TOPIC)) {
        sinkList.add(sinkElement.getValue());

/**
 * The initialization method for {@link Sink}, which will be called before other methods and validate
 * the all configuration and getting the intial values.
 *
 * @param outputStreamDefinition containing stream definition bind to the {@link Sink}
 * @param optionHolder           Option holder containing static and dynamic configuration related
 *                               to the {@link Sink}
 * @param configReader           to read the sink related system configuration.
 * @param siddhiAppContext       the context of the {@link org.wso2.siddhi.query.api.SiddhiApp} used to
 *                               get siddhi related utilty functions.
 */
@Override
protected void init(StreamDefinition outputStreamDefinition, OptionHolder optionHolder,
          ConfigReader configReader, SiddhiAppContext siddhiAppContext) {
  //read configurations
  this.messageIdOption = optionHolder.validateAndGetOption(HttpConstants.MESSAGE_ID);
  this.sourceId = optionHolder.validateAndGetStaticValue(HttpConstants.SOURCE_ID);
  this.httpHeaderOption = optionHolder.getOrCreateOption(HttpConstants.HEADERS, HttpConstants.DEFAULT_HEADER);
  this.mapType = outputStreamDefinition.getAnnotations().get(0).getAnnotations().get(0).getElements().get(0)
      .getValue();
}

/**
 * Obtain query name of each siddhi app elements
 */
private void loadQueryName(List<Annotation> queryAnnotations, SiddhiAppElements siddhiAppElements) {
  for (Annotation annotation : queryAnnotations) {
    for (Element element : annotation.getElements()) {
      siddhiAppElements.setQueryName(element.getValue());
    }
  }
  if (siddhiAppElements.getQueryName() == null) {
    siddhiAppElements.setQueryName(Constants.DEFAULT_QUERY_NAME);
  }
}

/**
 * Generates MapperPayloadOrAttribute object, with the given Siddhi Annotation
 * @param attributesOrPayloadAnnotation         Siddhi Annotation, denoting @attribute or @payload
 * @return                                      MapperPayloadOrAttribute object
 */
private MapperPayloadOrAttribute generateMapperPayloadOrAttributes(Annotation attributesOrPayloadAnnotation) {
  List<PayloadOrAttributeElement> elements = new ArrayList<>();
  for (Element element : attributesOrPayloadAnnotation.getElements()) {
    elements.add(generatePayloadOrAttributesElement(element));
  }
  MapperPayloadOrAttributeType mapperPayloadOrAttributesType = getMapperAttributeOrPayloadType(elements);
  if (mapperPayloadOrAttributesType == MapperPayloadOrAttributeType.MAP) {
    return generateMapperMapAttribute(attributesOrPayloadAnnotation.getName(), elements);
  }
  return generateMapperListAttribute(attributesOrPayloadAnnotation.getName(), elements);
}

  public StoreConfig generateStoreConfig(Annotation storeAnnotation) throws DesignGenerationException {
    String type = null;
    Map<String, String> options = new HashMap<>();
    for (Element element : storeAnnotation.getElements()) {
      if (element.getKey().equalsIgnoreCase("TYPE")) {
        type = element.getValue();
      } else {
        options.put(element.getKey(), element.getValue());
      }
    }
    if (type == null) {
      throw new DesignGenerationException("Can not find type for the Store");
    }
    StoreConfig storeConfig = new StoreConfig(type, options);
    preserveAndBindCodeSegment(storeAnnotation, storeConfig);

    return storeConfig;
  }
}

/**
 * Loads App level Annotations from the Siddhi app
 *
 * @return A reference to this object
 */
public EventFlowBuilder loadAppAnnotations() {
  String siddhiAppName = "";
  String siddhiAppDescription = "";
  List<String> appAnnotations = new ArrayList<>();
  AnnotationConfigGenerator annotationConfigGenerator = new AnnotationConfigGenerator();
  for (Annotation annotation : siddhiApp.getAnnotations()) {
    if (annotation.getName().equalsIgnoreCase("NAME")) {
      siddhiAppName = annotation.getElements().get(0).getValue();
      annotationConfigGenerator.preserveCodeSegment(annotation);
    } else if (annotation.getName().equalsIgnoreCase("DESCRIPTION")) {
      siddhiAppDescription = annotation.getElements().get(0).getValue();
      annotationConfigGenerator.preserveCodeSegment(annotation);
    } else {
      appAnnotations.add(
          "@App:" + annotationConfigGenerator.generateAnnotationConfig(annotation).split("@")[1]);
    }
  }
  siddhiAppConfig.setSiddhiAppName(siddhiAppName);
  siddhiAppConfig.setSiddhiAppDescription(siddhiAppDescription);
  siddhiAppConfig.setAppAnnotationList(appAnnotations);
  siddhiAppConfig.addElementCodeSegments(annotationConfigGenerator.getPreservedCodeSegments());
  return this;
}

/**
 * Util method which validates the elements from an annotation to verify that they comply to the accepted standards.
 *
 * @param annotation the annotation to be validated.
 */
public static void validateAnnotation(Annotation annotation) {
  if (annotation == null) {
    return;
  }
  List<Element> elements = annotation.getElements();
  for (Element element : elements) {
    if (isEmpty(element.getValue())) {
      throw new RDBMSTableException("Annotation '" + annotation.getName() + "' contains illegal value(s). " +
          "Please check your query and try again.");
    }
  }
}

/**
 * Generates config for a Mapper
 * @param mapAnnotation                     Siddhi annotation that contains details of a Siddhi Mapper
 * @return                                  MapperConfig object
 * @throws DesignGenerationException        Error while generating MapperConfig
 */
private MapperConfig generateMapperConfig(Annotation mapAnnotation) throws DesignGenerationException {
  String type = null;
  List<String> options = new ArrayList<>();
  for (Element element : mapAnnotation.getElements()) {
    if (element.getKey().equalsIgnoreCase(TYPE)) {
      type = element.getValue();
    } else {
      options.add(element.toString());
    }
  }
  if (type == null) {
    throw new DesignGenerationException("Unable to find 'type' of the mapper");
  }
  MapperPayloadOrAttribute payloadOrAttribute = null;
  if (!mapAnnotation.getAnnotations().isEmpty()) {
    payloadOrAttribute = generateMapperPayloadOrAttributes(mapAnnotation.getAnnotations().get(0));
  }
  MapperConfig mapperConfig = new MapperConfig(type, options, payloadOrAttribute);
  preserveAndBindCodeSegment(mapAnnotation, mapperConfig);
  return mapperConfig;
}

for (Element el : streamDefinition.getAnnotations().get(0).getAnnotations().get(0).getElements()) {
  if (el.getKey().contains(REGULAR_EXPRESSION_GROUP)) {
    regexGroupMap.put(el.getKey()

String correlationId = null;
List<String> options = new ArrayList<>();
for (Element element : sourceOrSinkAndConnectedElement.getKey().getElements()) {
  if (element.getKey().equalsIgnoreCase(TYPE)) {
    type = element.getValue();

if (primaryKeys != null) {
  primaryKeysEnabled = true;
  primaryKeys.getElements().forEach(elem -> {
    for (int i = 0; i < this.attributes.size(); i++) {
      if (this.attributes.get(i).getName().equalsIgnoreCase(elem.getValue())) {

/**
 * Utility method which can be used to check if the given primary key is valid i.e. non empty
 * and is made up of attributes and return an index model when PrimaryKey is valid.
 *
 * @param primaryKey     the PrimaryKey annotation which contains the primary key attributes.
 * @param attributeNames List containing names of the attributes.
 * @return List of String with primary key attributes.
 */
public static IndexModel extractPrimaryKey(Annotation primaryKey, List<String> attributeNames) {
  if (primaryKey == null) {
    return null;
  }
  Document primaryKeyIndex = new Document();
  primaryKey.getElements().forEach(
      element -> {
        if (!isEmpty(element.getValue()) && attributeNames.contains(element.getValue())) {
          primaryKeyIndex.append(element.getValue(), 1);
        } else {
          throw new SiddhiAppCreationException("Annotation '" + primaryKey.getName() + "' contains " +
              "value '" + element.getValue() + "' which is not present in the attributes of the " +
              "Event Table.");
        }
      }
  );
  return new IndexModel(primaryKeyIndex, new IndexOptions().unique(true));
}

if (annotation != null) {
  Element element = null;
  for (Element aElement : annotation.getElements()) {
    if (elementName == null) {
      if (aElement.getKey() == null) {

/**
 * Load sink related data
 */
private void loadSinks(SiddhiApp siddhiApp, SiddhiAppRuntime siddhiAppRuntime, List<SiddhiAppElements>
    listOfSiddhiAppElements, String
                siddhiAppString) {
  for (List<Sink> sinks : siddhiAppRuntime.getSinks()) {
    for (Sink sink : sinks) {
      for (Annotation annotation : sink.getStreamDefinition().getAnnotations()) {
        for (Element element : annotation.getElements()) {
          if (Objects.equals(element.getValue(), sink.getType())) {
            SiddhiAppElements siddhiAppElements = new SiddhiAppElements();
            siddhiAppElements.setInputStreamId(sink.getStreamDefinition().getId());
            loadInputData(siddhiApp, siddhiAppRuntime, sink.getStreamDefinition().getId(),
                siddhiAppString,
                siddhiAppElements);
            siddhiAppElements.setOutputStreamId(sink.getType());
            siddhiAppElements.setOutputStreamType(Constants.SINK_TYPE);
            siddhiAppElements.setOutputStreamSiddhiApp(getDefinition(annotation, siddhiAppString));
            listOfSiddhiAppElements.add(siddhiAppElements);
          }
        }
      }
    }
  }
}

/**
 * Load source related data
 */
private void loadSources(SiddhiApp siddhiApp, SiddhiAppRuntime siddhiAppRuntime, List<SiddhiAppElements>
    listOfSiddhiAppElements, String siddhiAppString) {
  for (List<Source> sources : siddhiAppRuntime.getSources()) {
    for (Source source : sources) {
      for (Annotation annotation : source.getStreamDefinition().getAnnotations()) {
        for (Element element : annotation.getElements()) {
          if (Objects.equals(element.getValue(), source.getType())) {
            SiddhiAppElements siddhiAppElements = new SiddhiAppElements();
            siddhiAppElements.setOutputStreamId(source.getStreamDefinition().getId());
            siddhiAppElements.setInputStreamId(source.getType());
            siddhiAppElements.setInputStreamType(Constants.SOURCE_TYPE);
            loadOutputData(siddhiApp, siddhiAppRuntime, source.getStreamDefinition().getId(),
                siddhiAppString,
                siddhiAppElements);
            siddhiAppElements.setInputStreamSiddhiApp(getDefinition(annotation, siddhiAppString));
            listOfSiddhiAppElements.add(siddhiAppElements);
          }
        }
      }
    }
  }
}