Application: gvSIG desktop

/**

 * 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 3 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.fmap.dal.store.dbf;

import java.io.File;

import java.io.IOException;

import java.math.BigDecimal;

import java.nio.charset.Charset;

import java.util.ArrayList;

import java.util.Date;

import java.util.Iterator;

import java.util.List;

import java.util.Locale;

import org.apache.commons.io.FileUtils;

import org.apache.commons.lang3.mutable.MutableInt;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataServerExplorer;

import org.gvsig.fmap.dal.DataStore;

import org.gvsig.fmap.dal.DataStoreNotification;

import org.gvsig.fmap.dal.DataTypes;

import org.gvsig.fmap.dal.FileHelper;

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.exception.ValidateDataParametersException;

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.FeatureType.FeatureTypeChanged;

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

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

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

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

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

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

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

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

import org.gvsig.fmap.dal.resource.ResourceAction;

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

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

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.spi.DataStoreProviderServices;

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

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

import org.gvsig.metadata.MetadataLocator;

import org.gvsig.metadata.MetadataManager;

import org.gvsig.metadata.exceptions.MetadataException;

import org.gvsig.tools.dataTypes.CoercionContext;

import org.gvsig.tools.dataTypes.CoercionContextDecimal;

import org.gvsig.tools.dataTypes.CoercionException;

import org.gvsig.tools.dispose.DisposableIterator;

import org.gvsig.tools.dynobject.DynObject;

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

import org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.logger.FilteredLogger;

import org.gvsig.tools.math.BigDecimalUtils;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import sun.security.ec.point.ProjectivePoint;

public class DBFStoreProvider extends AbstractFeatureStoreProvider implements

        ResourceConsumer {

    private static final Logger LOG = LoggerFactory.getLogger(DBFStoreProvider.class);

    public static final int MAX_FIELD_NAME_LENGTH = DbaseFile.MAX_FIELD_NAME_LENGTH;

    public static final String NAME = DataStore.DBASE_PROVIDER_NAME;

    public static final String DESCRIPTION = "DBF file";

    public static final String METADATA_DEFINITION_NAME = NAME;

    private static final String METADATA_ENCODING = "Encoding";

    private static final String METADATA_CODEPAGE = "CodePage";

    private DbaseFile dbfFile = null;

    private ResourceProvider dbfResource;

    private long counterNewsOIDs = -1;

    private DBFFeatureWriter writer;

    private boolean loTengoEnUso;

    private boolean allowDuplicatedFieldNames;

    private FilteredLogger logger;

    protected EditableFeatureType featureType;

    protected static void registerMetadataDefinition() throws MetadataException {

        MetadataManager manager = MetadataLocator.getMetadataManager();

        if (manager.getDefinition(METADATA_DEFINITION_NAME) == null) {

            manager.addDefinition(

                    METADATA_DEFINITION_NAME,

                    DBFStoreParameters.class.getResourceAsStream("DBFStoreMetadata.xml"),

                    DBFStoreParameters.class.getClassLoader()

            );

        }

    }

    public DBFStoreProvider(DBFStoreParameters params,

            DataStoreProviderServices storeServices)

            throws InitializeException {

        this(

                params,

                storeServices,

                FileHelper.newMetadataContainer(METADATA_DEFINITION_NAME)

        );

    }

    protected DBFStoreProvider(DBFStoreParameters params,

            DataStoreProviderServices storeServices, DynObject metadata)

            throws InitializeException {

        super(params, storeServices, metadata);

        this.logger = new FilteredLogger(LOG, "DBFStoreProvider", -1);

        this.logger.setInterval(2000L);

        this.init(params, storeServices);

    }

    protected void init(DBFStoreParameters params,

            DataStoreProviderServices storeServices) throws InitializeException {

        if (params == null) {

            throw new InitializeException(new NullPointerException("params is null"));

        }

        File theFile = getDBFParameters().getDBFFile();

        if (theFile == null) {

            throw new InitializeException(new NullPointerException("dbf file is null"));

        }

        initResource(params, storeServices);

        Charset charset = params.getEncoding();

        allowDuplicatedFieldNames = params.allowDuplicatedFieldNames();

        this.dbfFile = new DbaseFile(theFile, charset, allowDuplicatedFieldNames);

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

        this.initFeatureType();

    }

    @Override

    public Object getDynValue(String name) throws DynFieldNotFoundException {

        try {

            this.open();

        } catch (OpenException e) {

            throw new RuntimeException(e);

        }

        if (METADATA_ENCODING.equalsIgnoreCase(name)) {

            return this.dbfFile.getOriginalCharset();

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

            return this.dbfFile.getCodePageInt();

        }

        return super.getDynValue(name);

    }

    protected void initResource(DBFStoreParameters params,

            DataStoreProviderServices storeServices) throws InitializeException {

        File theFile = getDBFParameters().getDBFFile();

        dbfResource

                = this.createResource(FileResource.NAME,

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

        dbfResource.addConsumer(this);

    }

    protected void initResource(ResourceProvider resource,

        DataStoreProviderServices storeServices){

        dbfResource = resource;

        dbfResource.addConsumer(this);

    }

    @Override

    public String getProviderName() {

        return NAME;

    }

    protected DBFStoreParameters getDBFParameters() {

        return (DBFStoreParameters) super.getParameters();

    }

    @Override

    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.openServerExplorer(FilesystemServerExplorer.NAME, params);

        } catch (DataException | ValidateDataParametersException e) {

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

        }

    }

    @Override

    protected FeatureProvider internalGetFeatureProviderByReference(

            FeatureReferenceProviderServices reference, FeatureType featureType)

            throws DataException {

        return this.getFeatureProviderByIndex(

                ((Number) reference.getOID()).longValue(), featureType, null);

    }

    @Override

    public void performChanges(Iterator deleteds, Iterator inserteds,

            Iterator updateds, Iterator originalFeatureTypesUpdated)

            throws PerformEditingException {

        /*

         * This will throw an exception if there are new fields

         * with names too long

         */

        checkNewFieldsNameSize(originalFeatureTypesUpdated);

        try {

            // TODO repasar el concepto de enUso de un recurso.

            loTengoEnUso = true;

            final FeatureStore theStore = this.getStoreServices().getFeatureStore();

            resourceCloseRequest();

            getResource().execute(new ResourceAction() {

                public Object run() throws Exception {

                    FeatureSet set = null;

                    DisposableIterator iter = null;

                    try {

                        set = theStore.getFeatureSet();

                        DBFStoreParameters tmpParams

                                = (DBFStoreParameters) getDBFParameters().getCopy();

                        File tmp_file = File.createTempFile(

                                "tmp_" + System.currentTimeMillis(), ".dbf");

                        tmp_file.deleteOnExit();

                        tmpParams.setDBFFile(tmp_file);

                        writer.begin(tmpParams, theStore.getDefaultFeatureType(),

                                set.getSize());

                        iter = set.fastIterator();

                        while (iter.hasNext()) {

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

                            writer.append(feature);

                        }

                        writer.end();

                        loTengoEnUso = false;

                        try {

                            close();

                        } catch (CloseException e1) {

                            throw new PerformEditingException(getProviderName(), e1);

                        }

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

                        File target_file = getDBFParameters().getDBFFile();

                        if (target_file.exists()) {

                            target_file.delete();

                        }

                        tmp_file.renameTo(target_file);

                        if (tmp_file.exists() && !target_file.exists()) {

                            // Renaming failed, let's simply copy.

                            // We assume we cannot delete it, but we

                            // used deleteOnExit and it's

                            // temporary, so no problem

                            LOG.info("Warning: copying tmp file instead of renaming: "

                                    + target_file.getName());

                            FileUtils.copyFile(tmp_file, target_file);

                        }

                        resourcesNotifyChanges();

                        initFeatureType();

                    } finally {

                        loTengoEnUso = false;

                        if (set != null) {

                            set.dispose();

                        }

                        if (iter != null) {

                            iter.dispose();

                        }

                    }

                    return null;

                }

            });

        } catch (ResourceExecuteException | ResourceException e) {

            throw new PerformEditingException(NAME, e);

        }

        this.counterNewsOIDs = -1;

    }

    protected void checkNewFieldsNameSize(Iterator ft_upd) throws PerformEditingException {

        String long_fields = getNewFieldsWithNameTooLong(ft_upd);

        if (long_fields != null) {

            AttributeNameException ane = new AttributeNameTooLongException(

                    long_fields,

                    getProviderName(),

                    MAX_FIELD_NAME_LENGTH);

            throw new PerformEditingException(getProviderName(), ane);

        }

    }

    /**

     * Returns null or a string which is a comma-separated list

     */

    protected String getNewFieldsWithNameTooLong(Iterator ft_updated) {

        String resp = "";

        FeatureTypeChanged item;

        FeatureType ft;

        FeatureAttributeDescriptor[] atts;

        while (ft_updated.hasNext()) {

            item = (FeatureTypeChanged) ft_updated.next();

            ft = item.getTarget();

            atts = ft.getAttributeDescriptors();

            for (FeatureAttributeDescriptor att : atts) {

                if (att.getName().length() > MAX_FIELD_NAME_LENGTH) {

                    if (resp.length() == 0) {

                        resp = att.getName();

                    } else {

                        resp = resp + ", " + att.getName();

                    }

                }

            }

        }

        if (resp.length() == 0) {

            return null;

        } else {

            return "(" + resp + ")";

        }

    }

    @Override

    public FeatureProvider createFeatureProvider(FeatureType providerFeatureType) throws DataException {

        return new DBFFeatureProvider(this, providerFeatureType, null);

    }

    public FeatureProvider createFeatureProvider(FeatureType providerFeatureType, FeatureType storeFeatureType) throws DataException {

        return new DBFFeatureProvider(this, providerFeatureType, storeFeatureType);

    }

    protected void initFeatureType() throws InitializeException {

        this.featureType = this.getTheFeatureType();

        FeatureType defaultType = this.featureType.getNotEditableCopy();

        this.setStoreFeatureType(defaultType);

    }

    protected void setStoreFeatureType(FeatureType ftype) {

        FeatureStoreProviderServices store = this.getStoreServices();

        List<FeatureType> ftypes = new ArrayList<>();

        ftypes.add(ftype);

        store.setFeatureTypes(ftypes, ftype);

    }

    protected EditableFeatureType getTheFeatureType() throws InitializeException {

        try {

            this.open();

        } catch (DataException e) {

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

        }

        EditableFeatureType featureType = (EditableFeatureType) getResource().execute(

            new ResourceAction() {

                public Object run() throws Exception {

                    EditableFeatureType featureType = getStoreServices().createFeatureType(getName());

                    featureType.setHasOID(true);

                    dbfFile.getHeader().toFeatureType(

                            featureType,

                            getDBFParameters().handleDatesAsStrings()

                    );

                    return featureType;

                }

            }

        );

        return featureType;

    }

    protected void loadValue(DBFFeatureProvider featureProvider, long rowIndex,

            FeatureAttributeDescriptor descriptor) throws ReadException {

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

            // Nothing to do

            return;

        }

        int dbfFieldIndex = this.dbfFile.getFieldIndex(descriptor.getName());

        if (dbfFieldIndex < 0) {

            // Someone asked to load a field

            // which does not exist in the DBF file. This can happen

            // in editing process when a field has been added

            // in the current editing session, so we simply do nothing.

            // The expansion manager is expected to manage those new fields

            // and their values.

            this.logger.warn("The requested field ("+descriptor.getName()+") does not exist in the DBF file. Assumed it's a new field in editing mode.");

            return;

        }

        String value = null;

        try {

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

        } catch (DataException e) {

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

        }

        value = value.trim();

        FieldFormatter formatter = new FieldFormatter();

        int index = descriptor.getIndex();

        Object defaultValue = descriptor.getDefaultValueCoerced();

        switch (descriptor.getType()) {

            case DataTypes.STRING:

                featureProvider.set(index, formatter.parseString(value, (String) defaultValue));

                break;

            case DataTypes.DECIMAL:

                BigDecimal d = formatter.parseDecimal(

                    value,

                    descriptor.getMathContext(),

                    descriptor.getScale(),

                    (BigDecimal) defaultValue

                );

                if (!BigDecimalUtils.isValid(d, descriptor.getScale(), descriptor.getPrecision())) {

                    DBFStoreParameters params = this.getDBFParameters();

                    if(params.allowInconsistenciesInDecimals() ) {

                        MutableInt scale = new MutableInt(descriptor.getScale());

                        MutableInt precision = new MutableInt(descriptor.getPrecision());

                        d = BigDecimalUtils.fixIfCan(d, scale, precision);

                        updateStoreScaleAndPrecision(featureProvider, descriptor, scale.intValue(), precision.intValue());

                    } else {

                        FeatureType storeFeatureType = featureProvider.getStoreFeatureType();

                        if(storeFeatureType != null){

                            FeatureAttributeDescriptor storeDescriptor = storeFeatureType.getAttributeDescriptor(descriptor.getName());

                            if (storeDescriptor instanceof EditableFeatureAttributeDescriptor && BigDecimalUtils.isValid(d, storeDescriptor.getScale(), storeDescriptor.getPrecision())) {

                                ((EditableFeatureAttributeDescriptor)descriptor).setScale(storeDescriptor.getScale());

                                ((EditableFeatureAttributeDescriptor)descriptor).setPrecision(storeDescriptor.getPrecision());

                            }

                        }

                    }

                }

                featureProvider.set(index,d);

                break;

            case DataTypes.DOUBLE:

                featureProvider.set(index, formatter.parseDouble(value, (Double) defaultValue));

                break;

            case DataTypes.FLOAT:

                featureProvider.set(index, formatter.parseFloat(value, (Float) defaultValue));

                break;

            case DataTypes.LONG:

                featureProvider.set(index, formatter.parseLong(value, (Long) defaultValue));

                break;

            case DataTypes.INT:

                featureProvider.set(index, formatter.parseInt(value, (Integer) defaultValue));

                break;

            case DataTypes.BYTE:

                featureProvider.set(index, formatter.parseByte(value, (Byte) defaultValue));

                break;

            case DataTypes.BOOLEAN:

                featureProvider.set(index, formatter.parseBoolean(value, (Boolean) defaultValue));

                break;

            case DataTypes.TIMESTAMP:

                featureProvider.set(index, formatter.parseTimestamp(value, (java.sql.Timestamp) defaultValue));

                break;

            case DataTypes.TIME:

                featureProvider.set(index, formatter.parseTime(value, (java.sql.Time) defaultValue));

                break;

            case DataTypes.DATE:

                featureProvider.set(index, formatter.parseDate(value, (java.sql.Date) defaultValue));

                break;

            default: {

                    Object v;

                    try {

                        v = descriptor.getDataType().coerce(value);

                    } catch (CoercionException ex) {

                        v = defaultValue;

                    }

                    featureProvider.set(index, v);

                }

                break;

        }

    }

    protected FeatureProvider getFeatureProviderByIndex(long index) throws DataException {

        return this

                .getFeatureProviderByIndex(index, this.getStoreServices()

                        .getDefaultFeatureType(), null);

    }

    @Override

    public long getFeatureCount() throws ReadException, OpenException,

            ResourceNotifyChangesException {

        this.open();

        return (long) getResource().execute(() -> (long) dbfFile.getRecordCount());

    }

    @Override

    public FeatureSetProvider createSet(FeatureQuery query, FeatureType featureType)

            throws DataException {

        return new DBFSetProvider(this, query, featureType, null);

    }

    public FeatureSetProvider createSet(FeatureQuery query, FeatureType providerFeatureType, FeatureType storeFeatureType)

            throws DataException {

        return new DBFSetProvider(this, query, providerFeatureType, storeFeatureType);

    }

    public boolean canCreate() {

        return true;

    }

    public boolean canWriteGeometry(int geometryType, int geometrySubType) throws DataException {

        return false;

    }

    public void open() throws OpenException {

        if (this.dbfFile.isOpen()) {

            return;

        }

        try {

            getResource().execute(new ResourceAction() {

                public Object run() throws Exception {

                    openFile();

                    resourcesOpen();

                    return null;

                }

            });

        } catch (ResourceExecuteException e) {

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

        }

    }

    protected void openFile() throws FileNotFoundException,

            UnsupportedVersionException, IOException, DataException {

        this.dbfFile.open();

        // necessary when editing the file

        this.getDBFParameters().setEffectiveEncoding(this.dbfFile.getCharsetName());

    }

    public void close() throws CloseException {

        if( loTengoEnUso ) {

            return;

        }

        if (dbfFile == null || !this.dbfFile.isOpen()) {

            return;

        }

        super.close();

        //Cerrar recurso

        try {

            getResource().execute(new ResourceAction() {

                public Object run() throws Exception {

                    closeFile();

                    resourcesNotifyClose();

                    return null;

                }

            });

        } catch (ResourceExecuteException  e) {

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

        }

    }

    protected void closeFile() throws CloseException {

        this.dbfFile.close();

    }

    @Override

    protected void doDispose() throws BaseException {

        this.close();

        dbfFile = null;

        disposeResource();

        super.doDispose();

    }

    protected void disposeResource() {

        this.dbfResource.removeConsumer(this);

        dbfResource = null;

    }

    public boolean closeResourceRequested(ResourceProvider resource) {

        try {

            this.close();

        } catch (CloseException e) {

            return false;

        }

        return true;

    }

    public boolean allowWrite() {

        if(allowDuplicatedFieldNames || this.getDBFParameters().allowInconsistenciesInDecimals()){

            return false;

        }

        return this.dbfFile.isWritable();

    }

    public void refresh() throws OpenException {

        try {

            this.close();

        } catch (CloseException e) {

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

        }

        this.open();

        try {

            this.initFeatureType();

        } catch (InitializeException e) {

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

        }

    }

    protected FeatureProvider getFeatureProviderByIndex(long index,

            FeatureType providerFeatureType, FeatureType storeFeatureType) throws DataException {

        FeatureProvider featureProvider = this.createFeatureProvider(providerFeatureType, storeFeatureType);

        featureProvider.setOID(index);

        return featureProvider;

    }

    protected void initFeatureProviderByIndex(FeatureProvider featureProvider,

            long index, FeatureType featureType) throws DataException {

        featureProvider.setOID(index);

    }

    protected void loadFeatureProviderByIndex(FeatureProvider featureProvider)

            throws DataException {

        long index = ((Long) featureProvider.getOID());

        int rec_count = this.dbfFile.getRecordCount();

        if (index >= rec_count) {

            ReadException rex = new ReadException(this.getName(),

                    new ArrayIndexOutOfBoundsException(

                            "Index of requested feature ("

                            + index + ") is >= record count (" + rec_count + ")"));

            LOG.info("Error while loading feature. ", rex);

            throw rex;

        }

//        long t1 = System.nanoTime();

        ((DBFFeatureProvider)featureProvider).setBroken(false);

        for (FeatureAttributeDescriptor desc : featureProvider.getType()) {

            try {

                this.loadValue((DBFFeatureProvider)featureProvider, index, desc);

            } catch (Throwable th) {

                this.logger.warn("Can't load value for attribute '"+desc.getName()+"'", th);

                ((DBFFeatureProvider)featureProvider).setBroken(true);

                featureProvider.set(desc.getIndex(), null);

            }

        }

//        long t2 = System.nanoTime();

//        LOG.info("load "+index+" in :"+(t2-t1));

    }

    @Override

    public int getOIDType() {

        return DataTypes.LONG;

    }

    @Override

    public Object createNewOID() {

        if (this.counterNewsOIDs < 0) {

            try {

                this.counterNewsOIDs = this.getFeatureCount();

            } catch (DataException e) {

                LOG.warn("Can't initialice counter for news OIDs.",e);

            }

        } else {

            this.counterNewsOIDs++;

        }

        return counterNewsOIDs;

    }

    @Override

    public boolean supportsAppendMode() {

        return true;

    }

    @Override

    public void append(final FeatureProvider featureProvider)

            throws DataException {

        getResource().execute(() -> {

            writer.append(getStoreServices().createFeature(featureProvider));

            return null;

        });

    }

    @Override

    public void beginAppend() throws DataException {

        this.close();

        getResource().execute(() -> {

            writer.begin(getDBFParameters(),

                    getStoreServices().getDefaultFeatureType(),

                    getStoreServices().getFeatureStore().getFeatureCount());

            return null;

        });

    }

    public void endAppend() throws DataException {

        getResource().execute(new ResourceAction() {

            public Object run() throws Exception {

                writer.end();

                resourcesNotifyChanges();

                counterNewsOIDs = -1;

                return null;

            }

        });

    }

    public void resourceChanged(ResourceProvider resource) {

        if (this.getStoreServices()!=null){

            this.getStoreServices().notifyChange(

                    DataStoreNotification.RESOURCE_CHANGED,

                    resource);

        }

    }

    protected void resourcesNotifyChanges()

            throws ResourceNotifyChangesException {

        this.dbfResource.notifyChanges();

    }

    protected void resourcesNotifyClose() throws ResourceNotifyCloseException {

        this.dbfResource.notifyClose();

    }

    protected void resourcesOpen() throws ResourceNotifyOpenException {

        this.dbfResource.notifyOpen();

    }

    public Object getSourceId() {

        return this.getDBFParameters().getFile();

    }

    public String getName() {

        String name = this.getDBFParameters().getFile().getName();

        int n = name.lastIndexOf(".");

        if (n < 1) {

            return name;

        }

        return name.substring(0, n);

    }

    public String getFullName() {

        return this.getDBFParameters().getFile().getAbsolutePath();

    }

    protected void resourceCloseRequest() throws ResourceException {

        this.dbfResource.closeRequest();

    }

    public ResourceProvider getResource() {

        return dbfResource;

    }

    @Override

    public void fixFeatureTypeFromParameters() {

        FeatureStoreProviderServices store = this.getStoreServices();

        try {

            int sizeWithoutComputed = 0;

            for (FeatureAttributeDescriptor featureAttributeDescriptor : store.getDefaultFeatureType()) {

                if (featureAttributeDescriptor.isComputed()) {

                    continue;

                }

                sizeWithoutComputed +=1;

            }

            if(this.featureType.size()!=sizeWithoutComputed) {

                this.setStoreFeatureType(featureType.getNotEditableCopy());

            }

        } catch (DataException ex) {

        }

    }

    private void updateStoreScaleAndPrecision(DBFFeatureProvider featureProvider, FeatureAttributeDescriptor descriptor, int scale, int precision) {

        if(descriptor.getType() == DataTypes.DECIMAL){

            if(descriptor.getScale() == scale && descriptor.getPrecision() == precision) {

                return;

            }

            FeatureType ft = this.getFeatureStore().getDefaultFeatureTypeQuietly();

            FeatureAttributeDescriptor d = ft.getAttributeDescriptor(descriptor.getName());

            if(d.getScale() == scale && d.getPrecision() == precision) {

                ((DBFFeatureProvider)featureProvider).setProviderFeatureType(ft);

                return;

            }

            EditableFeatureType eft = ft.getEditable();

            EditableFeatureAttributeDescriptor ed = (EditableFeatureAttributeDescriptor) eft.getAttributeDescriptor(descriptor.getName());

            ed.setScale(scale);

            ed.setPrecision(precision);

            ft = eft.getNotEditableCopy();

            ((DBFFeatureProvider)featureProvider).setProviderFeatureType(ft);

            this.setStoreFeatureType(ft);

        }

    }

}