utils.hpp

Go to the documentation of this file.

 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
  *  _____.___.                 .___                    .__.__      *
  *  \__  |   | ____   ____   __| _/___________    _____|__|  |     *
  *   /   |   |/ ___\ / ___\ / __ |\_  __ \__  \  /  ___/  |  |     *
  *   \____   / /_/  > /_/  > /_/ | |  | \// __ \_\___ \|  |  |__   *
  *   / ______\___  /\___  /\____ | |__|  (____  /____  >__|____/   *
  *   \/     /_____//_____/      \/            \/     \/            *
  *                          - Common -                             *
  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
  * This software can be used by students and other personal of the *
  * Bern University of Applied Sciences under the terms of the MIT  *
  * license.                                                        *
  * For other persons this software is under the terms of the GNU   *
  * General Public License version 2.                               *
  *                                                                 *
  * Copyright © 2021, Bern University of Applied Sciences.     *
  * All rights reserved.                                            *
  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
#pragma once
 
#include <cpp/common/attributes.hpp>
 
#include <cstring>      // memcpy
#include <type_traits>  // Type trait checks
#include <utility>
 
 
#define TOKEN_CONCAT_IMPL(x, y) x ## y
#define TOKEN_CONCAT(x, y) TOKEN_CONCAT_IMPL(x, y)
#define ANONYMOUS_VARIABLE(prefix) TOKEN_CONCAT(prefix, __COUNTER__)
 
 
namespace bsp {
 
    template<typename T>
    struct dependent_false : std::false_type {};
 
    template<typename T>
    constexpr auto dependent_false_v = dependent_false<T>::value;
 
 
    #define SCOPE_GUARD ::bsp::scope_guard::ScopeGuardOnExit() + [&]()
 
    #define ON_SCOPE_EXIT auto ANONYMOUS_VARIABLE(SCOPE_EXIT_) = SCOPE_GUARD
 
    namespace scope_guard {
 
        template<class F>
        class ScopeGuardImpl {
        private:
            F m_func;
            bool m_active;
        public:
            constexpr ScopeGuardImpl(F func) : m_func(std::move(func)), m_active(true) { }
            ~ScopeGuardImpl() { if (this->m_active) { this->m_func(); } }
 
            void release() { this->m_active = false; }
 
            ScopeGuardImpl(ScopeGuardImpl &&other) noexcept : m_func(std::move(other.m_func)), m_active(other.m_active) {
                other.cancel();
            }
 
            ScopeGuardImpl& operator=(ScopeGuardImpl &&) = delete;
        };
 
        enum class ScopeGuardOnExit { };
 
        template <typename F>
        constexpr ScopeGuardImpl<F> operator+(ScopeGuardOnExit, F&& f) {
            return ScopeGuardImpl<F>(std::forward<F>(f));
        }
 
    }
 
    template <typename To, typename From>
    To bit_cast(const From& src) noexcept {
        return *reinterpret_cast<const To*>(&src);
    }
 
    NO_RETURN ALWAYS_INLINE static void unreachable() {
        __builtin_unreachable();
    }
 
    template<typename T>
    constexpr T byteSwap(T value) {
        static_assert(std::is_integral<T>::value, "Only integral types can be byte swapped");
        static_assert(sizeof(T) <= sizeof(u64), "Value cannot be bigger than 64 bit");
 
        if constexpr (sizeof(T) == 1)       return value;
        else if constexpr (sizeof(T) == 2)  return __builtin_bswap16(value);
        else if constexpr (sizeof(T) == 4)  return __builtin_bswap32(value);
        else if constexpr (sizeof(T) == 8)  return __builtin_bswap64(value);
        else bsp::unreachable();
    }
 
    template<typename T>
    auto enumValue(T value) {
        static_assert(std::is_enum<T>::value, "Cannot get value of non-enum type");
 
        return static_cast<typename std::underlying_type<T>::type>(value);
    }
 
    template<typename T>
    struct PACKED ByteSwapped {
        constexpr ByteSwapped() : m_value(0) {}
        constexpr ByteSwapped(T value) : m_value(byteSwap(value)) {}
 
        constexpr operator T() const noexcept {
            return byteSwap(this->m_value);
        }
 
        constexpr auto operator=(T value) {
            this->m_value = byteSwap(value);
 
            return *this;
        }
 
        constexpr auto operator=(const ByteSwapped &value) {
            this->m_value = value.m_value;
 
            return *this;
        }
    private:
        T m_value;
    };
 
    ALWAYS_INLINE void doNotOptimize(const auto& value) {
      asm volatile("" : : "r,m"(value) : "memory");
    }
}