atomic_casts.h

// Copyright (c) Electronic Arts Inc. All rights reserved.
 
 
#ifndef EASTL_ATOMIC_INTERNAL_CASTS_H
#define EASTL_ATOMIC_INTERNAL_CASTS_H
 
#if defined(EA_PRAGMA_ONCE_SUPPORTED)
    #pragma once
#endif
 
 
#include <EASTL/internal/type_transformations.h>
 
 
namespace eastl
{
 
 
namespace internal
{
 
 
template <typename T>
EASTL_FORCE_INLINE volatile T* AtomicVolatileCast(T* ptr) EA_NOEXCEPT
{
    static_assert(!eastl::is_volatile<volatile T*>::value, "eastl::atomic<T> : pointer must not be volatile, the pointed to type must be volatile!");
    static_assert(eastl::is_volatile<volatile T>::value, "eastl::atomic<T> : the pointed to type must be volatile!");
 
    return reinterpret_cast<volatile T*>(ptr);
}
 
 
template <typename Integral, typename T>
EASTL_FORCE_INLINE volatile Integral* AtomicVolatileIntegralCast(T* ptr) EA_NOEXCEPT
{
    static_assert(!eastl::is_volatile<volatile Integral*>::value, "eastl::atomic<T> : pointer must not be volatile, the pointed to type must be volatile!");
    static_assert(eastl::is_volatile<volatile Integral>::value, "eastl::atomic<T> : the pointed to type must be volatile!");
    static_assert(eastl::is_integral<Integral>::value, "eastl::atomic<T> : Integral cast must cast to an Integral type!");
    static_assert(sizeof(Integral) == sizeof(T), "eastl::atomic<T> : Integral and T must be same size for casting!");
 
    return reinterpret_cast<volatile Integral*>(ptr);
}
 
template <typename Integral, typename T>
EASTL_FORCE_INLINE Integral* AtomicIntegralCast(T* ptr) EA_NOEXCEPT
{
    static_assert(eastl::is_integral<Integral>::value, "eastl::atomic<T> : Integral cast must cast to an Integral type!");
    static_assert(sizeof(Integral) == sizeof(T), "eastl::atomic<T> : Integral and T must be same size for casting!");
 
    return reinterpret_cast<Integral*>(ptr);
}
 
 
template <typename ToType, typename FromType>
EASTL_FORCE_INLINE volatile ToType* AtomicVolatileTypeCast(FromType* ptr) EA_NOEXCEPT
{
    static_assert(!eastl::is_volatile<volatile ToType*>::value, "eastl::atomic<T> : pointer must not be volatile, the pointed to type must be volatile!");
    static_assert(eastl::is_volatile<volatile ToType>::value, "eastl::atomic<T> : the pointed to type must be volatile!");
 
    return reinterpret_cast<volatile ToType*>(ptr);
}
 
template <typename ToType, typename FromType>
EASTL_FORCE_INLINE ToType* AtomicTypeCast(FromType* ptr) EA_NOEXCEPT
{
    return reinterpret_cast<ToType*>(ptr);
}
 
 
template <typename Pun, typename T, eastl::enable_if_t<!eastl::is_same_v<Pun, T>, int> = 0>
EASTL_FORCE_INLINE Pun AtomicTypePunCast(const T& fromType) EA_NOEXCEPT
{
    static_assert(sizeof(Pun) == sizeof(T), "eastl::atomic<T> : Pun and T must be the same size for type punning!");
 
    typename eastl::aligned_storage<sizeof(Pun), alignof(Pun)>::type ret;
    __builtin_memcpy(eastl::addressof(ret), eastl::addressof(fromType), sizeof(Pun));
    return reinterpret_cast<Pun&>(ret);
}
 
template <typename Pun, typename T, eastl::enable_if_t<eastl::is_same_v<Pun, T>, int> = 0>
EASTL_FORCE_INLINE Pun AtomicTypePunCast(const T& fromType) EA_NOEXCEPT
{
    return fromType;
}
 
 
template <typename T>
EASTL_FORCE_INLINE T AtomicNegateOperand(T val) EA_NOEXCEPT
{
    static_assert(eastl::is_integral<T>::value, "eastl::atomic<T> : Integral Negation must be an Integral type!");
    static_assert(!eastl::is_volatile<T>::value, "eastl::atomic<T> : T must not be volatile!");
 
    return static_cast<T>(0U - static_cast<eastl::make_unsigned_t<T>>(val));
}
 
EASTL_FORCE_INLINE ptrdiff_t AtomicNegateOperand(ptrdiff_t val) EA_NOEXCEPT
{
    return -val;
}
 
 
} // namespace internal
 
 
} // namespace eastl
 
 
#define EASTL_ATOMIC_VOLATILE_CAST(ptr)         \
    eastl::internal::AtomicVolatileCast((ptr))
 
#define EASTL_ATOMIC_VOLATILE_INTEGRAL_CAST(IntegralType, ptr)      \
    eastl::internal::AtomicVolatileIntegralCast<IntegralType>((ptr))
 
#define EASTL_ATOMIC_INTEGRAL_CAST(IntegralType, ptr)       \
    eastl::internal::AtomicIntegralCast<IntegralType>((ptr))
 
#define EASTL_ATOMIC_VOLATILE_TYPE_CAST(ToType, ptr)        \
    eastl::internal::AtomicVolatileTypeCast<ToType>((ptr))
 
#define EASTL_ATOMIC_TYPE_CAST(ToType, ptr)         \
    eastl::internal::AtomicTypeCast<ToType>((ptr))
 
#define EASTL_ATOMIC_TYPE_PUN_CAST(PunType, fromType)       \
    eastl::internal::AtomicTypePunCast<PunType>((fromType))
 
#define EASTL_ATOMIC_NEGATE_OPERAND(val)        \
    eastl::internal::AtomicNegateOperand((val))
 
 
#endif /* EASTL_ATOMIC_INTERNAL_CASTS_H */