private static void addExtensionMetaDataIntoNamespaceList(List<NamespaceMetaData> namespaceList,
                                                              Class<?> extensionClass, Log logger,
                                                              boolean includeOrigin) {
        Extension extensionAnnotation = extensionClass.getAnnotation(Extension.class);

        if (extensionAnnotation != null) {      // Discarding extension classes without annotation
            ExtensionMetaData extensionMetaData = new ExtensionMetaData();

            // Finding extension type
            String extensionType = null;
            for (Map.Entry<ExtensionType, Class<?>> entry : ExtensionType.getSuperClassMap().entrySet()) {
                Class<?> superClass = entry.getValue();
                if (superClass.isAssignableFrom(extensionClass) && superClass != extensionClass) {
                    extensionType = entry.getKey().getValue();
                    break;
                }
            }

            // Discarding the extension if it belongs to an unknown type
            if (extensionType == null) {
                logger.warn("Discarding extension (belonging to an unknown extension type): "
                        + extensionClass.getCanonicalName());
                return;
            }
            extensionMetaData.setName(extensionAnnotation.name());
            extensionMetaData.setDescription(extensionAnnotation.description());
            extensionMetaData.setDeprecated(extensionAnnotation.deprecated());

            if (includeOrigin) {
                Manifest manifest = getManifest(extensionClass);
                Attributes attributes = manifest.getMainAttributes();
                extensionMetaData.setOriginName(attributes.getValue("Bundle-Name"));
                extensionMetaData.setOriginVersion(attributes.getValue("Bundle-Version"));
            }

            // Adding query parameters
            ParameterMetaData[] parameters = new ParameterMetaData[extensionAnnotation.parameters().length];
            Map<String, ParameterMetaData> parameterMap = new HashMap<>();
            for (int i = 0; i < extensionAnnotation.parameters().length; i++) {
                Parameter parameterAnnotation = extensionAnnotation.parameters()[i];
                ParameterMetaData parameter = new ParameterMetaData();
                parameter.setName(parameterAnnotation.name());
                parameter.setType(Arrays.asList(parameterAnnotation.type()));
                parameter.setDescription(parameterAnnotation.description());
                parameter.setOptional(parameterAnnotation.optional());
                parameter.setDynamic(parameterAnnotation.dynamic());
                parameter.setDefaultValue(parameterAnnotation.defaultValue());
                parameterMap.put(parameter.getName(), parameter);
                parameters[i] = parameter;
            }
            extensionMetaData.setParameters(Arrays.asList(parameters));

            // Adding parameter overloads
            if (extensionAnnotation.parameterOverloads().length > 0) {
                ParameterOverloadMetaData[] parameterOverloads = new ParameterOverloadMetaData[
                        extensionAnnotation.parameterOverloads().length];
                for (int i = 0; i < extensionAnnotation.parameterOverloads().length; i++) {
                    ParameterOverload parameterOverloadAnnotation = extensionAnnotation.parameterOverloads()[i];
                    ParameterOverloadMetaData parameterOverload = new ParameterOverloadMetaData();
                    ParameterMetaData[] overloadParameters = new ParameterMetaData[
                            parameterOverloadAnnotation.parameterNames().length];
                    for (int j = 0; j < parameterOverloadAnnotation.parameterNames().length; j++) {
                        ParameterMetaData parameterMetaData = parameterMap.
                                get(parameterOverloadAnnotation.parameterNames()[j]);
                        if (parameterMetaData != null) {
                            overloadParameters[j] = parameterMetaData;
                        } else if (parameterOverloadAnnotation.parameterNames()[j].
                                equals(SiddhiConstants.REPETITIVE_PARAMETER_NOTATION)) {
                            ParameterMetaData repetitiveParamMetaData =
                                    new ParameterMetaData();
                            ParameterMetaData previousParameterMetaData = parameterMap.
                                    get(parameterOverloadAnnotation.parameterNames()[j - 1]);
                            repetitiveParamMetaData.setName(SiddhiConstants.REPETITIVE_PARAMETER_NOTATION);
                            repetitiveParamMetaData.setType(previousParameterMetaData.getType());
                            repetitiveParamMetaData.setDescription(previousParameterMetaData.getDescription());
                            repetitiveParamMetaData.setOptional(previousParameterMetaData.isOptional());
                            repetitiveParamMetaData.setDynamic(previousParameterMetaData.isDynamic());
                            repetitiveParamMetaData.setDefaultValue(previousParameterMetaData.getDefaultValue());
                            overloadParameters[j] = repetitiveParamMetaData;
                        }
                    }
                    parameterOverload.setParameters(Arrays.asList(overloadParameters));
                    parameterOverloads[i] = parameterOverload;
                }
                extensionMetaData.setParameterOverloads(Arrays.asList(parameterOverloads));
            }
            // Adding system parameters
            SystemParameterMetaData[] systemParameters =
                    new SystemParameterMetaData[extensionAnnotation.systemParameter().length];
            for (int i = 0; i < extensionAnnotation.systemParameter().length; i++) {
                SystemParameter systemParameterAnnotation = extensionAnnotation.systemParameter()[i];

                SystemParameterMetaData systemParameter = new SystemParameterMetaData();
                systemParameter.setName(systemParameterAnnotation.name());
                systemParameter.setDescription(systemParameterAnnotation.description());
                systemParameter.setDefaultValue(systemParameterAnnotation.defaultValue());
                systemParameter.setPossibleParameters(Arrays.asList(systemParameterAnnotation.possibleParameters()));
                systemParameters[i] = systemParameter;
            }
            extensionMetaData.setSystemParameters(Arrays.asList(systemParameters));

            // Adding return attributes
            ReturnAttributeMetaData[] returnAttributes =
                    new ReturnAttributeMetaData[extensionAnnotation.returnAttributes().length];
            for (int i = 0; i < extensionAnnotation.returnAttributes().length; i++) {
                ReturnAttribute parameterAnnotation = extensionAnnotation.returnAttributes()[i];

                ReturnAttributeMetaData returnAttribute = new ReturnAttributeMetaData();
                returnAttribute.setName(parameterAnnotation.name());
                returnAttribute.setType(Arrays.asList(parameterAnnotation.type()));
                returnAttribute.setDescription(parameterAnnotation.description());
                returnAttributes[i] = returnAttribute;
            }
            extensionMetaData.setReturnAttributes(Arrays.asList(returnAttributes));

            // Adding examples
            ExampleMetaData[] examples = new ExampleMetaData[extensionAnnotation.examples().length];
            for (int i = 0; i < extensionAnnotation.examples().length; i++) {
                Example exampleAnnotation = extensionAnnotation.examples()[i];

                ExampleMetaData exampleMetaData = new ExampleMetaData();
                exampleMetaData.setSyntax(exampleAnnotation.syntax());
                exampleMetaData.setDescription(exampleAnnotation.description());
                examples[i] = exampleMetaData;
            }
            extensionMetaData.setExamples(Arrays.asList(examples));

            // Finding the namespace
            String namespaceName = extensionAnnotation.namespace();
            if (Objects.equals(namespaceName, "")) {
                namespaceName = Constants.CORE_NAMESPACE;
            }

            // Finding the relevant namespace in the namespace list
            NamespaceMetaData namespace = null;
            for (NamespaceMetaData existingNamespace : namespaceList) {
                if (Objects.equals(existingNamespace.getName(), namespaceName)) {
                    namespace = existingNamespace;
                    break;
                }
            }
            // Creating namespace if it doesn't exist
            if (namespace == null) {
                namespace = new NamespaceMetaData();
                namespace.setName(namespaceName);
                namespace.setExtensionMap(new TreeMap<>());
                namespaceList.add(namespace);
            }

            // Adding to the relevant extension metadata list in the namespace
            List<ExtensionMetaData> extensionMetaDataList = namespace.getExtensionMap()
                    .computeIfAbsent(extensionType, k -> new ArrayList<>());

            extensionMetaDataList.add(extensionMetaData);
        }
    }
Generate extension meta data from the annotated data in the class

@param namespaceList  The list of namespaces to which the new extension will be added
@param extensionClass Class from which meta data should be extracted from
@param logger         The maven plugin logger
@param includeOrigin  Add origin to the docs
modules/siddhi-doc-gen/src/main/java/io/siddhi/doc/gen/core/utils/DocumentationUtils.java