common.hpp

Go to the documentation of this file.

 
#pragma once
#include <algorithm>
#include <array>
#include <cassert>
#include <cmath>
#include <cstdint>
#include <cstdlib>
#include <deque>
#include <limits>
#include <memory>
#if !defined(CSV_ENABLE_THREADS) || CSV_ENABLE_THREADS
#include <mutex>
#endif
 
#if defined(_WIN32)
# ifndef WIN32_LEAN_AND_MEAN
#  define WIN32_LEAN_AND_MEAN
# endif
# include <windows.h>
# undef max
# undef min
#elif defined(__linux__)
# include <unistd.h>
#endif
 
#include <type_traits>
 
#if defined(__EMSCRIPTEN__)
#undef CSV_ENABLE_THREADS
#define CSV_ENABLE_THREADS 0
#elif !defined(CSV_ENABLE_THREADS)
#define CSV_ENABLE_THREADS 1
#endif
 
// Minimal portability macros (Hedley subset) with CSV_ prefix.
#if defined(CSV_CODE_COVERAGE)
    #define CSV_CONST
    #define CSV_PURE
    #define CSV_FORCE_INLINE inline
    #define CSV_PRIVATE
    #define CSV_NON_NULL(...)
#elif defined(__clang__) || defined(__GNUC__)
    #define CSV_CONST __attribute__((__const__))
    #define CSV_PURE __attribute__((__pure__))
    #define CSV_FORCE_INLINE inline __attribute__((__always_inline__))
    #if defined(_WIN32)
        #define CSV_PRIVATE
    #else
        #define CSV_PRIVATE __attribute__((__visibility__("hidden")))
    #endif
    #define CSV_NON_NULL(...) __attribute__((__nonnull__(__VA_ARGS__)))
#elif defined(_MSC_VER)
    #define CSV_CONST
    #define CSV_PURE
    #define CSV_FORCE_INLINE __forceinline
    #define CSV_PRIVATE
    #define CSV_NON_NULL(...)
#else
    #define CSV_CONST
    #define CSV_PURE
    #define CSV_FORCE_INLINE inline
    #define CSV_PRIVATE
    #define CSV_NON_NULL(...)
#endif
 
// MSVC-specific warning suppression helpers. Use __pragma so the macros
// work inside other macro bodies (where #pragma is not allowed).
#ifdef _MSC_VER
#  define CSV_MSVC_PUSH_DISABLE(w) __pragma(warning(push)) __pragma(warning(disable: w))
#  define CSV_MSVC_POP             __pragma(warning(pop))
#else
#  define CSV_MSVC_PUSH_DISABLE(w)
#  define CSV_MSVC_POP
#endif
 
// Detect compiler exception support to select the optional throwing APIs.
#if defined(__cpp_exceptions) || defined(_CPPUNWIND) || defined(__EXCEPTIONS)
#define CSV_EXCEPTIONS_ENABLED 1
#else
#define CSV_EXCEPTIONS_ENABLED 0
#endif
 
// Keep complete handlers out of compiler-disabled builds: unreachable branches
// would still need named catch variables and exception-only declarations.
// Usage: CSV_TRY { ... } CSV_CATCH((const Error& error), { ... })
// Parenthesize the catch declaration so template commas remain one argument.
// Keep preprocessing directives outside the catch-body macro argument.
#if CSV_EXCEPTIONS_ENABLED
#define CSV_TRY try
#define CSV_CATCH(exception_declaration, ...) catch exception_declaration __VA_ARGS__
#else
#define CSV_TRY
#define CSV_CATCH(exception_declaration, ...)
#endif
 
 
// Detect C++ standard version BEFORE namespace to properly include string_view
// MSVC: __cplusplus == 199711L unless /Zc:__cplusplus is set; use _MSVC_LANG instead.
#if defined(_MSVC_LANG) && _MSVC_LANG > __cplusplus
#  define CSV_CPLUSPLUS _MSVC_LANG
#else
#  define CSV_CPLUSPLUS __cplusplus
#endif
 
#if CSV_CPLUSPLUS >= 202302L
#define CSV_HAS_CXX23
#endif
 
#if CSV_CPLUSPLUS >= 202002L
#define CSV_HAS_CXX20
#endif
 
#if CSV_CPLUSPLUS >= 201703L
#define CSV_HAS_CXX17
#endif
 
#if CSV_CPLUSPLUS >= 201402L
#define CSV_HAS_CXX14
#endif
 
// Annotate intentional switch fallthroughs in parser hot loops without
// reshaping the control flow just to appease compiler diagnostics.
#if defined(CSV_HAS_CXX17)
#define CSV_FALLTHROUGH [[fallthrough]]
#elif defined(__clang__) && defined(__has_cpp_attribute)
#if __has_cpp_attribute(clang::fallthrough)
#define CSV_FALLTHROUGH [[clang::fallthrough]]
#else
#define CSV_FALLTHROUGH ((void)0)
#endif
#elif defined(__GNUC__) && __GNUC__ >= 7
#define CSV_FALLTHROUGH __attribute__((fallthrough))
#else
#define CSV_FALLTHROUGH ((void)0)
#endif
 
// Include string_view BEFORE csv namespace to avoid namespace pollution issues
#ifdef CSV_HAS_CXX17
#include <string_view>
#else
#include "../external/string_view.hpp"
#endif
 
#ifdef CSV_HAS_CXX20
#include <ranges>
#endif
 
namespace csv {
#ifdef _MSC_VER
#pragma region Compatibility Macros
#endif
// Allows static assertions without specifying a message
#define STATIC_ASSERT(x) static_assert(x, "Assertion failed")
 
#ifdef NDEBUG
    #define CSV_DEBUG_ASSERT(x) ((void)sizeof(x), (void)0)
#else
    #define CSV_DEBUG_ASSERT(x) assert(x)
#endif
 
#ifdef CSV_HAS_CXX17
    using string_view = std::string_view;
#else
    using string_view = nonstd::string_view;
#endif
 
#ifdef CSV_HAS_CXX17
    #define IF_CONSTEXPR if constexpr
    #define CONSTEXPR_VALUE constexpr
 
    #define CONSTEXPR_17 constexpr
#else
    #define IF_CONSTEXPR if
    #define CONSTEXPR_VALUE const
 
    #define CONSTEXPR_17 inline
#endif
 
#ifdef CSV_HAS_CXX14
    template<bool B, class T = void>
    using enable_if_t = std::enable_if_t<B, T>;
 
    #define CONSTEXPR_14 constexpr
    #define CONSTEXPR_VALUE_14 constexpr
#else
    template<bool B, class T = void>
    using enable_if_t = typename std::enable_if<B, T>::type;
 
    #define CONSTEXPR_14 inline
    #define CONSTEXPR_VALUE_14 const
#endif
 
    namespace internals {
        template<bool B, class T = void>
        using enable_if_t = csv::enable_if_t<B, T>;
    }
 
#ifdef CSV_HAS_CXX17
    template<typename F, typename... Args>
    using invoke_result_t = typename std::invoke_result<F, Args...>::type;
#else
    template<typename F, typename... Args>
    using invoke_result_t = typename std::result_of<F(Args...)>::type;
#endif
 
    template<typename... Ts>
    using void_t = void;
 
    template<typename F, typename ReturnType, typename Enable, typename... Args>
    struct is_invocable_returning_impl : std::false_type {};
 
    template<typename F, typename ReturnType, typename... Args>
    struct is_invocable_returning_impl<
        F,
        ReturnType,
        void_t<invoke_result_t<F, Args...>>,
        Args...
    > : std::integral_constant<
        bool,
        std::is_convertible<invoke_result_t<F, Args...>, ReturnType>::value
    > {};
 
    template<typename F, typename ReturnType, typename... Args>
    struct is_invocable_returning : is_invocable_returning_impl<F, ReturnType, void, Args...> {};
 
    // Resolves g++ bug with regard to constexpr methods.
    // Keep this gated to C++17+, since C++11/14 pedantic mode rejects constexpr
    // non-static members when the enclosing class is non-literal.
    // See: https://stackoverflow.com/questions/36489369/constexpr-non-static-member-function-with-non-constexpr-constructor-gcc-clang-d
#if defined(__GNUC__) && !defined(__clang__)
    #if defined(CSV_HAS_CXX17) && (((__GNUC__ == 7) && (__GNUC_MINOR__ >= 2)) || (__GNUC__ >= 8))
        #define CONSTEXPR constexpr
    #endif
#else
    #ifdef CSV_HAS_CXX17
        #define CONSTEXPR constexpr
    #endif
#endif
 
#ifndef CONSTEXPR
#define CONSTEXPR inline
#endif
 
#ifdef _MSC_VER
#pragma endregion
#endif
 
    namespace internals {
        template<typename T>
        class is_hashable {
        private:
            template<typename U>
            static auto test(int) -> decltype(
                std::hash<U>{}(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>
        class is_equality_comparable {
        private:
            template<typename U>
            static auto test(int) -> decltype(
                std::declval<const U&>() == 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>
        class lazy_shared_ptr {
        public:
            lazy_shared_ptr() = default;
            lazy_shared_ptr(const lazy_shared_ptr&) = delete;
            lazy_shared_ptr& operator=(const lazy_shared_ptr&) = delete;
 
            lazy_shared_ptr(lazy_shared_ptr&& other) noexcept : value_(std::move(other.value_)) {}
 
            lazy_shared_ptr& operator=(lazy_shared_ptr&& other) noexcept {
                if (this != &other) {
                    value_ = std::move(other.value_);
                }
 
                return *this;
            }
 
            template<typename Factory>
            T& get_or_create(Factory&& factory) const {
#if CSV_ENABLE_THREADS
                std::call_once(init_once_, [this, &factory]() {
                    value_ = factory();
                });
#else
                if (!value_) {
                    value_ = factory();
                }
#endif
                return *value_;
            }
 
            T* get() const noexcept {
                return value_.get();
            }
 
        private:
            mutable std::shared_ptr<T> value_ = nullptr;
#if CSV_ENABLE_THREADS
            mutable std::once_flag init_once_;
#endif
        };
 
        #ifdef CSV_HAS_CXX20
        #ifdef _MSC_VER
        #pragma region CXX20 Concepts
        #endif
 
        template<typename T>
        concept csv_string_field_range =
            std::ranges::input_range<std::remove_reference_t<T>>
            && std::convertible_to<
                std::ranges::range_reference_t<std::remove_reference_t<T>>,
                csv::string_view
            >;
 
        template<typename T>
        concept has_to_sv_range = requires(const std::remove_reference_t<T>& value) {
            { value.to_sv_range() } -> std::ranges::input_range;
            requires std::convertible_to<
                std::ranges::range_reference_t<decltype(value.to_sv_range())>,
                csv::string_view
            >;
        };
 
        template<typename T>
        concept csv_row_like = csv_string_field_range<T> || has_to_sv_range<T>;
 
        template<typename T>
        concept csv_write_rows_input_range =
            std::ranges::input_range<std::remove_reference_t<T>>
            && csv_row_like<
                std::ranges::range_reference_t<std::remove_reference_t<T>>
            >;
 
        #ifdef _MSC_VER
        #pragma endregion
        #endif
        #endif
 
        // PAGE_SIZE macro could be already defined by the host system.
#if defined(PAGE_SIZE)
#undef PAGE_SIZE
#endif
 
// Get operating system specific details
#if defined(_WIN32)
        inline int getpagesize() {
            _SYSTEM_INFO sys_info = {};
            GetSystemInfo(&sys_info);
            return std::max(sys_info.dwPageSize, sys_info.dwAllocationGranularity);
        }
 
        const int PAGE_SIZE = getpagesize();
#elif defined(__linux__) 
        const int PAGE_SIZE = getpagesize();
#else
        const int PAGE_SIZE = 4096;
#endif
 
        constexpr size_t CSV_CHUNK_SIZE_DEFAULT = 10000000; // 10MB
 
        typedef std::uint32_t CSVChunkIndex;
 
        CONSTEXPR_VALUE_14 CSVChunkIndex CSV_CHUNK_INDEX_MAX = (std::numeric_limits<CSVChunkIndex>::max)();
 
        CONSTEXPR_VALUE_14 size_t CSV_CHUNK_SIZE_MAX = CSV_CHUNK_INDEX_MAX;
 
        constexpr size_t CSV_CHUNK_SIZE_FLOOR = 500 * 1024; // 500KB
 
        constexpr size_t CSV_SPECULATIVE_PARALLEL_MIN_BYTES = 50ull * 1024ull * 1024ull; // 50MB
 
        template<typename T>
        inline bool is_equal(T a, T b, T epsilon = 0.001) {
            static_assert(std::is_floating_point<T>::value, "T must be a floating point type.");
            return std::abs(a - b) < epsilon;
        }
 
        enum class ParseFlags {
            QUOTE_ESCAPE_QUOTE = 0, 
            QUOTE = 2 | 1,          
            NOT_SPECIAL = 4,        
            DELIMITER = 4 | 1,      
            CARRIAGE_RETURN = 4 | 2, 
            NEWLINE = 4 | 2 | 1     
        };
 
        constexpr ParseFlags quote_escape_flag(ParseFlags flag, bool quote_escape) noexcept {
            return (ParseFlags)((int)flag & ~((int)ParseFlags::QUOTE * quote_escape));
        }
 
        // Assumed to be true by parsing functions: allows for testing
        // if an item is DELIMITER or NEWLINE with a >= statement
        STATIC_ASSERT(ParseFlags::DELIMITER < ParseFlags::CARRIAGE_RETURN);
        STATIC_ASSERT(ParseFlags::DELIMITER < ParseFlags::NEWLINE);
        STATIC_ASSERT(ParseFlags::CARRIAGE_RETURN < ParseFlags::NEWLINE);
 
        STATIC_ASSERT(quote_escape_flag(ParseFlags::NOT_SPECIAL, false) == ParseFlags::NOT_SPECIAL);
        STATIC_ASSERT(quote_escape_flag(ParseFlags::QUOTE, false) == ParseFlags::QUOTE);
        STATIC_ASSERT(quote_escape_flag(ParseFlags::DELIMITER, false) == ParseFlags::DELIMITER);
        STATIC_ASSERT(quote_escape_flag(ParseFlags::CARRIAGE_RETURN, false) == ParseFlags::CARRIAGE_RETURN);
        STATIC_ASSERT(quote_escape_flag(ParseFlags::NEWLINE, false) == ParseFlags::NEWLINE);
 
        STATIC_ASSERT(quote_escape_flag(ParseFlags::NOT_SPECIAL, true) == ParseFlags::NOT_SPECIAL);
        STATIC_ASSERT(quote_escape_flag(ParseFlags::QUOTE, true) == ParseFlags::QUOTE_ESCAPE_QUOTE);
        STATIC_ASSERT(quote_escape_flag(ParseFlags::DELIMITER, true) == ParseFlags::NOT_SPECIAL);
        STATIC_ASSERT(quote_escape_flag(ParseFlags::CARRIAGE_RETURN, true) == ParseFlags::NOT_SPECIAL);
        STATIC_ASSERT(quote_escape_flag(ParseFlags::NEWLINE, true) == ParseFlags::NOT_SPECIAL);
 
        using ParseFlagMap = std::array<ParseFlags, 256>;
 
        using WhitespaceMap = std::array<bool, 256>;
    }
 
    constexpr int CSV_NOT_FOUND = -1;
 
    constexpr unsigned CHAR_OFFSET = std::numeric_limits<char>::is_signed ? 128 : 0;
}