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.util.Collection;

import java.util.HashMap;

import java.util.Iterator;

import java.util.LinkedHashMap;

import java.util.LinkedHashSet;

import java.util.Map;

import java.util.Set;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dataTypes.DataTypes;

import org.gvsig.tools.dynobject.AbstractDynMethod;

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;

import org.gvsig.tools.dynobject.DynMethod;

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.dynobject.DynObjectException;

import org.gvsig.tools.dynobject.DynObjectManager;

import org.gvsig.tools.dynobject.DynObjectValueItem;

import org.gvsig.tools.dynobject.DynStruct;

import org.gvsig.tools.dynobject.Tags;

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

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

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

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

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

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

import org.gvsig.tools.exception.ListBaseException;

import org.gvsig.tools.script.Script;

public class DefaultDynClass implements DynClass_v2{

    public class FieldAndIndex {

        DefaultDynField field;

        int index;

        FieldAndIndex(DynField field, int index) {

            this.field = (DefaultDynField) field;

            this.index = index;

        }

        public int getIndex() {

            return this.index;

        }

        public DefaultDynField getDynField() {

            return this.field;

        }

    }

    public class MethodAndIndex {

        DynMethod method;

        int index;

        MethodAndIndex(DynMethod method, int index) {

            this.method = method;

            this.index = index;

        }

        public int getIndex() {

            return this.index;

        }

        public DynMethod getDynMethod() {

            return this.method;

        }

    }

    DynObjectManager manager;

    private DynClassName name;

    private String description;

    private boolean isAnonymous;

    private Map classes;

    private Map declaredFieldsMap;

    private Map declaredMethodsMap;

    // This attributes are calculated by consolide method

    private DefaultDynClass[] superClasses;

    private Map superClassesMap;

    private DynField[] declaredFields;

    private Map fieldsMap;

    private DynField[] fields;

    private DynMethod[] declaredMethods;

    private Map methodsMap;

    private DynMethod[] methods;

    private final Tags tags = new DefaultTags();

    private String label = null;

    private Script script = null;

    @SuppressWarnings("OverridableMethodCallInConstructor")

    public DefaultDynClass(String name) {

        this((DynObjectManager)null, (DynClassName)null, (String)null);

        this.setName( new DefaultDynClassName(name));

    }

    public DefaultDynClass(DynObjectManager manager, String name,

        String description) {

        this(manager, null, name, description);

    }

    public DefaultDynClass(DynObjectManager manager, String namespace,

        String name, String description) {

        this(

                manager, 

                manager.createDynClassName(namespace, name), 

                description

        );

    }

    public DefaultDynClass(DynObjectManager manager, DynClassName name,

        String description) {

        if( manager == null ) {

            manager = ToolsLocator.getDynObjectManager();

        }

        this.isAnonymous = false;

        this.classes = new LinkedHashMap();

        this.declaredFieldsMap = new HashMap();

        this.declaredMethodsMap = new HashMap();

        this.forceConsolide();  

        this.manager = manager;

        this.name = name;

        this.description = description;

    }

    public void setName(DynClassName name) {

        this.name = name;

    }

    @Override

    public String getName() {

        return this.name.getName();

    }

    @Override

    public String getNamespace() {

        return this.name.getNamespace();

    }

    @Override

    public String getFullName() {

        return this.name.getFullName();

    }

    @Override

    public String toString() {

        StringBuilder buffer = new StringBuilder();

        buffer.append("DynClass").append("[").append(this.hashCode())

            .append("]").append("( ").append("name='")

            .append(this.getFullName()).append("', ").append("fields='")

            .append(this.declaredFieldsMap.toString()).append(" )");

        return buffer.toString();

    }

    public DefaultDynClass(DynObjectManager manager, String name,

        String description, DynClass[] superClases) {

        this(manager, name, description);

        for (DynClass dynClass : superClases) {

            if (!this.classes.containsKey(dynClass.getFullName())) {

                this.classes.put(dynClass.getFullName(), dynClass);

            }

        }

    }

    public DynObjectManager getManager() {

        return this.manager;

    }

    @Override

    public Script getScript() {

        return this.script;

    }

    @Override

    public void setScript(Script script) {

        this.script = script;

    }

    synchronized public void consolide() {

        // Use classes and decalredFieldsMap to update all.

        // Updates superClasses array

        this.superClasses =

            (DefaultDynClass[]) buildSuperDynClassSet().toArray(

                new DefaultDynClass[] {});

        // Updates declaredFields array

        this.declaredFields =

            (DynField[]) this.declaredFieldsMap.values().toArray(

                new DynField[] {});

        // Updates declaredMethods array

        this.declaredMethods =

            (DynMethod[]) this.declaredMethodsMap.values().toArray(

                new DynMethod[] {});

        // Updates fieldsMap

        this.fieldsMap = new LinkedHashMap();

        int index = 0;

        for (DynField declaredField : this.declaredFields) {

            this.fieldsMap.put(

                    declaredField.getName().toLowerCase(), 

                    new FieldAndIndex(declaredField, index++)

            );

        }

        for (DefaultDynClass superClasse : this.superClasses) {

            Iterator it = superClasse.declaredFieldsMap.values().iterator();

            while (it.hasNext()) {

                DynField field = (DynField) it.next();

                if (!this.fieldsMap.containsKey(field.getName().toLowerCase())) {

                    this.fieldsMap.put(field.getName().toLowerCase(),

                            new FieldAndIndex(field, index++));

                }

            }

        }

        // Updates methodsMap

        this.methodsMap = new LinkedHashMap();

        index = 0;

        for (DynMethod declaredMethod : this.declaredMethods) {

            this.methodsMap.put(

                    declaredMethod.getName(), 

                    new MethodAndIndex(declaredMethod, index++)

            );

        }

        for (DefaultDynClass superClasse : this.superClasses) {

            Iterator it = superClasse.declaredMethodsMap.values().iterator();

            while (it.hasNext()) {

                DynMethod method = (DynMethod) it.next();

                if (!this.methodsMap.containsKey(method.getName())) {

                    this.methodsMap.put(method.getName(), new MethodAndIndex(

                            method, index++));

                }

            }

        }

        // Updates fields array

        this.fields = new DynField[this.fieldsMap.size()];

        int i = 0;

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

        while (it.hasNext()) {

            FieldAndIndex findex = (FieldAndIndex) it.next();

            DynField field = findex.getDynField();

            fields[i++] = field;

        }

        // Updates methods array

        this.methods = new DynMethod[this.methodsMap.size()];

        i = 0;

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

        while (it.hasNext()) {

            MethodAndIndex mindex = (MethodAndIndex) it.next();

            DynMethod method = mindex.getDynMethod();

            methods[i++] = method;

        }

        // Updates superClassesMap

        this.superClassesMap = new HashMap();

        for (i = 0; i < this.superClasses.length; i++) {

            this.superClassesMap.put(this.superClasses[i].getFullName(),

                this.superClasses[i]);

        }

    }

    synchronized private void forceConsolide() {

        this.superClasses = null;

        this.superClassesMap = null;

        this.declaredFields = null;

        this.fieldsMap = null;

        this.fields = null;

        this.declaredMethods = null;

        this.methodsMap = null;

        this.methods = null;

    }

    private Set buildSuperDynClassSet() {

        Set dynClassParents = new LinkedHashSet();

        buildSuperDynClassList(this, dynClassParents);

        return dynClassParents;

    }

    private void buildSuperDynClassList(DefaultDynClass dynClass, Set allParents) {

        Collection values = dynClass.classes.values();

        Iterator it = values.iterator();

        while (it.hasNext()) {

            DynClass dc = (DynClass) it.next();

            allParents.add(dc);

        }

        it = values.iterator();

        while (it.hasNext()) {

            DefaultDynClass dc = (DefaultDynClass) it.next();

            buildSuperDynClassList(dc, allParents);

        }

    }

    public Map createValues(Map oldValues) {

        if (this.fields == null) {

            consolide();

        }

        HashMap extended = new HashMap();

        if (oldValues != null) {

            extended.putAll(oldValues);

        }

        return extended;

    }

    public void extendAll(String[] structNames) {

        if (structNames == null)

            return;

        for (String structName : structNames) {

            DynStruct dynStruct = manager.get(structName);

            if (dynStruct == null) {

                throw new DynClassNotFoundException(structName);

            }

            if (this.classes.containsKey(dynStruct.getFullName())) {

                continue;

            }

            this.classes.put(dynStruct.getFullName(), dynStruct);

        }

        this.forceConsolide();

    }

    @Override

    public void extend(DynStruct dynStruct) {

        if (this.classes.containsKey(dynStruct.getFullName())) {

            return;

        }

        this.classes.put(dynStruct.getFullName(), dynStruct);

        this.forceConsolide();

    }

    @Override

    public void extend(String structName) {

        DynClass dynClass = manager.get(structName);

        if (dynClass == null) {

            throw new DynClassNotFoundException(structName);

        }

        extend(dynClass);

    }

    @Override

    public void extend(String namespace, String structame) {

        DynClass dynClass = manager.get(namespace, structame);

        if (dynClass == null) {

            throw new DynClassNotFoundException(new DefaultDynClassName(

                structame).getFullName());

        }

        extend(dynClass);

    }

    public int getFieldIndex(String name) {

        if (this.fieldsMap == null) {

            consolide();

        }

        FieldAndIndex f =

            (FieldAndIndex) this.fieldsMap.get(name.toLowerCase());

        if (f == null) {

            return -1;

        }

        return f.index;

    }

    @Override

    public DynField getDeclaredDynField(String name) {

        return (DynField) this.declaredFieldsMap.get(name.toLowerCase());

    }

    @Override

    public DynField[] getDeclaredDynFields() {

        return this.declaredFields;

    }

    @Override

    public String getDescription() {

        return this.description;

    }

    @Override

    public DynField getDynField(String name) {

        if (this.fieldsMap == null) {

            consolide();

        }

        FieldAndIndex findex =

            (FieldAndIndex) fieldsMap.get(name.toLowerCase());

        return findex == null ? null : findex.getDynField();

    }

    public FieldAndIndex getDynFieldAndIndex(String name) {

        if (this.fieldsMap == null) {

            consolide();

        }

        return (FieldAndIndex) this.fieldsMap.get(name.toLowerCase());

    }

    @Override

    public DynField[] getDynFields() {

        if (this.fields == null) {

            consolide();

        }

        return this.fields;

    }

    @Override

    public DynField addDynField(String name) {

        DynField field = new DefaultDynField(name, DataTypes.STRING);

        return this.addDynField(field);

    }

    @Override

    public DynField addDynField(String name, int type) {

        DynField field = new DefaultDynField(name,type);

        return this.addDynField(field);

    }

    public DynField addDynField(DynField field) {

        declaredFieldsMap.put(field.getName().toLowerCase(), field);

        try {

                if( field.getOder() == 0 ) {

                        field.setOrder(declaredFieldsMap.size()+1 );

                }

        } catch(Exception ex) {

                // Ignore errors when try to add an automated order

        }

        this.forceConsolide();

        return field;

    }

    @Override

    public DynClass[] getSuperDynClasses() {

        if (this.superClasses == null) {

            consolide();

        }

        return this.superClasses;

    }

    @Override

    public DynStruct[] getSuperDynStructs() {

        return this.getSuperDynClasses();

    }

    @Override

    public DynObject newInstance() {

        return this.manager.createDynObject(this);

    }

    @Override

    public boolean isInstance(DynObject dynObject) {

        if (this.superClassesMap == null) {

            consolide();

        }

        DefaultDynClass objClass = (DefaultDynClass) dynObject.getDynClass();

        if (this.superClassesMap.containsKey(objClass.getFullName())) {

            return true;

        }

                if (this.getFullName().equals(objClass.getFullName())) {

                        return true;

                }

        if (objClass.isAnonymous) {

            Iterator it = objClass.classes.values().iterator();

            while (it.hasNext()) {

                DynClass dc = (DynClass) it.next();

                if (this.superClassesMap.containsKey(dc.getFullName())) {

                    return true;

                }

            }

        }

        return false;

    }

    @Override

    public void removeDynField(String name) {

        this.declaredFieldsMap.remove(name.toLowerCase());

        this.forceConsolide();

    }

    public void setAnonymous(boolean isAnonymous) {

        this.isAnonymous = isAnonymous;

    }

    public boolean isAnonymous() {

        return isAnonymous;

    }

    @Override

    public int hashCode() {

        return name.hashCode();

    }

    @Override

    public boolean equals(Object obj) {

        if (this == obj) {

            return true;

        }

        if (obj instanceof DynClass) {

            return this.getFullName().equals(((DynClass) obj).getFullName());

        }

        return false;

    }

    @Override

    public void addDynMethod(DynMethod dynMethod) {

        this.manager.registerDynMethod(this, dynMethod);

    }

    void addMethod(DynMethod dynMethod) {

        declaredMethodsMap.put(dynMethod.getName(), dynMethod);

        this.forceConsolide();

    }

    @Override

    public DynMethod getDeclaredDynMethod(String name) {

        return (DynMethod) this.declaredMethodsMap.get(name);

    }

    @Override

    public DynMethod[] getDeclaredDynMethods() {

        if (this.declaredMethods == null) {

            consolide();

        }

        return this.declaredMethods;

    }

    @Override

    public DynMethod getDynMethod(String name) throws DynMethodException {

        if (this.methodsMap == null) {

            consolide();

        }

        MethodAndIndex mindex = (MethodAndIndex) methodsMap.get(name);

        if( mindex != null ) {

            return mindex.getDynMethod();

        }

        if( this.script == null ) {

            return null;

        }

        return new ScriptMethod(this.script,name);

    }

    private class ScriptMethod extends AbstractDynMethod {

        private final Script script;

        public ScriptMethod(Script script, String methodName) {

            super(methodName);

            this.script = script;

        }

        @Override

        public Object invoke(DynObject self, Object[] args) throws DynMethodException {

            try {

                return this.script.invokeFunction(this.getName(), args);

            } catch (NoSuchMethodException ex) {

                throw new DynMethodNotSupportedException(this.getName(),DefaultDynClass.this.getName());

            }

        }

    }

    @Override

    public DynMethod getDynMethod(int code) throws DynMethodException {

        return this.manager.getDynMethod(code);

    }

    @Override

    public DynMethod[] getDynMethods() {

        if (this.methods == null) {

            consolide();

        }

        return this.methods;

    }

    @Override

    public void removeDynMethod(String name) {

        // TODO Auto-generated method stub

    }

    @Override

    public void validate(DynObject object) throws DynObjectValidateException {

        DynField fields[] = this.getDynFields();

        DynObjectValidateException exceptions =

            new DynObjectValidateException(this.getFullName());

        for (DynField field : fields) {

            try {

                field.validate(object.getDynValue(field.getName()));

            } catch (DynFieldValidateException | DynFieldNotFoundException e) {

                exceptions.add(e);

            }

        }

        if (exceptions.size() > 0) {

            throw exceptions;

        }

    }

    @Override

    public DynField addDynFieldString(String name) {

        return addDynField(name,DataTypes.STRING);

    }

    @Override

    public DynField addDynFieldDate(String name) {

        return addDynField(name,DataTypes.DATE);

    }

    @Override

    public DynField addDynFieldInt(String name) {

        return addDynField(name,DataTypes.INT);

    }

    @Override

    public DynField addDynFieldLong(String name) {

        return addDynField(name,DataTypes.LONG);

    }

    @Override

    public DynField addDynFieldDouble(String name) {

        return addDynField(name,DataTypes.DOUBLE);

    }

    @Override

    public DynField addDynFieldFloat(String name) {

        return addDynField(name,DataTypes.FLOAT);

    }

    @Override

    public DynField addDynFieldBoolean(String name) {

        return addDynField(name,DataTypes.BOOLEAN);

    }

    @Override

    public DynField addDynFieldFolder(String name) {

        return addDynField(name,DataTypes.FOLDER);

    }

    @Override

    public DynField addDynFieldFile(String name) {

        return addDynField(name,DataTypes.FILE);

    }

    @Override

    public DynField addDynFieldURL(String name) {

        return addDynField(name,DataTypes.URL);

    }

    @Override

    public DynField addDynFieldURI(String name) {

        return addDynField(name,DataTypes.URI);

    }

    @Override

    public DynField addDynFieldArray(String name) {

        return addDynField(name,DataTypes.ARRAY);

    }

    @Override

    public DynField addDynFieldObject(String name) {

        return addDynField(name,DataTypes.OBJECT);

    }

    @Override

    public DynField addDynFieldChoice(String name, int type,

        Object defaultValue, DynObjectValueItem[] values) {

        return addDynFieldChoice(name, type, defaultValue, values, false, true);

    }

    @Override

    public DynField addDynFieldChoice(String name, int type,

        Object defaultValue, DynObjectValueItem[] values, boolean mandatory,

        boolean persistent) {

        return addDynField(name,type)

            .setDefaultFieldValue(defaultValue).setMandatory(mandatory)

            .setPersistent(persistent).setAvailableValues(values)

            .setDescription(description);

    }

    @Override

    public DynField addDynFieldRange(String name, int type,

        Object defaultValue, Object min, Object max) {

        return addDynFieldRange(name, type, defaultValue, min, max, false, true);

    }

    @Override

    public DynField addDynFieldRange(String name, int type,

        Object defaultValue, Object min, Object max, boolean mandatory,

        boolean persistent) {

        return addDynField(name,type)

            .setDefaultFieldValue(defaultValue).setMandatory(mandatory)

            .setPersistent(persistent).setMinValue(min).setMaxValue(max);

    }

    @Override

    public DynField addDynFieldSingle(String name, int type, Object defaultValue) {

        return addDynFieldSingle(name, type, defaultValue, false, true);

    }

    @Override

    public DynField addDynFieldSingle(String name, int type,

        Object defaultValue, boolean mandatory, boolean persistent) {

        return addDynField(name,type)

            .setDefaultFieldValue(defaultValue).setMandatory(mandatory)

            .setPersistent(persistent);

    }

        public DynField addDynFieldObject(String name, String dynObjectFullName) {

        return addDynField(name).setType(DataTypes.DYNOBJECT).setSubtype(dynObjectFullName);

    }

    public DynField addDynFieldObjectList(String name, String fullDynObjectName) {

        DynField listDynField = this.addDynFieldList(name)

            .setElementsType(DataTypes.DYNOBJECT)

            .setSubtype(fullDynObjectName);

        return listDynField;

    }

    @Override

    public DynField addDynFieldList(String name) {

        return addDynField(name,DataTypes.LIST);

    }

    @Override

    public DynField addDynFieldMap(String name) {

        return addDynField(name).setType(DataTypes.MAP);

    }

    @Override

    public DynField addDynFieldSet(String name) {

        return addDynField(name).setType(DataTypes.SET);

    }

    @Override

    public void setDescription(String description) {

        this.description = description;

    }

    @Override

    public void setNamespace(String namespace) {

        this.name.setNamespace(namespace);

    }

    public void check() throws ListBaseException {

        ListBaseException exceptions = null;

        if (name == null) {

            exceptions =

                CheckDynClassListException.add(exceptions, name, "name", name);

        }

        DynField[] fields = this.getDynFields();

        for (DynField field : fields) {

            try {

                ((DefaultDynField)field).check();

            }catch (Exception ex) {

                exceptions =

                        CheckDynClassListException.add(exceptions, name, ex);

            }

        }

        if (exceptions != null) {

            throw exceptions;

        }

    }

    public static class CheckDynClassListException extends ListBaseException {

        /**

                 * 

                 */

        private static final long serialVersionUID = 9042601577056507657L;

        public static class CheckDynClassException extends DynObjectException {

            /**

                         * 

                         */

            private static final long serialVersionUID = -1447120375445458639L;

            public CheckDynClassException(String attrname, Object attrvalue) {

                super("Wrong value %(value) for attribute %(name).",

                    "Wrong_value_XvalueX_for_attribute_XnameX",

                    serialVersionUID);

            }

        }

        public CheckDynClassListException(DynClassName name) {

            super("Inconsistent DynClass %(name) definition.",

                "_Inconsistent_DynClass_XnameX_definition", serialVersionUID);

            String s;

            if (name == null) {

                s = "[unknow]";

            } else {

                s = name.getFullName();

            }

            setValue("name", s);

        }

        @SuppressWarnings({"ThrowableInstanceNotThrown", "ThrowableInstanceNeverThrown"})

        public static ListBaseException add(ListBaseException exceptions,

            DynClassName name, String attrname, Object attrvalue) {

            if (exceptions == null) {

                exceptions = new CheckDynClassListException(name);

            }

            exceptions.add(new CheckDynClassException(attrname, attrvalue));

            return exceptions;

        }

        @SuppressWarnings({"ThrowableInstanceNotThrown", "ThrowableInstanceNeverThrown"})

        public static ListBaseException add(ListBaseException exceptions,

            DynClassName name, Exception ex) {

            if (exceptions == null) {

                exceptions = new CheckDynClassListException(name);

            }

            exceptions.add(ex);

            return exceptions;

        }

    }

    private boolean isExtendable(Set superClassesSet, DynStruct dynStruct) {

        if ((superClassesSet == null) || (superClassesSet.isEmpty())) {

            return true;

        }

        return !superClassesSet.contains(dynStruct);

    }

    @Override

    public boolean isExtendable(DynStruct dynStruct) {

        if (dynStruct == null) {

            return false;

        }

        if (this.fieldsMap == null) {

            consolide();

        }

        Set superClassesSet = buildSuperDynClassSet();

        return isExtendable(superClassesSet, dynStruct);

    }

    private void removeDynStruct(DynStruct superDynStruct) {

        if (this.classes.containsKey(superDynStruct.getFullName())) {

            this.classes.remove(superDynStruct.getFullName());

        }

    }

    @Override

    public void remove(DynStruct superDynStruct) {

        if (superDynStruct != null) {

            this.removeDynStruct(superDynStruct);

            this.forceConsolide();

        }

    }

    public void removeAll(DynStruct[] superDynStruct) {

        if (superDynStruct != null) {

            for (DynStruct superDynStruct1 : superDynStruct) {

                removeDynStruct(superDynStruct1);

            }

            this.consolide();

        }

    }

    public void extend(DynStruct[] structs) {

        if (structs != null) {

            for (DynStruct struct : structs) {

                extend(struct);

            }

            this.consolide();

        }

    }

    @Override

    public Tags getTags() {

            return tags;

    }

    @Override

    public String getLabel() {

        if( this.label == null ) {

            if( this.getTags().get("label") == null ) {

                return this.getName();

            }

            return (String) this.getTags().get("label");

        }

        return this.label;

    }

    @Override

    public void setLabel(String label) {

        this.label = label;

    }

    public void renameField(String oldname, String newName) {

        DefaultDynField oldfield = (DefaultDynField) this.getDynField(oldname);

        if( oldfield == null ) {

            throw new RuntimeException("field name do not exists.");

        }

        DynField newfield = this.getDynField(newName);

        if( newfield != null ) {

            throw new RuntimeException("field name already exists.");

        }

        declaredFieldsMap.remove(oldfield);

        oldfield.setName(newName);

        declaredFieldsMap.put(oldfield.getName().toLowerCase(), oldfield);        

    }

}