common.hpp

Go to the documentation of this file.

#ifndef MTCORE_CSV_COMMON_HPP
#define MTCORE_CSV_COMMON_HPP
 
#include "mtcore/colls/optional.hpp"
 
namespace mtcore::csv {
  static constexpr u64 chunkSize = 64;
 
  enum class ReadErrorCode {
    INTERNAL_LIMIT_REACHED,
    UNEXPECTED_EOF,
    INVALID_LINE_ENDING,
    QUOTE_PREMATURELY_TERMINATED,
    UNEXPECTED_QUOTE,
 
    END_OF_FILE,
    ALLOCATION_FAILED,
    SIZE_EXCEEDED,
  };
 
  struct ReadError {
    ReadErrorCode code;
    size_t pos;
 
    bool operator==(const ReadError &o) const { return code == o.code && pos == o.pos; }
 
    bool operator==(const ReadErrorCode &o) const { return code == o; }
 
    bool operator!=(const ReadError &o) const { return !(*this == o); }
 
    bool operator!=(const ReadErrorCode &o) const { return !(*this == o); }
 
    static const ReadError END_OF_FILE;
    static const ReadError ALLOCATION_FAILED;
    static const ReadError SIZE_EXCEEDED;
 
    template<WriterImpl WI>
    Result<size_t, typename io::Writer<WI>::ErrType> fmt(io::Writer<WI> &writer, const io::FormatOptions &) {
      const char* codeStr = "";
      switch (code) {
        case ReadErrorCode::INTERNAL_LIMIT_REACHED:
          codeStr = "INTERNAL_LIMIT_REACHED";
          break;
        case ReadErrorCode::UNEXPECTED_EOF:
          codeStr = "UNEXPECTED_EOF";
          break;
        case ReadErrorCode::INVALID_LINE_ENDING:
          codeStr = "INVALID_LINE_ENDING";
          break;
        case ReadErrorCode::QUOTE_PREMATURELY_TERMINATED:
          codeStr = "QUOTE_PREMATURELY_TERMINATED";
          break;
        case ReadErrorCode::UNEXPECTED_QUOTE:
          codeStr = "UNEXPECTED_QUOTE";
          break;
        case ReadErrorCode::END_OF_FILE:
          codeStr = "END_OF_FILE";
          break;
        case ReadErrorCode::ALLOCATION_FAILED:
          codeStr = "ALLOCATION_FAILED";
          break;
        case ReadErrorCode::SIZE_EXCEEDED:
          codeStr = "SIZE_EXCEEDED";
          break;
      }
 
      return io::print(writer, "ReadError\\{{}, {}\\}", codeStr, pos);
    }
  };

  struct Options {
    Optional<char> cr        = '\r';
    char lf                  = '\n';
    char quote               = '"';
    char sep                 = ',';
    size_t internalIterLimit = 65536;
 
    [[nodiscard]] bool valid() const;
  };
 
  namespace common {
    [[nodiscard]] u64 quoted_regions(u64 m);
 
    Slice<const char> unquote_quoted(Slice<const char> data, Options opts);
 
    template<WriterImpl WI>
    Result<size_t, typename io::Writer<WI>::ErrType> decode(io::Writer<WI> &writer, Slice<const char> field,
                                                        const Options options = {}) {
      ensure(options.valid());
      const auto quote = options.quote;
      if (field.len < 2 || field[0] != quote) {
        return writer.write_all(field);
      }
 
      const auto data = unquote_quoted(field, options);
      Optional<char> nextChar;
      Optional<char> curChar;
      size_t ni      = 1;
      size_t written = 0;
 
      if (0 < data.len) {
        curChar = data[0];
        if (1 < data.len) {
          nextChar = data[1];
        }
      }
 
      char c;
      while (curChar.copy_if_present(c)) {
        mtdefer {
          ni++;
          curChar = nextChar;
          if (ni < data.len) {
            nextChar = data[ni];
          }
          else {
            nextChar = nullopt;
          }
        };
 
        if (c != quote) {
          if (auto r = writer.write(c); r.is_error()) {
            return r.error();
          }
          ++written;
          continue;
        }
 
        if (nextChar == quote) {
          mtdefer {
            ni += 1;
            curChar = nextChar;
            if (ni < data.len) {
              nextChar = data[ni];
            }
            else {
              nextChar = nullopt;
            }
          };
 
          if (auto r = writer.write(c); r.is_error()) {
            return r.error();
          }
          ++written;
        }
      }
 
      return success(written);
    }
  }  // namespace common
 
  [[nodiscard]] u64 bit_match_64(char ch, Slice<const char> s);
}  // namespace mtcore::csv
 
#endif  // MTCORE_CSV_COMMON_HPP