ArchetypeTypeParser.java

Go to the documentation of this file.

/*
 * Gridarta MMORPG map editor for Crossfire, Daimonin and similar games.
 * Copyright (C) 2000-2015 The Gridarta Developers.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */

package net.sf.gridarta.model.archetypetype;

import java.util.Collection;
import java.util.HashSet;
import java.util.LinkedHashSet;
import net.sf.gridarta.model.errorview.ErrorViewCategory;
import net.sf.gridarta.model.errorview.ErrorViewCollector;
import net.sf.gridarta.utils.StringUtils;
import net.sf.gridarta.utils.xml.ElementsIterable;
import nu.xom.Attribute;
import nu.xom.Element;
import nu.xom.Elements;
import org.apache.log4j.Category;
import org.apache.log4j.Logger;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;

public class ArchetypeTypeParser {

    @NotNull
    private static final int[] EMPTY_INT_ARRAY = new int[0];

    @NotNull
    private static final Category LOG = Logger.getLogger(ArchetypeTypeParser.class);

    @NotNull
    private final ArchetypeAttributeParser archetypeAttributeParser;

    public ArchetypeTypeParser(@NotNull final ArchetypeAttributeParser archetypeAttributeParser) {
        this.archetypeAttributeParser = archetypeAttributeParser;
    }

    @NotNull
    public ArchetypeType loadAttributeList(@NotNull final Element typeElement, @NotNull final ErrorViewCollector errorViewCollector, @Nullable final ArchetypeType parentArchetypeType, @NotNull final ArchetypeTypeSet archetypeTypeSet, @NotNull final IgnorelistsDefinition ignorelistsDefinition, final boolean isDefaultType) {
        final String typeName = parseTypeName(typeElement, isDefaultType);
        if (LOG.isDebugEnabled()) {
            LOG.debug("loadAttributeList: " + typeName);
        }
        final int typeNo = parseTypeNo(typeElement, isDefaultType, typeName, errorViewCollector);
        final Attribute typeElementAttribute = typeElement.getAttribute(Constants.XML_TYPE_DISPLAY);
        final String display = typeElementAttribute == null ? "" : typeElementAttribute.getValue();
        final boolean map = parseMap(typeElement);
        final int[] inv = parseInv(typeElement, typeName, errorViewCollector);
        final boolean allowsAllInv = parseAllowsAllInv(typeElement);
        final Collection<String> ignoreTable = new HashSet<>();
        final ArchetypeAttributesDefinition typeAttributes = isDefaultType ? new ArchetypeAttributesDefinition() : parseTypeAttributes(typeElement, typeName, errorViewCollector, ignoreTable, ignorelistsDefinition);

        final Collection<String> importTypes = new LinkedHashSet<>();
        for (final Element importTypeElement : new ElementsIterable(typeElement.getChildElements(Constants.XML_ELEMENT_IMPORT_TYPE))) {
            final String importType = parseImportType(importTypeElement, typeName, errorViewCollector);
            if (importType != null && !importTypes.add(importType)) {
                errorViewCollector.addWarning(ErrorViewCategory.TYPES_ENTRY_INVALID, "type " + typeName + " has duplicate import for '" + importType + "'.");
            }
        }

        final String defaultSectionName = typeNo == -1 ? ArchetypeAttributeSection.GENERAL_SECTION : ArchetypeAttributeSection.SPECIAL_SECTION;
        final ArchetypeAttributeSection attributeSection = new ArchetypeAttributeSection(defaultSectionName);
        final ArchetypeType newArchetypeType = new ArchetypeType(typeName, typeNo, display, map, inv, allowsAllInv, parseDescription(typeElement), parseUse(typeElement), typeAttributes);
        final Iterable<ArchetypeAttributeSection> attributeList = addAttributeList(typeElement, attributeSection, errorViewCollector, typeName, archetypeTypeSet);
        if (LOG.isDebugEnabled()) {
            LOG.debug("loadAttributeList: adding default section " + attributeSection);
        }
        newArchetypeType.addAttributeSection(attributeSection);
        for (final ArchetypeAttributeSection archetypeAttributeSection : attributeList) {
            if (LOG.isDebugEnabled()) {
                LOG.debug("loadAttributeList: adding section " + archetypeAttributeSection);
            }
            newArchetypeType.addAttributeSection(archetypeAttributeSection);
        }
        if (parentArchetypeType != null) {
            if (LOG.isDebugEnabled()) {
                LOG.debug("loadAttributeList: importing attributes from parent archetype type " + parentArchetypeType.getTypeName());
            }
            final Collection<String> autoIgnoreTable = new HashSet<>();
            for (final ArchetypeAttributeSection archetypeAttributeSection : attributeList) {
                for (final ArchetypeAttribute attribute : archetypeAttributeSection) {
                    if (LOG.isDebugEnabled()) {
                        LOG.debug("loadAttributeList: auto-ignore: " + attribute.getArchetypeAttributeName() + " [parent]");
                    }
                    autoIgnoreTable.add(attribute.getArchetypeAttributeName());
                }
            }
            for (final ArchetypeAttribute attribute : attributeSection) {
                if (LOG.isDebugEnabled()) {
                    LOG.debug("loadAttributeList: auto-ignore: " + attribute.getArchetypeAttributeName() + " [this]");
                }
                autoIgnoreTable.add(attribute.getArchetypeAttributeName());
            }

            if (parentArchetypeType.hasAttribute()) {
                for (final String importType : importTypes) {
                    if (LOG.isDebugEnabled()) {
                        LOG.debug("loadAttributeList: importing attributes from " + importType);
                    }
                    addImportList(importType, newArchetypeType, errorViewCollector, typeName, archetypeTypeSet, autoIgnoreTable);
                }
            }

            if (LOG.isDebugEnabled()) {
                LOG.debug("loadAttributeList: importing default attributes from " + parentArchetypeType.getTypeName());
            }
            addDefaultList(parentArchetypeType, newArchetypeType, autoIgnoreTable, ignoreTable);
        }

        return newArchetypeType;
    }

    private static void addDefaultList(@NotNull final Iterable<ArchetypeAttributeSection> archetypeType, @NotNull final ArchetypeType newArchetypeType, @NotNull final Collection<String> autoIgnoreTable, @NotNull final Collection<String> ignoreTable) {
        for (final ArchetypeAttributeSection archetypeAttributeSection : archetypeType) {
            for (final ArchetypeAttribute archetypeAttribute : archetypeAttributeSection) {
                // add all attributes from the default_type which are not in the ignoreTable
                final String archetypeAttributeName = archetypeAttribute.getArchetypeAttributeName();
                if (ignoreTable.contains(archetypeAttributeName)) {
                    if (LOG.isDebugEnabled()) {
                        LOG.debug("addDefaultList: skipping " + archetypeAttributeName + " because of ignoreTable");
                    }
                    continue;
                }
                if (autoIgnoreTable.contains(archetypeAttributeName)) {
                    if (LOG.isDebugEnabled()) {
                        LOG.debug("addDefaultList: skipping " + archetypeAttributeName + " because of autoIgnoreTable");
                    }
                    continue;
                }
                if (LOG.isDebugEnabled()) {
                    LOG.debug("addDefaultList: adding " + archetypeAttributeName + " to section " + archetypeAttributeSection);
                }
                newArchetypeType.addArchetypeAttribute(archetypeAttributeSection.getSectionName(), archetypeAttribute);
            }
        }
    }

    private static void addImportList(@NotNull final String importName, @NotNull final ArchetypeType newArchetypeType, @NotNull final ErrorViewCollector errorViewCollector, @NotNull final String typeName, @NotNull final ArchetypeTypeSet archetypeTypeSet, @NotNull final Collection<String> autoIgnoreTable) {
        final ArchetypeType importType = archetypeTypeSet.getArchetypeType(importName);
        if (importType == null) {
            if (LOG.isDebugEnabled()) {
                LOG.debug("addImportList: skipping " + importName + " because it does not exist");
            }
            errorViewCollector.addWarning(ErrorViewCategory.TYPES_ENTRY_INVALID, typeName + ": import type \"" + importName + "\" not found!");
            return;
        }

        for (final ArchetypeAttributeSection archetypeAttributeSection : importType) {
            final String sectionName = archetypeAttributeSection.getSectionName();
            if (sectionName.equals(ArchetypeAttributeSection.GENERAL_SECTION)) {
                if (LOG.isDebugEnabled()) {
                    LOG.debug("addImportList: skipping section " + sectionName + " because it is the general section");
                }
                continue;
            }

            for (final ArchetypeAttribute archetypeAttribute : archetypeAttributeSection) {
                final String attributeName = archetypeAttribute.getArchetypeAttributeName();
                if (autoIgnoreTable.contains(attributeName)) {
                    if (LOG.isDebugEnabled()) {
                        LOG.debug("addImportList: skipping " + attributeName + " because of autoIgnoreTable");
                    }
                    continue;
                }

                if (LOG.isDebugEnabled()) {
                    LOG.debug("addImportList: adding " + archetypeAttribute + " to section " + sectionName);
                }
                newArchetypeType.addArchetypeAttribute(sectionName, archetypeAttribute);
                if (LOG.isDebugEnabled()) {
                    LOG.debug("addImportList: auto-ignore: " + attributeName + " [import]");
                }
                autoIgnoreTable.add(attributeName);
            }
        }
    }

    @Nullable
    private static String parseImportType(@NotNull final Element importTypeElement, @NotNull final String typeName, @NotNull final ErrorViewCollector errorViewCollector) {
        final Attribute nameAttribute = importTypeElement.getAttribute(Constants.XML_IMPORT_TYPE_NAME);
        if (nameAttribute == null) {
            errorViewCollector.addWarning(ErrorViewCategory.TYPES_ENTRY_INVALID, "type " + typeName + " has " + Constants.XML_ELEMENT_IMPORT_TYPE + " element without '" + Constants.XML_IMPORT_TYPE_NAME + "'.");
            return null;
        }

        final String name = nameAttribute.getValue();
        if (name.isEmpty()) {
            errorViewCollector.addWarning(ErrorViewCategory.TYPES_ENTRY_INVALID, "type " + typeName + " has " + Constants.XML_ELEMENT_IMPORT_TYPE + " element with empty '" + Constants.XML_IMPORT_TYPE_NAME + "'.");
            return null;
        }

        return name;
    }

    @NotNull
    private static String parseTypeName(@NotNull final Element typeElement, final boolean isDefaultType) {
        return isDefaultType ? "default" : typeElement.getAttribute(Constants.XML_TYPE_NAME).getValue();
    }

    private static int parseTypeNo(@NotNull final Element typeElement, final boolean isDefaultType, @NotNull final String typeName, @NotNull final ErrorViewCollector errorViewCollector) {
        if (isDefaultType) {
            return -1;
        }

        final String number = typeElement.getAttribute(Constants.XML_TYPE_NUMBER).getValue();
        try {
            return Integer.parseInt(number);
        } catch (final NumberFormatException ignored) {
            errorViewCollector.addWarning(ErrorViewCategory.TYPES_ENTRY_INVALID, "type " + typeName + " has invalid type number '" + number + "'.");
            return -1;
        }
    }

    private static boolean parseMap(@NotNull final Element typeElement) {
        final Attribute attribute = typeElement.getAttribute(Constants.XML_TYPE_MAP);
        return attribute != null && attribute.getValue().equals("yes");
    }

    @Nullable
    private static int[] parseInv(@NotNull final Element typeElement, @NotNull final String typeName, @NotNull final ErrorViewCollector errorViewCollector) {
        final Attribute attribute = typeElement.getAttribute(Constants.XML_TYPE_INV);
        if (attribute == null) {
            return null;
        }

        final String inv = attribute.getValue();
        if (inv.isEmpty()) {
            return EMPTY_INT_ARRAY;
        }
        if (inv.equals("*")) {
            return null;
        }

        final String[] types = StringUtils.PATTERN_COMMA.split(inv, -1);
        final int[] result = new int[types.length];
        for (int i = 0; i < types.length; i++) {
            try {
                result[i] = Integer.parseInt(types[i]);
            } catch (final NumberFormatException ignored) {
                errorViewCollector.addWarning(ErrorViewCategory.TYPES_ENTRY_INVALID, "type " + typeName + " has invalid inv specification '" + types[i] + "'.");
                result[i] = -1;
            }
        }
        return result;
    }

    private static boolean parseAllowsAllInv(@NotNull final Element typeElement) {
        final Attribute attribute = typeElement.getAttribute(Constants.XML_TYPE_ALLOWS_ALL_INV);
        return attribute != null && attribute.getValue().equals("yes");
    }

    @NotNull
    private static ArchetypeAttributesDefinition parseTypeAttributes(@NotNull final Element typeElement, @NotNull final String typeName, @NotNull final ErrorViewCollector errorViewCollector, @NotNull final Collection<String> ignoreTable, @NotNull final IgnorelistsDefinition ignorelistsDefinition) {
        final ArchetypeAttributesDefinition typeAttributes = parseRequiredAttribute(typeElement, typeName, errorViewCollector);

        final Elements ignoreElements = typeElement.getChildElements(Constants.XML_ELEMENT_IGNORE);
        if (ignoreElements.size() > 0) {
            final Element ignoreElement = ignoreElements.get(0);
            parseAttributeAttributes(ignoreElement, typeName, errorViewCollector, ignoreTable);
            parseIgnoreListAttribute(ignoreElement, typeName, errorViewCollector, ignoreTable, ignorelistsDefinition);
        }

        return typeAttributes;
    }

    @NotNull
    private static ArchetypeAttributesDefinition parseRequiredAttribute(@NotNull final Element typeElement, @NotNull final String typeName, @NotNull final ErrorViewCollector errorViewCollector) {
        final ArchetypeAttributesDefinition attributes = new ArchetypeAttributesDefinition();
        final Elements requiredElements = typeElement.getChildElements(Constants.XML_ELEMENT_REQUIRED);
        if (requiredElements.size() > 0) {
            for (final Element attributeElement : new ElementsIterable(requiredElements.get(0).getChildElements(Constants.XML_ELEMENT_ATTRIBUTE))) {
                final Attribute archAttribute = attributeElement.getAttribute(Constants.XML_ATTRIBUTE_ARCH);
                if (archAttribute == null) {
                    errorViewCollector.addWarning(ErrorViewCategory.TYPES_ENTRY_INVALID, Constants.XML_ELEMENT_REQUIRED + ": element of type " + typeName + ": " + Constants.XML_ELEMENT_ATTRIBUTE + " missing '" + Constants.XML_ATTRIBUTE_ARCH + "'.");
                    continue;
                }
                final String attributeValue = archAttribute.getValue();
                if (attributeValue.isEmpty()) {
                    errorViewCollector.addWarning(ErrorViewCategory.TYPES_ENTRY_INVALID, Constants.XML_ELEMENT_REQUIRED + ": element of type " + typeName + ": " + Constants.XML_ELEMENT_ATTRIBUTE + " empty '" + Constants.XML_ATTRIBUTE_ARCH + "'.");
                    continue;
                }

                final Attribute valueAttribute = attributeElement.getAttribute(Constants.XML_ATTRIBUTE_VALUE);
                if (valueAttribute == null) {
                    errorViewCollector.addWarning(ErrorViewCategory.TYPES_ENTRY_INVALID, Constants.XML_ELEMENT_REQUIRED + ": element of type " + typeName + ": " + Constants.XML_ELEMENT_ATTRIBUTE + " missing '" + Constants.XML_ATTRIBUTE_VALUE + "'.");
                    continue;
                }
                final String value = valueAttribute.getValue();
                if (value.isEmpty()) {
                    errorViewCollector.addWarning(ErrorViewCategory.TYPES_ENTRY_INVALID, Constants.XML_ELEMENT_REQUIRED + ": element of type " + typeName + ": " + Constants.XML_ELEMENT_ATTRIBUTE + " empty '" + Constants.XML_ATTRIBUTE_VALUE + "'.");
                    continue;
                }

                attributes.add(new ArchetypeAttributeDefinition(attributeValue, value));
            }
        }
        return attributes;
    }

    private static void parseAttributeAttributes(@NotNull final Element ignoreElement, @NotNull final String typeName, @NotNull final ErrorViewCollector errorViewCollector, @NotNull final Collection<String> ignoreTable) {
        for (final Element attributeElement : new ElementsIterable(ignoreElement.getChildElements(Constants.XML_ELEMENT_ATTRIBUTE))) {
            final Attribute archAttribute = attributeElement.getAttribute(Constants.XML_ATTRIBUTE_ARCH);
            if (archAttribute == null) {
                errorViewCollector.addWarning(ErrorViewCategory.TYPES_ENTRY_INVALID, Constants.XML_ELEMENT_IGNORE + ": section of type " + typeName + ": " + Constants.XML_ELEMENT_ATTRIBUTE + " missing '" + Constants.XML_ATTRIBUTE_ARCH + "'.");
                continue;
            }

            final String attributeValue = archAttribute.getValue();
            if (attributeValue.isEmpty()) {
                errorViewCollector.addWarning(ErrorViewCategory.TYPES_ENTRY_INVALID, Constants.XML_ELEMENT_IGNORE + ": section of type " + typeName + ": " + Constants.XML_ELEMENT_ATTRIBUTE + " empty '" + Constants.XML_ATTRIBUTE_ARCH + "'.");
                continue;
            }

            ignoreTable.add(attributeValue);
        }
    }

    private static void parseIgnoreListAttribute(@NotNull final Element ignoreElement, @NotNull final String typeName, @NotNull final ErrorViewCollector errorViewCollector, @NotNull final Collection<String> ignoreTable, @NotNull final IgnorelistsDefinition ignorelistsDefinition) {
        for (final Element ignoreListElement : new ElementsIterable(ignoreElement.getChildElements(Constants.XML_ELEMENT_IGNORE_LIST))) {
            final Attribute nameAttribute = ignoreListElement.getAttribute(Constants.XML_IGNORE_LIST_NAME);
            if (nameAttribute == null) {
                errorViewCollector.addWarning(ErrorViewCategory.TYPES_ENTRY_INVALID, Constants.XML_ELEMENT_IGNORE + ": section of type " + typeName + ": " + Constants.XML_ELEMENT_IGNORE_LIST + " missing '" + Constants.XML_IGNORE_LIST_NAME + "'.");
                continue;
            }

            final String name = nameAttribute.getValue();
            final Iterable<String> ignoreList = ignorelistsDefinition.get(name);
            if (ignoreList == null) {
                errorViewCollector.addWarning(ErrorViewCategory.TYPES_ENTRY_INVALID, Constants.XML_ELEMENT_IGNORE + ": section of type " + typeName + ": " + Constants.XML_ELEMENT_IGNORE_LIST + " with " + Constants.XML_IGNORE_LIST_NAME + " \"" + name + "\" is undefined.");
                continue;
            }

            for (final String ignoreItem : ignoreList) {
                ignoreTable.add(ignoreItem);
            }
        }
    }

    @Nullable
    private static String parseDescription(@NotNull final Element root) {
        final Elements elements = root.getChildElements(Constants.XML_DESCRIPTION);
        return elements.size() == 0 ? null : elements.get(0).getValue().trim();
    }

    @Nullable
    private static String parseUse(@NotNull final Element root) {
        final Elements elements = root.getChildElements(Constants.XML_USE);
        return elements.size() == 0 ? null : elements.get(0).getValue().trim();
    }

    @NotNull
    private Iterable<ArchetypeAttributeSection> addAttributeList(@NotNull final Element typeElement, @NotNull final ArchetypeAttributeSection defaultAttributeSection, @NotNull final ErrorViewCollector errorViewCollector, @NotNull final String typeName, @NotNull final ArchetypeTypeSet archetypeTypeSet) {
        final ArchetypeAttributeSections sections = new ArchetypeAttributeSections();
        for (final Element childElement : new ElementsIterable(typeElement.getChildElements())) {
            final String childName = childElement.getLocalName();

            if (childName.equals(Constants.XML_ELEMENT_ATTRIBUTE)) {
                parseAttribute(childElement, errorViewCollector, typeName, archetypeTypeSet, sections, defaultAttributeSection.getSectionName());
            } else if (childName.equals(Constants.XML_ELEMENT_SECTION) && childElement.getChildElements().size() > 0) {
                final Attribute nameAttribute = childElement.getAttribute(Constants.XML_SECTION_NAME);
                if (nameAttribute == null) {
                    errorViewCollector.addWarning(ErrorViewCategory.TYPES_ENTRY_INVALID, "type " + typeName + " contains a " + Constants.XML_ELEMENT_SECTION + " missing '" + Constants.XML_SECTION_NAME + "'.");
                    continue;
                }

                final String sectionName = nameAttribute.getValue();
                if (sectionName.isEmpty()) {
                    errorViewCollector.addWarning(ErrorViewCategory.TYPES_ENTRY_INVALID, "type " + typeName + " contains a " + Constants.XML_ELEMENT_SECTION + " with empty '" + Constants.XML_SECTION_NAME + "'.");
                    continue;
                }

                for (final Element element : new ElementsIterable(childElement.getChildElements(Constants.XML_ELEMENT_ATTRIBUTE))) {
                    parseAttribute(element, errorViewCollector, typeName, archetypeTypeSet, sections, sectionName);
                }
            }
        }
        return sections;
    }

    private void parseAttribute(@NotNull final Element attributeElement, @NotNull final ErrorViewCollector errorViewCollector, @NotNull final String typeName, @NotNull final ArchetypeTypeSet archetypeTypeSet, @NotNull final ArchetypeAttributeSections sections, @NotNull final String sectionName) {
        final ArchetypeAttribute archetypeAttribute = parseAttribute(attributeElement, errorViewCollector, typeName, archetypeTypeSet);
        if (archetypeAttribute == null) {
            return;
        }

        final String effectiveSectionName = archetypeAttribute instanceof ArchetypeAttributeText ? archetypeAttribute.getAttributeName() : sectionName; // text attributes get their own section
        sections.addArchetypeAttribute(effectiveSectionName, archetypeAttribute);
    }

    @Nullable
    private ArchetypeAttribute parseAttribute(@NotNull final Element attributeElement, @NotNull final ErrorViewCollector errorViewCollector, @NotNull final String typeName, @NotNull final ArchetypeTypeSet archetypeTypeSet) {
        try {
            return archetypeAttributeParser.load(attributeElement, errorViewCollector, archetypeTypeSet, typeName);
        } catch (final MissingAttributeException ex) {
            errorViewCollector.addWarning(ErrorViewCategory.TYPES_ENTRY_INVALID, "type " + typeName + ": " + ex.getMessage());
            return null;
        }
    }

}