csv/slice.hpp

Go to the documentation of this file.

#ifndef MTCORE_CSV_SLICE_HPP
#define MTCORE_CSV_SLICE_HPP
 
#include "mtcore/colls/slice.hpp"
#include "mtcore/csv/common.hpp"
#include "mtcore/io/reader.hpp"
#include "mtcore/csv/writer.hpp"
 
namespace mtcore::csv {
  struct SliceParser {
    Slice<const char> slice;
    Options options;
 
    struct Field {
      Slice<const char> data;
      Options options;
 
      template<WriterImpl WI>
      Result<size_t, typename io::Writer<WI>::ErrType> decode(io::Writer<WI> &writer) const {
        return mtcore::csv::common::decode(writer, data, options);
      }
 
      [[nodiscard]] Result<Slice<char>, AllocationError> copy(Allocator alloc) const;
    };
 
    struct RowField {
      Field field = {};
      bool rowEnd = false;
    };
 
    struct FieldParser {
      using IterElem = RowField;
 
      Slice<const char> data;
      Options opts;
      Optional<ReadError> error = nullopt;
      struct {
        u64 prevQuote       = 0;
        u64 prevCr          = 0;
        u64 prevQuoteEnds   = 0;
        u64 prevFieldSeps   = static_cast<u64>(1) << (chunkSize - 1);
        u64 fieldSeparators = 0;
        u64 startChunk      = 0;
        u64 startChunkPos   = 0;
        u64 endChunk        = 0;
        u64 nextChunk       = 0;
        bool fieldStart     = true;
        bool skip           = false;
      } state = {};
 
      FieldParser(const Slice<const char> &data, const Options &opts);
 
      [[nodiscard]] size_t start_pos() const;
 
      [[nodiscard]] bool done() const;
 
      [[nodiscard]] bool has_next_chunk() const;
 
      Optional<RowField> next();
    };
    static_assert(is_iterator<FieldParser>, "Not an iterator");
 
    struct Row {
      Slice<const char> data;
      Options opts;
      size_t len = 0;
 
      struct Iter {
        FieldParser fieldParser;
        using IterElem = Field;
 
        Optional<Field> next();
      };
      static_assert(is_iterator<Iter>, "Not an iterator");
 
      [[nodiscard]] Iter iter() const;
 
      [[nodiscard]] size_t size() const;
 
      Field operator[](size_t i) const;
    };
 
    using IterElem = Row;
 
    struct Iter {
      FieldParser parser;
 
      using IterElem = Row;
 
      Optional<Row> next();
      [[nodiscard]] Optional<ReadError> error() const { return parser.error; };
    };
 
    static_assert(is_iterator<Iter>, "Not an iterator");
 
    [[nodiscard]] Iter iter() const;
 
    struct RowReader {
      using ReadElem = Row;
      using ErrType  = ReadError;
      Iter iter;
 
      Result<Slice<const ReadElem>, ErrType> read(Slice<ReadElem> out) {
        Row cur;
        size_t read = 0;
        while (read < out.len && iter.next().copy_if_present(cur)) {
          out[read++] = cur;
        }
        if (iter.parser.error.has_value()) {
          return error(iter.parser.error.value());
        }
        return success(out.sub(0, read).to_const());
      }
    };
 
    [[nodiscard]] io::Reader<RowReader> rows() const { return {RowReader{iter()}}; }
 
    struct FieldReader {
      using ReadElem = std::variant<RowEnd, Field>;
      using ErrType  = ReadError;
      FieldParser iter;
      bool rowEnd = false;
 
      Result<Slice<const ReadElem>, ErrType> read(Slice<ReadElem> out) {
        RowField cur;
        size_t read = 0;
        if (!out.empty() && rowEnd) {
          out[read++] = RowEnd{};
          rowEnd      = false;
        }
 
        while (read < out.len && iter.next().copy_if_present(cur)) {
          out[read++] = cur.field;
          if (cur.rowEnd) {
            if (read < out.len) {
              out[read++] = RowEnd{};
            }
            else {
              rowEnd = true;
            }
          }
        }
 
        if (iter.error.has_value()) {
          return error(iter.error.value());
        }
        return success(out.sub(0, read).to_const());
      }
    };
 
    [[nodiscard]] io::Reader<FieldReader> fields() const { return {FieldReader{iter().parser}}; }
  };
}  // namespace mtcore::csv
 
#endif  // MTCORE_CSV_SLICE_HPP