common.hpp

Go to the documentation of this file.

 
#pragma once
#include <algorithm>
#include <array>
#include <cmath>
#include <cstdlib>
#include <deque>
 
#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
 
#define CSV_INLINE
 
#pragma once
#include <type_traits>
 
// Minimal portability macros (Hedley subset) with CSV_ prefix.
#if defined(__clang__) || defined(__GNUC__)
    #define CSV_CONST __attribute__((__const__))
    #define CSV_PURE __attribute__((__pure__))
    #define CSV_PRIVATE __attribute__((__visibility__("hidden")))
    #define CSV_NON_NULL(...) __attribute__((__nonnull__(__VA_ARGS__)))
#elif defined(_MSC_VER)
    #define CSV_CONST
    #define CSV_PURE
    #define CSV_PRIVATE
    #define CSV_NON_NULL(...)
#else
    #define CSV_CONST
    #define CSV_PURE
    #define CSV_PRIVATE
    #define CSV_NON_NULL(...)
#endif
 
#if defined(__GNUC__) || defined(__clang__)
    #define CSV_UNREACHABLE() __builtin_unreachable()
#elif defined(_MSC_VER)
    #define CSV_UNREACHABLE() __assume(0)
#else
    #define CSV_UNREACHABLE() abort()
#endif
 
// This library uses C++ exceptions for error reporting in public APIs.
#if defined(__cpp_exceptions) || defined(_CPPUNWIND) || defined(__EXCEPTIONS)
    #define CSV_EXCEPTIONS_ENABLED 1
#else
    #define CSV_EXCEPTIONS_ENABLED 0
#endif
 
#if !CSV_EXCEPTIONS_ENABLED
    #error "csv-parser requires C++ exceptions. Enable exception handling (for example, remove -fno-exceptions or use /EHsc)."
#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 (defined(CMAKE_CXX_STANDARD) && CMAKE_CXX_STANDARD == 20) || CSV_CPLUSPLUS >= 202002L
#define CSV_HAS_CXX20
#endif
 
#if (defined(CMAKE_CXX_STANDARD) && CMAKE_CXX_STANDARD == 17) || CSV_CPLUSPLUS >= 201703L
#define CSV_HAS_CXX17
#endif
 
#if (defined(CMAKE_CXX_STANDARD) && CMAKE_CXX_STANDARD >= 14) || CSV_CPLUSPLUS >= 201402L
#define CSV_HAS_CXX14
#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
 
namespace csv {
#ifdef _MSC_VER
#pragma region Compatibility Macros
#endif
#define STATIC_ASSERT(x) static_assert(x, "Assertion failed")
 
#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
 
#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
 
    // Resolves g++ bug with regard to constexpr methods
    // See: https://stackoverflow.com/questions/36489369/constexpr-non-static-member-function-with-non-constexpr-constructor-gcc-clang-d
#if defined __GNUC__ && !defined __clang__
    #if (__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 {
        // 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 ITERATION_CHUNK_SIZE = 10000000; // 10MB
 
        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 | 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::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::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::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;
}