| gvSIG desktop 1

/* gvSIG. Geographic Information System of the Valencian Government

 *

 * Copyright (C) 2007-2008 Infrastructures and Transports Department

 * of the Valencian Government (CIT)

 * 

 * 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 2

 * 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.

 * 

 */

/*

 * AUTHORS (In addition to CIT):

 * 2008 Prodevelop S.L. main development

 */

package org.gvsig.normalization.operations;

import java.io.File;

import java.util.ArrayList;

import java.util.List;

import org.apache.log4j.Logger;

import org.gvsig.normalization.patterns.Element;

import org.gvsig.normalization.patterns.Patternnormalization;

import com.hardcode.gdbms.driver.exceptions.InitializeWriterException;

import com.hardcode.gdbms.driver.exceptions.ReadDriverException;

import com.hardcode.gdbms.engine.values.Value;

import com.iver.cit.gvsig.exceptions.visitors.StartWriterVisitorException;

import com.iver.cit.gvsig.exceptions.visitors.StopWriterVisitorException;

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

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

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

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

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

import com.iver.cit.gvsig.fmap.edition.writers.dbf.DbfWriter;

/**

 * @author <a href="mailto:jsanz@prodevelop.es"> Jorge Gaspar Sanz Salinas</a>

 * @author <a href="mailto:vsanjaime@prodevelop.es"> Vicente Sanjaime Calvet</a>

 */

public class StringListNormalization extends AbstractNormalization implements

                NormalizationNewTable {

        private static final Logger log = Logger

                        .getLogger(StringListNormalization.class);

        @SuppressWarnings("unchecked")

        private ArrayList fileChains;

        private NormalizationTableDriver driver;

        private File ouputFile;

        /**

         * Builder available for New Table from File

         * 

         * @param pat

         * @param chains

         */

        @SuppressWarnings("unchecked")

        public StringListNormalization(Patternnormalization pat, ArrayList chains,

                        File theFile) {

                super(pat);

                this.ouputFile = theFile;

                fileChains = chains;

                FieldDescription[] fieldDescs = new FieldDescription[numNewImportedFields()];

                // Second table

                FieldDescription auxfd = null;

                int posi = -1;

                // Pattern fields

                int contad = pattern.getElements().size();

                for (int j = 0; j < contad; j++) {

                        if (((Element) pattern.getElements().get(j)).getImportfield()) {

                                posi++;

                                auxfd = readAddressNormPattern((Element) pattern.getElements()

                                                .get(j));

                                fieldDescs[posi] = auxfd;

                        }

                }

                driver = new NormalizationTableDriver(fieldDescs);

        }

        /**

         * From a file, a new table is created

         * 

         * @return

         */

        public boolean createNewTable() {

                return true;

        }

        /**

         * Fill all rows with values normalized

         * 

         * @param row

         * @throws ReadDriverException

         */

        @SuppressWarnings("unchecked")

        public void fillRow(int row) throws ReadDriverException {

                int posi = -1;

                /* TABLE */

                int nfields = nameNewFields.length;

                Value[] vals = new Value[nfields];

                /* CUTTING AND FILTERING */

                String splitString = "";

                List chains = null;

                List splittedChains = null;

                String cadena = "";

                int tipoCampo = 0;

                splitString = (String) fileChains.get(row);

                splittedChains = nAlgorithm.splitChain(splitString);

                nAlgorithm.setRow(row);

                chains = nAlgorithm.filterSplitChains(splittedChains);

                /* CREATING VALUES */

                for (int j = 0; j < nameNewFields.length; j++) {

                        posi++;

                        try {

                                cadena = (String) chains.get(posNameNewFields[j]);

                        } catch (Exception e) {

                                log.warn("Null chain replaced for white");

                                update("ERROR.errornullsubstring." + (row + 1));

                                cadena = "";

                        }

                        cadena = cadena.trim();

                        tipoCampo = driver.getFieldType(posi);

                        // create values

                        vals[posi] = createValue(row, tipoCampo, posi, cadena);

                }

                driver.addRow(vals);

        }

        /**

         * Get the row count

         * 

         * @return number of rows

         */

        public long getRowCount() {

                try {

                        return this.driver.getRowCount();

                } catch (ReadDriverException e) {

                        log.error("Error retrieving the number of rows of the driver");

                        return -1;

                }

        }

        /**

         * Get the estimated row count

         * 

         * @return number of rows

         */

        public long getEstimatedRowCount() {

                return this.fileChains.size();

        }

        /**

         * Tasks necessary before normalize

         * 

         * @return process ok

         */

        public boolean preProcess() {

                update("INFO.normalizing");

                return true;

        }

        /**

         * Tasks necessary after normalize. Write dbf file

         * 

         * @return process ok

         */

        public boolean postProcess() {

                update("INFO.writtingdbf");

                DbfWriter dbf = new DbfWriter();

                dbf.setFile(this.ouputFile);

                TableDefinition td = new TableDefinition();

                td.setName("secondTable");

                td.setFieldsDesc(driver.getFieldDescriptions());

                try {

                        dbf.initialize(td);

                } catch (InitializeWriterException e) {

                        log.error("ERROR initializing dbf", e);

                        return false;

                }

                try {

                        dbf.preProcess();

                } catch (StartWriterVisitorException e1) {

                        log.error("ERROR preprocessing dbf", e1);

                        return false;

                }

                DefaultRowEdited dre;

                for (int i = 0; i < getRowCount(); i++) {

                        try {

                                Value[] vals = driver.getValues(i);

                                DefaultRow dr = new DefaultRow(vals);

                                dre = new DefaultRowEdited(dr, IRowEdited.STATUS_ADDED, i);

                                dbf.process(dre);

                        } catch (Exception ioe) {

                                log.warn("ERROR traversing driver", ioe);

                        }

                }

                try {

                        dbf.postProcess();

                } catch (StopWriterVisitorException e) {

                        log.error("ERROR in the postprocess", e);

                        return false;

                }

                update("INFO.endnormalizing");

                return true;

        }

        /**

         * Get the driver

         * 

         * @return driver

         */

        public NormalizationTableDriver getDriver() {

                return this.driver;

        }

        /**

         * Get the output file

         * 

         * @return dbf file

         */

        public File getOuputFile() {

                return this.ouputFile;

        }

}