Changeset 6848 for SRUServer

Timestamp:

11/25/15 14:18:20 (8 years ago)

Author:

Oliver Schonefeld

Message:

• use a Builder pattern for SRuQueryParserRegistry

Location:

SRUServer/trunk/src/main/java/eu/clarin/sru/server

Files:

• SRUQueryParserRegistry.java (modified) (3 diffs)
• utils/SRUSearchEngineBase.java (modified) (3 diffs)
• utils/SRUServerServlet.java (modified) (1 diff)

SRUServer/trunk/src/main/java/eu/clarin/sru/server/SRUQueryParserRegistry.java

@@ -17 +17 @@
 package eu.clarin.sru.server;
 
+import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
-import java.util.concurrent.CopyOnWriteArrayList;
 
 
 /**
- * Class for registering query parsers. The query parser for CQL will be
- * automatically registered.
+ * A registry to keep track of registered {@link SRUQueryParser} to be used by
+ * the {@link SRUServer}.
  *
  * @see SRUQueryParser
  */
 public class SRUQueryParserRegistry {
-    private CopyOnWriteArrayList<SRUQueryParser<?>> queryParsers =
-            new CopyOnWriteArrayList<SRUQueryParser<?>>();
+    private final List<SRUQueryParser<?>> parsers;
 
 
@@ -36 +35 @@
      * Constructor.
      */
-    public SRUQueryParserRegistry() {
-        queryParsers.add(new CQLQueryParser());
-        queryParsers.add(new SearchTermsQueryParser());
-    }
-
-
-    /**
-     * Register a new query parser
-     *
-     * @param parser
-     *            the query parser instance to be registered
-     * @throws SRUConfigException
-     *             if a query parser for the same query type was already
-     *             registered
-     */
-    public void registerQueryParser(SRUQueryParser<?> parser)
-            throws SRUConfigException {
-        if (parser == null) {
-            throw new NullPointerException("parser == null");
+    private SRUQueryParserRegistry(List<SRUQueryParser<?>> parsers) {
+        if (parsers == null) {
+            throw new NullPointerException("parsers == null");
         }
-        if (parser.getQueryType() == null) {
-            throw new NullPointerException("parser.getQueryType() == null");
+        if (parsers.isEmpty()) {
+            throw new IllegalArgumentException("parsers is empty!");
         }
-        synchronized (this) {
-            final String queryType = parser.getQueryType();
-            for (SRUQueryParser<?> queryParser : queryParsers) {
-                if (queryType.equals(queryParser.getQueryType())) {
-                    throw new SRUConfigException(
-                            "query parser for queryType '" + queryType +
-                                    "' is already registered");
-                }
-            } // for
-            queryParsers.add(parser);
-        } // synchronized (this)
+        this.parsers = Collections.unmodifiableList(parsers);
     }
 
@@ -85 +58 @@
             throw new NullPointerException("queryType == null");
         }
-        for (SRUQueryParser<?> queryParser : queryParsers) {
-            if (queryType.equals(queryParser.getQueryType())) {
-                return queryParser;
+        return findParser(parsers, queryType);
+    }
+
+
+    /**
+     * Get a list of all registered query parsers.
+     *
+     * @return a list of registered query parsers
+     */
+    public List<SRUQueryParser<?>> getQueryParsers() {
+        return parsers;
+    }
+
+
+    /**
+     * Builder for creating {@link SRUQueryParserRegistry} instances.
+     */
+    public static class Builder {
+        private final List<SRUQueryParser<?>> parsers =
+                new ArrayList<SRUQueryParser<?>>();
+
+
+        /**
+         * Constructor.
+         *
+         * @param registerDefaults
+         *            if <code>true</code>, register SRU/CQL standard query
+         *            parsers (queryType <em>cql</em> and <em>searchTerms</em>),
+         *            otherwise do nothing
+         */
+        public Builder(boolean registerDefaults) {
+            if (registerDefaults) {
+                registerDefaults();
             }
-        } // for
+        }
+
+
+        /**
+         * Constructor. Automaticaly registers registers SRU/CQL standard query
+         * parsers (queryType <em>cql</em> and <em>searchTerms</em>).
+         */
+        public Builder() {
+            this(true);
+        }
+
+
+        public Builder registerDefaults() {
+            if (findParser(parsers, SRUConstants.SRU_QUERY_TYPE_CQL) == null) {
+                try {
+                    register(new CQLQueryParser());
+                } catch (SRUConfigException e) {
+                    /* IGNORE */
+                }
+            }
+            if (findParser(parsers, SRUConstants.SRU_QUERY_TYPE_SEARCH_TERMS) == null) {
+                try {
+                    register(new SearchTermsQueryParser());
+                } catch (SRUConfigException e) {
+                    /* IGNORE */
+                }
+            }
+            return this;
+        }
+
+
+        /**
+         * Register a new query parser
+         *
+         * @param parser
+         *            the query parser instance to be registered
+         * @throws SRUConfigException
+         *             if a query parser for the same query type was already
+         *             registered
+         */
+        public Builder register(SRUQueryParser<?> parser) throws SRUConfigException {
+            if (parser == null) {
+                throw new NullPointerException("parser == null");
+            }
+            if (parser.getQueryType() == null) {
+                throw new NullPointerException("parser.getQueryType() == null");
+            }
+
+            // duplicate-save add ...
+            if (findParser(parsers, parser.getQueryType()) == null) {
+                parsers.add(parser);
+            } else {
+                throw new SRUConfigException("query parser for queryType '" +
+                        parser.getQueryType() + "' is already registered");
+            }
+
+            return this;
+        }
+
+
+        /**
+         * Create a configured {@link SRUQueryParserRegistry} instance from this
+         * builder.
+         *
+         * @return a {@link SRUQueryParserRegistry} instance
+         */
+        public SRUQueryParserRegistry build() {
+            return new SRUQueryParserRegistry(parsers);
+        }
+    }
+
+
+    private static final SRUQueryParser<?> findParser(
+            List<SRUQueryParser<?>> parsers, String queryType) {
+        for (SRUQueryParser<?> parser : parsers) {
+            if (queryType.equals(parser.getQueryType())) {
+                return parser;
+            }
+        }
         return null;
     }
 
-
-    public List<SRUQueryParser<?>> getQueryParsers() {
-        return Collections.unmodifiableList(queryParsers);
-    }
-
 } // class SRUQueryParserRegistry

SRUServer/trunk/src/main/java/eu/clarin/sru/server/utils/SRUSearchEngineBase.java

@@ -30 +30 @@
 import eu.clarin.sru.server.SRUSearchEngine;
 import eu.clarin.sru.server.SRUSearchResultSet;
+import eu.clarin.sru.server.SRUServer;
 import eu.clarin.sru.server.SRUServerConfig;
 
@@ -89 +90 @@
      * @param config
      *            the {@link SRUServerConfig} object for this search engine
-     * @param queryParsers
-     *            the {@link SRUQueryParserRegistry} object for this search
-     *            engine. Register additional query parsers with this object.
+     * @param parsersRegistryBuilder
+     *            the {@link SRUQueryParserRegistry.Builder} object to be used
+     *            for this search engine. Use to register additional query
+     *            parsers with the {@link SRUServer}.
      * @param params
      *            additional parameters gathered from the Servlet configuration
@@ -100 +102 @@
     public void init(ServletContext context,
             SRUServerConfig config,
-            SRUQueryParserRegistry queryParsers,
+            SRUQueryParserRegistry.Builder parsersRegistryBuilder,
             Map<String, String> params) throws SRUConfigException {
     }

SRUServer/trunk/src/main/java/eu/clarin/sru/server/utils/SRUServerServlet.java

@@ -248 +248 @@
          */
         try {
-            final SRUQueryParserRegistry parsers = new SRUQueryParserRegistry();
-            searchEngine.init(ctx, sruServerConfig, parsers, params);
+            final SRUQueryParserRegistry.Builder builder =
+                    new SRUQueryParserRegistry.Builder();
+            searchEngine.init(ctx, sruServerConfig, builder, params);
+            final SRUQueryParserRegistry parsers = builder.build();
             sruServer = new SRUServer(sruServerConfig, parsers, searchEngine);
         } catch (SRUConfigException e) {