utils/formats/csv/reader.hpp

Go to the documentation of this file.

#ifndef GENESIS_UTILS_FORMATS_CSV_READER_H_
#define GENESIS_UTILS_FORMATS_CSV_READER_H_
 
/*
    Genesis - A toolkit for working with phylogenetic data.
    Copyright (C) 2014-2018 Lucas Czech and HITS gGmbH
 
    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 3 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, see <http://www.gnu.org/licenses/>.
 
    Contact:
    Lucas Czech <lucas.czech@h-its.org>
    Exelixis Lab, Heidelberg Institute for Theoretical Studies
    Schloss-Wolfsbrunnenweg 35, D-69118 Heidelberg, Germany
*/
 
#include "genesis/utils/io/input_source.hpp"
 
#include <iosfwd>
#include <memory>
#include <string>
#include <vector>
 
namespace genesis {
namespace utils {
 
// =================================================================================================
//     Forward Declarations
// =================================================================================================
 
class InputStream;
 
// =================================================================================================
//     Csv Reader
// =================================================================================================
 
class CsvReader
{
public:
 
    // ---------------------------------------------------------------------
    //     Typedefs and Enums
    // ---------------------------------------------------------------------
 
    using Field = std::string;
    using Line  = std::vector<Field>;
    using Table = std::vector<Line>;
 
    // ---------------------------------------------------------------------
    //     Constructor and Rule of Five
    // ---------------------------------------------------------------------
 
    CsvReader()  = default;
    ~CsvReader() = default;
 
    CsvReader( CsvReader const& ) = default;
    CsvReader( CsvReader&& )      = default;
 
    CsvReader& operator= ( CsvReader const& ) = default;
    CsvReader& operator= ( CsvReader&& )      = default;
 
    // ---------------------------------------------------------------------
    //     Reading
    // ---------------------------------------------------------------------
 
    Table read( std::shared_ptr<BaseInputSource> source ) const;
 
    // ---------------------------------------------------------------------
    //     Parsing
    // ---------------------------------------------------------------------
 
    Table parse_document(
        utils::InputStream& input_stream
    ) const;
 
    std::string parse_field(
        utils::InputStream& input_stream
    ) const;
 
    std::vector<std::string> parse_line(
        utils::InputStream& input_stream
    ) const;
 
    // ---------------------------------------------------------------------
    //     Properties
    // ---------------------------------------------------------------------
 
    CsvReader&         comment_chars( std::string const& chars )
    {
        comment_chars_ = chars;
        return *this;
    }
 
    std::string const& comment_chars() const
    {
        return comment_chars_;
    }
 
    CsvReader&         trim_chars( std::string const& chars )
    {
        trim_chars_ = chars;
        return *this;
    }
 
    std::string const& trim_chars() const
    {
        return trim_chars_;
    }
 
    CsvReader&         quotation_chars( std::string const& chars )
    {
        quotation_chars_ = chars;
        return *this;
    }
 
    std::string const& quotation_chars() const
    {
        return quotation_chars_;
    }
 
    CsvReader&         separator_chars( std::string const& chars )
    {
        separator_chars_ = chars;
        return *this;
    }
 
    std::string const& separator_chars() const
    {
        return separator_chars_;
    }
 
    CsvReader& skip_empty_lines( bool value )
    {
        skip_empty_lines_ = value;
        return *this;
    }
 
    bool       skip_empty_lines() const
    {
        return skip_empty_lines_;
    }
 
    CsvReader& merge_separators( bool value )
    {
        merge_separators_ = value;
        return *this;
    }
 
    bool       merge_separators() const
    {
        return merge_separators_;
    }
 
    CsvReader& use_escapes( bool value )
    {
        use_escapes_ = value;
        return *this;
    }
 
    bool       use_escapes() const
    {
        return use_escapes_;
    }
 
    CsvReader& use_twin_quotes( bool value )
    {
        use_twin_quotes_ = value;
        return *this;
    }
 
    bool       use_twin_quotes() const
    {
        return use_twin_quotes_;
    }
 
    // ---------------------------------------------------------------------
    //     Members
    // ---------------------------------------------------------------------
 
private:
 
    // We store the following char sets as strings and use find() to check whether a given char
    // is part of the sets. This is linear in length of the string. As there are usually just a
    // few chars in there, this is fast. We also tested with a char lookup table, which offers
    // constant time, but still was slower. See also http://stackoverflow.com/a/29068727/4184258
    std::string comment_chars_     = "";
    std::string trim_chars_        = "";
    std::string quotation_chars_   = "\"";
    std::string separator_chars_   = ",";
 
    bool        skip_empty_lines_  = false;
    bool        merge_separators_  = false;
    bool        use_escapes_       = false;
    bool        use_twin_quotes_   = true;
 
    // We use a buffer in order to make copying and resizing strings rare and hence fast.
    // This buffer will grow for bigger csv input fields (but never shrink). We then copy from it,
    // so that the new strings are as small as possible. After some fields, the buffer size
    // approaches a value where it rarely needs to grow any more. Speedup (using a 4MB file): ~20%.
    mutable std::string buffer_;
 
};
 
} // namespace utils
} // namespace genesis
 
#endif // include guard