StdTypes.hpp

Go to the documentation of this file.

// @formatter:off
//
// Balau core C++ library
//
// Copyright (C) 2008 Bora Software (contact@borasoftware.com)
//
// Licensed under the Boost Software License - Version 1.0 - August 17th, 2003.
// See the LICENSE file for the full license text.
//


#ifndef COM_BORA_SOFTWARE__BALAU_TYPE__STD_TYPES
#define COM_BORA_SOFTWARE__BALAU_TYPE__STD_TYPES

// Switches for optional features.
#include <Balau/BalauConfig.hpp>























#pragma clang diagnostic push
#pragma ide diagnostic ignored "OCUnusedGlobalDeclarationInspection"

#include <cassert>
#include <climits>
#include <cstdint>
#include <istream>
#include <limits>
#include <ostream>
#include <sstream>
#include <typeindex>
#include <utility>
#include <vector>


static_assert(CHAR_BIT                   == 8, "char size is not 8 bits");

static_assert(sizeof(signed char)        == 1, "signed char size is not 8 bits");
static_assert(sizeof(signed short)       == 2, "signed short size is not 16 bits");
static_assert(sizeof(signed int)         == 4, "signed int size is not 32 bits");
static_assert(sizeof(signed long long)   == 8, "signed long long size is not 64 bits");

static_assert(sizeof(unsigned char)      == 1, "unsigned char size is not 8 bits");
static_assert(sizeof(unsigned short)     == 2, "unsigned short size is not 16 bits");
static_assert(sizeof(unsigned int)       == 4, "unsigned int size is not 32 bits");
static_assert(sizeof(unsigned long long) == 8, "unsigned long long size is not 64 bits");

static_assert(sizeof(int8_t)             == 1, "int8_t is not 8 bits");
static_assert(sizeof(int16_t)            == 2, "int16_t is not 16 bits");
static_assert(sizeof(int32_t)            == 4, "int32_t is not 32 bits");
static_assert(sizeof(int64_t)            == 8, "int64_t is not 64 bits");

static_assert(sizeof(uint8_t)            == 1, "uint8_t is not 8 bits");
static_assert(sizeof(uint16_t)           == 2, "uint16_t is not 16 bits");
static_assert(sizeof(uint32_t)           == 4, "uint32_t is not 32 bits");
static_assert(sizeof(uint64_t)           == 8, "uint64_t is not 64 bits");


#if INTPTR_MAX == INT32_MAX
    #define BalauPointerSize_ 32
#elif INTPTR_MAX == INT64_MAX
    #define BalauPointerSize_ 64
#else
    #error "Pointer size not supported for this platform."
#endif

#define BalauPointerSize BalauPointerSize_


#ifdef BALAU_USE_BOOST_STRING_VIEW
    #include <Balau/Type/Impl/StringView.hpp>
#else
    #include <string_view>
#endif


extern const std::string BalauVersion;


inline void _Balau_SwallowSemiColon_() {}


namespace std { // NOLINT

// Missing standard library stream typedefs.

using u16istream = basic_istream<char16_t>;
using u16ostream = basic_ostream<char16_t>;

using u16ifstream = basic_ifstream<char16_t>;
using u16ofstream = basic_ofstream<char16_t>;

using u16istringstream = basic_istringstream<char16_t>;
using u16ostringstream = basic_ostringstream<char16_t>;

using u32istream = basic_istream<char32_t>;
using u32ostream = basic_ostream<char32_t>;

using u32ifstream = basic_ifstream<char32_t>;
using u32ofstream = basic_ofstream<char32_t>;

using u32istringstream = basic_istringstream<char32_t>;
using u32ostringstream = basic_ostringstream<char32_t>;

// Additional hash / equal_to functions.

template <typename T> struct hash<const vector<T>> {
    size_t operator () (const vector<T> & vector) const noexcept {
        hash<T> elementHashFunction;

        size_t h = vector.size();
        for (auto & element : vector) {
            h ^= elementHashFunction(element) + 0x9e3779b9 + (h << 6U) + (h >> 2U);
        }

        return h;
    }
};

template <> struct hash<char *> {
    size_t operator () (char * const & ptr) const noexcept {
        return (((size_t) ptr) >> 6U) * 31U;
    }
};

template <typename T> struct equal_to<vector<T>> {
    bool operator () (const vector<T> & lhs, const vector<T> & rhs) const {
        if (lhs.size() != rhs.size()) {
            return false;
        }

        for (size_t m = 0; m < lhs.size(); m++) {
            if (!equal_to(lhs[m], rhs[m])) {
                return false;
            }
        }

        return true;
    }
};

} // namespace std

#pragma clang diagnostic pop

#endif // COM_BORA_SOFTWARE__BALAU_TYPE__STD_TYPES