Application: gvSIG desktop

        <field name="header" type="string" mandatory="false" defaultValue="" group="Advanced">

        <field name="skipLines" label="Number of lines to skip" type="integer" mandatory="false" defaultValue="0" group="Advanced">

          <description>The number of lines to skip at begin of file</description>

        </field>

        <field name="fieldsDefinition" label="Fields definition" type="string" mandatory="false" defaultValue="" group="Advanced">

          <description>If set use this to define fields of fixed length instead of use a separator.\nThe format is a list of values separateds by spaces of the form N:M\nwhere N is the position of the first character of field, and M the last.\nCan accept N: to use form the N character to the end of line.</description>

        </field>

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

 * MA 02110-1301, USA.

import org.apache.commons.lang3.BooleanUtils;

import org.apache.commons.lang3.StringUtils;

        OpenDataStoreParameters, FilesystemStoreParameters {

    private static final Logger logger = LoggerFactory.getLogger(CSVStoreParameters.class);

    private static final String LOCALE = "locale";

    private DelegatedDynObject parameters;

    public CSVStoreParameters() {

        this(PARAMETERS_DEFINITION_NAME);

    }

    protected CSVStoreParameters(String parametersDefinitionName) {

        this(parametersDefinitionName, CSVStoreProvider.NAME);

    }

    public CSVStoreParameters(String parametersDefinitionName, String name) {

        super();

        this.parameters = (DelegatedDynObject) FileHelper.newParameters(parametersDefinitionName);

        this.setDynValue(DataStoreProviderServices.PROVIDER_PARAMTER_NAME, name);

    }

    public String getDataStoreName() {

        return (String) this.getDynValue(DataStoreProviderServices.PROVIDER_PARAMTER_NAME);

    }

    public String getDescription() {

        return this.getDynClass().getDescription();

    }

    protected DelegatedDynObject getDelegatedDynObject() {

        return parameters;

    }

    public boolean isValid() {

        if ( getFileName(this) == null ) {

            return false;

        }

        return true;

    }

    public File getFile() {

        return (File) this.getDynValue(FILE);

    }

    public void setFile(File file) {

        this.setDynValue(FILE, file);

    }

    public static CsvPreference getPredefinedCSVPreferences(DynObject dynobj) {

        String s = (String) dynobj.getDynValue(PROFILE);

        if ( "NONE".equalsIgnoreCase(s) ) {

            return null;

        }

        if ( "STANDARD_PREFERENCE".equalsIgnoreCase(s) ) {

            return CsvPreference.STANDARD_PREFERENCE;

        }

        if ( "EXCEL_PREFERENCE".equalsIgnoreCase(s) ) {

            return CsvPreference.EXCEL_PREFERENCE;

        }

        if ( "EXCEL_NORTH_EUROPE_PREFERENCE".equalsIgnoreCase(s) ) {

            return CsvPreference.EXCEL_NORTH_EUROPE_PREFERENCE;

        }

        if ( "TAB_PREFERENCE".equalsIgnoreCase(s) ) {

            return CsvPreference.TAB_PREFERENCE;

        }

        return null;

    }

    public static QuoteMode getQuoteMode(DynObject dynobj) {

        String s = (String) dynobj.getDynValue(QUOTEPOLICY);

        if ( "AlwaysQuoteMode".equalsIgnoreCase(s) ) {

            return new AlwaysQuoteMode();

        }

        if ( "NormalQuoteMode".equalsIgnoreCase(s) ) {

            return new NormalQuoteMode();

        }

        return null;

    }

    static IProjection getCRS(DynObject dynobj) {

        return (IProjection) dynobj.getDynValue(CRS);

    }

    static String getFileName(DynObject dynobj) {

        File f = (File) dynobj.getDynValue(FILE);

        if ( f == null ) {

            return null;

        }

        return f.getPath();

    }

    static File getFile(DynObject dynobj) {

        File f = (File) dynobj.getDynValue(FILE);

        return f;

    }

    public static String getRecordSeparator(DynObject dynobj) {

        String s = (String) dynobj.getDynValue(RECORDSEPARATOR);

        return StringEscapeUtils.unescapeJava(s);

    }

    static Locale getLocale(DynObject dynobj) {

        try {

            String s = (String) dynobj.getDynValue(LOCALE);

            if ( s.trim().length() == 0 ) {

                return null;

            }

            if ( "DEFAULT".equalsIgnoreCase(s.trim()) ) {

                return Locale.getDefault();

            }

            Locale locale = null;

            // locale = Locale.forLanguageTag(s); // Since java 1.7

            String[] ss = s.split("-");

            switch (ss.length) {

            case 1:

                locale = new Locale(ss[0]);

                break;

            case 2:

                locale = new Locale(ss[0], ss[1]);

                break;

            case 3:

            default:

                locale = new Locale(ss[0], ss[1], ss[2]);

                break;

            }

            return locale;

        } catch (Exception ex) {

            logger.warn("Can't get locale from CSV parameters.", ex);

            return null;

        }

    }

    public static String getCommentStartMarker(DynObject dynobj) {

        String s = (String) dynobj.getDynValue(COMMENTSTARTMARKER);

        return StringEscapeUtils.unescapeJava(s);

    }

    public static String getQuoteCharacter(DynObject dynobj) {

        String s = (String) dynobj.getDynValue(QUOTECHAR);

        s = StringEscapeUtils.unescapeJava(s);

        if ( StringUtils.isBlank(s) ) {

            return null;

        }

        return s.substring(0, 1);

    }

    public static String getDelimiter(DynObject dynobj) {

        String s = (String) dynobj.getDynValue(DELIMITER);

        s = StringEscapeUtils.unescapeJava(s);

        if ( StringUtils.isBlank(s) ) {

            return null;

        }

        return s.substring(0, 1);

    }

    static String getHeader(DynObject dynobj) {

        String s = (String) dynobj.getDynValue(HEADER);

        s = StringEscapeUtils.unescapeJava(s);

        if ( StringUtils.isBlank(s) ) {

            return null;

        }

        return s;

    }

    static String[] getHeaders(DynObject dynobj) {

        String s = getHeader(dynobj);

        if ( StringUtils.isBlank(s) ) {

            return null;

        }

        String sep = getDelimiter(dynobj);

        if ( sep == null ) {

            sep = getDelimiter(s);

            if ( sep == null ) {

                // Chungo

                return null;

            }

        }

        String[] ss = s.split("[" + sep + "]");

        return ss;

    }

    private static String getDelimiter(String line) {

        String sep = null;

        // Cuiaddo con los ":", los he puesto al final a proposito

        // ya que podian estar en la cadena para separar el size

        // size de cada tipo.

        String seps = ",;-|@#/+$%&!:";

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

            sep = seps.substring(i, 1);

            if ( line.contains(seps.substring(i, 1)) ) {

                break;

            }

            sep = null;

        }

        return sep;

    }

    static String getCharset(DynObject dynobj) {

        String s = (String) dynobj.getDynValue(CHARSET);

        return StringEscapeUtils.unescapeJava(s);

    }

    static String[] getPointDimensionNames(DynObject dynobj) {

        String s = (String) dynobj.getDynValue("point");

        if ( StringUtils.isBlank(s) ) {

            return null;

        }

        return s.split(",");

    }

    public static boolean getSurroundingSpacesNeedQuotes(DynObject dynobj) {

        Boolean b = (Boolean) dynobj.getDynValue(SURROUNDINGSPACESNEEDQUOTES);

        return BooleanUtils.isTrue(b);

    }

    static boolean getAutomaticTypesDetection(DynObject dynobj) {

        Boolean b = (Boolean) dynobj.getDynValue(AUTOMATICTYPESDETECTION);

        return BooleanUtils.isTrue(b);

    }

    static boolean getIgnoreErrors(DynObject dynobj) {

        Boolean b = (Boolean) dynobj.getDynValue(IGNOREERRORS);

        return BooleanUtils.isTrue(b);

    }

    static int[] getFieldTypes(DynObject dynobj) {

        String s = (String) dynobj.getDynValue(FIELDTYPES);

        if ( StringUtils.isBlank(s) ) {

            return null;

        }

        String sep = getDelimiter(s);

        if ( sep == null ) {

            return null;

        }

        DataTypesManager dataTypeManager = ToolsLocator.getDataTypesManager();

        String fieldTypeNames[] = s.split("[" + sep + "]");

        int fieldTypes[] = new int[fieldTypeNames.length];

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

            s = fieldTypeNames[i].trim();

            if ( s.contains(":") ) {

                s = s.split(":")[0];

            }

            fieldTypes[i] = dataTypeManager.getType(s);

        }

        return fieldTypes;

    }

    static int[] getFieldSizes(DynObject dynobj) {

        String s = (String) dynobj.getDynValue(FIELDTYPES);

        if ( StringUtils.isBlank(s) ) {

            return null;

        }

        String sep = getDelimiter(s);

        if ( sep == null ) {

            return null;

        }

        String fieldTypeNames[] = s.split("[" + sep + "]");

        int fieldSizes[] = new int[fieldTypeNames.length];

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

            String fieldtype = fieldTypeNames[i].trim();

            if ( fieldtype.contains(":") ) {

                try {

                    s = fieldtype.split(":")[1];

                    fieldSizes[i] = Integer.parseInt(s);

                } catch (Exception ex) {

                    logger.warn("Can't get size of field " + i + " (" + fieldtype + ").", ex);

                }

            } else {

                fieldSizes[i] = 0;

            }

        }

        return fieldSizes;

    }

    static int getSkipLines(DynObject dynobj) {

        Integer n = (Integer) dynobj.getDynValue("skipLines");

        if ( n == null ) {

            return 0;

        }

        return new Integer(n);

    }

    static String getRawFieldsDefinition(DynObject dynobj) {

        String s = (String) dynobj.getDynValue("fieldsDefinition");

        if ( StringUtils.isBlank(s) ) {

            return null;

        }

        return s.trim();

    }

    public static class FieldDefinition {

        private int start;

        private int end;

        public FieldDefinition(String def) {

            def = def.trim();

            String[] ss = def.split(":");

            this.start = Integer.parseInt(ss[0])-1;

            if ( ss.length < 2 ) {

                this.end = -1;

            } else {

                this.end = Integer.parseInt(ss[1])-1;

            }

        }

        public int getStart() {

            return this.start;

        }

        public int getEnd() {

            return this.end;

        }

        public boolean getToEndOfLine() {

            return this.end == -1;

        }

    }

    public static FieldDefinition[] getFieldsDefinition(DynObject dynobj) {

        String definition = getRawFieldsDefinition(dynobj);

        if ( definition == null ) {

            return null;

        }

        int i=0;

        try {

            String[] defs = StringUtils.split(definition);

            FieldDefinition[] fieldsDefinition = new FieldDefinition[defs.length];

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

                fieldsDefinition[i] = new FieldDefinition(defs[i]);

            }

            return fieldsDefinition;

        } catch (Exception ex) {

            throw  new IllegalArgumentException("Can't recognize the format field definition '"+definition+"' ("+i+").");

        }

    }

package org.gvsig.fmap.dal.store.csv.simplereaders;

import java.io.IOException;

import java.util.List;

public interface SimpleReader {

    public String[] getHeader() throws IOException;

    public List<String> read() throws IOException;

    public void close() throws IOException;

    public List<String> skip(int lines) throws IOException;

}

package org.gvsig.fmap.dal.store.csv.simplereaders;

import java.io.FileReader;

import java.io.IOException;

import java.util.List;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.fmap.dal.store.csv.CSVStoreParameters;

import org.gvsig.tools.dynobject.DynObject;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.supercsv.comment.CommentStartsWith;

import org.supercsv.io.CsvListReader;

import org.supercsv.prefs.CsvPreference;

import org.supercsv.quote.QuoteMode;

public class CSVReader implements SimpleReader {

    //

    // http://supercsv.sourceforge.net/examples_reading.html

    // http://supercsv.sourceforge.net/apidocs/index.html

    //

    private static final Logger logger = LoggerFactory.getLogger(CSVReader.class);

    CsvListReader reader;

    private CSVStoreParameters parameters;

    public CSVReader(FileReader in, CSVStoreParameters parameters) {

        this.parameters = parameters;

        CsvPreference preferences = getCSVPreferences();

        this.reader = new CsvListReader(in, preferences);

    }    

    public CSVReader(CSVStoreParameters parameters) {

        this.parameters = parameters;

        CsvPreference preferences = getCSVPreferences();

        this.reader = null;

    }

    public CSVStoreParameters getParameters() {

        return this.parameters;

    }

    public String[] getHeader() throws IOException {

        return this.reader.getHeader(true);

    }

    public List<String> read() throws IOException {

        return reader.read();

    }

    public void close() throws IOException {

        this.reader.close();

    }

    public List<String> skip(int lines) throws IOException {

        List<String> row = null;

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

            row = reader.read();

        }

        return row;

    }

    public CsvPreference getCSVPreferences() {

        try {

            String s = null;

            char quoteChar;

            int delimiterChar;

            String endOfLineSymbols;

            DynObject params = this.getParameters();

            CsvPreference.Builder builder = null;

            CsvPreference defaultPreference = CSVStoreParameters

                    .getPredefinedCSVPreferences(params);

            if ( defaultPreference == null ) {

                defaultPreference = CsvPreference.STANDARD_PREFERENCE;

            }

            endOfLineSymbols = CSVStoreParameters.getRecordSeparator(params);

            if ( StringUtils.isBlank(endOfLineSymbols) ) {

                endOfLineSymbols = defaultPreference.getEndOfLineSymbols();

            }

            s = CSVStoreParameters.getQuoteCharacter(params);

            if ( StringUtils.isBlank(s) ) {

                quoteChar = (char) defaultPreference.getQuoteChar();

            } else {

                quoteChar = s.charAt(0);

            }

            s = CSVStoreParameters.getDelimiter(params);

            if ( StringUtils.isBlank(s) ) {

                delimiterChar = defaultPreference.getDelimiterChar();

            } else {

                delimiterChar = s.charAt(0);

            }

            builder = new CsvPreference.Builder(quoteChar, delimiterChar,

                    endOfLineSymbols);

            s = CSVStoreParameters.getCommentStartMarker(params);

            if ( !StringUtils.isBlank(s) ) {

                CommentStartsWith cs = new CommentStartsWith(s);

                builder.skipComments(cs);

            }

            builder.surroundingSpacesNeedQuotes(CSVStoreParameters

                    .getSurroundingSpacesNeedQuotes(params));

            QuoteMode quoteMode = CSVStoreParameters.getQuoteMode(params);

            if ( quoteMode != null ) {

                builder.useQuoteMode(quoteMode);

            }

            return builder.build();

        } catch (Exception e) {

            logger.warn("Can't make preferences for CSV '" + getFullFileName()

                    + "'.", e);

            return null;

        }

    }

    private String getFullFileName() {

        // Usar solo para mostrar mensajes en el logger.

        String s = "(unknow)";

        try {

            s = getParameters().getFile().getAbsolutePath();

        } catch (Exception e2) {

            s = "(unknow)";

        }

        return s;        

    }

}

package org.gvsig.fmap.dal.store.csv.simplereaders;

import java.io.BufferedReader;

import java.io.FileReader;

import java.io.IOException;

import java.util.ArrayList;

import java.util.List;

import org.gvsig.fmap.dal.store.csv.CSVStoreParameters;

public class FixedLenReader implements SimpleReader {

    BufferedReader reader = null;

    CSVStoreParameters.FieldDefinition fieldsDefinition[] = null;

    List fields = null;

    private final int fieldCount;

    private final CSVStoreParameters parameters;

    private String commentStartMarker;

    public FixedLenReader(FileReader reader, CSVStoreParameters parameters) {

        this.parameters = parameters;

        this.reader = new BufferedReader(reader);

        this.fieldsDefinition = CSVStoreParameters.getFieldsDefinition(parameters);

        this.fieldCount = this.fieldsDefinition.length;

        this.fields = new ArrayList(this.fieldCount);

        for( int i=0; i<this.fieldCount; i++ ) {

            this.fields.add(null);

        }

        this.commentStartMarker = CSVStoreParameters.getCommentStartMarker(parameters);

    }

    public String[] getHeader() throws IOException {

        String[] header = new String[this.fieldCount];

        for( int i=0; i<this.fieldCount; i++ ) {

            header[i] = Character.toString((char) (i+'A')).toUpperCase();

        }

        return header;

    }

    public List<String> read() throws IOException {

        String line = this.reader.readLine();

        while( line!=null && line.startsWith(this.commentStartMarker) ) {

            line = this.reader.readLine();

        }

        return this.parse(line);

    }

    public List<String> parse(String line) throws IOException {

        if( line == null ) {

            return null;

        }

        for ( int i = 0; i < this.fieldCount; i++ ) {

            CSVStoreParameters.FieldDefinition fieldDefinition = this.fieldsDefinition[i];

            String value;

            if ( fieldDefinition.getToEndOfLine() ) {

                value = line.substring(fieldDefinition.getStart());

            } else {

                value = line.substring(

                        fieldDefinition.getStart(),

                        fieldDefinition.getEnd()

                );

            }

            this.fields.set(i, value);

        }

        return this.fields;

    }

    public void close() throws IOException {

        this.reader.close();

        this.reader = null;

    }

    public List<String> skip(int lines) throws IOException {

        String line = null;

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

            line = this.reader.readLine();

            while( line!=null && line.startsWith(this.commentStartMarker) ) {

                line = this.reader.readLine();

            }

        }

        return this.parse(line);

    }

}

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

 * MA 02110-1301, USA.

import org.gvsig.fmap.dal.store.csv.simplereaders.CSVReader;

import org.gvsig.fmap.dal.store.csv.simplereaders.FixedLenReader;

import org.gvsig.fmap.dal.store.csv.simplereaders.SimpleReader;

        ResourceConsumer {

            DataStoreProviderServices storeServices) throws InitializeException {

                parameters,

                storeServices,

                FileHelper.newMetadataContainer(METADATA_DEFINITION_NAME)

                FileResource.NAME,

                new Object[]{file.getAbsolutePath()}

        // Usar solo para mostrar mensajes en el logger.

        String s = "(unknow)";

        try {

            s = getCSVParameters().getFile().getAbsolutePath();

        } catch (Exception e2) {

            s = "(unknow)";

        }

        return s;

        if ( this.data != null ) {

        try {

            loadFeatures();

        } catch (RuntimeException e) {

            logger.warn("Can't load features from CSV '" + getFullFileName() + "'.", e);

            throw e;

        } catch (Exception e) {

            logger.warn("Can't load features from CSV '" + getFullFileName() + "'.", e);

            throw new RuntimeException(e);

        }

                    .createServerExplorerParameters(FilesystemServerExplorer.NAME);

            return manager.openServerExplorer(FilesystemServerExplorer.NAME, params);

        private Envelope envelope = null;

        private boolean calculate_envelope = false;

        private CsvListWriter listWriter = null;

        private CsvPreference csvpreferences = null;

        private FileWriter fwriter = null;

        private FeatureType ftype;

        private File file;

        private String[] values;

        private FeatureAttributeDescriptor[] descriptors;

        private Coercion convert = null;

        private int errorcounts = 0;

        private Throwable lasterror = null;

        private Locale locale = null;

        public void initialize(File file, FeatureType ftype, CsvPreference csvpreferences) {

            this.file = file;

            this.ftype = ftype;

            this.csvpreferences = csvpreferences;

            this.locale = CSVStoreParameters.getLocale(getCSVParameters());

            if ( csvpreferences == null ) {

                this.csvpreferences = CsvPreference.STANDARD_PREFERENCE;

            }

            if ( ftype.getDefaultGeometryAttributeName() != null ) {

                this.calculate_envelope = true;

            }

            this.descriptors = this.ftype.getAttributeDescriptors();

            this.convert = ToolsLocator.getDataTypesManager().getCoercion(org.gvsig.tools.dataTypes.DataTypes.STRING);

            this.errorcounts = 0;

        }

        public void begin() {

                this.fwriter = new FileWriter(file);

            } catch (IOException e) {

                logger.warn("Can't open file for write (" + file.getAbsolutePath() + ").", e);

                throw new RuntimeException(e);

            }

            this.listWriter = new CsvListWriter(this.fwriter, this.csvpreferences);

            int n = 0;

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

                FeatureAttributeDescriptor descriptor = descriptors[i];

                if ( descriptor.getEvaluator() == null ) {

                    n++;

                }

            }

            String[] header = new String[n];

            this.values = new String[n];

            n = 0;

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

                FeatureAttributeDescriptor descriptor = descriptors[i];

                if ( descriptor.getEvaluator() == null ) {

                    String name = descriptor.getName();

                    String typeName = descriptor.getDataTypeName();

                    if ( descriptor.getDataType().getType() == DataTypes.STRING ) {

                        header[n++] = name + "__" + typeName + "__" + descriptor.getSize();

                    } else {

                        header[n++] = name + "__" + typeName;

                    }

                }

            }

            try {

                listWriter.writeHeader(header);

            } catch (Exception e) {

                logger.warn("Can't write header '" + header.toString() + "' file for write (" + file.getAbsolutePath() + ").", e);

                throw new RuntimeException(e);

            }

        }

        public void add(FeatureProvider feature) {

            if ( this.calculate_envelope ) {

                Geometry geom = feature.getDefaultGeometry();

                if ( geom != null ) {

                    if ( envelope == null ) {

                        try {

                            envelope = (Envelope) geom.getEnvelope().clone();

                        } catch (CloneNotSupportedException e) {

                            logger.warn("Este error no deberia pasar, siempre se puede hacer un clone de un envelope.", e);

                        }

                    } else {

                        envelope.add(geom.getEnvelope());

                    }

                }

            }

            int n = 0;

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

                FeatureAttributeDescriptor descriptor = descriptors[i];

                if ( descriptor.getEvaluator() == null ) {

                    Object value = feature.get(i);

                    try {

                        n++;

                        if ( this.convert != null && this.convert instanceof CoercionWithLocale ) {

                            values[n] = (String) ((CoercionWithLocale) this.convert).coerce(value, this.locale);

                        } else {

                            values[n] = (String) this.convert.coerce(value);

                        }

                    } catch (CoercionException e) {

                        try {

                            values[n] = value.toString();

                        } catch (Exception ex) {

                            values[n] = "";

                        }

                        if ( errorcounts++ <= 10 ) {

                            this.lasterror = e;

                            logger.warn("Can't convert value of field " + i + " to string in CVS file '" + getFullFileName() + "'.", e);

                            if ( errorcounts == 10 ) {

                                logger.warn("Too many error writing CVS file '" + getFullFileName() + "', don't output more.");

                            }

                        }

                    }

                }

            }

            try {

                this.listWriter.writeHeader(values);

            } catch (IOException e) {

                if ( errorcounts++ <= 10 ) {

                    this.lasterror = e;

                    logger.warn("Can't write values to CVS file '" + getFullFileName() + "'.", e);

                    if ( errorcounts == 10 ) {

                        logger.warn("Too many error writing CVS file '" + getFullFileName() + "', don't output more.");

                    }

                }

            }

        }

        public void end() throws PerformEditingException {

            if ( this.errorcounts > 0 ) {

                throw new PerformEditingException(this.file.getAbsolutePath(), lasterror);

            }

            if ( listWriter != null ) {

                try {

                    listWriter.close();

                } catch (Exception ex) {

                    // Ignore error

                }

                listWriter = null;

            }

            if ( fwriter != null ) {

                try {

                    fwriter.close();

                } catch (Exception ex) {

                    // Ignore error

                }

                fwriter = null;

            }

        }

        public Envelope getEnvelope() {

            return this.envelope;

        }

                        writer.initialize(file, getStoreServices().getDefaultFeatureType(), getCSVPreferences());

                        features

                                = getStoreServices().getFeatureStore()

                                .getFeatureSet();

                        taskStatus.setRangeOfValues(0, 0);

                        long counter = 0;

                        while ( it.hasNext() ) {

                                    (org.gvsig.fmap.dal.feature.Feature) it.next());

                            if ( feature.getOID() == null ) {

                        if ( writer.getEnvelope() != null ) {

                        if ( it != null ) {

                        if ( features != null ) {

                private CsvPreference getCSVPreferences() {

                    CSVReader reader = new CSVReader(getCSVParameters());

                    return reader.getCSVPreferences();

                }

        throw new UnsupportedOperationException();

        throw new UnsupportedOperationException();

        throw new UnsupportedOperationException();

        if ( this.envelope != null ) {

            return this.envelope;