Object.h

Go to the documentation of this file.

#pragma once
 
 
#include <cstdint>
#include <utility>
 
#define NAMESPACE_SPH_BEGIN namespace Sph {
#define NAMESPACE_SPH_END }
 
NAMESPACE_SPH_BEGIN
 
 
#ifdef __GNUC__
#ifdef __clang__
#define SPH_CLANG
#else
#define SPH_GCC
#endif
#endif
 
#ifdef SPH_DEBUG
#define INLINE inline
#define INL
#else
#define INLINE __attribute__((always_inline)) inline
#define INL __attribute__((always_inline))
#endif
 
#define NO_INLINE __attribute__((noinline))
 
#define UNUSED(x)
 
#define MARK_USED(x) (void)sizeof(x)
 
#define SPH_FALLTHROUGH [[fallthrough]];
 
#define DEPRECATED __attribute__((deprecated))
 
#define SPH_LIKELY(x) __builtin_expect(bool(x), 1)
#define SPH_UNLIKELY(x) __builtin_expect(bool(x), 0)
 
 
struct Noncopyable {
    Noncopyable() = default;
 
    Noncopyable(const Noncopyable&) = delete;
    Noncopyable(Noncopyable&&) = default;
    Noncopyable& operator=(const Noncopyable&) = delete;
    Noncopyable& operator=(Noncopyable&&) = default;
};
 
struct Immovable {
    Immovable() = default;
 
    Immovable(const Immovable&) = delete;
    Immovable(Immovable&&) = delete;
    Immovable& operator=(const Immovable&) = delete;
    Immovable& operator=(Immovable&&) = delete;
};
 
 
class Local {
    void* operator new(std::size_t) = delete;
    void* operator new[](std::size_t) = delete;
    void operator delete(void*) = delete;
    void operator delete[](void*) = delete;
};
 
struct Polymorphic {
    virtual ~Polymorphic() {}
};
 
template <typename T>
class Badge {
private:
    friend T;
 
    Badge() {}
};
 
namespace Detail {
template <std::size_t N1, std::size_t N2>
struct StaticForType {
    template <typename TVisitor>
    INLINE static void action(TVisitor&& visitor) {
        visitor.template visit<N1>();
        StaticForType<N1 + 1, N2>::action(std::forward<TVisitor>(visitor));
    }
};
template <std::size_t N>
struct StaticForType<N, N> {
    template <typename TVisitor>
    INLINE static void action(TVisitor&& visitor) {
        visitor.template visit<N>();
    }
};
} // namespace Detail
 
template <std::size_t N1, std::size_t N2, typename TVisitor>
INLINE void staticFor(TVisitor&& visitor) {
    Detail::StaticForType<N1, N2>::action(std::forward<TVisitor>(visitor));
}
 
namespace Detail {
template <typename... TArgs>
void expandPack(TArgs&&...) {}
} // namespace Detail
 
template <typename TVisitor, typename... TArgs>
INLINE void staticForEach(TVisitor&& visitor, TArgs&&... args) {
    Detail::expandPack(visitor(std::forward<TArgs>(args))...);
}
 
 
namespace Detail {
template <std::size_t I, std::size_t N>
struct SelectNthType {
    template <typename TValue, typename... TOthers>
    INLINE static decltype(auto) action(TValue&& UNUSED(value), TOthers&&... others) {
        return SelectNthType<I + 1, N>::action(std::forward<TOthers>(others)...);
    }
};
template <std::size_t N>
struct SelectNthType<N, N> {
    template <typename TValue, typename... TOthers>
    INLINE static decltype(auto) action(TValue&& value, TOthers&&... UNUSED(others)) {
        return std::forward<TValue>(value);
    }
};
} // namespace Detail
 
template <std::size_t N, typename TValue, typename... TOthers>
INLINE decltype(auto) selectNth(TValue&& value, TOthers&&... others) {
    return Detail::SelectNthType<0, N>::action(std::forward<TValue>(value), std::forward<TOthers>(others)...);
}
 
NAMESPACE_SPH_END