csv_writer.hpp

Go to the documentation of this file.

 
#pragma once
#include <cmath>
#include <fstream>
#include <iostream>
#include <memory>
#ifdef CSV_HAS_CXX20
#include <ranges>
#endif
#include <stdexcept>
#include <string>
#include <tuple>
#include <type_traits>
#include <vector>
 
#include "basic_csv_parser_simd.hpp"
#include "common.hpp"
#include "csv_exceptions.hpp"
 
namespace csv {
namespace internals {
    static int DECIMAL_PLACES = 5;
 
        template<typename T>
        CSV_CONST CONSTEXPR_14
        long double pow10(const T& n) noexcept {
            static_assert(std::is_integral<T>::value, "pow10 only supports integral exponents");
 
            long double multiplicand = n > 0 ? 10 : 0.1,
                ret = 1;
            T iterations = n > 0 ? n : -n;
 
            for (T i = 0; i < iterations; i++) {
                ret *= multiplicand;
            }
 
            return ret;
        }
 
        template<>
        CSV_CONST CONSTEXPR_14
        long double pow10(const unsigned& n) noexcept {
            long double multiplicand = n > 0 ? 10 : 0.1,
                ret = 1;
 
            for (unsigned i = 0; i < n; i++) {
                ret *= multiplicand;
            }
 
            return ret;
        }
 
        template<typename T = int>
        inline T csv_abs(T x) {
            return abs(x);
        }
 
        template<>
        inline int csv_abs(int x) {
            return abs(x);
        }
 
        template<>
        inline long int csv_abs(long int x) {
            return labs(x);
        }
 
        template<>
        inline long long int csv_abs(long long int x) {
            return llabs(x);
        }
 
        template<>
        inline float csv_abs(float x) {
            return fabsf(x);
        }
 
        template<>
        inline double csv_abs(double x) {
            return fabs(x);
        }
 
        template<>
        inline long double csv_abs(long double x) {
            return fabsl(x);
        }
 
        template<
            typename T,
            csv::enable_if_t<std::is_arithmetic<T>::value, int> = 0
        >
        int num_digits(T x)
        {
            x = csv_abs(x);
            int digits = 0;
            for (; x >= 1; digits++)
                x /= 10;
 
            return (x == 0) ? 1 : digits;
        }
 
        template<typename T,
            csv::enable_if_t<std::is_unsigned<T>::value, int> = 0>
        inline std::string to_string(T value) {
            std::string digits_reverse = "";
            if (value == 0) return "0";
 
            for (; value > 0; value /= 10)
                digits_reverse += (char)('0' + (value % 10));
 
            return std::string(digits_reverse.rbegin(), digits_reverse.rend());
        }
 
        template<
            typename T,
            csv::enable_if_t<std::is_integral<T>::value && std::is_signed<T>::value, int> = 0
        >
        inline std::string to_string(T value) {
            return (value >= 0) ? to_string((size_t)value)
                : "-" + to_string((size_t)(value * -1));
        }
 
    template<
        typename T,
        csv::enable_if_t<std::is_floating_point<T>::value, int> = 0
    >
    inline std::string to_string(T value) {
        std::string result = "";
 
            long double integral_part;
            long double fractional_part = csv_abs(std::modf((long double)value, &integral_part));
 
            const long double scale = pow10(DECIMAL_PLACES);
            long double rounded_fractional = std::round(fractional_part * scale);
 
            // Work with the absolute value of the integral part so digit extraction
            // and carry both work correctly for negative numbers.
            long double abs_integral = csv_abs(integral_part);
 
            // Carry rounding overflow from fractional digits into integral digits.
            if (rounded_fractional >= scale) {
                abs_integral += 1;
                rounded_fractional = 0;
            }
 
            // Integral part
            if (value < 0) result = "-";
 
            if (abs_integral == 0) {
                result += "0";
            }
            else {
                for (int n_digits = num_digits(abs_integral); n_digits > 0; n_digits --) {
                    int digit = (int)(std::fmod(abs_integral, pow10(n_digits)) / pow10(n_digits - 1));
                    result += (char)('0' + digit);
                }
            }
 
            // Decimal part
            result += ".";
 
            if (rounded_fractional > 0) {
                for (int n_digits = DECIMAL_PLACES; n_digits > 0; n_digits--) {
                    int digit = (int)(std::fmod(rounded_fractional, pow10(n_digits)) / pow10(n_digits - 1));
                    result += (char)('0' + digit);
                }
            }
            else {
                result += "0";
            }
 
        return result;
    }
}
 
inline static void set_decimal_places(int precision) {
    internals::DECIMAL_PLACES = precision;
}
 
namespace internals {
    template<typename T, typename = void>
    struct is_iterable : std::false_type {};
 
        template<typename T>
        struct is_iterable<T, typename std::enable_if<true>::type> {
        private:
            template<typename U>
            static auto test(int) -> decltype(
                std::begin(std::declval<const U&>()),
                std::end(std::declval<const U&>()),
                std::true_type{}
            );
            template<typename>
            static std::false_type test(...);
        public:
            static constexpr bool value = decltype(test<T>(0))::value;
        };
 
    template<typename T, typename = void>
    struct is_tuple : std::false_type {};
 
        template<typename T>
        struct is_tuple<T, typename std::enable_if<true>::type> {
        private:
            template<typename U>
            static auto test(int) -> decltype(std::tuple_size<U>::value, std::true_type{});
            template<typename>
            static std::false_type test(...);
        public:
            static constexpr bool value = decltype(test<T>(0))::value;
        };
 
}
 
 
    template<class OutputStream, char Delim, char Quote>
    class DelimWriter {
    public:
        DelimWriter(OutputStream& _out, bool _quote_minimal = true)
            : out(&_out), quote_minimal(_quote_minimal) {}
 
        template<typename T = OutputStream,
            csv::enable_if_t<std::is_same<T, std::ofstream>::value, int> = 0>
        DelimWriter(const std::string& filename, bool _quote_minimal = true)
            : owned_out(new std::ofstream(filename, std::ios::out)),
            out(owned_out.get()),
            quote_minimal(_quote_minimal) {
            if (!owned_out->is_open())
                internals::throw_failed_open_for_writing(filename);
        }
 
        DelimWriter(const DelimWriter&) = delete;
        DelimWriter& operator=(const DelimWriter&) = delete;
 
        DelimWriter(DelimWriter&& other) noexcept
            : owned_out(std::move(other.owned_out)),
            out(other.out),
            quote_minimal(other.quote_minimal),
            auto_flush_(other.auto_flush_),
            batch_buffer_(std::move(other.batch_buffer_)) {
            if (owned_out) {
                out = owned_out.get();
            }
            other.out = nullptr;
            other.quote_minimal = true;
        }
 
        DelimWriter& operator=(DelimWriter&& other) noexcept {
            if (this == &other) return *this;
 
            owned_out = std::move(other.owned_out);
            out = other.out;
            quote_minimal = other.quote_minimal;
            auto_flush_ = other.auto_flush_;
            batch_buffer_ = std::move(other.batch_buffer_);
 
            if (owned_out) {
                out = owned_out.get();
            }
 
            other.out = nullptr;
            other.quote_minimal = true;
            return *this;
        }
 
        DelimWriter& set_auto_flush(bool value) & noexcept {
            this->auto_flush_ = value;
            return *this;
        }
 
        DelimWriter&& set_auto_flush(bool value) && noexcept {
            this->auto_flush_ = value;
            return std::move(*this);
        }
 
        bool get_auto_flush() const noexcept {
            return this->auto_flush_;
        }
 
        ~DelimWriter() {
            if (out) {
                flush_batch();
                out->flush();
            }
        }
 
        template<typename T, size_t N>
        DelimWriter& operator<<(const T (&record)[N]) {
            write_range_impl(record);
            return *this;
        }
 
        template<typename T, size_t N>
        DelimWriter& operator<<(const std::array<T, N>& record) {
            write_range_impl(record);
            return *this;
        }
 
        template<typename T>
        auto write_row(T&& record) -> decltype(*this << std::forward<T>(record)) {
            return *this << std::forward<T>(record);
        }
 
        template<typename T, typename U, typename... Rest>
        DelimWriter& write_row(T&& first, U&& second, Rest&&... rest) {
            this->write_tuple<0>(std::forward_as_tuple(
                std::forward<T>(first), std::forward<U>(second), std::forward<Rest>(rest)...));
            return *this;
        }
 
#ifdef CSV_HAS_CXX20
        template<std::ranges::input_range Rows>
            requires internals::csv_write_rows_input_range<Rows>
        DelimWriter& write_rows(Rows&& rows) {
            for (auto&& row : rows) {
                append_row_like(row);
                flush_batch_if_needed();
            }
 
            finish_write_call();
            return *this;
        }
 
        template<std::ranges::input_range Range>
        DelimWriter& operator<<(Range&& container)
            requires std::ranges::input_range<Range>
                && std::convertible_to<std::ranges::range_reference_t<Range>, csv::string_view> {
            write_range_impl(container);
            return *this;
        }
 
        template<typename RowLike>
        DelimWriter& operator<<(const RowLike& row)
            requires internals::has_to_sv_range<RowLike>
                && (!internals::csv_string_field_range<RowLike>) {
            append_row_like(row);
            finish_write_call();
            return *this;
        }
#else
        template<typename Range>
        typename std::enable_if<
            internals::is_iterable<Range>::value 
            && !internals::is_tuple<Range>::value
            && !std::is_same<Range, std::string>::value
            && !std::is_same<Range, csv::string_view>::value,
            DelimWriter&
        >::type operator<<(const Range& record) {
            write_range_impl(record);
            return *this;
        }
#endif
 
        template<typename... T>
        DelimWriter& operator<<(const std::tuple<T...>& record) {
            this->write_tuple<0, T...>(record);
            return *this;
        }
 
        void flush() {
            flush_batch();
            out->flush();
        }
 
    private:
        template<typename Range>
        inline void append_range_fields(Range&& record) {
            auto it = std::begin(record);
            auto end = std::end(record);
 
            if (it != end) {
                write_field(*it);
                ++it;
            }
 
            for (; it != end; ++it) {
                batch_buffer_.push_back(Delim);
                write_field(*it);
            }
        }
 
        size_t find_first_special_for_writer(csv::string_view in) const {
            size_t pos = internals::find_next_non_special(in, 0, simd_sentinels_);
 
            for (; pos < in.size(); ++pos) {
                char ch = in[pos];
                if (ch == Quote || ch == Delim || ch == '\r' || ch == '\n')
                    return pos;
            }
 
            return in.size();
        }
 
        template<typename Range>
        inline void write_range_impl(const Range& record) {
            append_range_fields(record);
 
            end_record();
            finish_write_call();
        }
 
#ifdef CSV_HAS_CXX20
        template<typename Row>
        void append_row_like(Row&& row) {
            IF_CONSTEXPR(internals::csv_string_field_range<Row>) {
                append_range_fields(std::forward<Row>(row));
            }
            else {
                append_range_fields(row.to_sv_range());
            }
 
            end_record();
        }
#endif
 
        template<
            typename T,
            csv::enable_if_t<
                !std::is_convertible<T, std::string>::value
                && !std::is_convertible<T, csv::string_view>::value
            , int> = 0
        >
        void write_field(T in) {
            const std::string serialized = internals::to_string(in);
            write_raw(serialized);
        }
 
        template<
            typename T,
            csv::enable_if_t<
                std::is_convertible<T, std::string>::value
                || std::is_convertible<T, csv::string_view>::value
            , int> = 0
        >
        void write_field(T in) {
            IF_CONSTEXPR(std::is_convertible<T, csv::string_view>::value) {
                write_escaped_field(in);
            }
            else {
                const std::string serialized(in);
                write_escaped_field(serialized);
            }
        }
 
        void write_raw(csv::string_view in) {
            if (!in.empty())
                batch_buffer_.append(in.data(), in.size());
        }
 
        void write_escaped_field(csv::string_view in) {
            const size_t first_special = find_first_special_for_writer(in);
 
            if (first_special == in.size()) {
                if (!quote_minimal) {
                    batch_buffer_.push_back(Quote);
                    write_raw(in);
                    batch_buffer_.push_back(Quote);
                } else {
                    write_raw(in);
                }
                return;
            }
 
            write_quoted_field(in, first_special);
        }
 
        void write_quoted_field(csv::string_view in, size_t first_special) {
            batch_buffer_.push_back(Quote);
 
            size_t chunk_start = 0;
            size_t pos = first_special;
            while (pos < in.size()) {
                if (in[pos] == Quote) {
                    write_raw(in.substr(chunk_start, pos - chunk_start));
                    batch_buffer_.push_back(Quote);
                    batch_buffer_.push_back(Quote);
                    chunk_start = pos + 1;
                }
 
                ++pos;
            }
 
            write_raw(in.substr(chunk_start));
            batch_buffer_.push_back(Quote);
        }
 
        template<size_t Index = 0, typename... T>
        typename std::enable_if<Index < sizeof...(T), void>::type write_tuple(const std::tuple<T...>& record) {
            write_field(std::get<Index>(record));
 
            CSV_MSVC_PUSH_DISABLE(4127)
            IF_CONSTEXPR (Index + 1 < sizeof...(T)) batch_buffer_.push_back(Delim);
            CSV_MSVC_POP
 
            this->write_tuple<Index + 1>(record);
        }
 
        template<size_t Index = 0, typename... T>
        typename std::enable_if<Index == sizeof...(T), void>::type write_tuple(const std::tuple<T...>& record) {
            (void)record;
            end_record();
            finish_write_call();
        }
 
        void end_record() {
            batch_buffer_.push_back('\n');
        }
 
        void finish_write_call() {
            if (this->auto_flush_) {
                flush_batch();
                out->flush();
                return;
            }
 
            flush_batch_if_needed();
        }
 
        void flush_batch() {
            if (batch_buffer_.empty()) return;
 
            out->write(batch_buffer_.data(), static_cast<std::streamsize>(batch_buffer_.size()));
            batch_buffer_.clear();
        }
 
        void flush_batch_if_needed() {
            if (batch_buffer_.size() >= batch_flush_threshold_)
                flush_batch();
        }
 
        std::unique_ptr<OutputStream> owned_out;
 
        OutputStream* out;
 
        bool quote_minimal;
        bool auto_flush_ = true;
        static constexpr size_t batch_flush_threshold_ = 64 * 1024;
        std::string batch_buffer_;
        internals::SentinelVecs simd_sentinels_{Delim, Quote};
    };
 
    template<class OutputStream>
    using CSVWriter = DelimWriter<OutputStream, ',', '"'>;
 
    template<class OutputStream>
    using TSVWriter = DelimWriter<OutputStream, '\t', '"'>;
 
    template<class OutputStream>
    inline CSVWriter<OutputStream> make_csv_writer(OutputStream& out, bool quote_minimal=true) {
        return CSVWriter<OutputStream>(out, quote_minimal);
    }
 
    template<class OutputStream>
    inline TSVWriter<OutputStream> make_tsv_writer(OutputStream& out, bool quote_minimal=true) {
        return TSVWriter<OutputStream>(out, quote_minimal);
    }
}