Interface CsvClient<T>

  • Type Parameters:
    T - the bean class into which the rows are converted
    All Known Implementing Classes:
    CsvClientImpl

    public interface CsvClient<T>

    The CsvClient is responsible for reading/writing CSV rows and converting those into beans/rows. There are a couple of ways to initialize a CsvClientImpl:

    • Just use a Reader/Writer. In this case you can only use the row functionality of CSVeed, not the bean functionality
    • Pass a Reader or Writer and point it to class. The org.csveed.annotations in the class are read, as is the order of the properties within the class.
    • Pass a Reader or Writer and roll your own instructions. Pass a BeanInstructions implementation with your own configuration settings
    Author:
    Robert Bor
    • Method Detail

      • writeBeans

        void writeBeans​(Collection<T> beans)
        Writes a collection of Beans to the table
        Parameters:
        beans - beans to write to the table
      • writeBean

        void writeBean​(T bean)
        Writes a single Bean to the table
        Parameters:
        bean - bean to write to the table
      • writeRow

        void writeRow​(Row row)
        Writes a single row to the table
        Parameters:
        row - single row
      • writeRow

        Row writeRow​(String[] row)
        Writes a single row (consisting of String cells) to the table
        Parameters:
        row - single row
        Returns:
        the written row
      • writeRows

        void writeRows​(Collection<Row> rows)
        Writes a collection of rows to the table
        Parameters:
        rows - collections of rows
      • writeRows

        void writeRows​(String[][] rows)
        Writes a two-dimensional array of cells (rows with cells) to the table
        Parameters:
        rows - two-dimensional array of cells
      • writeHeader

        Header writeHeader​(String[] header)
        Writes the header to the table
        Parameters:
        header - the header row
        Returns:
        the converted Header
      • writeHeader

        void writeHeader​(Header header)
        Writes the header to the table
        Parameters:
        header - the header row
      • writeHeader

        void writeHeader()
        Writes a header based on the bean properties to the table
      • readBeans

        List<T> readBeans()
        Reads all rows from the file and return these as beans.
        Returns:
        all beans read from the Reader
      • readBean

        T readBean()
        Reads a single row and returns this as a bean. The RowReader will keep track of its state.
        Returns:
        Bean read from the Reader
      • readRows

        List<Row> readRows()
        Reads all rows from the file and returns them as a List. After this, the RowReader will be finished
        Returns:
        all Rows read from the Reader
      • readRow

        Row readRow()
        Reads a single row from the file and returns this. The RowReader will keep track of its state.
        Returns:
        Row read from the Reader
      • readHeader

        Header readHeader()
        Returns the header of the CSV file. Only possibly returns a value when useHeader==true
        Returns:
        header or null if the useHeader==false
      • getCurrentLine

        int getCurrentLine()
        Returns the line from which the row was read. Note that a line is seen as a legitimate CSV row, not necessarily a printable line (unless multi-lines are used, these values are the same).
        Returns:
        current line number
      • isFinished

        boolean isFinished()
        States whether the Reader is done with the file
        Returns:
        true if file is finished
      • setUseHeader

        CsvClient<T> setUseHeader​(boolean useHeader)
        Makes sure that the first readable line is interpreted as the header line. That line will not be read as content. This method is called whenever CsvFile.useHeader() is used. The default value for this setting is true. This call is a facade for RowInstructions.setUseHeader(boolean).
        Parameters:
        useHeader - true if the header is interpreted and used
        Returns:
        convenience for chaining
      • setStartRow

        CsvClient<T> setStartRow​(int startRow)
        Sets the start row of the CSV file. If setUseHeader(boolean) == true, this will be the header row and the next ones are all content rows. This method is called whenever CsvFile.startRow() is used. The default value for this setting is 1. This call is a facade for RowInstructions.setStartRow(int).
        Parameters:
        startRow - the first row to start reading, including the header row
        Returns:
        convenience for chaining
      • setEscape

        CsvClient<T> setEscape​(char symbol)
        Sets the character that will be interpreted as an escape symbol while within a quoted field. This method is called whenever CsvFile.escape() is used. The default value for this setting is a double quote (") symbol. This call is a facade for RowInstructions.setEscape(char).
        Parameters:
        symbol - the symbol to use for escaping characters within a quoted field
        Returns:
        convenience for chaining
      • setQuote

        CsvClient<T> setQuote​(char symbol)
        Sets the character that will be interpreted as a quote symbol, signifying either the start or the end of a quoted field. This method is called whenever CsvFile.quote() is used. The default value for this setting is a double quote (") symbol. This call is a facade for RowInstructions.setQuote(char).
        Parameters:
        symbol - the symbol to use for indicating start/end of a quoted field
        Returns:
        convenience for chaining
      • setSeparator

        CsvClient<T> setSeparator​(char symbol)
        Sets the character that will be interpreted as a separator between cells. This method is called whenever CsvFile.separator() is used. The default value for this setting is a semi-colon (;). This call is a facade for RowInstructions.setSeparator(char).
        Parameters:
        symbol - the symbol to use as a separator between cells
        Returns:
        convenience for chaining
      • setComment

        CsvClient<T> setComment​(char symbol)
        Sets the character that will be interpreted as a comment field on the first position of a row. This method is called whenever CsvFile.comment() is used. The default value for this setting is a hashtag (#).
        Parameters:
        symbol - the symbol to use as the 0-position comment marker
        Returns:
        convenience for chaining
      • setEndOfLine

        CsvClient<T> setEndOfLine​(char[] symbols)
        Sets the characters (plural) that will be interpreted as end-of-line markers (unless within a quoted field). This method is called whenever CsvFile.endOfLine() is used. The default values for this setting are \r and \n. This call is a facade for RowInstructions.setEndOfLine(char[]).
        Parameters:
        symbols - the symbol to interpret as end-of-line markers (unless within a quoted field)
        Returns:
        convenience for chaining
      • skipEmptyLines

        CsvClient<T> skipEmptyLines​(boolean skip)
        Determines whether empty lines must be skipped or treated as single-column rows. This method is called whenever CsvFile.skipEmptyLines() is used. The default value for this setting is to skip the empty lines.
        Parameters:
        skip - true to skip empty lines, false to treat as single-column rows
        Returns:
        convenience for chaining
      • skipCommentLines

        CsvClient<T> skipCommentLines​(boolean skip)
        Determines whether comment lines must be skipped. This method is called whenever CsvFile.skipCommentLines() is used. The default value for this setting is to skip comment lines. This method exists to guarantee that lines are not accidentally treated as comment lines.
        Parameters:
        skip - true to skip comment lines, identified as starting with a comment marker
        Returns:
        convenience for chaining
      • setStartIndexDynamicColumns

        CsvClient<T> setStartIndexDynamicColumns​(int startIndex)
        A file can have a special layout with a dynamic number of columns. If the intention is to duplicate rows for every separate column, this is the method you require. It will remember the start position of the dynamic columns and treat every column after that as dynamic. For every dynamic column a row will be created. If a bean has fields annotated with @CsvHeaderName or @CsvHeaderValue, it will store the values of the header or the cell for that index column in the fields.
        Parameters:
        startIndex - the index where the dynamic columns start
        Returns:
        convenience for chaining
      • setDate

        CsvClient<T> setDate​(String propertyName,
                             String dateFormat)
        Determines what dateformat to apply to the cell value before storing it as a date. This method is called whenever CsvDate is used. The default for date format is dd-MM-yyyy.
        Parameters:
        propertyName - the name of the property to write the date to
        dateFormat - the date format to apply for parsing the date value
        Returns:
        convenience for chaining
      • setLocalizedNumber

        CsvClient<T> setLocalizedNumber​(String propertyName,
                                        Locale locale)
        Determines what Locale to apply to the cell value before converting it to a number. This method is called whenever CsvLocalizedNumber is used. The default for Locale is the Locale of the server.
        Parameters:
        propertyName - the name of the property to write the data to
        locale - the Locale to apply for converting the number
        Returns:
        convenience for chaining
      • setRequired

        CsvClient<T> setRequired​(String propertyName,
                                 boolean required)
        Determines if the field is required. If so, the cell may not be empty and a CsvException will be thrown if this occurs. This method is called whenever CsvCell.required() is used. The default for a property is false.
        Parameters:
        propertyName - property for which the requirement applies
        required - whether the cell must be not-null
        Returns:
        convenience for chaining
      • setConverter

        CsvClient<T> setConverter​(String propertyName,
                                  Converter converter)
        Sets a custom PropertyEditor for the property. This PropertyEditor is called to convert the text to the type of the property and set it on the bean. This method is called whenever CsvConverter.converter() is used. The default for a property is based on the wonderful set of PropertyEditors that Spring offers, which is all basics and some extras as well.
        Parameters:
        propertyName - property to which the converter must be applied
        converter - PropertyEditor to apply to the property
        Returns:
        convenience for chaining
      • ignoreProperty

        CsvClient<T> ignoreProperty​(String propertyName)
        Sets a field to be ignored for purposes of mapping. This method is called whenever CsvIgnore is used. By default none of the fields are ignored unless, custom instructions are used. In this case, all fields are ignored by default.
        Parameters:
        propertyName - property which must be ignored for mapping
        Returns:
        convenience for chaining
      • mapColumnIndexToProperty

        CsvClient<T> mapColumnIndexToProperty​(int columnIndex,
                                              String propertyName)
        Maps a column in the CSV to a specific property. This method is called whenever CsvCell.columnIndex() is used. By default there is NO mapping when custom instructions are used, so you should roll your own. Note that column indexes are 1-based, not 0-based.
        Parameters:
        columnIndex - index of the column for which the property mapping must be applied
        propertyName - property to which the index-based mapping must be applied
        Returns:
        convenience for chaining
      • mapColumnNameToProperty

        CsvClient<T> mapColumnNameToProperty​(String columnName,
                                             String propertyName)
        Maps a column name (which is found in the header) to a specific property. Note that to use this, headers must be enabled. This method is called whenever CsvCell.columnName() is used. By default there is NO mapping when custom instructions are used, so you should roll your own. Also, don't forget to setMapper(Class) to ColumnNameMapper for this to work.
        Parameters:
        columnName - name of the column for which the property mapping must be applied
        propertyName - property to which the name-based mapping must be applied
        Returns:
        convenience for chaining
      • setHeaderNameToProperty

        CsvClient<T> setHeaderNameToProperty​(String propertyName)
        Determines what property will receive the header name in the currently active dynamic column
        Parameters:
        propertyName - property in which the active dynamic header name must be stored
        Returns:
        convenience for chaining
      • setHeaderValueToProperty

        CsvClient<T> setHeaderValueToProperty​(String propertyName)
        Determines what property will receive the cell value in the currently active dynamic column
        Parameters:
        propertyName - property in which the active dynamic column value must be stored
        Returns:
        convenience for chaining