Application: gvSIG desktop

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

import java.io.File;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.util.ArrayList;

import java.util.HashSet;

import java.util.Iterator;

import java.util.List;

import java.util.Set;

import org.apache.commons.collections4.CollectionUtils;

import org.apache.commons.io.IOUtils;

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

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

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

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

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

import org.gvsig.timesupport.RelativeInterval;

import org.gvsig.timesupport.TimeSupportLocator;

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;

@SuppressWarnings("UseSpecificCatch")

public class DALFile implements Persistent {

    private static final String DALFILE_PERSISTENCE_DEFINITION_NAME = "DALFile";

    private static final String ATTRIBUTE_PERSISTENCE_DEFINITION_NAME = "DALFileAttribute";

    public static DALFile getDALFile() {

        DALFile f = new DALFile();

        return f;

    }

    public static DALFile getDALFile(File f) {

        DALFile df = new DALFile();

        df.read(f);

        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.addDynFieldList("attributes")

                .setClassOfItems(Attribute.class)

                .setMandatory(true)

                .setPersistent(true);

        }

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

            DynStruct definition = manager.addDefinition(

                Attribute.class,

                ATTRIBUTE_PERSISTENCE_DEFINITION_NAME, 

                ATTRIBUTE_PERSISTENCE_DEFINITION_NAME + " Persistent definition", 

                null, 

                null

            );

            definition.addDynFieldString("name")

                .setMandatory(true)

                .setPersistent(true);

            definition.addDynFieldInt("type")

                .setMandatory(true)

                .setPersistent(true);

            definition.addDynFieldInt("featureTypeIndex")

                .setMandatory(true)

                .setPersistent(true);

            definition.addDynFieldObject("emulator")

                .setClassOfValue(FeatureAttributeEmulator.class)

                .setMandatory(true)

                .setPersistent(true);

            definition.addDynFieldLong("IntervalStart")

                .setMandatory(false)

                .setPersistent(true);

            definition.addDynFieldLong("IntervalEnd")

                .setMandatory(false)

                .setPersistent(true);

        }

    }

    public static class Attribute implements Persistent {

        private String name;

        private int type;

        private FeatureAttributeEmulator emulator;

        private int featureTypeIndex;

        private RelativeInterval interval;

        public Attribute() {

        }

        private Attribute(int featureTypeIndex, FeatureAttributeDescriptor attrdesc) {

            this.featureTypeIndex = featureTypeIndex;

            this.name = attrdesc.getName();

            this.type = attrdesc.getType();

            this.emulator = attrdesc.getFeatureAttributeEmulator();

            if( attrdesc.getInterval()!=null && attrdesc.getInterval().isRelative() ) {

                this.interval = (RelativeInterval) attrdesc.getInterval();

            } else {

                this.interval = null;

            }

        }

        public boolean needPersist() {

            if( emulator!= null && emulator instanceof Persistent ) {

                return true;

            }

            if( this.interval!=null ) {

                return true;

            }

            return false;

        }

        @Override

        public void saveToState(PersistentState state) throws PersistenceException {

            state.set("name", name);

            state.set("type", type);

            state.set("featureTypeIndex", featureTypeIndex);

            state.set("emulator", emulator);

            if( this.interval!=null ) {

                state.set("intervalStart", interval.getStart().toMillis());

                state.set("intervalEnd", interval.getEnd().toMillis());

            } else {

                state.setNull("intervalStart");

                state.setNull("intervalEnd");

            }

        }

        @Override

        public void loadFromState(PersistentState state) throws PersistenceException {

            this.name = state.getString("name");

            this.type = state.getInt("type");

            this.featureTypeIndex = state.getInt("featureTypeIndex");

            this.emulator = (FeatureAttributeEmulator) state.get("emulator");

            if( state.get("intervalStart")!=null ) {

                this.interval = TimeSupportLocator.getManager().createRelativeInterval(

                        state.getLong("intervalStart"), 

                        state.getLong("intervalEnd")

                );

            }

        }

        private void fetch(DefaultFeatureAttributeDescriptor attrdesc) {

            attrdesc.setDataType(this.type);

            attrdesc.setName(this.name);

            attrdesc.setFeatureAttributeEmulator(this.emulator);

            attrdesc.setInterval(this.interval);

        }

    }

    private final List<Attribute> attributes;

    public DALFile() {

        this.attributes = new ArrayList<>();

    }

    public boolean isEmpty() {

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

            return true;

        }

        return false;

    }

    public void write(File f) {

        FileOutputStream out = null;

        try {

            PersistenceManager manager = ToolsLocator.getPersistenceManager();

            PersistentState state = manager.getState(this);

            out = new FileOutputStream(f);

            manager.saveState(state, out);

        } catch(Exception ex) {

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

        } finally {

            IOUtils.closeQuietly(out);

        }

    }

    public void read(File f) {

        FileInputStream in = null;

        try {

            PersistenceManager manager = ToolsLocator.getPersistenceManager();

            in = new FileInputStream(f);

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

            this.attributes.clear();

            this.attributes.addAll(x.attributes);

        } catch(Exception ex) {

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

        } finally {

            IOUtils.closeQuietly(in);

        }

    }

    public void setStore(FeatureStore store) throws DataException {

        this.attributes.clear();

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

        for( int n=0; n<types.size(); n++ ) {

            FeatureType type = types.get(n);

                for (FeatureAttributeDescriptor attrdesc : type) {

                    Attribute attribute = new Attribute(n,attrdesc);

                    if( attribute.needPersist() ) {

                        this.attributes.add(attribute);

                    }

            }

        }

    }

    public void updateStore(FeatureStore store) throws DataException {

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

        Set<DefaultFeatureType> needFixTypes = new HashSet<>();

        for (Attribute attribute : this.attributes) {

            DefaultFeatureType ft = (DefaultFeatureType) types.get(attribute.featureTypeIndex);

            DefaultFeatureAttributeDescriptor attrdesc = (DefaultFeatureAttributeDescriptor) ft.get(attribute.name);

            if( ft.get(attribute.name)==null ) {

                attrdesc = new DefaultFeatureAttributeDescriptor(ft);

                attribute.fetch(attrdesc);

                ft.add(attrdesc);

            } else {

                attribute.fetch(attrdesc);

            }

            needFixTypes.add(ft);

        }

        for (DefaultFeatureType type : needFixTypes) {

            type.fixAll();

        }

    }

    @Override

    public void saveToState(PersistentState state) throws PersistenceException {

        state.set("attributes", attributes);

    }

    @Override

    public void loadFromState(PersistentState state) throws PersistenceException {

        this.attributes.clear();

        Iterator<Attribute> it = state.getIterator("attributes");

        while( it.hasNext() ) {

            Attribute attribute = it.next();

            this.attributes.add(attribute);

        }

    }

}