rapidcsv

Rapidcsv provides a set of classes for parsing and interacting with CSV files in C++. The core API is organized around the following components:

• rapidcsv::Document: The primary interface for interacting with a loaded CSV file, allowing access to data via rows, columns, or specific cells.
• rapidcsv::Converter<T>: A template class used to define how data is converted from the raw CSV format into specific C++ types.
• rapidcsv::ConverterParams: Configuration parameters for the conversion process.
• rapidcsv::LabelParams: Configuration for handling column and row headers (labels).
• rapidcsv::LineReaderParams: Parameters for the line-by-line reading process.
• rapidcsv::SeparatorParams: Configuration for defining custom delimiters (e.g., commas, tabs, semicolons).
• rapidcsv::no_converter: A specialized converter type for cases where no conversion is required.

To build the example project that demonstrates how to use find_package with rapidcsv, follow these steps. First, install the library using the provided shell script, then create a build directory and use CMake to configure and build the project.

# Install the library
pushd ../../ ; ./make.sh install ; popd

# Build the example project
mkdir -p build && cd build && cmake .. && make

Rapidcsv is a header-only C++ library. You can install it using one of the following methods:

1. Manual: Copy rapidcsv.h to your project's include directory.
2. vcpkg: Available via the vcpkg package manager.
3. Conan: Available via the Conan package manager.

To use rapidcsv as a subdirectory in your own CMake project, you can symlink the repository into your project structure and use the add_subdirectory command. This allows you to build rapidcsv as part of your main build process.

Setup and Build Steps

1. Create a symbolic link to the rapidcsv directory within your project.
2. Create a build directory.
3. Run cmake and make to compile the project.

# Link the rapidcsv repository to your current directory
ln -s ../.. rapidcsv

# Create build directory and compile
mkdir -p build && cd build && cmake .. && make

To build the example project that demonstrates using FetchContent with CMake, follow these steps to create a build directory, configure the project with CMake, and compile using make.

mkdir -p build && cd build && cmake .. && make

To read a CSV file and extract a specific column into a std::vector, instantiate a rapidcsv::Document with the file path and use the GetColumn<T> method. By default, the first row is treated as column headers.

#include <iostream>
#include <vector>
#include "rapidcsv.h"

int main()
{
  rapidcsv::Document doc("examples/colhdr.csv");

  std::vector<float> col = doc.GetColumn<float>("Close");
  std::cout << "Read " << col.size() << " values." << std::endl;
}

You can extract entire rows or columns as vectors of a specified type T.

Get Columns:

• GetColumn<T>(size_t pColumnIdx): By zero-based index.
• GetColumn<T>(const std::string & pColumnName): By label name.

Get Rows:

• GetRow<T>(size_t pRowIdx): By zero-based index.
• GetRow<T>(const std::string & pRowName): By label name.

Both methods support an optional ConvFunc<T> pToVal for custom conversion.

// Get a whole column as a vector of ints
std::vector<int> ages = doc.GetColumn<int>("Age");

// Get a whole row as a vector of strings
std::vector<std::string> row = doc.GetRow<std::string>("RowName");

Use SeparatorParams to control how quoted cells are handled and LineReaderParams to manage comment and empty lines.

• Disable Auto-dequoting: Set pAutoQuote = false in SeparatorParams.
• Skip Comment Lines: Use LineReaderParams with pSkipCommentLines = true and specify the pCommentPrefix.
• Skip Empty Lines: Use LineReaderParams with pSkipEmptyLines = true.

// Disable auto-quoting
rapidcsv::SeparatorParams sep_params(',' /* pSeparator */, false /* pTrim */, rapidcsv::sPlatformHasCR, false /* pQuotedLinebreaks */, false /* pAutoQuote */);

// Skip comments starting with '#'
rapidcsv::LineReaderParams line_params(true /* pSkipCommentLines */, '#' /* pCommentPrefix */, false /* pSkipEmptyLines */);

rapidcsv::Document doc("file.csv", rapidcsv::LabelParams(), sep_params, rapidcsv::ConverterParams(), line_params);

You can retrieve individual cell values using several combinations of indices and names. Most methods are templated, allowing you to specify the desired return type T.

Access Methods:

• By Index: GetCell<T>(size_t pColumnIdx, size_t pRowIdx)
• By Name: GetCell<T>(const std::string & pColumnName, const std::string & pRowName)
• Mixed (Column Name, Row Index): GetCell<T>(const std::string & pColumnName, size_t pRowIdx)
• Mixed (Column Index, Row Name): GetCell<T>(size_t pColumnIdx, const std::string & pRowName)

All methods support an optional ConvFunc<T> pToVal parameter to provide a custom conversion function.

// Get an integer from a specific cell by name
int val = doc.GetCell<int>("Age", "John Doe");

// Get a double from a cell by index
double price = doc.GetCell<double>(0, 5);