WebSVN - OpenConcerto - Diff - Rev 132 and 156 - /trunk/OpenConcerto/src/org/openconcerto/sql/element/SQLElementNamesFromXML.java

 /*
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
+ *
  * Copyright 2011 OpenConcerto, by ILM Informatique. All rights reserved.
+ *
  * The contents of this file are subject to the terms of the GNU General Public License Version 3
  * only ("GPL"). You may not use this file except in compliance with the License. You can obtain a
  * copy of the License at http://www.gnu.org/licenses/gpl-3.0.html See the License for the specific
  * language governing permissions and limitations under the License.
+ *
  * When distributing the software, include this License Header Notice in each file.
  */
  package org.openconcerto.sql.element;
 import org.openconcerto.sql.Log;
 import org.openconcerto.utils.i18n.Grammar;
 import org.openconcerto.utils.i18n.NounClass;
 import org.openconcerto.utils.i18n.Phrase;
 import org.openconcerto.utils.i18n.VariantKey;
 import org.openconcerto.xml.JDOM2Utils;
 import java.io.IOException;
 import java.io.InputStream;
 import java.util.AbstractMap.SimpleEntry;
+import java.util.Collections;
+import java.util.HashMap;
 import java.util.Locale;
+import java.util.Map;
 import java.util.Map.Entry;
+import java.util.Set;
+import java.util.logging.Level;
 import java.util.regex.Pattern;
 import org.jdom2.Document;
 import org.jdom2.Element;
 import org.jdom2.JDOMException;
 import org.jdom2.input.SAXBuilder;
 import net.jcip.annotations.ThreadSafe;
 /**
  * Parses XML to create phrases.
+ *
  * <pre>
  *     &lt;element refid="elementCode">
  *         &lt;name base="elemName" nounClass="masculine">
  *             &lt;variant refids="singular,plural" value="elemNameBothSingularAndPlural" />
  *             &lt;variant idPattern="(singular|plural)" value="elemNameBothSingularAndPlural" />
  *         &lt;/name>
  *     &lt;/element>
  * </pre>
+ *
  * @author Sylvain
+ *
  */
 @ThreadSafe
-public class SQLElementNamesFromXML extends SQLElementNamesMap.ByCode {
+public class SQLElementNamesFromXML {
     static public final Pattern SPLIT_PATTERN = Pattern.compile("\\s*,\\s*");
+    static private final Set<Object> SHORT_VARIANTS = Collections.singleton(Grammar.PLURAL);
+    private static final String ELEMENT_ELEM_NAME = "element";
+    private static final String NAME_ID_ATTR = "refid";
+    private static final String VARIANT_ATTR = "variant";
+    private static final String VARIANT_REFIDS_ATTR = "refids";
+    private static final String VARIANT_VALUE_ATTR = "value";
+    private static final String NAME_PLURAL_ATTR = "namePlural";
+    static private final String getNounClassAttrName(final boolean shortForm) {
+        return shortForm ? "nameClass" : "nounClass";
+    }
+    // <element nameClass="masculine" name="contact fournisseur">
+    // <name nounClass="masculine" base="droit utilisateur">
+    static final private void setNounClassAndBase(final Element elem, final Phrase phrase, final boolean shortForm) {
+        elem.setAttribute(getNounClassAttrName(shortForm), phrase.getNounClass().getName());
+        elem.setAttribute(shortForm ? "name" : "base", phrase.getBase());
+    }
+    private final Locale locale;
     public SQLElementNamesFromXML(Locale locale) {
-        super(locale);
+        this.locale = locale;
+    }
+    public final Locale getLocale() {
+        return this.locale;
+    }
-    public final void load(final InputStream ins) throws JDOMException, IOException {
+    public final Map<String, Phrase> load(final InputStream ins) throws JDOMException, IOException {
-        final Grammar gr = Grammar.getInstance(getLocale());
         final Document doc = new SAXBuilder().build(ins);
+        return load(doc.getRootElement());
+    }
+    public final Map<String, Phrase> load(final Element root) throws IOException {
+        final Grammar gr = Grammar.getInstance(getLocale());
+        final Map<String, Phrase> res = new HashMap<>();
-        for (final Element elem : doc.getRootElement().getChildren("element"))
+        for (final Element elem : root.getChildren(ELEMENT_ELEM_NAME)) {
+            final Entry<String, Phrase> e = this.createPhrase(gr, elem);
-            this.load(gr, elem);
+            if (e != null)
+                res.put(e.getKey(), e.getValue());
+        }
+        return res;
+    }
     public final Entry<String, Phrase> createPhrase(final Element elem) throws IOException {
         return this.createPhrase(Grammar.getInstance(getLocale()), elem);
+    }
     private Entry<String, Phrase> createPhrase(final Grammar gr, final Element elem) throws IOException {
-        final String refid = elem.getAttributeValue("refid");
+        final String refid = elem.getAttributeValue(NAME_ID_ATTR);
         if (refid == null)
             throw new IOException("No refid attribute");
         final Element nameElem = elem.getChild("name");
         final boolean hasChild = nameElem != null;
         final String nameAttr = elem.getAttributeValue("name");
         if (!hasChild && nameAttr == null) {
+            // perhaps elem is just used to change item names
-            Log.get().warning("No name for code : " + refid);
+            Log.get().log(Level.FINER, "No name for code : {0}", refid);
             return null;
+        }
         if (hasChild && nameAttr != null) {
             Log.get().warning("Ignoring attribute : " + nameAttr);
+        }
         final String base = hasChild ? nameElem.getAttributeValue("base") : nameAttr;
         if (base == null)
             throw new IOException("No base for the name of " + refid);
-        final String nounClassName = hasChild ? nameElem.getAttributeValue("nounClass") : elem.getAttributeValue("nameClass");
+        final String nounClassName = (hasChild ? nameElem : elem).getAttributeValue(getNounClassAttrName(!hasChild));
         final NounClass nounClass = nounClassName == null ? null : gr.getNounClass(nounClassName);
         final Phrase res = new Phrase(gr, base, nounClass);
         if (!hasChild) {
             // most languages have at most 2 grammatical number
-            final String plural = elem.getAttributeValue("namePlural");
+            final String plural = elem.getAttributeValue(NAME_PLURAL_ATTR);
             if (plural != null)
                 res.putVariant(Grammar.PLURAL, plural);
         } else {
-            for (final Element variantElem : nameElem.getChildren("variant")) {
+            for (final Element variantElem : nameElem.getChildren(VARIANT_ATTR)) {
-                final String value = variantElem.getAttributeValue("value");
+                final String value = variantElem.getAttributeValue(VARIANT_VALUE_ATTR);
                 if (value == null) {
                     warning(refid, variantElem, "No value");
                     continue;
+                }
-                final String variantIDs = variantElem.getAttributeValue("refids");
+                final String variantIDs = variantElem.getAttributeValue(VARIANT_REFIDS_ATTR);
                 final String variantPattern = variantElem.getAttributeValue("idPattern");
                 if (variantIDs == null && variantPattern == null) {
                     warning(refid, variantElem, "No ID");
                 } else if (variantIDs != null) {
                     if (variantPattern != null) {
                         warning(refid, variantElem, "Ignorig pattern " + variantPattern);
+                    }
                     for (final String variantID : SPLIT_PATTERN.split(variantIDs)) {
                         final VariantKey variantKey = gr.getVariantKey(variantID);
                         if (variantKey == null) {
                             warning(refid, variantElem, "Ignorig " + variantID);
                         } else {
                             res.putVariant(variantKey, value);
+                        }
+                    }
                 } else {
                     assert variantIDs == null && variantPattern != null;
                     final Pattern p = Pattern.compile(variantPattern);
                     for (final VariantKey vk : gr.getVariantKeys()) {
                         if (p.matcher(vk.getID()).matches()) {
                             res.putVariant(vk, value);
+                        }
+                    }
+                }
+            }
+        }
         return new SimpleEntry<String, Phrase>(refid, res);
+    }
-    private void load(final Grammar gr, final Element elem) throws IOException {
-        final Entry<String, Phrase> entry = this.createPhrase(gr, elem);
-        if (entry != null)
-            this.put(entry.getKey(), entry.getValue());
-    }
     private void warning(final String refid, final Element variantElem, final String msg) {
         Log.get().warning(msg + " for variant of " + refid + " : " + JDOM2Utils.output(variantElem));
+    }
+    public final Element createElement(final String refID, final Phrase phrase) {
+        final Element elem = new Element(ELEMENT_ELEM_NAME);
+        elem.setAttribute(NAME_ID_ATTR, refID);
+        final Set<VariantKey> explicitVariants = phrase.getExplicitVariants();
+        final boolean shortForm = SHORT_VARIANTS.containsAll(explicitVariants);
+        final Element nameElem;
+        if (shortForm) {
+            nameElem = elem;
+        } else {
+            nameElem = new Element("name");
+            elem.addContent(nameElem);
+        }
+        setNounClassAndBase(nameElem, phrase, shortForm);
+        if (!shortForm) {
+            // <variant refids="plural" value="droits utilisateurs"
+            for (final VariantKey explicitVariant : explicitVariants) {
+                final Element variantElem = new Element(VARIANT_ATTR);
+                variantElem.setAttribute(VARIANT_REFIDS_ATTR, explicitVariant.getID());
+                variantElem.setAttribute(VARIANT_VALUE_ATTR, phrase.getVariant(explicitVariant));
+                nameElem.addContent(variantElem);
+            }
+        } else if (explicitVariants.contains(Grammar.PLURAL)) {
+            elem.setAttribute(NAME_PLURAL_ATTR, phrase.getVariant(Grammar.PLURAL));
+        }
+        return elem;
+    }
+}

Dépôt officiel du code source de l'ERP OpenConcerto

svn://code.openconcerto.org/openconcerto

(root)/trunk/OpenConcerto/src/org/openconcerto/sql/element/SQLElementNamesFromXML.java - Rev 132 → 156