Application: gvSIG desktop

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

import java.io.ByteArrayOutputStream;

import java.io.File;

import java.io.FileOutputStream;

import java.io.InputStream;

import java.io.OutputStream;

import java.nio.charset.StandardCharsets;

import java.util.ArrayList;

import java.util.List;

import java.util.Objects;

import org.apache.commons.codec.binary.Hex;

import org.apache.commons.collections4.CollectionUtils;

import org.apache.commons.io.FileUtils;

import org.apache.commons.io.IOUtils;

import org.apache.commons.lang3.ArrayUtils;

import org.apache.commons.lang3.StringUtils;

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

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

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

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

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynStruct;

import org.gvsig.tools.persistence.PersistenceManager;

import org.gvsig.tools.persistence.Persistent;

import org.gvsig.tools.persistence.PersistentState;

import org.gvsig.tools.persistence.exception.PersistenceException;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

@SuppressWarnings("UseSpecificCatch")

public class DALFile implements Persistent {

    private static final Logger LOGGER = LoggerFactory.getLogger(DALFile.class);

    private static final String DALFILE_PERSISTENCE_DEFINITION_NAME = "DALResources";

    public static DALFile getDALFile() {

        DALFile f = new DALFile();

        return f;

    }

    public static DALFile getDALFile(org.gvsig.tools.resourcesstorage.ResourcesStorage.Resource resource) {

        DALFile df = new DALFile();

        df.read(resource);

        return df;

    }

    public static void registerPersistenceDefinition() {

        PersistenceManager manager = ToolsLocator.getPersistenceManager();

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

            DynStruct definition = manager.addDefinition(

                DALFile.class,

                DALFILE_PERSISTENCE_DEFINITION_NAME, 

                DALFILE_PERSISTENCE_DEFINITION_NAME + " Persistent definition", 

                null, 

                null

            );

            definition.addDynFieldString("defaultFeatureType");

            definition.addDynFieldList("featureTypes")

                .setClassOfItems(FeatureType.class)

                .setPersistent(true);

        }

    }

    private final List<FeatureType> featureTypes;

    private String defaultFeatureTypeId;

    public DALFile() {

        this.featureTypes = new ArrayList<>();

    }

    public boolean isEmpty() {

        if( CollectionUtils.isEmpty(this.featureTypes) ) {

            return true;

        }

        return false;

    }

    public void write(org.gvsig.tools.resourcesstorage.ResourcesStorage.Resource resource) {

        try {

            OutputStream out = resource.asOutputStream();

            this.write(out);

            // Don't close the output stream

        } catch(Throwable ex) {

            throw new RuntimeException("Can't write DAL resource.",ex);

        }

    }

    public void write(File outfile) {

        this.write(outfile, "bin");

    }

    public void write(File outfile, String format) {

        switch(StringUtils.upperCase(format) ) {

            case "HEX":

                ByteArrayOutputStream buffer = new ByteArrayOutputStream();

                try {

                    this.write(buffer);

                    FileUtils.write(

                            outfile, 

                            Hex.encodeHexString(buffer.toByteArray()), 

                            StandardCharsets.UTF_8

                    );

                } catch(Throwable ex) {

                    throw new RuntimeException("Can't write DAL file.",ex);

                } finally {

                  IOUtils.closeQuietly(buffer);

                }

                break;

            case "BIN":

            default:

                OutputStream out = null;

                try {

                    out = new FileOutputStream(outfile);

                    this.write(out);

                } catch(Throwable ex) {

                    throw new RuntimeException("Can't write DAL file.",ex);

                } finally {

                  IOUtils.closeQuietly(out);

                }

                break;

        }

    }

    public void write(OutputStream out) {

        try {

            PersistenceManager manager = ToolsLocator.getPersistenceManager();

            PersistentState state = manager.getState(this);

            manager.saveState(state, out);

        } catch(Throwable ex) {

            throw new RuntimeException("Can't write DAL resource.",ex);

        }

    }

    public void read(org.gvsig.tools.resourcesstorage.ResourcesStorage.Resource resource) {

        if( resource==null ) {

            throw new IllegalArgumentException("Resource null is not a valid resource");

        }

        try {

            PersistenceManager manager = ToolsLocator.getPersistenceManager();

            InputStream in = resource.asInputStream();

            if( in == null ) {

                throw new RuntimeException("Can't read DAL resource, input stream is null (resname="+resource.getName()+", resurl="+Objects.toString(resource.getURL())+", restype="+resource.getClass().getName()+").");

            }

            DALFile x = (DALFile) manager.getObject(in);

            this.featureTypes.clear();

            this.featureTypes.addAll(x.featureTypes);

        } catch(Throwable ex) {

            throw new RuntimeException("Can't read DAL resource (resname="+resource.getName()+", resurl="+Objects.toString(resource.getURL())+", restype="+resource.getClass().getName()+").",ex);

        }

    }

    public void setFeatureType(FeatureType featureType) throws DataException {

        this.featureTypes.clear();

        this.featureTypes.add(featureType.getCopy());

        this.defaultFeatureTypeId = featureType.getId();

    }

    public void setStore(DefaultFeatureStore store) throws DataException {

        this.featureTypes.clear();

        List<FeatureType> theTypes = store.getFeatureTypes();

        for (FeatureType theType : theTypes) {

            FeatureType ft = theType.getCopy();

            ft = fixOID(store, ft);

            this.featureTypes.add(ft);

        }

        this.defaultFeatureTypeId = store.getDefaultFeatureType().getId();

    }

    private FeatureType fixOID(DefaultFeatureStore store, FeatureType featureType) {

        if (((FeatureStoreProviderFactory) store.getProviderFactory()).supportNumericOID()) {

            if (!featureType.hasOID() && ArrayUtils.isEmpty(featureType.getPrimaryKey())) {

                EditableFeatureType eft = featureType.getEditable();

                eft.setHasOID(true);

                FeatureType necft = eft.getNotEditableCopy();

                return necft;

            }

        }

        return featureType;

    }

    public void updateStore(DefaultFeatureStore store) throws DataException {

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

        FeatureType defaultFeatureType = null;

        for (FeatureType type : this.featureTypes) {

            ((DefaultFeatureType)type).setStore(store);

            theTypes.add(type);

            if( StringUtils.equals(defaultFeatureTypeId, type.getId()) ) {

                defaultFeatureType = type;

            }

        }

        if( theTypes.isEmpty() ) {

            return;

        }

        if( defaultFeatureType==null ) {

            defaultFeatureType = theTypes.get(0);

        }

        FeatureType ft = fixOID(store, defaultFeatureType);

        if(theTypes.get(0) == defaultFeatureType) {

            theTypes.set(0,ft);

        }

        store.setFeatureTypes(theTypes, ft);

    }

    @Override

    public void saveToState(PersistentState state) throws PersistenceException {

        state.set("defaultFeatureType", defaultFeatureTypeId);

        state.set("featureTypes", featureTypes);

    }

    @Override

    public void loadFromState(PersistentState state) throws PersistenceException {

        try {

            defaultFeatureTypeId = state.getString("defaultFeatureType");

            List<FeatureType> theTypes = state.getList("featureTypes");

            featureTypes.clear();

            for (FeatureType theType : theTypes) {

                this.featureTypes.add(theType);

            }

        } catch(Throwable th) {

            LOGGER.warn("Can't load DAL resource.", th);

            throw new PersistenceException(th);

        }

    }

}