BLI_csv_parse.hh

Go to the documentation of this file.

/* SPDX-FileCopyrightText: 2025 Blender Authors
 *
 * SPDX-License-Identifier: GPL-2.0-or-later */

 
#include "BLI_any.hh"
#include "BLI_function_ref.hh"
#include "BLI_linear_allocator.hh"
#include "BLI_offset_indices.hh"
#include "BLI_string_ref.hh"
#include "BLI_vector.hh"
 
namespace blender::csv_parse {

class CsvRecord {
 private:
  Span<Span<char>> fields_;
 
 public:
  CsvRecord(Span<Span<char>> fields);

  int64_t size() const;
  IndexRange index_range() const;

  Span<char> field(const int64_t index) const;
  StringRef field_str(const int64_t index) const;
};

class CsvRecords {
 private:
  OffsetIndices<int64_t> offsets_;
  Span<Span<char>> fields_;
 
 public:
  CsvRecords(OffsetIndices<int64_t> offsets, Span<Span<char>> fields);

  int64_t size() const;
  IndexRange index_range() const;

  CsvRecord record(const int64_t index) const;
};
 
struct CsvParseOptions {
  char delimiter = ',';
  char quote = '"';
  Span<char> quote_escape_chars = Span<char>(StringRef("\"\\"));
  int64_t chunk_size_bytes = 64 * 1024;
};

std::optional<Vector<Any<>>> parse_csv_in_chunks(
    const Span<char> buffer,
    const CsvParseOptions &options,
    FunctionRef<void(const CsvRecord &record)> process_header,
    FunctionRef<Any<>(const CsvRecords &records)> process_records);

template<typename ChunkT>
inline std::optional<Vector<ChunkT>> parse_csv_in_chunks(
    const Span<char> buffer,
    const CsvParseOptions &options,
    FunctionRef<void(const CsvRecord &record)> process_header,
    FunctionRef<ChunkT(const CsvRecords &records)> process_records)
{
  std::optional<Vector<Any<>>> result = parse_csv_in_chunks(
      buffer, options, process_header, [&](const CsvRecords &records) {
        return Any<>(process_records(records));
      });
  if (!result.has_value()) {
    return std::nullopt;
  }
  Vector<ChunkT> result_chunks;
  result_chunks.reserve(result->size());
  for (Any<> &value : *result) {
    result_chunks.append(std::move(value.get<ChunkT>()));
  }
  return result_chunks;
}

StringRef unescape_field(const StringRef str,
                         const CsvParseOptions &options,
                         LinearAllocator<> &allocator);
 
/* -------------------------------------------------------------------- */
 
inline CsvRecord::CsvRecord(Span<Span<char>> fields) : fields_(fields) {}
 
inline int64_t CsvRecord::size() const
{
  return fields_.size();
}
 
inline IndexRange CsvRecord::index_range() const
{
  return fields_.index_range();
}
 
inline Span<char> CsvRecord::field(const int64_t index) const
{
  BLI_assert(index >= 0);
  if (index >= fields_.size()) {
    return {};
  }
  return fields_[index];
}
 
inline StringRef CsvRecord::field_str(const int64_t index) const
{
  const Span<char> value = this->field(index);
  return StringRef(value.data(), value.size());
}

 
/* -------------------------------------------------------------------- */
 
inline CsvRecords::CsvRecords(const OffsetIndices<int64_t> offsets, const Span<Span<char>> fields)
    : offsets_(offsets), fields_(fields)
{
}
 
inline int64_t CsvRecords::size() const
{
  return offsets_.size();
}
 
inline IndexRange CsvRecords::index_range() const
{
  return offsets_.index_range();
}
 
inline CsvRecord CsvRecords::record(const int64_t index) const
{
  return CsvRecord(fields_.slice(offsets_[index]));
}

 
/* -------------------------------------------------------------------- */
 
namespace detail {

int64_t find_end_of_simple_field(Span<char> buffer, int64_t start, char delimiter);

std::optional<int64_t> find_end_of_quoted_field(Span<char> buffer,
                                                int64_t start,
                                                char quote,
                                                Span<char> escape_chars);

std::optional<int64_t> parse_record_fields(const Span<char> buffer,
                                           const int64_t start,
                                           const char delimiter,
                                           const char quote,
                                           const Span<char> quote_escape_chars,
                                           Vector<Span<char>> &r_fields);
 
}  // namespace detail

 
}  // namespace blender::csv_parse