Skeleton to provide search function

src/main/java/org/leolo/map/osm/extract/SearchProvider.java

@@ -0,0 +1,12 @@
+package org.leolo.map.osm.extract;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ElementType.TYPE})
+@Retention(RetentionPolicy.RUNTIME)
+public @interface SearchProvider {
+    String[] searchKey();
+}

src/main/java/org/leolo/map/osm/extract/SearchProviderManager.java

@@ -0,0 +1,112 @@
+package org.leolo.map.osm.extract;
+
+import eu.infomas.annotation.AnnotationDetector;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.leolo.map.osm.extract.model.SearchItem;
+
+import java.io.IOException;
+import java.lang.annotation.Annotation;
+import java.util.*;
+import java.util.function.BiConsumer;
+
+public class SearchProviderManager {
+
+    private static SearchProviderManager instance;
+    private Logger log = LogManager.getLogger();
+    private Hashtable<String, Class> items = new Hashtable<>();
+
+    public static synchronized SearchProviderManager getInstance(){
+        if(instance==null){
+            instance = new SearchProviderManager();
+        }
+        return instance;
+    }
+
+    private SearchProviderManager(){
+        AnnotationDetector.TypeReporter reporter = new AnnotationDetector.TypeReporter() {
+            @Override
+            public void reportTypeAnnotation(Class<? extends Annotation> annoClass, String clazz) {
+                log.atDebug().log("Class {} has annotation {}", clazz, annoClass.getName());
+                try {
+                    Class typeClass = Class.forName(clazz);
+                    if(SearchItem.class.isAssignableFrom(typeClass)){
+                        log.atDebug().log("Class {} is an output formatter", clazz);
+                        SearchProvider of = (SearchProvider) typeClass.getAnnotation(SearchProvider.class);
+                        for(String format: of.searchKey()){
+                            if(items.containsKey(format)){
+                                log.atWarn().log("Duplicated search type {}. Shared by (at least) {} and {}",
+                                        format,
+                                        typeClass.getName(),
+                                        items.get(format).getName()
+                                );
+                            }else{
+                                items.put(format, typeClass);
+                                log.atInfo().log("Registering class {} for search type {}", typeClass, format);
+                            }
+                        }
+                    }else{
+                        log.atError().log("Class {} does not implements OutputFormat but have annotation @OutputFormatter", clazz);
+                    }
+                } catch (ClassNotFoundException e) {
+                    log.atError().withThrowable(e).log(e.getMessage());
+                }
+            }
+
+            @Override
+            public Class<? extends Annotation>[] annotations() {
+                return new Class[]{SearchProvider.class};
+            }
+        };
+        final AnnotationDetector cf = new AnnotationDetector(reporter);
+        try {
+            cf.detect();
+        } catch (IOException e) {
+            log.atError().withThrowable(e).log(e.getMessage());
+        }
+    }
+
+    public int size() {
+        return items.size();
+    }
+
+    public boolean isEmpty() {
+        return items.isEmpty();
+    }
+
+    public Enumeration<String> keys() {
+        return items.keys();
+    }
+
+    public boolean containsKey(Object key) {
+        return items.containsKey(key);
+    }
+
+    public Class get(Object key) {
+        return items.get(key);
+    }
+
+    public Set<String> keySet() {
+        return items.keySet();
+    }
+
+    public void forEach(BiConsumer<? super String, ? super Class> action) {
+        items.forEach(action);
+    }
+
+    public int getOutputFormatterCount(){
+        HashSet<Class> set = new HashSet<>();
+        for(Class clazz:items.values()){
+            set.add(clazz);
+        }
+        return set.size();
+    }
+
+    public int getSearchProviderCount(){
+        HashSet<Class> set = new HashSet<>();
+        for(Class clazz:items.values()){
+            set.add(clazz);
+        }
+        return set.size();
+    }
+}

src/main/java/org/leolo/map/osm/extract/model/ActionFile.java

@@ -2,6 +2,7 @@ package org.leolo.map.osm.extract.model;
 
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
+import org.leolo.map.osm.extract.SearchProviderManager;
 import org.leolo.map.osm.extract.util.InputFile;
 import org.w3c.dom.Document;
 import org.w3c.dom.Element;
@@ -9,11 +10,13 @@ import org.w3c.dom.Node;
 import org.w3c.dom.NodeList;
 import org.xml.sax.SAXException;
 
+import javax.management.ReflectionException;
 import javax.xml.parsers.DocumentBuilder;
 import javax.xml.parsers.DocumentBuilderFactory;
 import javax.xml.parsers.ParserConfigurationException;
 import java.io.File;
 import java.io.IOException;
+import java.lang.reflect.InvocationTargetException;
 import java.util.*;
 
 public class ActionFile {
@@ -27,6 +30,7 @@ public class ActionFile {
 
     private String baseLanguage;
     private HashSet<String> otherLanguage = new HashSet<>();
+    private Vector<SearchItem> searches = new Vector<>();
 
     public ActionFile(InputFile path) throws IOException, SAXException, ParserConfigurationException {
         log.atInfo().log("Parsing action file");
@@ -102,6 +106,29 @@ public class ActionFile {
                 }
             }
         }
+        NodeList searchesNodeList = rootElement.getElementsByTagName("searches");
+        if(searchesNodeList.getLength()>0){
+            NodeList searches = searchesNodeList.item(0).getChildNodes();
+            for(int i=0;i<searches.getLength();i++){
+                Node child = searches.item(i);
+                if(child==null||"#text".equals(child.getNodeName()) || "#comment".equals(child.getNodeName())){
+                    continue;
+                }
+                log.atDebug().log("Search type {}; search key: {}", child.getNodeName(), child.getTextContent());
+                Class clazz = SearchProviderManager.getInstance().get(child.getNodeName());
+                if(clazz==null){
+                    log.atError().log("Unknown search type {}", child.getNodeName());
+                }else{
+                    try {
+                        SearchItem si = (SearchItem) clazz.getConstructor().newInstance();
+                        si.setSearchKey(child.getTextContent());
+                        this.searches.add(si);
+                    } catch (Exception e) {
+                        throw new RuntimeException(e);
+                    }
+                }
+            }
+        }
     }
 
 

src/main/java/org/leolo/map/osm/extract/model/SearchItem.java

@@ -17,6 +17,7 @@ public abstract class SearchItem {
     }
 
     protected abstract boolean matchString(String target);
+    public abstract void setSearchKey(String searchKey);
 
     public boolean matchNode(OsmNode node){
         return false;