Changeset 2986 for SRUClient

Timestamp:

06/04/13 16:15:35 (11 years ago)

Author:

oschonef

Message:

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

Location:

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

Files:

• SRUExplainRecordData.java (modified) (2 diffs)
• SRUExplainRecordDataParser.java (modified) (25 diffs)

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

@@ -258 +258 @@
     } // class DatabaseInfo
 
+    public static final class IndexInfo {
+        public static class Set {
+            private final String identifier;
+            private final String name;
+            private final List<LocalizedString> title;
+
+
+            Set(String identifier, String name, List<LocalizedString> title) {
+                this.identifier = identifier;
+                this.name = name;
+                if ((title != null) && !title.isEmpty()) {
+                    this.title = Collections.unmodifiableList(title);
+                } else {
+                    this.title = null;
+                }
+            }
+
+
+            public String getIdentifier() {
+                return identifier;
+            }
+
+
+            public String getName() {
+                return name;
+            }
+
+
+            public List<LocalizedString> getTitle() {
+                return title;
+            }
+        } // class IndexInfo.Set
+
+        public static class Index {
+            public static class Map {
+                private final boolean primary;
+                private final String set;
+                private final String name;
+
+
+                Map(boolean primary, String set, String name) {
+                    this.primary = primary;
+                    this.set     = set;
+                    this.name    = name;
+                }
+
+
+                public boolean isPrimary() {
+                    return primary;
+                }
+
+
+                public String getSet() {
+                    return set;
+                }
+
+
+                public String getName() {
+                    return name;
+                }
+            } // class IndexInfo.Index.Map
+
+            private final String id;
+            private final List<LocalizedString> title;
+            private final boolean can_search;
+            private final boolean can_scan;
+            private final boolean can_sort;
+            private final List<Index.Map> maps;
+
+
+            Index(String id, List<LocalizedString> title, boolean can_search,
+                    boolean can_scan, boolean can_sort, List<Map> maps) {
+                this.id = id;
+                if ((title != null) && !title.isEmpty()) {
+                    this.title = Collections.unmodifiableList(title);
+                } else {
+                    this.title = null;
+                }
+                this.can_search = can_search;
+                this.can_scan = can_scan;
+                this.can_sort = can_sort;
+                this.maps = maps;
+            }
+
+
+            public String getId() {
+                return id;
+            }
+
+
+            public List<LocalizedString> getTitle() {
+                return title;
+            }
+
+
+            public boolean canSearch() {
+                return can_search;
+            }
+
+
+            public boolean canScan() {
+                return can_scan;
+            }
+
+
+            public boolean canSort() {
+                return can_sort;
+            }
+
+
+            public List<Index.Map> getMaps() {
+                return maps;
+            }
+
+        } // class Index
+
+        private final List<IndexInfo.Set> sets;
+        private final List<IndexInfo.Index> indexes;
+
+
+        IndexInfo(List<IndexInfo.Set> sets, List<IndexInfo.Index> indexes) {
+            if ((sets != null) && !sets.isEmpty()) {
+                this.sets = Collections.unmodifiableList(sets);
+            } else {
+                this.sets = null;
+            }
+            if ((indexes != null) && !indexes.isEmpty()) {
+                this.indexes = Collections.unmodifiableList(indexes);
+            } else {
+                this.indexes = null;
+            }
+        }
+
+
+        public List<IndexInfo.Set> getSets() {
+            return sets;
+        }
+
+
+        public List<IndexInfo.Index> getIndexes() {
+            return indexes;
+        }
+    } // class IndexInfo
+
     private final ServerInfo serverInfo;
     private final DatabaseInfo databaseInfo;
-
-
-    SRUExplainRecordData(ServerInfo serverInfo, DatabaseInfo databaseInfo) {
+    private final IndexInfo indexInfo;
+
+
+    SRUExplainRecordData(ServerInfo serverInfo, DatabaseInfo databaseInfo,
+            IndexInfo indexInfo) {
         this.serverInfo   = serverInfo;
         this.databaseInfo = databaseInfo;
+        this.indexInfo    = indexInfo;
     }
 
@@ -289 +436 @@
     }
 
+
+    public IndexInfo getIndexInfo() {
+        return indexInfo;
+    }
+
 } // class SRUExplainRecordData

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

@@ -30 +30 @@
 
 import eu.clarin.sru.client.SRUExplainRecordData.DatabaseInfo;
+import eu.clarin.sru.client.SRUExplainRecordData.IndexInfo;
 import eu.clarin.sru.client.SRUExplainRecordData.LocalizedString;
 import eu.clarin.sru.client.SRUExplainRecordData.ServerInfo;
@@ -49 +50 @@
     private static final String TRANSPORT_HTTP  = "http";
     private static final String TRANSPORT_HTTPS = "https";
-    private static final String PRIMARY_TRUE    = "true";
+    private static final String STRING_TRUE     = "true";
     private static final String PRIMARY_FALSE   = "false";
     private static final Logger logger =
@@ -70 +71 @@
         // explain
         if (XmlStreamReaderUtils.peekStart(reader, ZEEREX_NS, "explain")) {
-            if (strict) {
-                logger.warn("namespace '{}' is not defined by ZeeRex, " +
-                        "enabling quirks mode (consider using namespace '{}'" +
-                        " which is defined)", ZEEREX_NS_QUIRK, ZEEREX_NS);
-            } else {
-                logger.info("namespace '{}' is not defined by ZeeRex, " +
-                        "enabling quirks mode (consider using namespace '{}'" +
-                        " which is defined)", ZEEREX_NS_QUIRK, ZEEREX_NS);
-            }
             return parseExplain(reader, version, strict, ZEEREX_NS);
         } else if (XmlStreamReaderUtils.peekStart(reader,
@@ -132 +124 @@
 
         // explain/indexInfo (optional)
-        while (XmlStreamReaderUtils.readStart(reader, ns, "indexInfo", false)) {
-            parseIndexInfo(reader, strict, ns);
+        IndexInfo indexInfo = null;
+        if (XmlStreamReaderUtils.readStart(reader, ns, "indexInfo", false)) {
+            indexInfo = parseIndexInfo(reader, strict, ns);
             XmlStreamReaderUtils.readEnd(reader, ns, "indexInfo");
-        } // while
+        } // if
 
         // explain/recordInfo or explain/schemaInfo
@@ -161 +154 @@
 
         XmlStreamReaderUtils.readEnd(reader, ns, "explain", true);
-        return new SRUExplainRecordData(serverInfo, databaseInfo);
+        return new SRUExplainRecordData(serverInfo, databaseInfo, indexInfo);
     }
 
@@ -252 +245 @@
          */
 
-        // make sure to remove any whitespace
-        XmlStreamReaderUtils.consumeWhitespace(reader);
-
         List<LocalizedString> title = null;
         List<LocalizedString> description = null;
@@ -268 +258 @@
 
         byte mode = 0; /* 1 = title, 2 = description, 3 = others */
-        while (reader.isStartElement()) {
+        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)) {
@@ -292 +291 @@
                     }
                 }
-                LocalizedString s = parseStringI18N(reader, strict, ns, "title");
+                LocalizedString s =
+                        parseStringI18N(reader, strict, ns, "title", true);
                 if (title == null) {
                     title = new ArrayList<LocalizedString>();
@@ -322 +322 @@
                 }
                 LocalizedString s =
-                        parseStringI18N(reader, strict, ns, "description");
+                        parseStringI18N(reader, strict, ns, "description", true);
                 if (description == null) {
                     description = new ArrayList<LocalizedString>();
@@ -330 +330 @@
             } else if (XmlStreamReaderUtils.peekStart(reader, ns, "author")) {
                 LocalizedString s =
-                        parseStringI18N(reader, strict, ns, "author");
+                        parseStringI18N(reader, strict, ns, "author", true);
                 if (author == null) {
                     author = new ArrayList<LocalizedString>();
@@ -338 +338 @@
             } else if (XmlStreamReaderUtils.peekStart(reader, ns, "contact")) {
                 LocalizedString s =
-                        parseStringI18N(reader, strict, ns, "contact");
+                        parseStringI18N(reader, strict, ns, "contact", true);
                 if (contact == null) {
                     contact = new ArrayList<LocalizedString>();
@@ -346 +346 @@
             } else if (XmlStreamReaderUtils.peekStart(reader, ns, "extent")) {
                 LocalizedString s =
-                        parseStringI18N(reader, strict, ns, "extent");
+                        parseStringI18N(reader, strict, ns, "extent", true);
                 if (extent == null) {
                     extent = new ArrayList<LocalizedString>();
@@ -354 +354 @@
             } else if (XmlStreamReaderUtils.peekStart(reader, ns, "history")) {
                 LocalizedString s =
-                        parseStringI18N(reader, strict, ns, "history");
+                        parseStringI18N(reader, strict, ns, "history", true);
                 if (history == null) {
                     history = new ArrayList<LocalizedString>();
@@ -363 +363 @@
                     ns, "restrictions")) {
                 LocalizedString s =
-                        parseStringI18N(reader, strict, ns, "restrictions");
+                        parseStringI18N(reader, strict, ns, "restrictions", true);
                 if (restrictions == null) {
                     restrictions = new ArrayList<LocalizedString>();
@@ -371 +371 @@
             } else if (XmlStreamReaderUtils.peekStart(reader, ns, "subjects")) {
                 LocalizedString s =
-                        parseStringI18N(reader, strict, ns, "subjects");
+                        parseStringI18N(reader, strict, ns, "subjects", true);
                 if (subjects == null) {
                     subjects = new ArrayList<LocalizedString>();
@@ -379 +379 @@
             } else if (XmlStreamReaderUtils.peekStart(reader, ns, "links")) {
                 LocalizedString s =
-                        parseStringI18N(reader, strict, ns, "links");
+                        parseStringI18N(reader, strict, ns, "links", true);
                 if (links == null) {
                     links = new ArrayList<LocalizedString>();
@@ -388 +388 @@
                     ns, "implementation")) {
                 LocalizedString s =
-                        parseStringI18N(reader, strict, ns, "implementation");
+                        parseStringI18N(reader, strict, ns, "implementation", true);
                 if (implementation == null) {
                     implementation = new ArrayList<LocalizedString>();
@@ -401 +401 @@
                 break;
             }
-
-            // make sure to remove any whitespace
-            XmlStreamReaderUtils.consumeWhitespace(reader);
-        } // while
+        } // for
 
         return new DatabaseInfo(title, description, author, contact,
@@ -412 +409 @@
 
 
-    private static Object parseIndexInfo(XMLStreamReader reader,
+    private static IndexInfo parseIndexInfo(XMLStreamReader reader,
             boolean strict, String ns) throws XMLStreamException,
             SRUClientException {
@@ -418 +415 @@
          * indexInfo ((set | index | sortKeywords)+)
          */
-        logger.debug("indexInfo");
         boolean found = false;
+        List<IndexInfo.Set> sets = null;
+        List<IndexInfo.Index> indexes = null;
         for (;;) {
             if (XmlStreamReaderUtils.readStart(reader, ns, "set", false, true)) {
-                logger.debug("-> set");
-                // FIXME: read attributes
+                final String identifier =
+                        XmlStreamReaderUtils.readAttributeValue(reader,
+                                null, "identifier");
+                final String name =
+                        XmlStreamReaderUtils.readAttributeValue(reader,
+                                null, "name");
                 XmlStreamReaderUtils.consumeStart(reader);
 
-                XmlStreamReaderUtils.readEnd(reader, ns, "set", true);
+                // indexInfo/set/title
+                List<LocalizedString> titles = null;
+                for (;;) {
+                    LocalizedString title =
+                            parseStringI18N(reader, strict, ns, "title", false);
+                    if (title == null) {
+                        break;
+                    }
+                    if (titles == null) {
+                        titles = new ArrayList<LocalizedString>();
+                    }
+                    titles.add(title);
+                } // for
+                XmlStreamReaderUtils.readEnd(reader, ns, "set");
+
+                if (sets == null) {
+                    sets = new ArrayList<IndexInfo.Set>();
+                }
+                sets.add(new IndexInfo.Set(identifier, name, titles));
                 found = true;
-            } else if (XmlStreamReaderUtils.readStart(reader, ns, "index", false, true)) {
-                logger.debug("-> index");
-                // FIXME: read attributes
+            } else if (XmlStreamReaderUtils.readStart(reader, ns,
+                    "index", false, true)) {
+                final String id =
+                        XmlStreamReaderUtils.readAttributeValue(reader, null, "id");
+                final boolean can_search =
+                        parseBooleanAttribute(reader, strict,null, "search");
+                final boolean can_scan =
+                        parseBooleanAttribute(reader, strict,null, "search");
+                final boolean can_sort =
+                        parseBooleanAttribute(reader, strict,null, "search");
                 XmlStreamReaderUtils.consumeStart(reader);
-                XmlStreamReaderUtils.readEnd(reader, ns, "index", true);
+
+                // indexInfo/index/title
+                List<LocalizedString> titles = null;
+                for (;;) {
+                    LocalizedString title =
+                            parseStringI18N(reader, strict, ns, "title", false);
+                    if (title == null) {
+                        break;
+                    }
+                    if (titles == null) {
+                        titles = new ArrayList<LocalizedString>();
+                    }
+                    titles.add(title);
+                } // for
+
+                // indexInfo/index/map ((attr+)|name)
+                List<IndexInfo.Index.Map> maps = null;
+                boolean first_map = true;
+                while (XmlStreamReaderUtils.readStart(reader, ns, "map",
+                        first_map, true)) {
+                    final boolean primary = parseBooleanAttribute(reader,
+                            strict, null, "primary");
+                    XmlStreamReaderUtils.consumeStart(reader);
+
+                    if (XmlStreamReaderUtils.peekStart(reader, ns, "attr")) {
+                        /*
+                         * skip "attr" elements, because they are not supported
+                         */
+                        while (XmlStreamReaderUtils.readStart(reader,
+                                ns, "attr", false)) {
+                            logger.debug("skipping 'attr'");
+                            XmlStreamReaderUtils.readEnd(reader, ns, "attr");
+                        } // while (attr)
+                    } else if (XmlStreamReaderUtils.peekStart(reader,
+                            ns, "name")) {
+                        XmlStreamReaderUtils.readStart(reader, ns, "name", true, true);
+                        final String set =
+                                XmlStreamReaderUtils.readAttributeValue(reader,
+                                        null, "set");
+                        // FIXME: check 'set'
+                        XmlStreamReaderUtils.consumeStart(reader);
+                        final String name =
+                                XmlStreamReaderUtils.readString(reader, false);
+                        // FIXME: check 'name'
+                        XmlStreamReaderUtils.readEnd(reader, ns, "name");
+                        if ((set != null) && (name != null)) {
+                            if (maps == null) {
+                                maps = new ArrayList<IndexInfo.Index.Map>();
+                            }
+                            maps.add(new IndexInfo.Index.Map(primary, set, name));
+                        }
+                    } else {
+                        // FIXME: error message
+                        throw new XMLStreamException(
+                                "expected 'attr' or 'name'",
+                                reader.getLocation());
+                    }
+
+                    XmlStreamReaderUtils.readEnd(reader, ns, "map");
+                    first_map = false;
+                } // while (map)
+
+                // indexInfo/index/configInfo (optional)
+                if (XmlStreamReaderUtils.readStart(reader, ns, "configInfo", false)) {
+                    logger.debug("skipping 'configInfo' within 'indexInfo/index'");
+                    XmlStreamReaderUtils.readEnd(reader, ns, "configInfo", true);
+                }
+
+                XmlStreamReaderUtils.readEnd(reader, ns, "index");
+                if (indexes == null) {
+                    indexes = new ArrayList<IndexInfo.Index>();
+                }
+                indexes.add(new IndexInfo.Index(id, titles, can_search,
+                        can_scan, can_sort, maps));
                 found = true;
             } else if (XmlStreamReaderUtils.readStart(reader, ns, "sortKeyword", false)) {
-                logger.debug("-> sortKeywords");
+                logger.debug("skipping 'sortKeywords'");
                 XmlStreamReaderUtils.readEnd(reader, ns, "sortKeyword", true);
                 found = true;
@@ -451 +551 @@
                     reader.getLocation());
         }
-        return null;
+        return ((sets != null) || (indexes != null))
+                ? new IndexInfo(sets, indexes)
+                : null;
     }
 
@@ -504 +606 @@
 
     private static LocalizedString parseStringI18N(XMLStreamReader reader,
-            boolean strict, String ns, String localName)
+            boolean strict, String ns, String localName, boolean required)
             throws XMLStreamException {
-        XmlStreamReaderUtils.readStart(reader, ns, localName, true, true);
+        if (!XmlStreamReaderUtils.readStart(reader, ns, localName, required,
+                true)) {
+            return null;
+        }
         final String lang = XmlStreamReaderUtils.readAttributeValue(reader,
                 null, "lang", false);
@@ -515 +620 @@
             }
         }
+        final boolean primary =
+                parseBooleanAttribute(reader, strict, null, "primary");
+        XmlStreamReaderUtils.consumeStart(reader);
+        String value = XmlStreamReaderUtils.readString(reader, false);
+        XmlStreamReaderUtils.readEnd(reader, ns, localName);
+        return new LocalizedString(value, lang, primary);
+    }
+
+
+    private static boolean parseBooleanAttribute(XMLStreamReader reader,
+            boolean strict, String ns, String localName)
+            throws XMLStreamException {
+        boolean result = false;
         final String s = XmlStreamReaderUtils.readAttributeValue(reader,
-                null, "primary", false);
-        boolean primary = false;
+                ns, localName, false);
         if (s != null) {
-            if (PRIMARY_TRUE.equalsIgnoreCase(s)) {
-                if (!PRIMARY_TRUE.equals(s)) {
+            if (STRING_TRUE.equalsIgnoreCase(s)) {
+                if (!STRING_TRUE.equals(s)) {
                     if (strict) {
                         throw new XMLStreamException("capitalization");
@@ -528 +645 @@
                     }
                 }
-                primary = true;
+                result = true;
             } else if (PRIMARY_FALSE.equalsIgnoreCase(s)) {
                 if (!PRIMARY_FALSE.equals(s)) {
@@ -538 +655 @@
                     }
                 }
-                primary = false;
+                result = false;
             } else {
                 // FIXME: message
-                throw new XMLStreamException("value of @primary invalid");
-            }
-        }
-        XmlStreamReaderUtils.consumeStart(reader);
-        String value = XmlStreamReaderUtils.readString(reader, false);
-        XmlStreamReaderUtils.readEnd(reader, ns, localName);
-        logger.debug("databaseInfo/{}='{}' (primary={}, lang={})", localName,
-                value, primary, lang);
-        return new LocalizedString(value, lang, primary);
+                throw new XMLStreamException("value of @" + localName + " invalid");
+            }
+        }
+        return result;
     }