Application: gvSIG desktop » gvSIG geoprocess

package org.gvsig.geoprocess.lib.sextante.dataObjects;

import java.io.File;

import java.util.Iterator;

import es.unex.sextante.core.Sextante;

import es.unex.sextante.dataObjects.AbstractTable;

import es.unex.sextante.dataObjects.IRecordsetIterator;

import es.unex.sextante.outputs.FileOutputChannel;

import es.unex.sextante.outputs.IOutputChannel;

import org.gvsig.app.project.ProjectManager;

import org.gvsig.app.project.documents.table.TableDocument;

import org.gvsig.app.project.documents.table.TableManager;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

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

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

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

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

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

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

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

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

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

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dataTypes.DataTypesManager;

public class TableDocumentITable extends AbstractTable {

    private final int PRECISION = 5;

    private TableDocument m_Table;

    private String m_sName;

    private String m_sFilename;

    private FeatureType featureType;

    private FeatureStore featureStore;

    public String getName() {

        if (m_Table != null) {

            return m_Table.getName();

        } else {

            return m_sName;

        }

    }

    public void create(final TableDocument table) {

        try {

            m_Table = table;

            featureStore = table.getStore();

            featureType = featureStore.getDefaultFeatureType();

        } catch (final DataException e) {

            Sextante.addErrorToLog(e);

        }

    }

    public void create(final String sName, final String sFilename,

        final Class<?>[] types, final String[] sFields) {

        try {

            m_sName = sName;

            final DataManager datamanager = DALLocator.getDataManager();

            final FilesystemServerExplorerParameters explorerParams =

                (FilesystemServerExplorerParameters) datamanager

                    .createServerExplorerParameters(FilesystemServerExplorer.NAME);

            explorerParams.setRoot(new File(sFilename).getParent());

            final FilesystemServerExplorer explorer =

                (FilesystemServerExplorer) datamanager.openServerExplorer(

                    FilesystemServerExplorer.NAME, explorerParams);

            final NewFeatureStoreParameters newParams =

                (NewFeatureStoreParameters) explorer.getAddParameters(new File(

                    sFilename));

            EditableFeatureType editableFeatureType =

                newParams.getDefaultFeatureType();

            featureType = editableFeatureType;

            loadFeatureType(sFields, types, editableFeatureType);

            newParams.setDefaultFeatureType(featureType);

            explorer.add(newParams.getDataStoreName(), newParams, true);

            final DataManager manager = DALLocator.getDataManager();

            featureStore =

                (FeatureStore) manager.openStore(newParams.getDataStoreName(),

                    newParams);

            featureStore.edit(FeatureStore.MODE_APPEND);

            featureType = featureStore.getDefaultFeatureType();

            m_sFilename = sFilename;

        } catch (final Exception e) {

            Sextante.addErrorToLog(e);

        }

    }

    private void loadFeatureType(final String[] fields, final Class<?>[] types,

        final EditableFeatureType featureType) {

        final int[] iTypes = getTypes(types);

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

            featureType.add(fields[i], iTypes[i]).setPrecision(PRECISION);

        }

    }

    private int[] getTypes(Class<?>[] classes) {

        DataTypesManager typesManager = ToolsLocator.getDataTypesManager();

        int[] types = new int[classes.length];

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

            types[i] = typesManager.getDataType(classes[i]).getType();

        }

        return types;

    }

    public void addRecord(final Object[] record) {

        try {

            final EditableFeature ef = featureStore.createNewFeature();

            @SuppressWarnings("unchecked")

            final Iterator<FeatureAttributeDescriptor> features =

                featureType.iterator();

            int i = 0;

            while (features.hasNext()) {

                final FeatureAttributeDescriptor featureAttributeDescriptor =

                    features.next();

                ef.set(featureAttributeDescriptor.getName(), record[i]);

                i++;

            }

            featureStore.insert(ef);

        } catch (final Exception e) {

            e.printStackTrace();

        }

    }

    public IRecordsetIterator iterator() {

        try {

            return new FeatureSetIRecordsetIterator(featureStore.getFeatureSet(m_Table

                .getQuery()));

        } catch (final DataException e) {

            throw new RuntimeException(e);

        }

    }

    public String getFieldName(final int i) {

        return ((FeatureAttributeDescriptor) featureType.get(i)).getName();

    }

    public Class<?> getFieldType(final int i) {

        return featureType.getAttributeDescriptor(i).getDataType()

            .getDefaultClass();

    }

    public int getFieldCount() {

        return featureType.size();

    }

    public long getRecordCount() {

        try {

            return featureStore.getFeatureSet(m_Table.getQuery()).getSize();

        } catch (final DataException e) {

            e.printStackTrace();

        }

        return 0;

    }

    public void postProcess() {

        try {

            final TableDocument table =

                (TableDocument) ProjectManager.getInstance().createDocument(

                    TableManager.TYPENAME, m_sName);

            table.setStore(featureStore);

        } catch (final Exception e) {

            return;

        }

        final TableDocument table = FileTools.openTable(m_sFilename, m_sName);

        create(table);

    }

    public void open() {

    }

    public void close() {

        // Nothing to do

    }

    public String getFilename() {

        return m_sFilename;

    }

    public void setName(final String name) {

        if (m_Table != null) {

            m_Table.setName(name);

        } else {

            m_sName = name;

        }

    }

    public Object getBaseDataObject() {

        return m_Table;

    }

    public void free() {

        m_Table = null;

    }

    public IOutputChannel getOutputChannel() {

        return new FileOutputChannel(m_sFilename);

    }

}