Application: gvSIG desktop

package org.gvsig.tools.dynobject.impl;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.Iterator;

import java.util.LinkedHashMap;

import java.util.Map;

import org.gvsig.tools.dynobject.DynClass;

import org.gvsig.tools.dynobject.DynField;

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.dynobject.DynObjectManager;

public class DefaultDynClass implements DynClass {

        class FieldAndIndex {

                DynField field;

                int index;

                FieldAndIndex(DynField field, int index) {

                        this.field = field;

                        this.index = index;

                }

        }

    private DefaultDynObjectManager manager;

    private String name;

    private String description;

    private Map parents;

        private Map fields;

    private Map declaredFields;

    private boolean needConsolide;

    public DefaultDynClass(DynObjectManager manager, String name, String description) {

            this.parents = new LinkedHashMap();

            this.fields = new LinkedHashMap();

            this.declaredFields = new HashMap();

            this.needConsolide = false;

            this.manager = (DefaultDynObjectManager) manager;

            this.name = name;

            this.description = description;

    }

    public DefaultDynClass(DynObjectManager manager, String name, String description, DynClass[] superClases) {

            this(manager,name,description);

            for( int i=0; i<superClases.length; i++ ) {

                    DynClass dynClass = superClases[i];

                    if( ! this.parents.containsKey(dynClass.getName()) ) {

                            this.parents.put(dynClass.getName(), dynClass);

                    }

            }

    }

           public DefaultDynObjectManager getManager() {

            return this.manager;

    }

    public Map getFieldsMap() {

            return this.fields;

    }

    public void consolide() {

            this.fields = new LinkedHashMap();

            int index = 0;

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

            while( it.hasNext() ) {

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

                    this.fields.put(field.getName(), new FieldAndIndex(field,index++));

            }

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

            while( it.hasNext() ) {

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

                    Map fields = dynClass.getFieldsMap();

                    Iterator itf = fields.values().iterator();

                    while( itf.hasNext() ) {

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

                            if( !this.fields.containsKey(field.getName()) ) {

                                    this.fields.put(field.getName(), new FieldAndIndex(field,index++));

                            }

                    }

            }

            this.needConsolide = false;

    }

        public void extend(DynClass dynClass) {

                if( this.parents.containsKey(dynClass.getName()) ) {

                        return;

                }

                this.parents.put(dynClass.getName(), dynClass);

                consolide();

        }

        public void extend(String dynClassName) {

                DynClass dynClass = manager.get(dynClassName);

                extend(dynClass);

        }

    int getFieldIndex(String name) {

            FieldAndIndex f = (FieldAndIndex) this.fields.get(name);

            if( f == null ) {

                    return -1;

            }

            return f.index;

    }

        public DynField getDeclaredDynField(String name) {

                return (DynField)this.declaredFields.get(name);

        }

        public DynField[] getDeclaredDynFields() {

                return (DynField[]) this.declaredFields.values().toArray();

        }

        public String getDescription() {

                return this.description;

        }

        public DynField getDynField(String name) {

                return ((FieldAndIndex)this.fields.get(name)).field;

        }

        public int getDynFieldsCount() {

                return this.fields.size();

        }

        public DynField[] getDynFields() {

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

                int i=0;

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

                while( it.hasNext() ) {

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

                        fields[i++] = field;

                }

                return fields;

        }

        public String getName() {

                return this.name;

        }

        public DynField addDynField(String name) {

                this.needConsolide = true;

                DynField field = new DefaultDynField(name);

                return field;

        }

        public ArrayList _getSuperDynClasses(ArrayList dcList) {

                Iterator iter = parents.values().iterator();

                while (iter.hasNext()) {

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

                        if (dc.parents.size() > 1)

                                dcList.add(dc._getSuperDynClasses(dcList));

                        if (!dcList.contains(dc))

                                dcList.add(dc);

                }

                return dcList;

        }

        public DynClass[] getSuperDynClasses() {

                ArrayList dcList = new ArrayList();

                return (DynClass[]) _getSuperDynClasses(dcList).toArray();

        }

        public DynObject newInstance() {

                return this.manager.createDynObject(this);

        }

        public boolean isInstance(DynObject dynObject) {

                ArrayList dcList = new ArrayList();

                _getSuperDynClasses(dcList);

                if (dcList.contains(dynObject.getDynClass()))

                        return true;

                return false;

        }

        public void removeDynField(String name) {

                // TODO Auto-generated method stub

                this.needConsolide = false;

        }

        public Iterator allParentDynClassesIterator() {

                // TODO Auto-generated method stub

                return null;

        }

}