SkUtils.h File Reference

#include "include/private/base/SkAttributes.h"
#include <cstring>
#include <type_traits>

Go to the source code of this file.

Namespaces
namespace	SkHexadecimalDigits

Macros
#define	SK_FP_SAFE_ABI

Functions
template<typename T , typename P >
static SK_ALWAYS_INLINE T SK_FP_SAFE_ABI	sk_unaligned_load (const P *ptr)
template<typename T , typename P >
static SK_ALWAYS_INLINE void SK_FP_SAFE_ABI	sk_unaligned_store (P *ptr, T val)
template<typename Dst , typename Src >
static SK_ALWAYS_INLINE Dst SK_FP_SAFE_ABI	sk_bit_cast (const Src &src)

Variables
const char	SkHexadecimalDigits::gUpper [16]
const char	SkHexadecimalDigits::gLower [16]

Macro Definition Documentation

SK_FP_SAFE_ABI

#define SK_FP_SAFE_ABI

Definition at line 42 of file SkUtils.h.

Function Documentation

sk_bit_cast()

template<typename Dst , typename Src >

static SK_ALWAYS_INLINE Dst SK_FP_SAFE_ABI sk_bit_cast ( const Src &  src )

static

Definition at line 68 of file SkUtils.h.

                                                                       {
    static_assert(sizeof(Dst) == sizeof(Src));
    static_assert(std::is_trivially_copyable<Dst>::value);
    static_assert(std::is_trivially_copyable<Src>::value);
    return sk_unaligned_load<Dst>(&src);
}

sk_unaligned_load()

template<typename T , typename P >

static SK_ALWAYS_INLINE T SK_FP_SAFE_ABI sk_unaligned_load ( const P *  ptr )

static

Definition at line 46 of file SkUtils.h.

                                                                         {
    static_assert(std::is_trivially_copyable_v<P> || std::is_void_v<P>);
    static_assert(std::is_trivially_copyable_v<T>);
    T val;
    // gcc's class-memaccess sometimes triggers when:
    // - `T` is trivially copyable but
    // - `T` is non-trivial (e.g. at least one eligible default constructor is
    //    non-trivial).
    // Use `reinterpret_cast<const void*>` to explicit suppress this warning; a
    // trivially copyable type is safe to memcpy from/to.
    memcpy(&val, static_cast<const void*>(ptr), sizeof(val));
    return val;
}

sk_unaligned_store()

template<typename T , typename P >

static SK_ALWAYS_INLINE void SK_FP_SAFE_ABI sk_unaligned_store ( P *  ptr, T  val  )

static

Definition at line 61 of file SkUtils.h.

                                                                              {
    static_assert(std::is_trivially_copyable<T>::value);
    memcpy(ptr, &val, sizeof(val));
}