427 lines
13 KiB
C
427 lines
13 KiB
C
|
/*
|
||
|
|
* Copyright 2006 The Android Open Source Project
|
||
|
|
*
|
||
|
|
* Use of this source code is governed by a BSD-style license that can be
|
||
|
|
* found in the LICENSE file.
|
||
|
|
*/
|
||
|
|
|
||
|
|
#ifndef SkTemplates_DEFINED
|
||
|
|
#define SkTemplates_DEFINED
|
||
|
|
|
||
|
|
#include "include/private/base/SkAlign.h"
|
||
|
|
#include "include/private/base/SkAssert.h"
|
||
|
|
#include "include/private/base/SkDebug.h"
|
||
|
|
#include "include/private/base/SkMalloc.h"
|
||
|
|
#include "include/private/base/SkTLogic.h"
|
||
|
|
|
||
|
|
#include <array>
|
||
|
|
#include <cstddef>
|
||
|
|
#include <cstdint>
|
||
|
|
#include <cstring>
|
||
|
|
#include <memory>
|
||
|
|
#include <type_traits>
|
||
|
|
#include <utility>
|
||
|
|
|
||
|
|
|
||
|
|
/** \file SkTemplates.h
|
||
|
|
|
||
|
|
This file contains light-weight template classes for type-safe and exception-safe
|
||
|
|
resource management.
|
||
|
|
*/
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Marks a local variable as known to be unused (to avoid warnings).
|
||
|
|
* Note that this does *not* prevent the local variable from being optimized away.
|
||
|
|
*/
|
||
|
|
template<typename T> inline void sk_ignore_unused_variable(const T&) { }
|
||
|
|
|
||
|
|
/**
|
||
|
|
* This is a general purpose absolute-value function.
|
||
|
|
* See SkAbs32 in (SkSafe32.h) for a 32-bit int specific version that asserts.
|
||
|
|
*/
|
||
|
|
template <typename T> static inline T SkTAbs(T value) {
|
||
|
|
if (value < 0) {
|
||
|
|
value = -value;
|
||
|
|
}
|
||
|
|
return value;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Returns a pointer to a D which comes immediately after S[count].
|
||
|
|
*/
|
||
|
|
template <typename D, typename S> inline D* SkTAfter(S* ptr, size_t count = 1) {
|
||
|
|
return reinterpret_cast<D*>(ptr + count);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Returns a pointer to a D which comes byteOffset bytes after S.
|
||
|
|
*/
|
||
|
|
template <typename D, typename S> inline D* SkTAddOffset(S* ptr, ptrdiff_t byteOffset) {
|
||
|
|
// The intermediate char* has the same cv-ness as D as this produces better error messages.
|
||
|
|
// This relies on the fact that reinterpret_cast can add constness, but cannot remove it.
|
||
|
|
return reinterpret_cast<D*>(reinterpret_cast<sknonstd::same_cv_t<char, D>*>(ptr) + byteOffset);
|
||
|
|
}
|
||
|
|
|
||
|
|
template <typename T, T* P> struct SkOverloadedFunctionObject {
|
||
|
|
template <typename... Args>
|
||
|
|
auto operator()(Args&&... args) const -> decltype(P(std::forward<Args>(args)...)) {
|
||
|
|
return P(std::forward<Args>(args)...);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
template <auto F> using SkFunctionObject =
|
||
|
|
SkOverloadedFunctionObject<std::remove_pointer_t<decltype(F)>, F>;
|
||
|
|
|
||
|
|
/** \class SkAutoTCallVProc
|
||
|
|
|
||
|
|
Call a function when this goes out of scope. The template uses two
|
||
|
|
parameters, the object, and a function that is to be called in the destructor.
|
||
|
|
If release() is called, the object reference is set to null. If the object
|
||
|
|
reference is null when the destructor is called, we do not call the
|
||
|
|
function.
|
||
|
|
*/
|
||
|
|
template <typename T, void (*P)(T*)> class SkAutoTCallVProc
|
||
|
|
: public std::unique_ptr<T, SkFunctionObject<P>> {
|
||
|
|
using inherited = std::unique_ptr<T, SkFunctionObject<P>>;
|
||
|
|
public:
|
||
|
|
using inherited::inherited;
|
||
|
|
SkAutoTCallVProc(const SkAutoTCallVProc&) = delete;
|
||
|
|
SkAutoTCallVProc(SkAutoTCallVProc&& that) : inherited(std::move(that)) {}
|
||
|
|
|
||
|
|
operator T*() const { return this->get(); }
|
||
|
|
};
|
||
|
|
|
||
|
|
|
||
|
|
namespace skia_private {
|
||
|
|
/** Allocate an array of T elements, and free the array in the destructor
|
||
|
|
*/
|
||
|
|
template <typename T> class AutoTArray {
|
||
|
|
public:
|
||
|
|
AutoTArray() {}
|
||
|
|
/** Allocate count number of T elements
|
||
|
|
*/
|
||
|
|
explicit AutoTArray(int count) {
|
||
|
|
SkASSERT(count >= 0);
|
||
|
|
if (count) {
|
||
|
|
fArray.reset(new T[count]);
|
||
|
|
}
|
||
|
|
SkDEBUGCODE(fCount = count;)
|
||
|
|
}
|
||
|
|
|
||
|
|
AutoTArray(AutoTArray&& other) : fArray(std::move(other.fArray)) {
|
||
|
|
SkDEBUGCODE(fCount = other.fCount; other.fCount = 0;)
|
||
|
|
}
|
||
|
|
AutoTArray& operator=(AutoTArray&& other) {
|
||
|
|
if (this != &other) {
|
||
|
|
fArray = std::move(other.fArray);
|
||
|
|
SkDEBUGCODE(fCount = other.fCount; other.fCount = 0;)
|
||
|
|
}
|
||
|
|
return *this;
|
||
|
|
}
|
||
|
|
|
||
|
|
/** Reallocates given a new count. Reallocation occurs even if new count equals old count.
|
||
|
|
*/
|
||
|
|
void reset(int count = 0) { *this = AutoTArray(count); }
|
||
|
|
|
||
|
|
/** Return the array of T elements. Will be NULL if count == 0
|
||
|
|
*/
|
||
|
|
T* get() const { return fArray.get(); }
|
||
|
|
|
||
|
|
/** Return the nth element in the array
|
||
|
|
*/
|
||
|
|
T& operator[](int index) const {
|
||
|
|
SkASSERT((unsigned)index < (unsigned)fCount);
|
||
|
|
return fArray[index];
|
||
|
|
}
|
||
|
|
|
||
|
|
/** Aliases matching other types, like std::vector. */
|
||
|
|
const T* data() const { return fArray.get(); }
|
||
|
|
T* data() { return fArray.get(); }
|
||
|
|
|
||
|
|
private:
|
||
|
|
std::unique_ptr<T[]> fArray;
|
||
|
|
SkDEBUGCODE(int fCount = 0;)
|
||
|
|
};
|
||
|
|
|
||
|
|
/** Wraps AutoTArray, with room for kCountRequested elements preallocated.
|
||
|
|
*/
|
||
|
|
template <int kCountRequested, typename T> class AutoSTArray {
|
||
|
|
public:
|
||
|
|
AutoSTArray(AutoSTArray&&) = delete;
|
||
|
|
AutoSTArray(const AutoSTArray&) = delete;
|
||
|
|
AutoSTArray& operator=(AutoSTArray&&) = delete;
|
||
|
|
AutoSTArray& operator=(const AutoSTArray&) = delete;
|
||
|
|
|
||
|
|
/** Initialize with no objects */
|
||
|
|
AutoSTArray() {
|
||
|
|
fArray = nullptr;
|
||
|
|
fCount = 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
/** Allocate count number of T elements
|
||
|
|
*/
|
||
|
|
AutoSTArray(int count) {
|
||
|
|
fArray = nullptr;
|
||
|
|
fCount = 0;
|
||
|
|
this->reset(count);
|
||
|
|
}
|
||
|
|
|
||
|
|
~AutoSTArray() {
|
||
|
|
this->reset(0);
|
||
|
|
}
|
||
|
|
|
||
|
|
/** Destroys previous objects in the array and default constructs count number of objects */
|
||
|
|
void reset(int count) {
|
||
|
|
T* start = fArray;
|
||
|
|
T* iter = start + fCount;
|
||
|
|
while (iter > start) {
|
||
|
|
(--iter)->~T();
|
||
|
|
}
|
||
|
|
|
||
|
|
SkASSERT(count >= 0);
|
||
|
|
if (fCount != count) {
|
||
|
|
if (fCount > kCount) {
|
||
|
|
// 'fArray' was allocated last time so free it now
|
||
|
|
SkASSERT((T*) fStorage != fArray);
|
||
|
|
sk_free(fArray);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (count > kCount) {
|
||
|
|
fArray = (T*) sk_malloc_throw(count, sizeof(T));
|
||
|
|
} else if (count > 0) {
|
||
|
|
fArray = (T*) fStorage;
|
||
|
|
} else {
|
||
|
|
fArray = nullptr;
|
||
|
|
}
|
||
|
|
|
||
|
|
fCount = count;
|
||
|
|
}
|
||
|
|
|
||
|
|
iter = fArray;
|
||
|
|
T* stop = fArray + count;
|
||
|
|
while (iter < stop) {
|
||
|
|
new (iter++) T;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/** Return the number of T elements in the array
|
||
|
|
*/
|
||
|
|
int count() const { return fCount; }
|
||
|
|
|
||
|
|
/** Return the array of T elements. Will be NULL if count == 0
|
||
|
|
*/
|
||
|
|
T* get() const { return fArray; }
|
||
|
|
|
||
|
|
T* begin() { return fArray; }
|
||
|
|
|
||
|
|
const T* begin() const { return fArray; }
|
||
|
|
|
||
|
|
T* end() { return fArray + fCount; }
|
||
|
|
|
||
|
|
const T* end() const { return fArray + fCount; }
|
||
|
|
|
||
|
|
/** Return the nth element in the array
|
||
|
|
*/
|
||
|
|
T& operator[](int index) const {
|
||
|
|
SkASSERT(index < fCount);
|
||
|
|
return fArray[index];
|
||
|
|
}
|
||
|
|
|
||
|
|
/** Aliases matching other types, like std::vector. */
|
||
|
|
const T* data() const { return fArray; }
|
||
|
|
T* data() { return fArray; }
|
||
|
|
size_t size() const { return fCount; }
|
||
|
|
|
||
|
|
private:
|
||
|
|
#if defined(SK_BUILD_FOR_GOOGLE3)
|
||
|
|
// Stack frame size is limited for SK_BUILD_FOR_GOOGLE3. 4k is less than the actual max,
|
||
|
|
// but some functions have multiple large stack allocations.
|
||
|
|
static const int kMaxBytes = 4 * 1024;
|
||
|
|
static const int kCount = kCountRequested * sizeof(T) > kMaxBytes
|
||
|
|
? kMaxBytes / sizeof(T)
|
||
|
|
: kCountRequested;
|
||
|
|
#else
|
||
|
|
static const int kCount = kCountRequested;
|
||
|
|
#endif
|
||
|
|
|
||
|
|
int fCount;
|
||
|
|
T* fArray;
|
||
|
|
alignas(T) char fStorage[kCount * sizeof(T)];
|
||
|
|
};
|
||
|
|
|
||
|
|
/** Manages an array of T elements, freeing the array in the destructor.
|
||
|
|
* Does NOT call any constructors/destructors on T (T must be POD).
|
||
|
|
*/
|
||
|
|
template <typename T,
|
||
|
|
typename = std::enable_if_t<std::is_trivially_default_constructible<T>::value &&
|
||
|
|
std::is_trivially_destructible<T>::value>>
|
||
|
|
class AutoTMalloc {
|
||
|
|
public:
|
||
|
|
/** Takes ownership of the ptr. The ptr must be a value which can be passed to sk_free. */
|
||
|
|
explicit AutoTMalloc(T* ptr = nullptr) : fPtr(ptr) {}
|
||
|
|
|
||
|
|
/** Allocates space for 'count' Ts. */
|
||
|
|
explicit AutoTMalloc(size_t count)
|
||
|
|
: fPtr(count ? (T*)sk_malloc_throw(count, sizeof(T)) : nullptr) {}
|
||
|
|
|
||
|
|
AutoTMalloc(AutoTMalloc&&) = default;
|
||
|
|
AutoTMalloc& operator=(AutoTMalloc&&) = default;
|
||
|
|
|
||
|
|
/** Resize the memory area pointed to by the current ptr preserving contents. */
|
||
|
|
void realloc(size_t count) {
|
||
|
|
fPtr.reset(count ? (T*)sk_realloc_throw(fPtr.release(), count * sizeof(T)) : nullptr);
|
||
|
|
}
|
||
|
|
|
||
|
|
/** Resize the memory area pointed to by the current ptr without preserving contents. */
|
||
|
|
T* reset(size_t count = 0) {
|
||
|
|
fPtr.reset(count ? (T*)sk_malloc_throw(count, sizeof(T)) : nullptr);
|
||
|
|
return this->get();
|
||
|
|
}
|
||
|
|
|
||
|
|
T* get() const { return fPtr.get(); }
|
||
|
|
|
||
|
|
operator T*() { return fPtr.get(); }
|
||
|
|
|
||
|
|
operator const T*() const { return fPtr.get(); }
|
||
|
|
|
||
|
|
T& operator[](int index) { return fPtr.get()[index]; }
|
||
|
|
|
||
|
|
const T& operator[](int index) const { return fPtr.get()[index]; }
|
||
|
|
|
||
|
|
/** Aliases matching other types, like std::vector. */
|
||
|
|
const T* data() const { return fPtr.get(); }
|
||
|
|
T* data() { return fPtr.get(); }
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Transfer ownership of the ptr to the caller, setting the internal
|
||
|
|
* pointer to NULL. Note that this differs from get(), which also returns
|
||
|
|
* the pointer, but it does not transfer ownership.
|
||
|
|
*/
|
||
|
|
T* release() { return fPtr.release(); }
|
||
|
|
|
||
|
|
private:
|
||
|
|
std::unique_ptr<T, SkOverloadedFunctionObject<void(void*), sk_free>> fPtr;
|
||
|
|
};
|
||
|
|
|
||
|
|
template <size_t kCountRequested,
|
||
|
|
typename T,
|
||
|
|
typename = std::enable_if_t<std::is_trivially_default_constructible<T>::value &&
|
||
|
|
std::is_trivially_destructible<T>::value>>
|
||
|
|
class AutoSTMalloc {
|
||
|
|
public:
|
||
|
|
AutoSTMalloc() : fPtr(fTStorage) {}
|
||
|
|
|
||
|
|
AutoSTMalloc(size_t count) {
|
||
|
|
if (count > kCount) {
|
||
|
|
fPtr = (T*)sk_malloc_throw(count, sizeof(T));
|
||
|
|
} else if (count) {
|
||
|
|
fPtr = fTStorage;
|
||
|
|
} else {
|
||
|
|
fPtr = nullptr;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
AutoSTMalloc(AutoSTMalloc&&) = delete;
|
||
|
|
AutoSTMalloc(const AutoSTMalloc&) = delete;
|
||
|
|
AutoSTMalloc& operator=(AutoSTMalloc&&) = delete;
|
||
|
|
AutoSTMalloc& operator=(const AutoSTMalloc&) = delete;
|
||
|
|
|
||
|
|
~AutoSTMalloc() {
|
||
|
|
if (fPtr != fTStorage) {
|
||
|
|
sk_free(fPtr);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// doesn't preserve contents
|
||
|
|
T* reset(size_t count) {
|
||
|
|
if (fPtr != fTStorage) {
|
||
|
|
sk_free(fPtr);
|
||
|
|
}
|
||
|
|
if (count > kCount) {
|
||
|
|
fPtr = (T*)sk_malloc_throw(count, sizeof(T));
|
||
|
|
} else if (count) {
|
||
|
|
fPtr = fTStorage;
|
||
|
|
} else {
|
||
|
|
fPtr = nullptr;
|
||
|
|
}
|
||
|
|
return fPtr;
|
||
|
|
}
|
||
|
|
|
||
|
|
T* get() const { return fPtr; }
|
||
|
|
|
||
|
|
operator T*() {
|
||
|
|
return fPtr;
|
||
|
|
}
|
||
|
|
|
||
|
|
operator const T*() const {
|
||
|
|
return fPtr;
|
||
|
|
}
|
||
|
|
|
||
|
|
T& operator[](int index) {
|
||
|
|
return fPtr[index];
|
||
|
|
}
|
||
|
|
|
||
|
|
const T& operator[](int index) const {
|
||
|
|
return fPtr[index];
|
||
|
|
}
|
||
|
|
|
||
|
|
/** Aliases matching other types, like std::vector. */
|
||
|
|
const T* data() const { return fPtr; }
|
||
|
|
T* data() { return fPtr; }
|
||
|
|
|
||
|
|
// Reallocs the array, can be used to shrink the allocation. Makes no attempt to be intelligent
|
||
|
|
void realloc(size_t count) {
|
||
|
|
if (count > kCount) {
|
||
|
|
if (fPtr == fTStorage) {
|
||
|
|
fPtr = (T*)sk_malloc_throw(count, sizeof(T));
|
||
|
|
memcpy((void*)fPtr, fTStorage, kCount * sizeof(T));
|
||
|
|
} else {
|
||
|
|
fPtr = (T*)sk_realloc_throw(fPtr, count, sizeof(T));
|
||
|
|
}
|
||
|
|
} else if (count) {
|
||
|
|
if (fPtr != fTStorage) {
|
||
|
|
fPtr = (T*)sk_realloc_throw(fPtr, count, sizeof(T));
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
this->reset(0);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private:
|
||
|
|
// Since we use uint32_t storage, we might be able to get more elements for free.
|
||
|
|
static const size_t kCountWithPadding = SkAlign4(kCountRequested*sizeof(T)) / sizeof(T);
|
||
|
|
#if defined(SK_BUILD_FOR_GOOGLE3)
|
||
|
|
// Stack frame size is limited for SK_BUILD_FOR_GOOGLE3. 4k is less than the actual max, but some functions
|
||
|
|
// have multiple large stack allocations.
|
||
|
|
static const size_t kMaxBytes = 4 * 1024;
|
||
|
|
static const size_t kCount = kCountRequested * sizeof(T) > kMaxBytes
|
||
|
|
? kMaxBytes / sizeof(T)
|
||
|
|
: kCountWithPadding;
|
||
|
|
#else
|
||
|
|
static const size_t kCount = kCountWithPadding;
|
||
|
|
#endif
|
||
|
|
|
||
|
|
T* fPtr;
|
||
|
|
union {
|
||
|
|
uint32_t fStorage32[SkAlign4(kCount*sizeof(T)) >> 2];
|
||
|
|
T fTStorage[1]; // do NOT want to invoke T::T()
|
||
|
|
};
|
||
|
|
};
|
||
|
|
|
||
|
|
using UniqueVoidPtr = std::unique_ptr<void, SkOverloadedFunctionObject<void(void*), sk_free>>;
|
||
|
|
|
||
|
|
} // namespace skia_private
|
||
|
|
|
||
|
|
template<typename C, std::size_t... Is>
|
||
|
|
constexpr auto SkMakeArrayFromIndexSequence(C c, std::index_sequence<Is...> is)
|
||
|
|
-> std::array<decltype(c(std::declval<typename decltype(is)::value_type>())), sizeof...(Is)> {
|
||
|
|
return {{ c(Is)... }};
|
||
|
|
}
|
||
|
|
|
||
|
|
template<size_t N, typename C> constexpr auto SkMakeArray(C c)
|
||
|
|
-> std::array<decltype(c(std::declval<typename std::index_sequence<N>::value_type>())), N> {
|
||
|
|
return SkMakeArrayFromIndexSequence(c, std::make_index_sequence<N>{});
|
||
|
|
}
|
||
|
|
|
||
|
|
#endif
|