| gvSIG desktop 1

package org.gvsig.fmap.dal.store.dbf;

import java.io.File;

import java.io.IOException;

import java.text.DateFormat;

import java.text.ParseException;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Date;

import java.util.Iterator;

import java.util.List;

import java.util.Locale;

import java.util.Set;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataServerExplorer;

import org.gvsig.fmap.dal.DataStoreNotification;

import org.gvsig.fmap.dal.DataTypes;

import org.gvsig.fmap.dal.exception.CloseException;

import org.gvsig.fmap.dal.exception.DataException;

import org.gvsig.fmap.dal.exception.FileNotFoundException;

import org.gvsig.fmap.dal.exception.InitializeException;

import org.gvsig.fmap.dal.exception.OpenException;

import org.gvsig.fmap.dal.exception.ReadException;

import org.gvsig.fmap.dal.exception.UnsupportedVersionException;

import org.gvsig.fmap.dal.feature.EditableFeatureAttributeDescriptor;

import org.gvsig.fmap.dal.feature.EditableFeatureType;

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

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

import org.gvsig.fmap.dal.feature.FeatureQuery;

import org.gvsig.fmap.dal.feature.FeatureSet;

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

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

import org.gvsig.fmap.dal.feature.exception.PerformEditingException;

import org.gvsig.fmap.dal.feature.exception.UnknowDataTypeException;

import org.gvsig.fmap.dal.feature.impl.DefaultFeatureType;

import org.gvsig.fmap.dal.feature.spi.AbstractFeatureStoreProvider;

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

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

import org.gvsig.fmap.dal.feature.spi.FeatureSetProvider;

import org.gvsig.fmap.dal.feature.spi.FeatureStoreProvider;

import org.gvsig.fmap.dal.feature.spi.FeatureStoreProviderServices;

import org.gvsig.fmap.dal.resource.exception.AccessResourceException;

import org.gvsig.fmap.dal.resource.exception.ResourceBeginException;

import org.gvsig.fmap.dal.resource.exception.ResourceNotifyChangesException;

import org.gvsig.fmap.dal.resource.exception.ResourceNotifyCloseException;

import org.gvsig.fmap.dal.resource.exception.ResourceNotifyOpenException;

import org.gvsig.fmap.dal.resource.file.FileResource;

import org.gvsig.fmap.dal.resource.spi.ResourceConsumer;

import org.gvsig.fmap.dal.resource.spi.ResourceProvider;

import org.gvsig.fmap.dal.serverexplorer.filesystem.FilesystemServerExplorer;

import org.gvsig.fmap.dal.serverexplorer.filesystem.FilesystemServerExplorerParameters;

import org.gvsig.fmap.dal.store.dbf.utils.DbaseFile;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DelegatedDynObject;

import org.gvsig.tools.dynobject.DynClass;

import org.gvsig.tools.dynobject.DynField;

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.dynobject.DynObjectManager;

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

import org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.persistence.PersistenceException;

import org.gvsig.tools.persistence.PersistentState;

public class DBFStoreProvider extends AbstractFeatureStoreProvider implements

                ResourceConsumer {

        public static String NAME = "DBFStore";

        public static String DESCRIPTION = "DBF file";

        //        private DBFResource dbf = null;

        private DbaseFile dbfFile = null;

        private ResourceProvider dbfResource;

        private static final Locale ukLocale = new Locale("en", "UK");

        private static final String DYNCLASS_NAME = "DBFStore";

        protected static DynClass DYNCLASS = null;

        private DBFStoreParameters dbfParams;

        private long counterNewsOIDs = -1;

        private DBFFeatureWriter writer;

        public DBFStoreProvider() throws InitializeException {

                super();

                writer = new DBFFeatureWriter(this.getName());

        }

        public DBFStoreProvider(DBFStoreParameters params)

                        throws InitializeException {

                super();

                this.init(params);

                writer = new DBFFeatureWriter(this.getName());

        }

        protected void init(DBFStoreParameters params) throws InitializeException {

                this.dbfParams = params;

                this.dynObject = (DelegatedDynObject) ToolsLocator

                                .getDynObjectManager().createDynObject(

                                DYNCLASS);

                this.dynObject.setDynValue("DefaultSRS", null);

                this.dynObject.setDynValue("Envelope", null);

                File theFile = getDBFParameters().getDBFFile();

                dbfResource = this.createResource(FileResource.NAME,

                                new Object[] { theFile.getAbsolutePath() });

                dbfResource.addConsumer(this);

                this.dbfFile = new DbaseFile(theFile);

        }

        public FeatureStoreProvider initialize(FeatureStoreProviderServices store)

                        throws InitializeException {

                super.initialize(store);

                this.initFeatureType();

                return this;

        }

        public String getName() {

                return NAME;

        }

        protected DBFStoreParameters getDBFParameters() {

                return dbfParams;

        }

        public DataServerExplorer getExplorer() throws ReadException {

                DataManager manager = DALLocator.getDataManager();

                FilesystemServerExplorerParameters params;

                try {

                        params = (FilesystemServerExplorerParameters) manager

                                        .createServerExplorerParameters(FilesystemServerExplorer.NAME);

                        params.setRoot(this.getDBFParameters().getDBFFile().getParent());

                        return manager.createServerExplorer(params);

                } catch (DataException e) {

                        throw new ReadException(this.getName(), e);

                }

        }

        public FeatureData getFeatureDataByReference(

                        FeatureReferenceProviderServices reference, FeatureType featureType)

                        throws DataException {

                return this.getFeatureDataByIndex(((Long) reference.getOID())

                                .longValue(),

                                featureType);

        }

        public FeatureData getFeatureDataByReference(

                        FeatureReferenceProviderServices reference) throws DataException {

                return this.getFeatureDataByReference(reference, this.store

                                .getDefaultFeatureType());

        }

        public void performEditing(Iterator deleteds, Iterator inserteds,

                        Iterator updateds)

                        throws PerformEditingException {

                try {

                        this.resourcesBegin();

                        FeatureSet set = this.store.getFeatureSet();

                        DBFStoreParameters tmpParams = (DBFStoreParameters) this

                                        .getDBFParameters().getCopy();

                        tmpParams.setDBFFileName(tmpParams.getDBFFileName() + ".tmp");

                        writer.begin(tmpParams, this.store

                                        .getDefaultFeatureType(), set.getSize());

                        Iterator iter = set.iterator();

                        while (iter.hasNext()) {

                                Feature feature=(Feature) iter.next();

                                writer.append(feature);

                        }

                        writer.end();

                        try {

                                this.close();

                        } catch (CloseException e1) {

                                throw new PerformEditingException(this.getName(), e1);

                        }

                        this.getDBFParameters().getDBFFile().delete();

                        tmpParams.getDBFFile().renameTo(

                                        this.getDBFParameters().getDBFFile());

                        this.resourcesNotifyChanges();

                        this.initFeatureType();

                } catch (Exception e) {

                        throw new PerformEditingException(this.getName(), e);

                } finally {

                        this.resourcesEnd();

                }

                this.counterNewsOIDs = -1;

        }

        /*

         * ==================================================

         */

        public FeatureData createFeatureData(FeatureType type) throws DataException {

                return new DBFFeatureData(this, (DefaultFeatureType) type);

        }

        /*

         * ===================================================

         */

        FeatureStoreProviderServices getProviderServices() {

                return this.store;

        }

        protected void initFeatureType() throws InitializeException {

                FeatureType defaultType = this.getTheFeatureType().getNotEditableCopy();

                List types = new ArrayList(1);

                types.add(defaultType);

                this.store.setFeatureTypes(types, defaultType);

        }

        protected EditableFeatureType getTheFeatureType() throws InitializeException {

                try {

                        this.open();

                        this.resourcesBegin();

                } catch (DataException e) {

                        throw new InitializeException(this.getName(), e);

                }

                try {

                        int fieldCount = -1;

                        fieldCount = dbfFile.getFieldCount();

                        EditableFeatureType fType = this.store.createFeatureType();

                        fType.setHasOID(true);

                        int precision;

                        for (int i = 0; i < fieldCount; i++) {

                                char fieldType = dbfFile.getFieldType(i);

                                EditableFeatureAttributeDescriptor attr;

                                if (fieldType == 'L') {

                                        attr = fType

                                                        .add(dbfFile.getFieldName(i), DataTypes.BOOLEAN);

                                        attr.setDefaultValue(new Boolean(false));

                                        attr.setAllowNull(false);

                                } else if ((fieldType == 'F') || (fieldType == 'N')) {

                                        precision = dbfFile.getFieldDecimalLength(i);

                                        if (precision > 0) {

                                                attr = fType.add(dbfFile.getFieldName(i),

                                                                DataTypes.DOUBLE, dbfFile.getFieldLength(i));

                                                attr.setPrecision(precision);

                                                attr.setDefaultValue(new Double(0));

                                        } else {

                                                attr = fType

                                                                .add(dbfFile.getFieldName(i), DataTypes.INT);

                                                attr.setDefaultValue(new Integer(0));

                                        }

                                        attr.setAllowNull(false);

                                } else if (fieldType == 'C') {

                                        attr = fType.add(dbfFile.getFieldName(i), DataTypes.STRING);

                                        attr.setSize(dbfFile.getFieldLength(i));

                                        attr.setDefaultValue("");

                                        attr.setAllowNull(false);

                                } else if (fieldType == 'D') {

                                        attr = fType.add(dbfFile.getFieldName(i), DataTypes.DATE);

                                        attr.setDefaultValue(null);

                                        attr.setAllowNull(true);

                                } else {

                                        throw new InitializeException(this.getName(),

                                                        new UnknowDataTypeException(

                                                                        dbfFile.getFieldName(i), "" + fieldType,

                                                                        this.getName()));

                                }

                        }

                        return fType;

                } finally {

                        this.resourcesEnd();

                }

        }

        protected void loadValue(FeatureData featureData, int rowIndex,

                        FeatureAttributeDescriptor descriptor) throws ReadException {

                if (descriptor.getEvaluator() != null) {

                        // Nothing to do

                        return;

                }

                int fieldIndex = descriptor.getIndex();

                int originalIndes = descriptor.getIndex();

                if (fieldIndex >= this.dbfFile.getFieldCount()

                                || !this.dbfFile.getFieldName(descriptor.getIndex()).equals(

                                descriptor.getName())) {

                        for (int i = 0; i < this.dbfFile.getFieldCount(); i++) {

                                if (descriptor.getName().equals(this.dbfFile.getFieldName(i))) {

                                        originalIndes = i;

                                        break;

                                }

                        }

                }

                String value = null;

                try {

                        value = this.dbfFile.getStringFieldValue(rowIndex, originalIndes);

                } catch (DataException e) {

                        throw new ReadException(this.store.getName(), e);

                }

                value = value.trim();

                int fieldType = descriptor.getDataType();

                switch (fieldType) {

                case DataTypes.STRING:

                        featureData.set(fieldIndex, value);

                        break;

                case DataTypes.DOUBLE:

                        try {

                                featureData.set(fieldIndex, new Double(value));

                        } catch (NumberFormatException e) {

                                featureData.set(fieldIndex, null);

                        }

                        break;

                case DataTypes.INT:

                        try {

                                featureData.set(fieldIndex, new Integer(value));

                        } catch (NumberFormatException e) {

                                featureData.set(fieldIndex, null);

                        }

                        break;

                case DataTypes.FLOAT:

                        try {

                                featureData.set(fieldIndex, new Float(value));

                        } catch (NumberFormatException e) {

                                featureData.set(fieldIndex, null);

                        }

                        break;

                case DataTypes.LONG:

                        try {

                                featureData.set(fieldIndex, new Long(value));

                        } catch (NumberFormatException e) {

                                featureData.set(fieldIndex, null);

                        }

                        break;

                case DataTypes.BOOLEAN:

                        featureData.set(fieldIndex, new Boolean(value));

                        break;

                case DataTypes.BYTE:

                        try {

                                featureData.set(fieldIndex, new Byte(value));

                        } catch (NumberFormatException e) {

                                featureData.set(fieldIndex, null);

                        }

                        break;

                case DataTypes.DATE:

                        String year = value.substring(0, 4);

                        String month = value.substring(4, 6);

                        String day = value.substring(6, 8);

                        DateFormat df;

                        if (descriptor.getDateFormat() == null){

                                df = DateFormat.getDateInstance(DateFormat.SHORT,

                                                ukLocale);

                        } else{

                                df = descriptor.getDateFormat();

                        }

                        /*

                         * Calendar c = Calendar.getInstance(); c.clear();

                         * c.set(Integer.parseInt(year), Integer.parseInt(month),

                         * Integer.parseInt(day)); c.set(Calendar.MILLISECOND, 0);

                         */

                        String strAux = month + "/" + day + "/" + year;

                        Date dat = null;

                        try {

                                dat = df.parse(strAux);

                        } catch (ParseException e) {

                                throw new ReadException(this.store.getName(), e);

                        }

                        featureData.set(fieldIndex, dat);

                        break;

                default:

                        featureData.set(fieldIndex, descriptor.getDefaultValue());

                        break;

                }

        }

        /***

         * NOT supported in Alter Mode

         *

         * @param index

         * @return

         * @throws ReadException

         */

        protected FeatureData getFeatureDataByIndex(long index) throws DataException {

                return this

                                .getFeatureDataByIndex(index, this.store

                                .getDefaultFeatureType());

        }

        protected int getFeatureCount() throws ReadException, OpenException,

                        ResourceNotifyChangesException {

                this.open();

                try {

                        this.resourcesBegin();

                } catch (ResourceBeginException e) {

                        throw new ReadException(this.getName(), e);

                }

                try {

                        return this.dbfFile.getRecordCount();

                } finally {

                        this.resourcesEnd();

                }

        }

        public FeatureSetProvider createSet(FeatureQuery query)

                        throws DataException {

                return new DBFSetProvider(this, query);

        }

        public boolean canCreate() {

                return true;

        }

        public boolean canWriteGeometry(int geometryType) throws DataException {

                return false;

        }

        public void open() throws OpenException {

                if (this.dbfFile.isOpen()) {

                        return;

                }

                try {

                        this.resourcesBegin();

                } catch (ResourceBeginException e) {

                        throw new OpenException(this.getName(), e);

                }

                try {

                        this.openFile();

                        this.resourcesOpen();

                        // Load metadata values

                        this.loadMetadataValues();

                } catch (UnsupportedVersionException e) {

                        throw new OpenException(this.getName(), e);

                } catch (ResourceNotifyOpenException e) {

                        throw new OpenException(this.getName(), e);

                } catch (FileNotFoundException e) {

                        throw new OpenException(this.getName(), e);

                } catch (IOException e) {

                        throw new OpenException(this.getName(), e);

                } catch (BaseException e) {

                        throw new OpenException(this.getName(), e);

                } finally {

                        this.resourcesEnd();

                }

        }

        protected void openFile() throws FileNotFoundException,

                        UnsupportedVersionException, IOException, DataException {

                this.dbfFile.open();

        }

        protected void loadMetadataValues() throws DynFieldNotFoundException,

                        ReadException {

                this.dynObject.setDynValue(DBFLibrary.DYNFIELD_CODEPAGE_NAME, new Byte(

                                this.dbfFile.getCodePage()));

        }

        public void close() throws CloseException {

                if (!this.dbfFile.isOpen()) {

                        return;

                }

                super.close();

                //Cerrar recurso

                try {

                        this.resourcesBegin();

                } catch (ResourceBeginException e) {

                        throw new CloseException(this.getName(), e);

                }

                try {

                        this.closeFile();

                        this.resourcesNotifyClose();

                } catch (ResourceNotifyCloseException e) {

                        throw new CloseException(this.getName(), e);

                } finally {

                        this.resourcesEnd();

                }

        }

        protected void closeFile() throws CloseException {

                this.dbfFile.close();

        }

        public void dispose() throws CloseException {

                this.close();

                dbfFile = null;

                this.dbfResource.removeConsumer(this);

                dbfResource = null;

                super.dispose();

        }

        public boolean closeResourceRequested(ResourceProvider resource) {

                try {

                        this.close();

                } catch (CloseException e) {

                        return false;

                }

                return true;

        }

        public boolean allowWrite() {

                File file;

                try {

                        file = new File((String) this.dbfResource.get());

                } catch (AccessResourceException e) {

                        return false;

                }

                return file.canWrite();

        }

        public void refresh() throws OpenException {

                try {

                        this.close();

                } catch (CloseException e) {

                        throw new OpenException(this.getName(), e);

                }

                this.open();

                try {

                        this.initFeatureType();

                } catch (InitializeException e) {

                        throw new OpenException(this.getName(), e);

                }

        }

        /**

         *

         * @param index

         * @param featureType

         * @return

         * @throws ReadException

         */

        protected FeatureData getFeatureDataByIndex(long index,

                        FeatureType featureType) throws DataException {

                FeatureData featureData = this.createFeatureData(featureType);

                featureData.setOID(new Long(index));

                return featureData;

        }

        protected void initFeatureDataByIndex(FeatureData featureData,

                        long index, FeatureType featureType) throws DataException {

                featureData.setOID(new Long(index));

        }

        /**

         *

         * @param featureData

         * @throws DataException

         */

        protected void loadFeatureDataByIndex(FeatureData featureData)

                        throws DataException {

                this.open();

                this.resourcesBegin();

                long index = ((Long) featureData.getOID()).longValue();

                try {

                        if (index >= this.dbfFile.getRecordCount()) {

                                // FIXME

                                throw new ArrayIndexOutOfBoundsException("" + index);

                        }

                        Iterator iterator = featureData.getType().iterator();

                        while (iterator.hasNext()) {

                                FeatureAttributeDescriptor descriptor = (FeatureAttributeDescriptor) iterator

                                                .next();

                                this.loadValue(featureData, (int) index, descriptor);

                        }

                } finally {

                        this.resourcesEnd();

                }

        }

        public int getFeatureReferenceOIDType() {

                return DataTypes.LONG;

        }

        public Object createNewOID() {

                if (this.counterNewsOIDs < 0) {

                        try {

                                this.counterNewsOIDs = this.getFeatureCount();

                        } catch (DataException e) {

                                e.printStackTrace();

                        }

                }else{

                        this.counterNewsOIDs++;

                }

                return new Long(counterNewsOIDs);

        }

        public boolean supportsAppendMode() {

                return true;

        }

        public void append(Feature feature) throws DataException {

                this.resourcesBegin();

                try {

                        writer.append(feature);

                } finally {

                        this.resourcesEnd();

                }

        }

        public void beginAppend() throws DataException {

                this.close();

                this.resourcesBegin();

                try {

                        FeatureSet set = this.store.getFeatureSet();

                        writer.begin(this.getDBFParameters(), this.store

                                        .getDefaultFeatureType(), set.getSize());

                } finally {

                        this.resourcesEnd();

                }

        }

        public void endAppend() throws DataException {

                this.resourcesBegin();

                try {

                        writer.end();

                        this.resourcesNotifyChanges();

                        this.counterNewsOIDs = -1;

                } finally {

                        this.resourcesEnd();

                }

        }

        public PersistentState getState() throws PersistenceException {

                // Nothing to do

                return null;

        }

        public void loadState(PersistentState state) throws PersistenceException {

                try {

                        this.init((DBFStoreParameters) this.store.getParameters());

                } catch (InitializeException e) {

                        throw new PersistenceException(e);

                }

        }

        public void setState(PersistentState state) throws PersistenceException {

                try {

                        this.init((DBFStoreParameters) this.store.getParameters());

                } catch (InitializeException e) {

                        throw new PersistenceException(e);

                }

        }

        public Object getMetadataID() {

                try {

                        return ((FileResource) this.dbfResource).getFile()

                                        .getAbsolutePath();

                } catch (AccessResourceException e) {

                        // FIXME Exception

                        throw new RuntimeException(e);

                }

        }

        public Iterator getChilds() {

                return Arrays.asList(new DynObject[] { this.dbfParams }).iterator();

        }

        protected static void registerDynClass() {

                DynObjectManager dynman = ToolsLocator.getDynObjectManager();

                DynClass dynClass;

                DynField field;

                if (DYNCLASS == null) {

                        dynClass = dynman.add(DYNCLASS_NAME,

                                        "DBF File Store");

                        field = DBFLibrary.addCodePageField(dynClass);

                        dynClass.extend(dynman.get(FeatureStore.DYNCLASS_NAME));

                        DYNCLASS = dynClass;

                }

        }

        public Object getDynValue(String name) throws DynFieldNotFoundException {

                try {

                        this.open();

                } catch (OpenException e) {

                        // FIXME

                        throw new RuntimeException(e);

                }

                return super.getDynValue(name);

        }

        /*

         * (non-Javadoc)

         *

         * @see org.gvsig.metadata.Metadata#getMetadataChildren()

         */

        public Set getMetadataChildren() {

                return null;

        }

        /*

         * (non-Javadoc)

         *

         * @see org.gvsig.metadata.Metadata#getMetadataName()

         */

        public String getMetadataName() {

                return this.getDBFParameters().getDBFFile().getName();

        }

        /*

         * (non-Javadoc)

         *

         * @see

         * org.gvsig.fmap.dal.resource.spi.ResourceConsumer#resourceChanged(org.

         * gvsig.fmap.dal.resource.spi.ResourceProvider)

         */

        public void resourceChanged(ResourceProvider resource) {

                this.store.notifyChange(DataStoreNotification.RESOURCE_CHANGED,

                                resource);

        }

        protected void resourcesBegin() throws ResourceBeginException {

                this.dbfResource.begin();

        }

        protected void resourcesEnd() {

                this.dbfResource.end();

        }

        /**

         *

         * @throws ResourceNotifyChangesException

         */

        protected void resourcesNotifyChanges()

                        throws ResourceNotifyChangesException {

                this.dbfResource.notifyChanges();

        }

        /**

         * @throws ResourceNotifyCloseException

         *

         */

        protected void resourcesNotifyClose() throws ResourceNotifyCloseException {

                this.dbfResource.notifyClose();

        }

        /**

         * @throws ResourceNotifyOpenException

         *

         */

        protected void resourcesOpen() throws ResourceNotifyOpenException {

                this.dbfResource.notifyOpen();

        }

}