| gvSIG desktop 1

package org.gvsig.fmap.data.feature.impl;

import java.lang.ref.WeakReference;

import java.util.ArrayList;

import java.util.Iterator;

import org.gvsig.fmap.data.exceptions.DataException;

import org.gvsig.fmap.data.feature.Feature;

import org.gvsig.fmap.data.feature.FeatureAttributeDescriptor;

import org.gvsig.fmap.data.feature.FeatureStore;

import org.gvsig.fmap.data.feature.FeatureType;

import org.gvsig.fmap.data.feature.spi.FeatureData;

import org.gvsig.fmap.data.feature.spi.FeatureReferenceProviderServices;

import org.gvsig.tools.persistence.AbstractPersistenceManager;

import org.gvsig.tools.persistence.PersistenceException;

import org.gvsig.tools.persistence.Persistent;

import org.gvsig.tools.persistence.PersistentState;

public class DefaultFeatureReference implements

                FeatureReferenceProviderServices, Persistent {

        private Object oid;

        private Object[] pk;

        private WeakReference storeRef;

        private boolean isNewFeature;

        public DefaultFeatureReference(DefaultFeature feature) {

                this(feature, false);

        }

        public DefaultFeatureReference(DefaultFeature feature, boolean isNewFeature) {

                this(feature.getStore(), feature.getData(),

                                isNewFeature);

        }

        public DefaultFeatureReference(FeatureStore store,

                        FeatureData fdata, boolean isNewFeature) {

                this.isNewFeature = isNewFeature;

                this.oid = null;

                this.pk = null;

                this.storeRef = new WeakReference(store);

                if (isNewFeature) {

                        this.oid = getStore().getProvider().createNewOID();

                } else {

                        if (fdata.getType().hasOID()) {

                                if (this.oid == null) {

                                        // FIXME: petar

                                }

                                this.oid = fdata.getOID();

                        } else {

                                this.pk = this.calculatePK(fdata);

                                if (this.pk == null) {

                                        // FIXME: pete

                                }

                        }

                }

        }

        public DefaultFeatureReference(FeatureStore store) {

                this.isNewFeature = false;

                this.oid = null;

                this.pk = null;

                this.storeRef = new WeakReference(store);

        }

        public DefaultFeatureReference(FeatureStore store, Object oid) {

                this.isNewFeature = false;

                this.oid = oid;

                this.pk = null;

                this.storeRef = new WeakReference(store);

        }

        public DefaultFeatureReference(FeatureStore store, Object[] pk) {

                this.isNewFeature = false;

                this.oid = null;

                this.pk = pk;

                this.storeRef = new WeakReference(store);

        }

        private DefaultFeatureStore getStore() {

                return (DefaultFeatureStore) this.storeRef.get();

        }

        private Object[] calculatePK(FeatureData fdata) {

                ArrayList key = new ArrayList();

                FeatureType type = fdata.getType();

                Iterator it = type.iterator();

                while (it.hasNext()) {

                        FeatureAttributeDescriptor attr = (FeatureAttributeDescriptor) it

                                        .next();

                        if (attr.isPrimaryKey()) {

                                key.add(fdata.get(attr.getIndex()));

                        }

                }

                if (key.size() < 1) {

                        return null;

                }

                return key.toArray();

        }

        public Feature getFeature() throws DataException {

                return this.getStore().getFeatureByReference(this);

        }

        public Feature getFeature(FeatureType featureType) throws DataException {

                return this.getStore().getFeatureByReference(this, featureType);

        }

        public Object[] getKey() {

                return this.pk;

        }

        public Object getOID() {

                return this.oid;

        }

        public boolean isNewFeature() {

                return this.isNewFeature;

        }

        public PersistentState getState() throws PersistenceException {

                return AbstractPersistenceManager.getState(this);

        }

        public void loadState(PersistentState state) throws PersistenceException {

                state.set("oid", oid);

                state.set("isNewFeature", isNewFeature);

                state.set("pk.elements", pk.length);

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

                        state.set("pk.item" + i, pk[0]);

                }

        }

        public void setState(PersistentState state) throws PersistenceException {

                this.oid = state.get("oid");

                this.isNewFeature = state.getBoolean("isNewFeature");

                this.pk = new Object[state.getInt("pk.elements")];

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

                        this.pk[i] = state.get("pk.item" + i);

                }

        }

}