Changeset 2989 for SRUClient

Timestamp:

06/05/13 12:57:12 (11 years ago)

Author:

oschonef

Message:

• add support for parsing configInfo within ZeeRex? (explain) record data

Location:

SRUClient/trunk/src

Files:

• main/java/eu/clarin/sru/client/SRUExplainRecordData.java (modified) (3 diffs)
• main/java/eu/clarin/sru/client/SRUExplainRecordDataParser.java (modified) (9 diffs)
• main/java/eu/clarin/sru/client/XmlStreamReaderUtils.java (modified) (2 diffs)
• test/java/eu/clarin/sru/client/TestUtils.java (modified) (2 diffs)

SRUClient/trunk/src/main/java/eu/clarin/sru/client/SRUExplainRecordData.java

@@ -19 +19 @@
 import java.util.Collections;
 import java.util.List;
+import java.util.Map;
 import java.util.Set;
 
@@ -402 +403 @@
     } // class IndexInfo
 
+    public static class ConfigInfo {
+        private final Map<String, String> defaults;
+        private final Map<String, String> settings;
+        private final Map<String, String> supports;
+
+
+        ConfigInfo(Map<String, String> defaults, Map<String, String> settings,
+                Map<String, String> supports) {
+            if ((defaults != null) && !defaults.isEmpty()) {
+                this.defaults = Collections.unmodifiableMap(defaults);
+            } else {
+                this.defaults = Collections.emptyMap();
+            }
+            if ((settings != null) && !settings.isEmpty()) {
+                this.settings = Collections.unmodifiableMap(settings);
+            } else {
+                this.settings = Collections.emptyMap();
+            }
+            if ((supports != null) && !supports.isEmpty()) {
+                this.supports = Collections.unmodifiableMap(supports);
+            } else {
+                this.supports = Collections.emptyMap();
+            }
+        }
+
+
+        public Map<String, String> getDefaults() {
+            return defaults;
+        }
+
+
+        public Map<String, String> getSettings() {
+            return settings;
+        }
+
+
+        public Map<String, String> getSupports() {
+            return supports;
+        }
+    } // class ConfigInfo
+
     private final ServerInfo serverInfo;
     private final DatabaseInfo databaseInfo;
     private final IndexInfo indexInfo;
+    private final ConfigInfo configInfo;
 
 
     SRUExplainRecordData(ServerInfo serverInfo, DatabaseInfo databaseInfo,
-            IndexInfo indexInfo) {
+            IndexInfo indexInfo, ConfigInfo configInfo) {
         this.serverInfo   = serverInfo;
         this.databaseInfo = databaseInfo;
         this.indexInfo    = indexInfo;
+        this.configInfo   = configInfo;
     }
 
@@ -441 +485 @@
     }
 
+
+    public ConfigInfo getConfigInfo() {
+        return configInfo;
+    }
+
 } // class SRUExplainRecordData

SRUClient/trunk/src/main/java/eu/clarin/sru/client/SRUExplainRecordDataParser.java

@@ -18 +18 @@
 
 import java.util.ArrayList;
+import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
+import java.util.Map;
 import java.util.Set;
 
@@ -29 +31 @@
 import org.slf4j.LoggerFactory;
 
+import eu.clarin.sru.client.SRUExplainRecordData.ConfigInfo;
 import eu.clarin.sru.client.SRUExplainRecordData.DatabaseInfo;
 import eu.clarin.sru.client.SRUExplainRecordData.IndexInfo;
@@ -85 +88 @@
             return parseExplain(reader, version, strict, ZEEREX_NS_QUIRK);
         } else {
-            throw new XMLStreamException("expected element '" +
+            throw new XMLStreamException("expected start tag for element '" +
                     new QName(ZEEREX_NS, "explain") + " at this position",
                     reader.getLocation());
@@ -148 +151 @@
 
         // explain/configInfo (optional)
+        ConfigInfo configInfo = null;
         if (XmlStreamReaderUtils.readStart(reader, ns, "configInfo", false)) {
-            parseConfigInfo(reader, strict, ns);
+            configInfo = parseConfigInfo(reader, strict, ns);
             XmlStreamReaderUtils.readEnd(reader, ns, "configInfo");
         }
 
         XmlStreamReaderUtils.readEnd(reader, ns, "explain", true);
-        return new SRUExplainRecordData(serverInfo, databaseInfo, indexInfo);
+        return new SRUExplainRecordData(serverInfo, databaseInfo, indexInfo,
+                configInfo);
     }
 
@@ -259 +264 @@
         byte mode = 0; /* 1 = title, 2 = description, 3 = others */
         for (;;) {
-            /*
-             * make sure to remove any whitespace and break, if we do not point
-             * to a start tag
-             */
-            XmlStreamReaderUtils.consumeWhitespace(reader);
-            if (!reader.isStartElement()) {
-                break;
-            }
-
             if (XmlStreamReaderUtils.peekStart(reader, ns, "title")) {
                 if ((mode != 0) && (mode != 1)) {
@@ -557 +553 @@
 
 
-    private static Object parseConfigInfo(XMLStreamReader reader,
+    private static ConfigInfo parseConfigInfo(XMLStreamReader reader,
             boolean strict, String ns) throws XMLStreamException,
             SRUClientException {
@@ -563 +559 @@
          * configInfo ((default|setting|supports)*)
          */
-        logger.debug("configInfo");
+        Map<String, String> defaults = null;
+        Map<String, String> settings = null;
+        Map<String, String> supports = null;
         for (;;) {
-            if (XmlStreamReaderUtils.readStart(reader,
-                    ns, "default", false, true)) {
-                final String type =
-                        XmlStreamReaderUtils.readAttributeValue(reader,
-                                null, "type", true);
-                XmlStreamReaderUtils.consumeStart(reader);
-                final String value =
-                        XmlStreamReaderUtils.readString(reader, true);
-                XmlStreamReaderUtils.readEnd(reader, ns, "default");
-                logger.debug("-> default: type={}, value={}", type, value);
-            } else if (XmlStreamReaderUtils.readStart(reader,
-                    ns, "setting", false, true)) {
-                final String type =
-                        XmlStreamReaderUtils.readAttributeValue(reader,
-                                null, "type", true);
-                XmlStreamReaderUtils.consumeStart(reader);
-                final String value =
-                        XmlStreamReaderUtils.readString(reader, true);
-                XmlStreamReaderUtils.readEnd(reader, ns, "setting");
-                logger.debug("-> setting: type={}, value={}", type, value);
-            } else if (XmlStreamReaderUtils.readStart(reader,
-                    ns, "supports", false, true)) {
-                final String type =
-                        XmlStreamReaderUtils.readAttributeValue(reader,
-                                null, "type", true);
-                XmlStreamReaderUtils.consumeStart(reader);
-                final String value =
-                        XmlStreamReaderUtils.readString(reader, true);
-                XmlStreamReaderUtils.readEnd(reader, ns, "supports");
-
-                logger.debug("-> supports: type={}, value={}", type, value);
+            if (XmlStreamReaderUtils.peekStart(reader, ns, "default")) {
+                defaults = parseConfigInfoItem(reader, strict, ns, "default", defaults);
+            } else if (XmlStreamReaderUtils.peekStart(reader, ns, "setting")) {
+                settings = parseConfigInfoItem(reader, strict, ns, "setting", settings);
+            } else if (XmlStreamReaderUtils.peekStart(reader, ns, "supports")) {
+                supports = parseConfigInfoItem(reader, strict, ns, "supports", supports);
             } else {
                 break;
@@ -601 +574 @@
         }
 
-        return null;
+        return ((defaults != null) || (settings != null) || (supports != null))
+                ? new ConfigInfo(defaults, settings, supports)
+                : null;
     }
 
@@ -664 +639 @@
     }
 
+
+    private static Map<String, String> parseConfigInfoItem(
+            XMLStreamReader reader, boolean strict, String ns,
+            String localName, Map<String, String> map)
+            throws XMLStreamException {
+        XmlStreamReaderUtils.readStart(reader, ns, localName, true, true);
+        final String type = XmlStreamReaderUtils.readAttributeValue(reader,
+                null, "type", true);
+        XmlStreamReaderUtils.consumeStart(reader);
+        final String value = XmlStreamReaderUtils.readString(reader, true);
+        XmlStreamReaderUtils.readEnd(reader, ns, localName);
+
+        if ((type != null) && (value != null)) {
+            if (map == null) {
+                map = new HashMap<String, String>();
+            }
+            if (map.containsKey(type)) {
+                logger.warn(
+                        "{} with type '{}' is already present, skipping duplicate entry",
+                        localName, type);
+            } else {
+                map.put(type, value);
+            }
+        }
+        return map;
+    }
+
 } // class SRUExplainRecordDataParser

SRUClient/trunk/src/main/java/eu/clarin/sru/client/XmlStreamReaderUtils.java

@@ -226 +226 @@
 
 
-    public static String peekElementLocalName(XMLStreamReader reader)
-            throws XMLStreamException {
-        consumeWhitespace(reader);
-        if (!reader.isStartElement()) {
-            throw new XMLStreamException("not at a start elment event",
-                    reader.getLocation());
-        }
-        return reader.getLocalName();
-    }
-
-
     public static boolean peekStart(XMLStreamReader reader,
-            String namespaceURI, String localName) throws XMLStreamException {
-        consumeWhitespace(reader);
-        if (!reader.isStartElement()) {
-            throw new XMLStreamException("not at a start elment event",
-                    reader.getLocation());
+            String namespaceURI, String localName)
+            throws XMLStreamException {
+        if (reader.isWhiteSpace()) {
+            consumeWhitespace(reader);
+        }
+        if (!reader.isStartElement()) {
+            return false;
         }
         return namespaceURI.equals(reader.getNamespaceURI()) &&
@@ -252 +243 @@
             throws XMLStreamException {
         if (!reader.isStartElement()) {
-            throw new XMLStreamException("not at a start elment event",
+            throw new XMLStreamException("not at a start element event",
                     reader.getLocation());
         }

SRUClient/trunk/src/test/java/eu/clarin/sru/client/TestUtils.java

@@ -24 +24 @@
 import org.w3c.dom.Node;
 
+import eu.clarin.sru.client.SRUExplainRecordData.ConfigInfo;
 import eu.clarin.sru.client.fcs.ClarinFCSRecordData;
 import eu.clarin.sru.client.fcs.DataView;
@@ -154 +155 @@
                     data.getServerInfo().getPort(),
                     data.getServerInfo().getDatabase());
+            ConfigInfo configInfo = data.getConfigInfo();
+            if (configInfo != null) {
+                if (configInfo.getDefaults() != null) {
+                    logger.debug("configInfo/default = {}",
+                            configInfo.getDefaults());
+                }
+                if (configInfo.getSettings() != null) {
+                    logger.debug("configInfo/setting = {}",
+                            configInfo.getSettings());
+                }
+                if (configInfo.getSupports() != null) {
+                    logger.debug("configInfo/supports = {}",
+                            configInfo.getSupports());
+                }
+            }
         }
     }