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>
 
#include "../external/string_view.hpp"
 
  // If there is another version of Hedley, then the newer one 
  // takes precedence.
  // See: https://github.com/nemequ/hedley
#include "../external/hedley.h"
 
namespace csv {
#ifdef _MSC_VER
#pragma region Compatibility Macros
#endif
#define STATIC_ASSERT(x) static_assert(x, "Assertion failed")
 
#if CMAKE_CXX_STANDARD == 17 || __cplusplus >= 201703L
#define CSV_HAS_CXX17
#endif
 
#if CMAKE_CXX_STANDARD >= 14 || __cplusplus >=  201402L
#define CSV_HAS_CXX14
#endif
 
#ifdef CSV_HAS_CXX17
#include <string_view>
    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
 
    // 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;
}