Application: gvSIG desktop » Library: org.gvsig.tools

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright (C) 2007-2013 gvSIG Association.

 *

 * 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.

 *

 * For any additional information, do not hesitate to contact us at info AT

 * gvsig.com, or visit our website www.gvsig.com.

 */

package org.gvsig.tools.dynobject.impl;

import java.io.IOException;

import java.io.InputStream;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.Iterator;

import java.util.LinkedHashMap;

import java.util.List;

import java.util.Map;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dataTypes.CoercionException;

import org.gvsig.tools.dataTypes.DataTypes;

import org.gvsig.tools.dynobject.DynClass;

import org.gvsig.tools.dynobject.DynClassName;

import org.gvsig.tools.dynobject.DynClass_v2;

import org.gvsig.tools.dynobject.DynField_v2;

import org.gvsig.tools.dynobject.DynMethod;

import org.gvsig.tools.dynobject.DynObjectManager;

import org.gvsig.tools.dynobject.DynObjectRuntimeException;

import org.gvsig.tools.dynobject.DynObjectValueItem;

import org.gvsig.tools.dynobject.Tags;

import org.gvsig.tools.dynobject.exception.DynFieldIsNotAContainerException;

import org.gvsig.tools.dynobject.exception.DynMethodException;

import org.gvsig.tools.exception.BaseRuntimeException;

import org.gvsig.tools.exception.ListBaseException;

import org.gvsig.tools.script.Script;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.xmlpull.v1.XmlPullParser;

import org.xmlpull.v1.XmlPullParserException;

import org.xmlpull.v1.XmlPullParserFactory;

public class DynClassImportHelper implements DynClassImportExportTags {

    private static final Logger LOG = LoggerFactory

            .getLogger(DynClassImportHelper.class);

    private DynObjectManager manager = ToolsLocator.getDynObjectManager();

    private Map dynClasses = null;

    private Tags globalTags = null;

    private List<Runnable> postLoadActions = new ArrayList<>();

    private class SetCalculateMethodAction implements Runnable {

        private final DynField_v2 field;

        private final String methodName;

        public SetCalculateMethodAction(DynField_v2 field, String methodName) {

            this.field = field;

            this.methodName = methodName;

        }

        @Override

        public void run() {

            DynMethod method = null;

            try {

                method = manager.getDynMethod(methodName);

                field.setCalculateMethod(method);

            } catch (DynMethodException ex) {

                LOG.warn("Cant create calculate field", ex);

            }

        }

    }

    private class SetDynClassOfItemsAction implements Runnable {

        private final DynField_v2 field;

        private final String dynClassName;

        public SetDynClassOfItemsAction(DynField_v2 field, String dynClassName) {

            this.field = field;

            this.dynClassName = dynClassName;

        }

        @Override

        public void run() {

            DynClass dynStruct = (DynClass) dynClasses.get(dynClassName);

            if (dynStruct == null) {

                // Try to search in registered DynClasses

                field.setClassOfItems(dynClassName);

            } else {

                field.setClassOfItems(dynStruct);

            }

        }

    }    

    private class SetDynClassOfValueAction implements Runnable {

        private final DynField_v2 field;

        private final String dynClassName;

        public SetDynClassOfValueAction(DynField_v2 field, String dynClassName) {

            this.field = field;

            this.dynClassName = dynClassName;

        }

        @Override

        public void run() {

            DynClass dynStruct = (DynClass) dynClasses.get(dynClassName);

            if (dynStruct == null) {

                // Try to search in registered DynClasses

                field.setClassOfValue(dynClassName);

            } else {

                field.setClassOfValue(dynStruct);

            }

        }

    }

    private String getNullWhenEmptyString(String value) {

        if (value != null) {

            if (value.trim().length() == 0) {

                return null;

            }

        }

        return value;

    }

    private String nextText(XmlPullParser parser)

            throws XmlPullParserException, IOException {

        return getNullWhenEmptyString(parser.nextText());

    }

    private String getAttributeValue(XmlPullParser parser, int i)

            throws XmlPullParserException, IOException {

        return getNullWhenEmptyString(parser.getAttributeValue(i));

    }

    public Map importDefinitions(InputStream resource, ClassLoader loader,

            String defaultNamespace) throws XmlPullParserException, IOException {

        XmlPullParserFactory factory = XmlPullParserFactory.newInstance(

                ToolsLocator.getInstance().getXmlPullParserFactoryClassNames(),

                null);

        XmlPullParser parser = factory.newPullParser();

        parser.setInput(resource, null);

        return importDefinitions(parser, loader, defaultNamespace);

    }

    private class Definitions extends HashMap implements Map {

        /**

         *

         */

        private static final long serialVersionUID = -3322643637478345069L;

        public Object put(Object key, Object value) {

            return super.put(((String) key).toLowerCase(), value);

        }

        public Object get(Object theName) {

            DynClass definition;

            definition = (DynClass) super.get(((String) theName).toLowerCase());

            if (definition != null) {

                return definition;

            }

            // No ha encontrado la clase pedida, podria ser que el namespace

            // no coincida, vamos a buscarla ignorando el namespace en caso

            // de que este no se haya indicado.

            DynClassName name = manager.createDynClassName((String) theName);

            if (name.getNamespace() == null) {

                // No han especificado namespace, asi que busco la primera

                // que tenga como nombre el indicado independientemente del

                // namespace que tenga.

                Iterator it = this.values().iterator();

                while (it.hasNext()) {

                    definition = (DynClass) it.next();

                    if (definition.getName().equalsIgnoreCase(name.getName())) {

                        return definition;

                    }

                }

            } else {

                // Han especificaso un namespace, asi que voy a buscar una que

                // no tenga namespace y su nombre concuerde.

                Iterator it = this.values().iterator();

                while (it.hasNext()) {

                    definition = (DynClass) it.next();

                    if (definition.getNamespace() == null

                            && definition.getName().equalsIgnoreCase(

                                    name.getName())) {

                        return definition;

                    }

                }

            }

            return null;

        }

        public boolean containsKey(Object key) {

            String lowerKey = ((String) key).toLowerCase();

            if (super.containsKey(lowerKey)) {

                return true;

            }

            Object value = this.get(lowerKey);

            return value != null;

        }

    }

    public Map importDefinitions(XmlPullParser parser, ClassLoader loader,

            String defaultNamespace) throws XmlPullParserException, IOException {

        dynClasses = new Definitions();

        globalTags = new DefaultTags();

        String version = null;

        if (loader == null) {

            loader = this.getClass().getClassLoader();

        }

        parser.nextTag();

        parser.require(XmlPullParser.START_TAG, null, DEFINITIONS_TAG);

        for (int i = 0; i < parser.getAttributeCount(); i++) {

            String name = parser.getAttributeName(i);

            if (name.equalsIgnoreCase(VERSION_TAG)) {

                version = this.getAttributeValue(parser, i);

            } else {

                throw new WrongVersionException(parser);

            }

        }

        parser.nextTag();

        if (parser.getName().equalsIgnoreCase(VERSION_TAG)) {

            parser.require(XmlPullParser.START_TAG, null, VERSION_TAG);

            version = parser.nextText();

            if (!version.trim().equals(VERSION_VALUE)) {

                throw new UnsupportedClassVersionError();

            }

            parser.require(XmlPullParser.END_TAG, "", VERSION_TAG);

            parser.nextTag();

        }

        if (parser.getName().equalsIgnoreCase(FIELD_TAGS_TAG)) {

            parser.nextTag();

            while (!(parser.getEventType() == XmlPullParser.END_TAG && parser

                    .getName().equals(FIELD_TAGS_TAG))) {

                checkEndDocument(parser);

                PairValueLabel pair = importValueItem(parser, VALUEITEM_TAGNAME_TAG);

                this.globalTags.set(pair.label, pair.value);

                parser.nextTag();

            }

        }

        parser.require(XmlPullParser.START_TAG, "", CLASSES_TAG);

        parser.nextTag();

        while (!(parser.getEventType() == XmlPullParser.END_TAG && parser

                .getName().equals(CLASSES_TAG))) {

            checkEndDocument(parser);

            DynClass dynClass = importDynClass(parser, loader,

                    defaultNamespace, dynClasses);

            try {

                ((DefaultDynClass) dynClass).check();

            } catch (ListBaseException e) {

                throw new DynObjectRuntimeException(e);

            }

            if (dynClasses.get(dynClass.getFullName()) != null) {

                throw new DuplicateDynClassException(parser,

                        dynClass.getFullName());

            }

            dynClasses.put(dynClass.getFullName(), dynClass);

        }

        parser.require(XmlPullParser.END_TAG, "", CLASSES_TAG);

        parser.nextTag();

        parser.require(XmlPullParser.END_TAG, "", DEFINITIONS_TAG);

        parser.next();

        parser.require(XmlPullParser.END_DOCUMENT, null, null);

        for( Runnable postaction : this.postLoadActions ) {

            postaction.run();

        }

        LOG.debug("Imported classes {}", new Object[]{getKeys(dynClasses)});

        return dynClasses;

    }

    private String getKeys(Map theMap) {

        List l = new ArrayList(theMap.keySet());

        return l.toString();

    }

    private DynClass importDynClass(XmlPullParser parser, ClassLoader loader,

            String defaultNamespace, Map classes)

            throws XmlPullParserException, IOException {

        DynObjectManager manager = ToolsLocator.getDynObjectManager();

        DynClass_v2 dynClass;

        List superClasses = new ArrayList();

        Map values = new HashMap();

        List tagsValues = null;

        parser.require(XmlPullParser.START_TAG, null, CLASS_TAG);

        //

        // Collect class attributes from tag attributes

        //

        for (int i = 0; i < parser.getAttributeCount(); i++) {

            values.put(parser.getAttributeName(i),

                    this.getAttributeValue(parser, i));

        }

        parser.nextTag();

        while (!(parser.getEventType() == XmlPullParser.END_TAG && parser.getName().equals(CLASSES_TAG))) {

            // Es preciso que exista el tag fields aunque este vacio, si no falla

            // el parseo tal como esta implememtado.

            checkEndDocument(parser);

            parser.require(XmlPullParser.START_TAG, null, null);

            String tagName = parser.getName();

            if (tagName.equalsIgnoreCase(CLASS_DESCRIPTION_TAG)) {

                values.put(CLASS_DESCRIPTION_TAG, this.nextText(parser));

            } else if (tagName.equalsIgnoreCase(CLASS_NAME_TAG)) {

                values.put(CLASS_NAME_TAG, this.nextText(parser));

            } else if (tagName.equalsIgnoreCase(CLASS_LABEL_TAG)) {

                values.put(CLASS_LABEL_TAG, this.nextText(parser));

            } else if (tagName.equalsIgnoreCase(CLASS_NAMESPACE_TAG)) {

                values.put(CLASS_NAMESPACE_TAG, this.nextText(parser));

            } else if (tagName.equalsIgnoreCase(CLASS_SUPERCLASSNAMES_TAG)) {

                parser.nextTag();

                while (!(parser.getEventType() == XmlPullParser.END_TAG && parser

                        .getName().equals(CLASS_SUPERCLASSNAMES_TAG))) {

                    checkEndDocument(parser);

                    parser.require(XmlPullParser.START_TAG, "",

                            CLASS_SUPERCLASSNAME_TAG);

                    superClasses.add(manager.createDynClassName(

                            defaultNamespace, this.nextText(parser)));

                    parser.require(XmlPullParser.END_TAG, null,

                            CLASS_SUPERCLASSNAME_TAG);

                    parser.nextTag();

                }

            } else if (tagName.equalsIgnoreCase(CLASS_EXTENDS_TAG)) {

                parser.nextTag();

                while (!(parser.getEventType() == XmlPullParser.END_TAG && parser

                        .getName().equals(CLASS_EXTENDS_TAG))) {

                    checkEndDocument(parser);

                    superClasses

                            .add(importSuperClass(parser, defaultNamespace));

                    parser.nextTag();

                }

            } else if (tagName.equalsIgnoreCase(CLASS_TAGS_TAG)) {

                parser.nextTag();

                tagsValues = new ArrayList();

                while (!(parser.getEventType() == XmlPullParser.END_TAG && parser

                        .getName().equals(CLASS_TAGS_TAG))) {

                    checkEndDocument(parser);

                    tagsValues.add(importValueItem(parser, VALUEITEM_TAGNAME_TAG));

                    parser.nextTag();

                }

            } else if (tagName.equalsIgnoreCase(CLASS_CODE_TAG)) {

                String langcode = parser.getAttributeValue(null, CLASS_LANGCODE_TAG);

                if (StringUtils.isEmpty(langcode)) {

                    langcode = "python";

                }

                values.put(CLASS_CODE_TAG, this.nextText(parser));

                values.put(CLASS_LANGCODE_TAG, langcode);

            } else {

                break;

            }

            parser.require(XmlPullParser.END_TAG, null, tagName);

            parser.nextTag();

        }

        parser.require(XmlPullParser.START_TAG, null, CLASS_FIELDS_TAG);

        parser.nextTag();

        //

        // Create dynclass

        //

        if (values.get(CLASS_NAME_TAG) == null) {

            throw new NeedTagOrAttributeException(parser, CLASS_NAME_TAG);

        }

        if (values.get(CLASS_NAMESPACE_TAG) == null) {

            values.put(CLASS_NAMESPACE_TAG, defaultNamespace);

        }

        dynClass = (DynClass_v2) manager.createDynClass(

                (String) values.get(CLASS_NAMESPACE_TAG),

                (String) values.get(CLASS_NAME_TAG),

                (String) values.get(CLASS_DESCRIPTION_TAG));

        dynClass.getTags().add(globalTags);

        if (values.get(CLASS_CODE_TAG) != null) {

            Script script = ToolsLocator.getScriptManager().createScript(

                    dynClass.getName(),

                    (String) (values.get(CLASS_CODE_TAG)),

                    (String) (values.get(CLASS_LANGCODE_TAG))

            );

            dynClass.setScript(script);

        }

        if (values.get(CLASS_LABEL_TAG) != null) {

            dynClass.setLabel((String) (values.get(CLASS_LABEL_TAG)));

        }

        for (int i = 0; i < superClasses.size(); i++) {

            DynClassName superClass = (DynClassName) superClasses.get(i);

            if (superClass.getName() == null) {

                throw new NeedTagOrAttributeException(parser, CLASS_NAME_TAG);

            }

            DynClass superDynClass = (DynClass) classes.get(superClass

                    .getFullName());

            if (superDynClass == null) {

                superDynClass = ToolsLocator.getDynObjectManager().get(

                        superClass.getNamespace(), superClass.getName());

                if (superDynClass == null) {

                    throw new CantLocateDynClassException(parser,

                            superClass.getFullName());

                }

            }

            dynClass.extend(superDynClass);

        }

        if (tagsValues != null && !tagsValues.isEmpty()) {

            if (dynClass instanceof DynClass_v2) {

                for (int i = 0; i < tagsValues.size(); i++) {

                    PairValueLabel pair = (PairValueLabel) tagsValues.get(i);

                    if (pair.label != null) {

                        ((DynClass_v2) dynClass).getTags().set(pair.label, pair.value);

                    }

                }

            }

        }

        //

        // Parse and load fields of dynclass

        //

        while (!(parser.getEventType() == XmlPullParser.END_TAG && parser

                .getName().equals(CLASS_FIELDS_TAG))) {

            checkEndDocument(parser);

            importDynField(parser, (DynClass_v2) dynClass, loader);

            parser.nextTag();

        }

        parser.require(XmlPullParser.END_TAG, null, CLASS_FIELDS_TAG);

        parser.nextTag();

        parser.require(XmlPullParser.END_TAG, null, CLASS_TAG);

        parser.nextTag();

        return dynClass;

    }

    private DynClassName importSuperClass(XmlPullParser parser,

            String defaultNamespace) throws XmlPullParserException, IOException {

        String name = null;

        String namespace = defaultNamespace;

        parser.require(XmlPullParser.START_TAG, null, CLASS_EXTENDS_CLASS_TAG);

        for (int i = 0; i < parser.getAttributeCount(); i++) {

            String attrname = parser.getAttributeName(i);

            if (attrname.equalsIgnoreCase(CLASS_NAME_TAG)) {

                name = this.getAttributeValue(parser, i);

            } else if (attrname.equalsIgnoreCase(CLASS_NAMESPACE_TAG)) {

                namespace = this.getAttributeValue(parser, i);

            } else {

                throw new UnexpectedTagOrAttributeException(parser, attrname);

            }

        }

        if (name == null) {

            name = this.nextText(parser);

        } else {

            parser.nextTag();

        }

        parser.require(XmlPullParser.END_TAG, null, CLASS_EXTENDS_CLASS_TAG);

        DynClassName dynClassName = manager.createDynClassName(namespace, name);

        return dynClassName;

    }

    private void importDynField(XmlPullParser parser, DynClass_v2 dynClass,

            ClassLoader loader) throws XmlPullParserException, IOException {

        DynField_v2 field;

        List availableValues = null;

        List tagsValues = null;

        Map values = new LinkedHashMap();

        parser.require(XmlPullParser.START_TAG, null, FIELD_TAG);

        //

        // Collect field attributes from tag attributes

        //

        for (int i = 0; i < parser.getAttributeCount(); i++) {

            values.put(parser.getAttributeName(i),

                    this.getAttributeValue(parser, i));

        }

        parser.nextTag();

        //

        // Collect field attributes from tags

        //

        while (!(parser.getEventType() == XmlPullParser.END_TAG && parser

                .getName().equals(FIELD_TAG))) {

            checkEndDocument(parser);

            parser.require(XmlPullParser.START_TAG, null, null);

            String name = parser.getName();

            if (name.equalsIgnoreCase(FIELD_NAME_TAG)) {

                values.put(FIELD_NAME_TAG, this.nextText(parser));

            } else if (name.equalsIgnoreCase(FIELD_DESCRIPTION_TAG)) {

                values.put(FIELD_DESCRIPTION_TAG, this.nextText(parser));

            } else if (name.equalsIgnoreCase(FIELD_TYPE_TAG)) {

                values.put(FIELD_TYPE_TAG, this.nextText(parser));

            } else if (name.equalsIgnoreCase(FIELD_SUBTYPE_TAG)) {

                values.put(FIELD_SUBTYPE_TAG, this.nextText(parser));

            } else if (name.equalsIgnoreCase(FIELD_GROUP_TAG)) {

                values.put(FIELD_GROUP_TAG, this.nextText(parser));

            } else if (name.equalsIgnoreCase(FIELD_LABEL_TAG)) {

                values.put(FIELD_LABEL_TAG, this.nextText(parser));

            } else if (name.equalsIgnoreCase(FIELD_ORDER_TAG)) {

                values.put(FIELD_ORDER_TAG, this.nextText(parser));

            } else if (name.equalsIgnoreCase(FIELD_ISMANDATORY_TAG)) {

                values.put(FIELD_ISMANDATORY_TAG, this.nextText(parser));

            } else if (name.equalsIgnoreCase(FIELD_ISPERSISTENT_TAG)) {

                values.put(FIELD_ISPERSISTENT_TAG, this.nextText(parser));

            } else if (name.equalsIgnoreCase(FIELD_MINVALUE_TAG)) {

                values.put(FIELD_MINVALUE_TAG, this.nextText(parser));

            } else if (name.equalsIgnoreCase(FIELD_MAXVALUE_TAG)) {

                values.put(FIELD_MAXVALUE_TAG, this.nextText(parser));

            } else if (name.equalsIgnoreCase(FIELD_CLASSOFVALUE_TAG)) {

                values.put(FIELD_CLASSOFVALUE_TAG, this.nextText(parser));

            } else if (name.equalsIgnoreCase(FIELD_CLASSOFITEMS_TAG)) {

                values.put(FIELD_CLASSOFITEMS_TAG, this.nextText(parser));

            } else if (name.equalsIgnoreCase(FIELD_DEFAULTVALUE_TAG)) {

                values.put(FIELD_DEFAULTVALUE_TAG, this.nextText(parser));

            } else if (name.equalsIgnoreCase(FIELD_HIDDEN_TAG)) {

                values.put(FIELD_HIDDEN_TAG, this.nextText(parser));

            } else if (name.equalsIgnoreCase(FIELD_READONLY_TAG)) {

                values.put(FIELD_READONLY_TAG, this.nextText(parser));

            } else if (name.equalsIgnoreCase(FIELD_CALCULATE_TAG)) {

                values.put(FIELD_CALCULATE_TAG, this.nextText(parser));

            } else if (name.equalsIgnoreCase(FIELD_AVALILABLEVALUES_TAG)) {

                parser.nextTag();

                availableValues = new ArrayList();

                while (!(parser.getEventType() == XmlPullParser.END_TAG && parser

                        .getName().equals(FIELD_AVALILABLEVALUES_TAG))) {

                    checkEndDocument(parser);

                    availableValues.add(importValueItem(parser, VALUEITEM_LABEL_TAG));

                    parser.nextTag();

                }

            } else if (name.equalsIgnoreCase(FIELD_TAGS_TAG)) {

                parser.nextTag();

                tagsValues = new ArrayList();

                while (!(parser.getEventType() == XmlPullParser.END_TAG && parser

                        .getName().equals(FIELD_TAGS_TAG))) {

                    checkEndDocument(parser);

                    tagsValues.add(importValueItem(parser, VALUEITEM_TAGNAME_TAG));

                    parser.nextTag();

                }

            } else {

                break;

            }

            parser.require(XmlPullParser.END_TAG, null, name);

            parser.nextTag();

        }

        parser.require(XmlPullParser.END_TAG, null, FIELD_TAG);

        if (values.get(FIELD_NAME_TAG) == null) {

            throw new NeedTagOrAttributeException(parser, FIELD_NAME_TAG);

        }

        //

        // Get type and subtype first

        //

        String name = FIELD_TYPE_TAG;

        String value = (String) values.get(name);

        if (value == null) {

            throw new InvalidFieldTypeException(parser, value);

        }

        int type = ToolsLocator.getDataTypesManager().getType(value);

        if (type == DataTypes.INVALID) {

            throw new InvalidFieldTypeException(parser, value);

        }

        //

        // Create the field

        //

        field = (DynField_v2) dynClass.addDynField((String) values.get(FIELD_NAME_TAG), type);

        field.getTags().add(dynClass.getTags()); 

        //

        // Load other values in the field

        //

        Iterator names = values.keySet().iterator();

        while (names.hasNext()) {

            name = (String) names.next();

            value = (String) values.get(name);

            if (value == null) {

                continue;

            }

            if (name.equalsIgnoreCase(FIELD_NAME_TAG)) {

                // Do nothing

            } else if (name.equalsIgnoreCase(FIELD_DESCRIPTION_TAG)) {

                field.setDescription(value);

            } else if (name.equalsIgnoreCase(FIELD_CALCULATE_TAG)) {

                this.postLoadActions.add(new SetCalculateMethodAction(field, value));

            } else if (name.equalsIgnoreCase(FIELD_TYPE_TAG)) {

                // Do nothing

            } else if (name.equalsIgnoreCase(FIELD_SUBTYPE_TAG)) {

                field.setSubtype(value);

            } else if (name.equalsIgnoreCase(FIELD_GROUP_TAG)) {

                field.setGroup(value);

            } else if (name.equalsIgnoreCase(FIELD_LABEL_TAG)) {

                this.manager.setAttributeValue(field, "label", value);

            } else if (name.equalsIgnoreCase(FIELD_ORDER_TAG)) {

                field.setOrder(Integer.parseInt(value));

            } else if (name.equalsIgnoreCase(FIELD_ISMANDATORY_TAG)) {

                field.setMandatory(new Boolean(value).booleanValue());

            } else if (name.equalsIgnoreCase(FIELD_ISPERSISTENT_TAG)) {

                field.setPersistent(new Boolean(value).booleanValue());

            } else if (name.equalsIgnoreCase(FIELD_HIDDEN_TAG)) {

                field.setHidden(new Boolean(value).booleanValue());

            } else if (name.equalsIgnoreCase(FIELD_READONLY_TAG)) {

                field.setReadOnly(new Boolean(value).booleanValue());

            } else if (name.equalsIgnoreCase(FIELD_MINVALUE_TAG)) {

                field.setMinValue(value);

            } else if (name.equalsIgnoreCase(FIELD_MAXVALUE_TAG)) {

                field.setMaxValue(value);

            } else if (name.equalsIgnoreCase(FIELD_DEFAULTVALUE_TAG)) {

                field.setDefaultFieldValue(value);

            } else if (name.equalsIgnoreCase(FIELD_TYPEOFITEMS_TAG)) {

                int typeOfItems = ToolsLocator.getDataTypesManager().getType(value);

                if (typeOfItems == DataTypes.INVALID) {

                    throw new InvalidFieldTypeException(parser, value);

                }

                field.setTypeOfItems(typeOfItems);

            } else if (name.equalsIgnoreCase(FIELD_DYNCLASSOFITEMS_TAG)) {

                this.postLoadActions.add(new SetDynClassOfItemsAction(field, value));

            } else if (name.equalsIgnoreCase(FIELD_CLASSOFITEMS_TAG)) {

                if (field.getTypeOfItems() == DataTypes.DYNOBJECT) {

                    this.postLoadActions.add(new SetDynClassOfItemsAction(field, value));

                } else {

                    try {

                        Class klass;

                        klass = Class.forName(value, true, loader);

                        field.setClassOfItems(klass);

                    } catch (DynFieldIsNotAContainerException e) {

                        LOG.warn("No se ha encontrado la clase '" + value + "'.", e);

                        throw new IncompatibleAttributeValueException(parser,

                                FIELD_NAME_TAG);

                    } catch (ClassNotFoundException e) {

                        LOG.warn("No se ha encontrado la clase '" + value + "'.", e);

                        throw new CantLocateClassException(parser, FIELD_CLASSOFITEMS_TAG, value);

                    }

                }

            } else if (name.equalsIgnoreCase(FIELD_CLASSOFVALUE_TAG)) {

                if (field.getType() == DataTypes.DYNOBJECT) {

                    this.postLoadActions.add(new SetDynClassOfValueAction(field, value));

                } else {

                    try {

                        Class klass;

                        klass = Class.forName(value, true, loader);

                        field.setClassOfValue(klass);

                    } catch (DynFieldIsNotAContainerException e) {

                        LOG.warn("No se ha encontrado la clase '" + value + "'.", e);

                        throw new IncompatibleAttributeValueException(parser,

                                FIELD_NAME_TAG);

                    } catch (ClassNotFoundException e) {

                        LOG.warn("No se ha encontrado la clase '" + value + "'.", e);

                        throw new CantLocateClassException(parser, FIELD_CLASSOFVALUE_TAG, value);

                    }

                }

            } else if (name.equalsIgnoreCase(FIELD_AVALILABLEVALUES_TAG)) {

                // Do nothing

            } else {

                throw new UnexpectedTagOrAttributeException(parser, name);

            }

        }

        try {

            //

            // Coerce the min/max/default/available values to the type of

            // the field

            //

            if (availableValues != null && !availableValues.isEmpty()) {

                for (int i = 0; i < availableValues.size(); i++) {

                    PairValueLabel pair = (PairValueLabel) availableValues

                            .get(i);

                    if (pair.label == null) {

                        if (pair.value == null) {

                            pair.label = "null";

                        } else {

                            pair.label = pair.value.toString();

                        }

                    }

                    availableValues.set(i,

                            new DynObjectValueItem(field.coerce(pair.value),

                                    pair.label));

                }

                field.setAvailableValues(availableValues);

            }

            if (tagsValues != null && !tagsValues.isEmpty()) {

                for (int i = 0; i < tagsValues.size(); i++) {

                    PairValueLabel pair = (PairValueLabel) tagsValues.get(i);

                    if (pair.label != null) {

                        field.getTags().set(pair.label, pair.value);

                    }

                }

            }

            field.setMaxValue(field.coerce(values.get(FIELD_MAXVALUE_TAG)));

            field.setMinValue(field.coerce(values.get(FIELD_MINVALUE_TAG)));

            field.setDefaultFieldValue(field.coerce(values

                    .get(FIELD_DEFAULTVALUE_TAG)));

        } catch (CoercionException e) {

            throw new ParseCoerceException(e, parser);

        }

    }

    private class PairValueLabel {

        String label = null;

        String value = null;

    }

    private PairValueLabel importValueItem(XmlPullParser parser, String attributeName)

            throws XmlPullParserException, IOException {

        PairValueLabel pair = new PairValueLabel();

        if (parser.getName().equalsIgnoreCase(VALUEITEM_TAG)) {

            parser.require(XmlPullParser.START_TAG, null, VALUEITEM_TAG);

            for (int i = 0; i < parser.getAttributeCount(); i++) {

                String name = parser.getAttributeName(i);

                if (name.equalsIgnoreCase(attributeName)) {

                    pair.label = this.getAttributeValue(parser, i);

                } else if (name.equalsIgnoreCase(VALUEITEM_VALUE_TAG)) {

                    pair.value = this.getAttributeValue(parser, i);

                } else {

                    throw new UnexpectedTagOrAttributeException(parser, name);

                }

            }

            parser.nextTag();

            while (!(parser.getEventType() == XmlPullParser.END_TAG && parser

                    .getName().equals(VALUEITEM_TAG))) {

                checkEndDocument(parser);

                parser.require(XmlPullParser.START_TAG, null, null);

                String name = parser.getName();

                if (name.equalsIgnoreCase(attributeName)) {

                    pair.label = this.nextText(parser);

                } else if (name.equalsIgnoreCase(VALUEITEM_VALUE_TAG)) {

                    pair.value = this.nextText(parser);

                } else {

                    break;

                }

                parser.require(XmlPullParser.END_TAG, null, name);

                parser.nextTag();

            }

            parser.require(XmlPullParser.END_TAG, null, VALUEITEM_TAG);

        } else {

            parser.require(XmlPullParser.START_TAG, null, VALUEITEM_VALUE_TAG);

            for (int i = 0; i < parser.getAttributeCount(); i++) {

                String name = parser.getAttributeName(i);

                if (name.equalsIgnoreCase(attributeName)) {

                    pair.label = parser.getAttributeValue(i);

                } else if (name.equalsIgnoreCase(VALUEITEM_VALUE_TAG)) {

                    pair.value = this.getAttributeValue(parser, i);

                } else {

                    throw new UnexpectedTagOrAttributeException(parser, name);

                }

            }

            if (pair.value == null) {

                pair.value = parser.nextText();

            } else {

                pair.value += parser.nextText();

            }

            parser.require(XmlPullParser.END_TAG, null, VALUEITEM_VALUE_TAG);

        }

        return pair;

    }

    private void checkEndDocument(XmlPullParser parser)

            throws XmlPullParserException {

        if (parser.getEventType() == XmlPullParser.END_DOCUMENT) {

            throw new UnexpectedTagOrAttributeException(parser,

                    "(end-of-document)");

        }

    }

    public static abstract class ImportDynClassesException extends

            BaseRuntimeException {

        /**

         *

         */

        private static final long serialVersionUID = 3346283395112730192L;

        /**

         * Don't call this constructor form subclasses.

         *

         * @param parser

         */

        public ImportDynClassesException(XmlPullParser parser) {

            super(

                    "Error importing classes from file at line %(line) column %(column).",

                    "_Error_importing_classes_from_file_at_line_XlineX_column_XcolumnX",

                    serialVersionUID);

        }

        protected ImportDynClassesException(XmlPullParser parser, String msg,

                String key, long code) {

            super(

                    "Error importing classes from file at line %(line) column %(column). "

                    + msg, key, code);

            this.setValue("line", new Integer(parser.getLineNumber()));

            this.setValue("column", new Integer(parser.getColumnNumber()));

        }

    }

    public static class DuplicateDynClassException extends

            ImportDynClassesException {

        /**

         *

         */

        private static final long serialVersionUID = 3653024321140806121L;

        public DuplicateDynClassException(XmlPullParser parser, String name) {

            super(parser, "Duplicate DynClass definition for '%(name)'.",

                    "_Duplicate_DynClass_definition_for_XnameX",

                    serialVersionUID);

            this.setValue("name", name);

        }

    }

    public static class InvalidFieldTypeException extends

            ImportDynClassesException {

        /**

         *

         */

        private static final long serialVersionUID = 8501343258053356775L;

        public InvalidFieldTypeException(XmlPullParser parser, String value) {

            super(parser, "Invalid field type '%(value)'.",

                    "_Invalid_field_type_XvalueX", serialVersionUID);

            this.setValue("value", value);

        }

    }

    public static class UnexpectedTagOrAttributeException extends

            ImportDynClassesException {

        /**

         *

         */

        private static final long serialVersionUID = -808282903423455613L;

        public UnexpectedTagOrAttributeException(XmlPullParser parser,

                String tag) {

            super(parser, "Unexpected tag or attribute '%(tag)'.",

                    "_Unexpected_tag_or_attribute_XtagX", serialVersionUID);

            this.setValue("tag", tag);

        }

    }

    public static class NeedTagOrAttributeException extends

            ImportDynClassesException {

        /**

         *

         */

        private static final long serialVersionUID = -808282903423455613L;

        public NeedTagOrAttributeException(XmlPullParser parser, String tag) {

            super(parser, "Need tag or attribute '%(tag)'.",

                    "_Need_tag_or_attribute_XtagX", serialVersionUID);

            this.setValue("tag", tag);

        }

    }

    public static class CantLocateClassException extends

            ImportDynClassesException {

        /**

         *

         */

        private static final long serialVersionUID = 5733585544096433612L;

        public CantLocateClassException(XmlPullParser parser, String tagname) {

            super(parser, "Can't locate class named in attribute '%(name)'.",

                    "_Cant_locate_class_XnameX", serialVersionUID);

            this.setValue("name", tagname);

        }

        public CantLocateClassException(XmlPullParser parser, String tagname,

                String className) {

            super(parser, "Can't locate class named in attribute '%(name)' "

                    + "whose name is '%(className)'.", "_Cant_locate_class_XnameX",

                    serialVersionUID);

            this.setValue("name", tagname);

            this.setValue("className", className);

        }

    }

    public static class CantLocateDynClassException extends

            ImportDynClassesException {

        /**

         *

         */

        private static final long serialVersionUID = 6286170415562358806L;

        public CantLocateDynClassException(XmlPullParser parser, String tagname) {

            super(parser,

                    "Can't locate DynClass '%(name). Look at the extends tag.",

                    "_Cant_locate_DynClass_XnameX", serialVersionUID);

            this.setValue("name", tagname);

        }

    }

    public static class IncompatibleAttributeValueException extends

            ImportDynClassesException {

        /**

         *

         */

        private static final long serialVersionUID = 2646530094487375049L;

        public IncompatibleAttributeValueException(XmlPullParser parser,

                String name) {

            super(parser, "Incompatible attribute value for field '%(name)'.",

                    "_Incompatible_attribute_value_for_field_XnameX",

                    serialVersionUID);

            this.setValue("name", name);

        }

        public IncompatibleAttributeValueException(XmlPullParser parser,

                String name, String value) {

            super(

                    parser,

                    "Incompatible attribute value '%(value)', for field '%(name)'.",

                    "_Incompatible_attribute_value_for_field_XnameX",

                    serialVersionUID);

            this.setValue("name", name);

            this.setValue("value", value);

        }

    }

    public static class ParseCoerceException extends ImportDynClassesException {

        /**

         *

         */

        private static final long serialVersionUID = 1447718822981628834L;

        public ParseCoerceException(Throwable cause, XmlPullParser parser) {

            super(parser, "Can't convert value.", "_Cant_convert_value",

                    serialVersionUID);

            this.initCause(cause);

        }

    }

    public static class WrongVersionException extends ImportDynClassesException {

        private static final long serialVersionUID = 6620589308398698367L;

        public WrongVersionException(XmlPullParser parser) {

            super(parser, "Wrong format version.", "_Wrong_format_version",

                    serialVersionUID);

        }

    }

}