csv_writer.hpp

Go to the documentation of this file.

 
#pragma once
#include <fstream>
#include <iostream>
#include <memory>
#include <stdexcept>
#include <string>
#include <tuple>
#include <type_traits>
#include <vector>
 
#include "common.hpp"
#include "data_type.hpp"
 
namespace csv {
    namespace internals {
        static int DECIMAL_PLACES = 5;
 
        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;
 
            while (x >= 1) {
                x /= 10;
                digits++;
            }
 
            return 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";
 
            while (value > 0) {
                digits_reverse += (char)('0' + (value % 10));
                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) {
            if (value >= 0)
                return to_string((size_t)value);
 
            return "-" + 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) {
#ifdef __clang__
            return std::to_string(value);
#else
            // TODO: Figure out why the below code doesn't work on clang
                std::string result = "";
 
                T integral_part;
                T fractional_part = std::abs(std::modf(value, &integral_part));
                integral_part = std::abs(integral_part);
 
                // Integral part
                if (value < 0) result = "-";
 
                if (integral_part == 0) {
                    result += "0";
                }
                else {
                    for (int n_digits = num_digits(integral_part); n_digits > 0; n_digits --) {
                        int digit = (int)(std::fmod(integral_part, pow10(n_digits)) / pow10(n_digits - 1));
                        result += (char)('0' + digit);
                    }
                }
 
                // Decimal part
                result += ".";
 
                if (fractional_part > 0) {
                    fractional_part *= (T)(pow10(DECIMAL_PLACES));
                    for (int n_digits = DECIMAL_PLACES; n_digits > 0; n_digits--) {
                        int digit = (int)(std::fmod(fractional_part, pow10(n_digits)) / pow10(n_digits - 1));
                        result += (char)('0' + digit);
                    }
                }
                else {
                    result += "0";
                }
 
                return result;
#endif
        }
    }
 
#ifndef __clang___
    inline static void set_decimal_places(int precision) {
        internals::DECIMAL_PLACES = precision;
    }
#endif
 
 
    template<class OutputStream, char Delim, char Quote, bool Flush>
    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())
                throw std::runtime_error("Failed to open file for writing: " + filename);
        }
 
        ~DelimWriter() {
            out->flush();
        }
 
        template<typename T, size_t Size>
        DelimWriter& operator<<(const std::array<T, Size>& record) {
            for (size_t i = 0; i < Size; i++) {
                (*out) << csv_escape(record[i]);
                if (i + 1 != Size) (*out) << Delim;
            }
 
            end_out();
            return *this;
        }
 
        template<typename... T>
        DelimWriter& operator<<(const std::tuple<T...>& record) {
            this->write_tuple<0, T...>(record);
            return *this;
        }
 
        template<
            typename T, typename Alloc, template <typename, typename> class Container,
 
            // Avoid conflicting with tuples with two elements
            csv::enable_if_t<std::is_class<Alloc>::value, int> = 0
        >
            DelimWriter& operator<<(const Container<T, Alloc>& record) {
            const size_t ilen = record.size();
            size_t i = 0;
            for (const auto& field : record) {
                (*out) << csv_escape(field);
                if (i + 1 != ilen) (*out) << Delim;
                i++;
            }
 
            end_out();
            return *this;
        }
 
        void flush() {
            out->flush();
        }
 
    private:
        template<
            typename T,
            csv::enable_if_t<
                !std::is_convertible<T, std::string>::value
                && !std::is_convertible<T, csv::string_view>::value
            , int> = 0
        >
        std::string csv_escape(T in) {
            return internals::to_string(in);
        }
 
        template<
            typename T,
            csv::enable_if_t<
                std::is_convertible<T, std::string>::value
                || std::is_convertible<T, csv::string_view>::value
            , int> = 0
        >
        std::string csv_escape(T in) {
            IF_CONSTEXPR(std::is_convertible<T, csv::string_view>::value) {
                return _csv_escape(in);
            }
            else {
                return _csv_escape(std::string(in));
            }
        }
 
        std::string _csv_escape(csv::string_view in) {
            // Do we need a quote escape
            bool quote_escape = false;
 
            for (auto ch : in) {
                if (ch == Quote || ch == Delim || ch == '\r' || ch == '\n') {
                    quote_escape = true;
                    break;
                }
            }
 
            if (!quote_escape) {
                if (quote_minimal) return std::string(in);
                else {
                    std::string ret(1, Quote);
                    ret += in.data();
                    ret += Quote;
                    return ret;
                }
            }
 
            // Start initial quote escape sequence
            std::string ret(1, Quote);
            for (auto ch: in) {
                if (ch == Quote) ret += std::string(2, Quote);
                else ret += ch;
            }
 
            // Finish off quote escape
            ret += Quote;
            return ret;
        }
 
        template<size_t Index = 0, typename... T>
        typename std::enable_if<Index < sizeof...(T), void>::type write_tuple(const std::tuple<T...>& record) {
            (*out) << csv_escape(std::get<Index>(record));
 
            IF_CONSTEXPR (Index + 1 < sizeof...(T)) (*out) << Delim;
 
            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_out();
        }
 
        void end_out() {
            (*out) << '\n';
            IF_CONSTEXPR(Flush) out->flush();
        }
 
        std::unique_ptr<OutputStream> owned_out;
 
        OutputStream* out;
 
        bool quote_minimal;
    };
 
    template<class OutputStream, bool Flush = true>
    using CSVWriter = DelimWriter<OutputStream, ',', '"', Flush>;
 
    template<class OutputStream, bool Flush = true>
    using TSVWriter = DelimWriter<OutputStream, '\t', '"', Flush>;
 
    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 CSVWriter<OutputStream, false> make_csv_writer_buffered(OutputStream& out, bool quote_minimal=true) {
        return CSVWriter<OutputStream, false>(out, quote_minimal);
    }
 
    template<class OutputStream>
    inline TSVWriter<OutputStream> make_tsv_writer(OutputStream& out, bool quote_minimal=true) {
        return TSVWriter<OutputStream>(out, quote_minimal);
    }
 
    template<class OutputStream>
    inline TSVWriter<OutputStream, false> make_tsv_writer_buffered(OutputStream& out, bool quote_minimal=true) {
        return TSVWriter<OutputStream, false>(out, quote_minimal);
    }
}