| gvSIG desktop 1

package com.iver.cit.gvsig.fmap.edition.writers.dbf;

import java.io.File;

import java.io.IOException;

import java.io.RandomAccessFile;

import java.nio.channels.FileChannel;

import java.nio.channels.WritableByteChannel;

import java.sql.Types;

import java.util.ArrayList;

import com.iver.cit.gvsig.fmap.core.IRow;

import com.iver.cit.gvsig.fmap.drivers.FieldDescription;

import com.iver.cit.gvsig.fmap.drivers.ITableDefinition;

import com.iver.cit.gvsig.fmap.drivers.shp.DbaseFileHeaderNIO;

import com.iver.cit.gvsig.fmap.drivers.shp.DbaseFileWriterNIO;

import com.iver.cit.gvsig.fmap.edition.EditionException;

import com.iver.cit.gvsig.fmap.edition.IFieldManager;

import com.iver.cit.gvsig.fmap.edition.IRowEdited;

import com.iver.cit.gvsig.fmap.edition.fieldmanagers.AddFieldCommand;

import com.iver.cit.gvsig.fmap.edition.fieldmanagers.FieldCommand;

import com.iver.cit.gvsig.fmap.edition.fieldmanagers.RemoveFieldCommand;

import com.iver.cit.gvsig.fmap.edition.fieldmanagers.RenameFieldCommand;

import com.iver.cit.gvsig.fmap.edition.writers.AbstractWriter;

import com.iver.cit.gvsig.fmap.layers.FBitSet;

public class DbfWriter extends AbstractWriter implements IFieldManager {

        private String dbfPath = null;

        private DbaseFileWriterNIO dbfWrite;

        private DbaseFileHeaderNIO myHeader;

        private int numRows;

        private Object[] record;

        private ArrayList fieldCommands = new ArrayList();

        // private FLyrVect lyrVect;

        private FBitSet selection = null;

        private FieldDescription[] originalFields;

        public void setFile(File f) {

                String strFichDbf = f.getAbsolutePath().replaceAll("\\.shp", ".dbf");

                dbfPath = strFichDbf.replaceAll("\\.SHP", ".DBF");

        }

        private WritableByteChannel getWriteChannel(String path) throws IOException {

                WritableByteChannel channel;

                File f = new File(path);

                if (!f.exists()) {

                        System.out.println("Creando fichero " + f.getAbsolutePath());

                        if (!f.createNewFile()) {

                                System.err.print("Error al crear el fichero "

                                                + f.getAbsolutePath());

                                throw new IOException("Cannot create file " + f);

                        }

                }

                RandomAccessFile raf = new RandomAccessFile(f, "rw");

                channel = raf.getChannel();

                return channel;

        }

        public void preProcess() throws EditionException {

                // Por ahora solo escribimos los primeros bytes

                // de las cabeceras. Luego en el postprocess los escribiremos

                // correctamente, con el fullExtent y el numero de

                // registros que tocan.

                alterTable();

                if (selection == null) {

                        try {

                                myHeader.setNumRecords(0);

                                dbfWrite = new DbaseFileWriterNIO(myHeader,

                                                (FileChannel) getWriteChannel(dbfPath));

                                record = new Object[myHeader.getNumFields()];

                                numRows = 0;

                        } catch (IOException e) {

                                e.printStackTrace();

                                throw new EditionException(e);

                        }

                }

        }

        public void process(IRowEdited row) throws EditionException {

                IRow rowEdit = (IRow) row.getLinkedRow();

                System.err.println("DBFWriter: " + row.getStatus() + " numRows = "

                                + numRows);

                switch (row.getStatus()) {

                case IRowEdited.STATUS_ADDED:

                case IRowEdited.STATUS_ORIGINAL:

                case IRowEdited.STATUS_MODIFIED:

                        try {

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

                                        record[i] = rowEdit.getAttribute(i);

                                dbfWrite.write(record);

                                numRows++;

                        } catch (IOException e) {

                                e.printStackTrace();

                                throw new EditionException(e);

                        }

                }

        }

        public void postProcess() throws EditionException {

                try {

                        myHeader.setNumRecords(numRows);

                        dbfWrite = new DbaseFileWriterNIO(myHeader,

                                        (FileChannel) getWriteChannel(dbfPath));

                } catch (IOException e) {

                        e.printStackTrace();

                        throw new EditionException(e);

                }

        }

        public String getName() {

                return "DBF Writer";

        }

        public boolean canWriteAttribute(int sqlType) {

                switch (sqlType) {

                case Types.DOUBLE:

                case Types.FLOAT:

                case Types.INTEGER:

                case Types.BIGINT:

                        return true;

                case Types.DATE:

                        return true;

                case Types.BIT:

                case Types.BOOLEAN:

                        return true;

                case Types.VARCHAR:

                case Types.CHAR:

                case Types.LONGVARCHAR:

                        return true; // TODO: Revisar esto, porque no creo que admita

                // campos muy grandes

                }

                return false;

        }

        public void initialize(ITableDefinition tableDefinition)

                        throws EditionException {

                originalFields = tableDefinition.getFieldsDesc();

                myHeader = DbaseFileHeaderNIO.createDbaseHeader(tableDefinition

                                .getFieldsDesc());

                if (dbfPath == null) {

                        throw new EditionException(

                                        "DBFWriter: You need to use setFile before initialize.");

                }

        }

        public FieldDescription[] getOriginalFields() {

                return originalFields;

        }

        public boolean alterTable() throws EditionException {

                ArrayList fields = new ArrayList();

                boolean bNeedRewrite = false;

                for (int i = 0; i < fieldCommands.size(); i++) {

                        FieldCommand fc = (FieldCommand) fieldCommands.get(i);

                        if (fc instanceof AddFieldCommand) {

                                AddFieldCommand addFC = (AddFieldCommand) fc;

                                bNeedRewrite = true;

                                fields.add(addFC.getFieldDesc());

                        }

                        if (fc instanceof RemoveFieldCommand) {

                                bNeedRewrite = true;

                                RemoveFieldCommand deleteFC = (RemoveFieldCommand) fc;

                                // for (int j=0; j < myHeader.getNumFields(); j++)

                                // {

                                // if

                                // (myHeader.getFieldName(j).compareTo(deleteFC.getFieldName())

                                // == 0)

                                // {

                                myHeader.removeColumn(deleteFC.getFieldName());

                                // break;

                                // }

                                // }

                        }

                        if (fc instanceof RenameFieldCommand) {

                                RenameFieldCommand renFC = (RenameFieldCommand) fc;

                                for (int j = 0; j < myHeader.getNumFields(); j++) {

                                        if (myHeader.getFieldName(j).compareTo(renFC.getAntName()) == 0) {

                                                myHeader.setFieldName(j, renFC.getNewName());

                                                break;

                                        }

                                }

                        }

                }

                FieldDescription[] fieldsDesc = (FieldDescription[]) fields

                                .toArray(new FieldDescription[0]);

                myHeader = DbaseFileHeaderNIO.createDbaseHeader(fieldsDesc);

                try {

                        dbfWrite = new DbaseFileWriterNIO(myHeader,

                                        (FileChannel) getWriteChannel(dbfPath));

//                        if (bNeedRewrite) {

//                                int aux = (int) (Math.random() * 1000);

//                                File fTemp = new File(System.getProperty("java.io.tmpdir")

//                                                + "/tmpDbf" + aux + ".dbf");

//

//                                // TODO: TERMINAR!!

//

//                        }

                } catch (IOException e) {

                        throw new EditionException(e);

                }

                return bNeedRewrite;

        }

        public void addField(FieldDescription fieldDesc) {

                AddFieldCommand c = new AddFieldCommand(fieldDesc);

                fieldCommands.add(c);

        }

        public FieldDescription removeField(String fieldName) {

                RemoveFieldCommand c = new RemoveFieldCommand(fieldName);

                FieldDescription[] act = getFields();

                FieldDescription found = null;

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

                {

                        if (act[i].getFieldAlias().compareToIgnoreCase(fieldName) == 0)

                        {

                                found = act[i];

                                break;

                        }

                }

                fieldCommands.add(c);

                return found;

        }

        public void renameField(String antName, String newName) {

                RenameFieldCommand c = new RenameFieldCommand(antName, newName);

                fieldCommands.add(c);

        }

        public FieldDescription[] getFields() {

                ArrayList aux = new ArrayList();

                for (int i=0; i < aux.size(); i++)

                {

                        aux.add(getOriginalFields()[i]);

                }

                // procesamos comandos para devolver los campos reales.

                for (int j=0; j < fieldCommands.size(); j++)

                {

                        FieldCommand fc = (FieldCommand) fieldCommands.get(j);

                        if (fc instanceof AddFieldCommand)

                        {

                                AddFieldCommand ac = (AddFieldCommand) fc;

                                aux.add(ac.getFieldDesc());

                        }

                        if (fc instanceof RemoveFieldCommand)

                        {

                                RemoveFieldCommand rc = (RemoveFieldCommand) fc;

                                for (int k = 0; k < aux.size(); k++) {

                                        FieldDescription fAux = (FieldDescription) aux.get(k);

                                        if (fAux.getFieldAlias().compareTo(rc.getFieldName()) == 0) {

                                                aux.remove(k);

                                                break;

                                        }

                                }

                        }

                        if (fc instanceof RenameFieldCommand)

                        {

                                RenameFieldCommand renc = (RenameFieldCommand) fc;

                                for (int k = 0; k < aux.size(); k++) {

                                        FieldDescription fAux = (FieldDescription) aux.get(k);

                                        if (fAux.getFieldAlias().compareTo(renc.getAntName()) == 0) {

                                                fAux.setFieldAlias(renc.getNewName());

                                                break;

                                        }

                                }

                        }                        

                }

                return (FieldDescription[]) aux.toArray(new FieldDescription[0]);

        }

}