parse-csv.H

Go to the documentation of this file.

 
/*
                          Aleph_w
 
  Data structures & Algorithms
  version 2.0.0b
  https://github.com/lrleon/Aleph-w
 
  This file is part of Aleph-w library
 
  Copyright (c) 2002-2026 Leandro Rabindranath Leon
 
  Permission is hereby granted, free of charge, to any person obtaining a copy
  of this software and associated documentation files (the "Software"), to deal
  in the Software without restriction, including without limitation the rights
  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  copies of the Software, and to permit persons to whom the Software is
  furnished to do so, subject to the following conditions:
 
  The above copyright notice and this permission notice shall be included in all
  copies or substantial portions of the Software.
 
  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  SOFTWARE.
*/
 
 
#ifndef PARSE_CSV_H
#define PARSE_CSV_H
 
#include <sstream>
#include <istream>
#include <ostream>
#include <fstream>
#include <string>
#include <tpl_array.H>
 
namespace Aleph
{
 
inline Array<std::string> csv_read_row(std::istream & in, char delimiter = ',')
{
  std::stringstream ss;
  bool inquotes = false;
  Array<std::string> row;  // Relying on RVO
  
  while (in.good())
    {
      int ch = in.get();
      
      // Check for EOF
      if (ch == std::char_traits<char>::eof())
        break;
      
      char c = static_cast<char>(ch);
      
      if (not inquotes and c == '"')  // Begin quoted field
        inquotes = true;
      else if (inquotes and c == '"')  // Quote character inside quoted field
        {
          if (in.peek() == '"')  // Two consecutive quotes resolve to one
            ss << static_cast<char>(in.get());
          else  // End of quoted field
            inquotes = false;
        }
      else if (not inquotes and c == delimiter)  // End of field
        {
          row.append(ss.str());
          ss.str("");
        }
      else if (not inquotes and (c == '\r' or c == '\n'))  // End of row
        {
          if (in.peek() == '\n')  // Handle CRLF
            in.get();
          row.append(ss.str());
          return row;
        }
      else
        ss << c;
    }
  
  // Handle last field if stream ended without newline
  if (ss.str().size() > 0 or row.size() > 0)
    row.append(ss.str());
    
  return row;
}
 
inline Array<std::string> csv_read_row(const std::string & line, 
                                       char delimiter = ',')
{
  std::stringstream ss(line);
  return csv_read_row(ss, delimiter);
}
 
inline Array<Array<std::string>> csv_read_all(std::istream & in, 
                                              char delimiter = ',')
{
  Array<Array<std::string>> result;
  
  while (in.good())
    {
      Array<std::string> row = csv_read_row(in, delimiter);
      if (row.size() == 0 and not in.good())
        break;
      result.append(std::move(row));
    }
  
  return result;
}
 
inline Array<Array<std::string>> csv_read_file(const std::string & filename,
                                               char delimiter = ',')
{
  std::ifstream file(filename);
  if (not file.is_open())
    throw std::runtime_error("Cannot open file: " + filename);
  
  return csv_read_all(file, delimiter);
}
 
inline std::string csv_escape(const std::string & field, char delimiter = ',')
{
  bool needs_quoting = false;
  
  // Check if quoting is needed
  for (char c : field)
    {
      if (c == delimiter or c == '"' or c == '\n' or c == '\r')
        {
          needs_quoting = true;
          break;
        }
    }
  
  if (not needs_quoting)
    return field;
  
  // Escape by quoting and doubling internal quotes
  std::string result = "\"";
  for (char c : field)
    {
      if (c == '"')
        result += "\"\"";
      else
        result += c;
    }
  result += "\"";
  
  return result;
}
 
inline void csv_write_row(std::ostream & out, 
                          const Array<std::string> & row,
                          char delimiter = ',',
                          const std::string & line_ending = "\n")
{
  for (size_t i = 0; i < row.size(); ++i)
    {
      if (i > 0)
        out << delimiter;
      out << csv_escape(row(i), delimiter);
    }
  out << line_ending;
}
 
inline void csv_write_all(std::ostream & out,
                          const Array<Array<std::string>> & rows,
                          char delimiter = ',',
                          const std::string & line_ending = "\n")
{
  for (size_t i = 0; i < rows.size(); ++i)
    csv_write_row(out, rows(i), delimiter, line_ending);
}
 
inline void csv_write_file(const std::string & filename,
                           const Array<Array<std::string>> & rows,
                           char delimiter = ',',
                           const std::string & line_ending = "\n")
{
  std::ofstream file(filename);
  if (not file.is_open())
    throw std::runtime_error("Cannot open file for writing: " + filename);
  
  csv_write_all(file, rows, delimiter, line_ending);
}
 
[[nodiscard]] inline size_t csv_num_columns(const Array<std::string> & row)
{
  return row.size();
}
 
[[nodiscard]] inline bool csv_is_rectangular(const Array<Array<std::string>> & rows)
{
  if (rows.size() == 0)
    return true;
  
  size_t expected_cols = rows(0).size();
  for (size_t i = 1; i < rows.size(); ++i)
    if (rows(i).size() != expected_cols)
      return false;
  
  return true;
}
 
inline Array<std::string> csv_get_column(const Array<Array<std::string>> & rows,
                                         size_t col_index)
{
  Array<std::string> column;
  
  for (size_t i = 0; i < rows.size(); ++i)
    {
      if (col_index >= rows(i).size())
        throw std::out_of_range("Column index " + std::to_string(col_index) +
                                " out of range for row " + std::to_string(i));
      column.append(rows(i)(col_index));
    }
  
  return column;
}
 
template <typename T>
[[nodiscard]] inline T csv_to_number(const std::string & field)
{
  std::istringstream ss(field);
  T value;
  ss >> value;
  
  if (ss.fail())
    throw std::invalid_argument("Cannot convert '" + field + "' to number");
  
  return value;
}
 
// Template specialization for int (uses std::stoi for better error handling)
template <>
[[nodiscard]] inline int csv_to_number<int>(const std::string & field)
{
  return std::stoi(field);
}
 
// Template specialization for long (uses std::stol for better error handling)
template <>
[[nodiscard]] inline long csv_to_number<long>(const std::string & field)
{
  return std::stol(field);
}
 
// Template specialization for double (uses std::stod for better error handling)
template <>
[[nodiscard]] inline double csv_to_number<double>(const std::string & field)
{
  return std::stod(field);
}
 
// Template specialization for float (uses std::stof for better error handling)
template <>
[[nodiscard]] inline float csv_to_number<float>(const std::string & field)
{
  return std::stof(field);
}
 
//============================================================================
// CsvRow - Row with header-based access
//============================================================================
 
class CsvRow
{
  Array<std::string> fields_;
  const Array<std::string> * header_;
  
public:
  explicit CsvRow(Array<std::string> fields)
    : fields_(std::move(fields)), header_(nullptr) {}
  
  CsvRow(Array<std::string> fields, const Array<std::string> & header)
    : fields_(std::move(fields)), header_(&header) {}
  
  [[nodiscard]] const std::string & operator[](size_t index) const
  {
    return fields_(index);
  }
  
  [[nodiscard]] const std::string & operator[](const std::string & column_name) const
  {
    if (header_ == nullptr)
      throw std::runtime_error("No header set for CsvRow");
    
    for (size_t i = 0; i < header_->size(); ++i)
      if ((*header_)(i) == column_name)
        return fields_(i);
    
    throw std::out_of_range("Column not found: " + column_name);
  }
  
  [[nodiscard]] const std::string & at(size_t index) const
  {
    if (index >= fields_.size())
      throw std::out_of_range("Index out of range: " + std::to_string(index));
    return fields_(index);
  }
  
  [[nodiscard]] bool has_column(const std::string & column_name) const
  {
    if (header_ == nullptr) return false;
    for (size_t i = 0; i < header_->size(); ++i)
      if ((*header_)(i) == column_name)
        return i < fields_.size();
    return false;
  }
  
  template <typename T>
  [[nodiscard]] T get(size_t index) const
  {
    return csv_to_number<T>(fields_(index));
  }
  
  template <typename T>
  [[nodiscard]] T get(const std::string & column_name) const
  {
    return csv_to_number<T>((*this)[column_name]);
  }
  
  [[nodiscard]] size_t size() const { return fields_.size(); }
  
  [[nodiscard]] bool empty() const { return fields_.size() == 0; }
  
  [[nodiscard]] const Array<std::string> & fields() const { return fields_; }
  
  [[nodiscard]] const Array<std::string> * header() const { return header_; }
};
 
//============================================================================
// CsvReader - Iterator-based reader for large files
//============================================================================
 
class CsvReader
{
  std::ifstream file_;
  std::istream * stream_;
  bool owns_stream_;
  char delimiter_;
  Array<std::string> header_;
  bool has_header_;
  size_t row_count_;
  
public:
  explicit CsvReader(const std::string & filename, char delimiter = ',')
    : file_(filename), stream_(&file_), owns_stream_(true), 
      delimiter_(delimiter), has_header_(false), row_count_(0)
  {
    if (not file_.is_open())
      throw std::runtime_error("Cannot open file: " + filename);
  }
  
  explicit CsvReader(std::istream & stream, char delimiter = ',')
    : stream_(&stream), owns_stream_(false), 
      delimiter_(delimiter), has_header_(false), row_count_(0) {}
  
  Array<std::string> read_header()
  {
    header_ = csv_read_row(*stream_, delimiter_);
    has_header_ = true;
    return header_;
  }
  
  [[nodiscard]] bool has_next() const
  {
    return stream_->good() and stream_->peek() != std::char_traits<char>::eof();
  }
  
  Array<std::string> next()
  {
    ++row_count_;
    return csv_read_row(*stream_, delimiter_);
  }
  
  CsvRow next_row()
  {
    ++row_count_;
    auto fields = csv_read_row(*stream_, delimiter_);
    if (has_header_)
      return CsvRow(std::move(fields), header_);
    return CsvRow(std::move(fields));
  }
  
  [[nodiscard]] size_t rows_read() const { return row_count_; }
  
  [[nodiscard]] const Array<std::string> & header() const { return header_; }
  
  [[nodiscard]] bool has_header() const { return has_header_; }
  
  void skip(size_t n)
  {
    for (size_t i = 0; i < n and has_next(); ++i)
      next();
  }
  
  void reset()
  {
    if (owns_stream_)
      {
        file_.clear();
        file_.seekg(0);
        row_count_ = 0;
        if (has_header_)
          read_header();  // Re-read header
      }
  }
  
  // Iterator support for range-based for loops
  class Iterator
  {
    CsvReader * reader_;
    Array<std::string> current_;
    bool at_end_;
    
  public:
    Iterator(CsvReader * reader, bool at_end)
      : reader_(reader), at_end_(at_end)
    {
      if (not at_end_ and reader_->has_next())
        current_ = reader_->next();
      else
        at_end_ = true;
    }
    
    const Array<std::string> & operator*() const { return current_; }
    
    Iterator & operator++()
    {
      if (reader_->has_next())
        current_ = reader_->next();
      else
        at_end_ = true;
      return *this;
    }
    
    bool operator!=(const Iterator & other) const
    {
      return at_end_ != other.at_end_;
    }
  };
  
  Iterator begin() { return Iterator(this, false); }
  Iterator end() { return Iterator(this, true); }
};
 
//============================================================================
// Filtering and Selection Functions
//============================================================================
 
template <typename Pred>
inline Array<Array<std::string>> csv_filter(const Array<Array<std::string>> & rows,
                                            Pred predicate)
{
  Array<Array<std::string>> result;
  for (size_t i = 0; i < rows.size(); ++i)
    if (predicate(rows(i)))
      result.append(rows(i));
  return result;
}
 
inline Array<Array<std::string>> csv_filter_by_value(
    const Array<Array<std::string>> & rows,
    size_t col_index,
    const std::string & value)
{
  return csv_filter(rows, [col_index, &value](const Array<std::string> & row) {
    return col_index < row.size() and row(col_index) == value;
  });
}
 
inline Array<Array<std::string>> csv_select_columns(
    const Array<Array<std::string>> & rows,
    const Array<size_t> & col_indices)
{
  Array<Array<std::string>> result;
  
  for (size_t i = 0; i < rows.size(); ++i)
    {
      Array<std::string> new_row;
      for (size_t j = 0; j < col_indices.size(); ++j)
        {
          size_t idx = col_indices(j);
          if (idx < rows(i).size())
            new_row.append(rows(i)(idx));
          else
            new_row.append("");  // Empty if column doesn't exist
        }
      result.append(std::move(new_row));
    }
  
  return result;
}
 
inline Array<Array<std::string>> csv_skip_rows(
    const Array<Array<std::string>> & rows,
    size_t n)
{
  Array<Array<std::string>> result;
  for (size_t i = n; i < rows.size(); ++i)
    result.append(rows(i));
  return result;
}
 
inline Array<Array<std::string>> csv_take_rows(
    const Array<Array<std::string>> & rows,
    size_t n)
{
  Array<Array<std::string>> result;
  size_t limit = (n < rows.size()) ? n : rows.size();
  for (size_t i = 0; i < limit; ++i)
    result.append(rows(i));
  return result;
}
 
//============================================================================
// Statistics Functions
//============================================================================
 
[[nodiscard]] inline size_t csv_count_rows(const Array<Array<std::string>> & rows)
{
  return rows.size();
}
 
[[nodiscard]] inline size_t csv_count_empty(const Array<Array<std::string>> & rows)
{
  size_t count = 0;
  for (size_t i = 0; i < rows.size(); ++i)
    for (size_t j = 0; j < rows(i).size(); ++j)
      if (rows(i)(j).empty())
        ++count;
  return count;
}
 
template <typename Pred>
[[nodiscard]] inline size_t csv_count_if(const Array<Array<std::string>> & rows,
                                         Pred predicate)
{
  size_t count = 0;
  for (size_t i = 0; i < rows.size(); ++i)
    if (predicate(rows(i)))
      ++count;
  return count;
}
 
template <typename Pred>
[[nodiscard]] inline size_t csv_find_row(const Array<Array<std::string>> & rows,
                                         Pred predicate)
{
  for (size_t i = 0; i < rows.size(); ++i)
    if (predicate(rows(i)))
      return i;
  return rows.size();
}
 
[[nodiscard]] inline size_t csv_find_by_value(
    const Array<Array<std::string>> & rows,
    size_t col_index,
    const std::string & value)
{
  return csv_find_row(rows, [col_index, &value](const Array<std::string> & row) {
    return col_index < row.size() and row(col_index) == value;
  });
}
 
inline Array<std::string> csv_distinct(const Array<Array<std::string>> & rows,
                                       size_t col_index)
{
  Array<std::string> result;
  for (size_t i = 0; i < rows.size(); ++i)
    {
      if (col_index >= rows(i).size()) continue;
      
      const std::string & val = rows(i)(col_index);
      bool found = false;
      for (size_t j = 0; j < result.size(); ++j)
        if (result(j) == val) { found = true; break; }
      
      if (not found)
        result.append(val);
    }
  return result;
}
 
//============================================================================
// Transformation Functions
//============================================================================
 
inline Array<Array<std::string>> csv_transpose(
    const Array<Array<std::string>> & rows)
{
  if (rows.size() == 0)
    return Array<Array<std::string>>();
  
  if (not csv_is_rectangular(rows))
    throw std::runtime_error("Cannot transpose non-rectangular CSV data");
  
  size_t num_rows = rows.size();
  size_t num_cols = rows(0).size();
  
  Array<Array<std::string>> result;
  for (size_t j = 0; j < num_cols; ++j)
    {
      Array<std::string> new_row;
      for (size_t i = 0; i < num_rows; ++i)
        new_row.append(rows(i)(j));
      result.append(std::move(new_row));
    }
  
  return result;
}
 
inline Array<Array<std::string>> csv_sort_by_column(
    const Array<Array<std::string>> & rows,
    size_t col_index,
    bool ascending = true)
{
  // Create index array
  Array<size_t> indices;
  for (size_t i = 0; i < rows.size(); ++i)
    indices.append(i);
  
  // Sort indices by column value
  for (size_t i = 0; i < indices.size(); ++i)
    for (size_t j = i + 1; j < indices.size(); ++j)
      {
        const std::string & a = (col_index < rows(indices(i)).size()) 
                                 ? rows(indices(i))(col_index) : "";
        const std::string & b = (col_index < rows(indices(j)).size()) 
                                 ? rows(indices(j))(col_index) : "";
        
        bool should_swap = ascending ? (a > b) : (a < b);
        if (should_swap)
          std::swap(indices(i), indices(j));
      }
  
  // Build sorted result
  Array<Array<std::string>> result;
  for (size_t i = 0; i < indices.size(); ++i)
    result.append(rows(indices(i)));
  
  return result;
}
 
template <typename T>
inline Array<Array<std::string>> csv_sort_by_column_numeric(
    const Array<Array<std::string>> & rows,
    size_t col_index,
    bool ascending = true)
{
  // Create pairs of (value, index)
  Array<std::pair<T, size_t>> pairs;
  for (size_t i = 0; i < rows.size(); ++i)
    {
      T val = (col_index < rows(i).size()) 
              ? csv_to_number<T>(rows(i)(col_index)) : T{};
      pairs.append({val, i});
    }
  
  // Sort pairs
  for (size_t i = 0; i < pairs.size(); ++i)
    for (size_t j = i + 1; j < pairs.size(); ++j)
      {
        bool should_swap = ascending 
                           ? (pairs(i).first > pairs(j).first)
                           : (pairs(i).first < pairs(j).first);
        if (should_swap)
          std::swap(pairs(i), pairs(j));
      }
  
  // Build sorted result
  Array<Array<std::string>> result;
  for (size_t i = 0; i < pairs.size(); ++i)
    result.append(rows(pairs(i).second));
  
  return result;
}
 
inline Array<Array<std::string>> csv_unique(
    const Array<Array<std::string>> & rows)
{
  Array<Array<std::string>> result;
  
  for (size_t i = 0; i < rows.size(); ++i)
    {
      bool is_duplicate = false;
      for (size_t j = 0; j < result.size(); ++j)
        {
          if (result(j).size() != rows(i).size()) continue;
          
          bool equal = true;
          for (size_t k = 0; k < rows(i).size(); ++k)
            if (result(j)(k) != rows(i)(k)) { equal = false; break; }
          
          if (equal) { is_duplicate = true; break; }
        }
      
      if (not is_duplicate)
        result.append(rows(i));
    }
  
  return result;
}
 
template <typename Func>
inline Array<Array<std::string>> csv_transform(
    const Array<Array<std::string>> & rows,
    Func func)
{
  Array<Array<std::string>> result;
  
  for (size_t i = 0; i < rows.size(); ++i)
    {
      Array<std::string> new_row;
      for (size_t j = 0; j < rows(i).size(); ++j)
        new_row.append(func(rows(i)(j)));
      result.append(std::move(new_row));
    }
  
  return result;
}
 
//============================================================================
// Utility Functions
//============================================================================
 
inline bool csv_skip_bom(std::istream & in)
{
  char c1 = in.get();
  char c2 = in.get();
  char c3 = in.get();
  
  if (c1 == '\xEF' and c2 == '\xBB' and c3 == '\xBF')
    return true;  // BOM skipped
  
  // Not a BOM, put characters back
  in.putback(c3);
  in.putback(c2);
  in.putback(c1);
  return false;
}
 
inline Array<Array<std::string>> csv_trim_fields(
    const Array<Array<std::string>> & rows)
{
  auto trim = [](const std::string & s) -> std::string {
    size_t start = 0;
    while (start < s.size() and std::isspace(static_cast<unsigned char>(s[start])))
      ++start;
    
    size_t end = s.size();
    while (end > start and std::isspace(static_cast<unsigned char>(s[end - 1])))
      --end;
    
    return s.substr(start, end - start);
  };
  
  return csv_transform(rows, trim);
}
 
inline Array<Array<std::string>> csv_fill_empty(
    const Array<Array<std::string>> & rows,
    const std::string & default_value)
{
  return csv_transform(rows, [&default_value](const std::string & s) {
    return s.empty() ? default_value : s;
  });
}
 
inline Array<Array<std::string>> csv_join_horizontal(
    const Array<Array<std::string>> & left,
    const Array<Array<std::string>> & right)
{
  Array<Array<std::string>> result;
  size_t max_rows = (left.size() > right.size()) ? left.size() : right.size();
  
  for (size_t i = 0; i < max_rows; ++i)
    {
      Array<std::string> new_row;
      
      // Add fields from left
      if (i < left.size())
        for (size_t j = 0; j < left(i).size(); ++j)
          new_row.append(left(i)(j));
      
      // Add fields from right
      if (i < right.size())
        for (size_t j = 0; j < right(i).size(); ++j)
          new_row.append(right(i)(j));
      
      result.append(std::move(new_row));
    }
  
  return result;
}
 
inline Array<Array<std::string>> csv_join_vertical(
    const Array<Array<std::string>> & top,
    const Array<Array<std::string>> & bottom)
{
  Array<Array<std::string>> result;
  
  for (size_t i = 0; i < top.size(); ++i)
    result.append(top(i));
  
  for (size_t i = 0; i < bottom.size(); ++i)
    result.append(bottom(i));
  
  return result;
}
 
inline Array<Array<std::string>> csv_inner_join(
    const Array<Array<std::string>> & left,
    size_t left_key_col,
    const Array<Array<std::string>> & right,
    size_t right_key_col)
{
  Array<Array<std::string>> result;
  
  for (size_t i = 0; i < left.size(); ++i)
    {
      if (left_key_col >= left(i).size()) continue;
      const std::string & left_key = left(i)(left_key_col);
      
      for (size_t j = 0; j < right.size(); ++j)
        {
          if (right_key_col >= right(j).size()) continue;
          
          if (left_key == right(j)(right_key_col))
            {
              // Combine rows (excluding duplicate key from right)
              Array<std::string> new_row;
              
              for (size_t k = 0; k < left(i).size(); ++k)
                new_row.append(left(i)(k));
              
              for (size_t k = 0; k < right(j).size(); ++k)
                if (k != right_key_col)
                  new_row.append(right(j)(k));
              
              result.append(std::move(new_row));
            }
        }
    }
  
  return result;
}
 
inline Array<Array<Array<std::string>>> csv_group_by(
    const Array<Array<std::string>> & rows,
    size_t col_index)
{
  Array<std::string> keys = csv_distinct(rows, col_index);
  Array<Array<Array<std::string>>> result;
  
  for (size_t k = 0; k < keys.size(); ++k)
    {
      Array<Array<std::string>> group;
      for (size_t i = 0; i < rows.size(); ++i)
        if (col_index < rows(i).size() and rows(i)(col_index) == keys(k))
          group.append(rows(i));
      result.append(std::move(group));
    }
  
  return result;
}
 
template <typename Func>
inline Array<Array<std::string>> csv_add_column(
    const Array<Array<std::string>> & rows,
    Func func)
{
  Array<Array<std::string>> result;
  
  for (size_t i = 0; i < rows.size(); ++i)
    {
      Array<std::string> new_row;
      for (size_t j = 0; j < rows(i).size(); ++j)
        new_row.append(rows(i)(j));
      new_row.append(func(rows(i)));
      result.append(std::move(new_row));
    }
  
  return result;
}
 
inline Array<Array<std::string>> csv_rename_column(
    const Array<Array<std::string>> & rows,
    const std::string & old_name,
    const std::string & new_name)
{
  if (rows.size() == 0)
    return rows;
  
  Array<Array<std::string>> result;
  
  // Process header
  Array<std::string> new_header;
  for (size_t j = 0; j < rows(0).size(); ++j)
    {
      if (rows(0)(j) == old_name)
        new_header.append(new_name);
      else
        new_header.append(rows(0)(j));
    }
  result.append(std::move(new_header));
  
  // Copy remaining rows
  for (size_t i = 1; i < rows.size(); ++i)
    result.append(rows(i));
  
  return result;
}
 
} // namespace Aleph
 
// Global namespace compatibility: export commonly used functions and classes
using Aleph::CsvRow;
using Aleph::CsvReader;
using Aleph::csv_read_row;
using Aleph::csv_read_all;
using Aleph::csv_read_file;
using Aleph::csv_escape;
using Aleph::csv_write_row;
using Aleph::csv_write_all;
using Aleph::csv_write_file;
using Aleph::csv_num_columns;
using Aleph::csv_is_rectangular;
using Aleph::csv_get_column;
using Aleph::csv_to_number;
using Aleph::csv_filter;
using Aleph::csv_filter_by_value;
using Aleph::csv_select_columns;
using Aleph::csv_skip_rows;
using Aleph::csv_take_rows;
using Aleph::csv_count_rows;
using Aleph::csv_count_empty;
using Aleph::csv_count_if;
using Aleph::csv_find_row;
using Aleph::csv_find_by_value;
using Aleph::csv_distinct;
using Aleph::csv_transpose;
using Aleph::csv_sort_by_column;
using Aleph::csv_sort_by_column_numeric;
using Aleph::csv_unique;
using Aleph::csv_transform;
using Aleph::csv_skip_bom;
using Aleph::csv_trim_fields;
using Aleph::csv_fill_empty;
using Aleph::csv_join_horizontal;
using Aleph::csv_join_vertical;
using Aleph::csv_inner_join;
using Aleph::csv_group_by;
using Aleph::csv_add_column;
using Aleph::csv_rename_column;
 
#endif // PARSE_CSV_H