rngine 0.7.2 → 0.8.1

package/shared/skia/include/private/SkTDArray.h

@@ -0,0 +1,247 @@
+/*
+ * 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 SkTDArray_DEFINED
+#define SkTDArray_DEFINED
+
+#include "include/private/SkAPI.h"
+#include "include/private/SkAssert.h"
+#include "include/private/SkDebug.h"
+#include "include/private/SkTo.h"
+
+#include <cstddef>
+#include <initializer_list>
+#include <utility>
+
+// We'd prefer not to use these types anymore. SkTDArray can be replaced skia_private::TArray
+
+class SK_SPI SkTDStorage {
+public:
+    explicit SkTDStorage(int sizeOfT);
+    SkTDStorage(const void* src, int size, int sizeOfT);
+
+    // Copy
+    SkTDStorage(const SkTDStorage& that);
+    SkTDStorage& operator= (const SkTDStorage& that);
+
+    // Move
+    SkTDStorage(SkTDStorage&& that);
+    SkTDStorage& operator= (SkTDStorage&& that);
+
+    ~SkTDStorage();
+
+    void reset();
+    void swap(SkTDStorage& that);
+
+    // Size routines
+    bool empty() const { return fSize == 0; }
+    void clear() { fSize = 0; }
+    int size() const { return fSize; }
+    void resize(int newSize);
+    size_t size_bytes() const { return this->bytes(fSize); }
+
+    // Capacity routines
+    int capacity() const { return fCapacity; }
+    void reserve(int newCapacity);
+    void shrink_to_fit();
+
+    void* data() { return fStorage; }
+    const void* data() const { return fStorage; }
+
+    // Deletion routines
+    void erase(int index, int count);
+    // Removes the entry at 'index' and replaces it with the last array element
+    void removeShuffle(int index);
+
+    // Insertion routines
+    void* prepend();
+
+    void append();
+    void append(int count);
+    void* append(const void* src, int count);
+
+    void* insert(int index);
+    void* insert(int index, int count, const void* src);
+
+    void pop_back() {
+        SkASSERT(fSize > 0);
+        fSize--;
+    }
+
+    friend bool operator==(const SkTDStorage& a, const SkTDStorage& b);
+    friend bool operator!=(const SkTDStorage& a, const SkTDStorage& b) {
+        return !(a == b);
+    }
+
+private:
+    // Fast path for pointer arithmetic. Assumes 'n' has already been bounds-checked.
+    size_t bytes(int n) const { return SkToSizeT(n) * SkToSizeT(fSizeOfT); }
+
+    // Safe path for memory allocations; protects against 32-bit overflow.
+    size_t safe_bytes(int n) const {
+        size_t size = SkToSizeT(n);
+        size_t sizeOfT = SkToSizeT(fSizeOfT);
+        SkASSERT_RELEASE(size <= SIZE_MAX / sizeOfT);
+        return size * sizeOfT;
+    }
+
+    void* address(int n) { return fStorage + this->bytes(n); }
+
+    // Adds delta to fSize. Crash if outside [0, INT_MAX]
+    int calculateSizeOrDie(int delta);
+
+    // Move the tail of the array defined by the indexes tailStart and tailEnd to dstIndex. The
+    // elements at dstIndex are overwritten by the tail.
+    void moveTail(int dstIndex, int tailStart, int tailEnd);
+
+    // Copy src into the array at dstIndex.
+    void copySrc(int dstIndex, const void* src, int count);
+
+    const int fSizeOfT;
+    std::byte* fStorage{nullptr};
+    int fCapacity{0};  // size of the allocation in fArray (#elements)
+    int fSize{0};    // logical number of elements (fSize <= fCapacity)
+};
+
+static inline void swap(SkTDStorage& a, SkTDStorage& b) {
+    a.swap(b);
+}
+
+// SkTDArray<T> implements a std::vector-like array for raw data-only objects that do not require
+// construction or destruction. The constructor and destructor for T will not be called; T objects
+// will always be moved via raw memcpy. Newly created T objects will contain uninitialized memory.
+template <typename T> class SkTDArray {
+public:
+    SkTDArray() : fStorage{sizeof(T)} {}
+    SkTDArray(const T src[], int count) : fStorage{src, count, sizeof(T)} { }
+    SkTDArray(const std::initializer_list<T>& list) : SkTDArray(list.begin(), list.size()) {}
+
+    // Copy
+    SkTDArray(const SkTDArray<T>& src) : SkTDArray(src.data(), src.size()) {}
+    SkTDArray<T>& operator=(const SkTDArray<T>& src) {
+        fStorage = src.fStorage;
+        return *this;
+    }
+
+    // Move
+    SkTDArray(SkTDArray<T>&& src) : fStorage{std::move(src.fStorage)} {}
+    SkTDArray<T>& operator=(SkTDArray<T>&& src) {
+        fStorage = std::move(src.fStorage);
+        return *this;
+    }
+
+    friend bool operator==(const SkTDArray<T>& a, const SkTDArray<T>& b) {
+        return a.fStorage == b.fStorage;
+    }
+    friend bool operator!=(const SkTDArray<T>& a, const SkTDArray<T>& b) { return !(a == b); }
+
+    void swap(SkTDArray<T>& that) {
+        using std::swap;
+        swap(fStorage, that.fStorage);
+    }
+
+    bool empty() const { return fStorage.empty(); }
+
+    // Return the number of elements in the array
+    int size() const { return fStorage.size(); }
+
+    // Return the total number of elements allocated.
+    // Note: capacity() - size() gives you the number of elements you can add without causing an
+    // allocation.
+    int capacity() const { return fStorage.capacity(); }
+
+    // return the number of bytes in the array: count * sizeof(T)
+    size_t size_bytes() const { return fStorage.size_bytes(); }
+
+    T*       data() { return static_cast<T*>(fStorage.data()); }
+    const T* data() const { return static_cast<const T*>(fStorage.data()); }
+    T*       begin() { return this->data(); }
+    const T* begin() const { return this->data(); }
+    T*       end() { return this->data() + this->size(); }
+    const T* end() const { return this->data() + this->size(); }
+
+    T& operator[](int index) {
+        return this->data()[sk_collection_check_bounds(index, this->size())];
+    }
+    const T& operator[](int index) const {
+        return this->data()[sk_collection_check_bounds(index, this->size())];
+    }
+
+    const T& back() const {
+        sk_collection_not_empty(this->empty());
+        return this->data()[this->size() - 1];
+    }
+    T& back() {
+        sk_collection_not_empty(this->empty());
+        return this->data()[this->size() - 1];
+    }
+
+    void reset() {
+        fStorage.reset();
+    }
+
+    void clear() {
+        fStorage.clear();
+    }
+
+    // Sets the number of elements in the array.
+    // If the array does not have space for count elements, it will increase
+    // the storage allocated to some amount greater than that required.
+    // It will never shrink the storage.
+    void resize(int count) {
+        fStorage.resize(count);
+    }
+
+    void reserve(int n) {
+        fStorage.reserve(n);
+    }
+
+    T* append() {
+        fStorage.append();
+        return this->end() - 1;
+    }
+    T* append(int count) {
+        fStorage.append(count);
+        return this->end() - count;
+    }
+    T* append(int count, const T* src) {
+        return static_cast<T*>(fStorage.append(src, count));
+    }
+
+    T* insert(int index) {
+        return static_cast<T*>(fStorage.insert(index));
+    }
+    T* insert(int index, int count, const T* src = nullptr) {
+        return static_cast<T*>(fStorage.insert(index, count, src));
+    }
+
+    void remove(int index, int count = 1) {
+        fStorage.erase(index, count);
+    }
+
+    void removeShuffle(int index) {
+        fStorage.removeShuffle(index);
+    }
+
+    // routines to treat the array like a stack
+    void push_back(const T& v) {
+        this->append();
+        this->back() = v;
+    }
+    void pop_back() { fStorage.pop_back(); }
+
+    void shrink_to_fit() {
+        fStorage.shrink_to_fit();
+    }
+
+private:
+    SkTDStorage fStorage;
+};
+
+template <typename T> static inline void swap(SkTDArray<T>& a, SkTDArray<T>& b) { a.swap(b); }
+
+#endif

package/shared/skia/include/private/SkTFitsIn.h

@@ -0,0 +1,92 @@
+/*
+ * Copyright 2013 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkTFitsIn_DEFINED
+#define SkTFitsIn_DEFINED
+
+#include <limits>
+#include <type_traits>
+
+/**
+ * std::underlying_type is only defined for enums. For integral types, we just want the type.
+ */
+template <typename T, class Enable = void>
+struct sk_strip_enum {
+    typedef T type;
+};
+
+template <typename T>
+struct sk_strip_enum<T, typename std::enable_if<std::is_enum<T>::value>::type> {
+    typedef typename std::underlying_type<T>::type type;
+};
+
+
+/**
+ * In C++ an unsigned to signed cast where the source value cannot be represented in the destination
+ * type results in an implementation defined destination value. Unlike C, C++ does not allow a trap.
+ * This makes "(S)(D)s == s" a possibly useful test. However, there are two cases where this is
+ * incorrect:
+ *
+ * when testing if a value of a smaller signed type can be represented in a larger unsigned type
+ * (int8_t)(uint16_t)-1 == -1 => (int8_t)0xFFFF == -1 => [implementation defined] == -1
+ *
+ * when testing if a value of a larger unsigned type can be represented in a smaller signed type
+ * (uint16_t)(int8_t)0xFFFF == 0xFFFF => (uint16_t)-1 == 0xFFFF => 0xFFFF == 0xFFFF => true.
+ *
+ * Consider the cases:
+ *   u = unsigned, less digits
+ *   U = unsigned, more digits
+ *   s = signed, less digits
+ *   S = signed, more digits
+ *   v is the value we're considering.
+ *
+ * u -> U: (u)(U)v == v, trivially true
+ * U -> u: (U)(u)v == v, both casts well defined, test works
+ * s -> S: (s)(S)v == v, trivially true
+ * S -> s: (S)(s)v == v, first cast implementation value, second cast defined, test works
+ * s -> U: (s)(U)v == v, *this is bad*, the second cast results in implementation defined value
+ * S -> u: (S)(u)v == v, the second cast is required to prevent promotion of rhs to unsigned
+ * u -> S: (u)(S)v == v, trivially true
+ * U -> s: (U)(s)v == v, *this is bad*,
+ *                             first cast results in implementation defined value,
+ *                             second cast is defined. However, this creates false positives
+ *                             uint16_t x = 0xFFFF
+ *                                (uint16_t)(int8_t)x == x
+ *                             => (uint16_t)-1        == x
+ *                             => 0xFFFF              == x
+ *                             => true
+ *
+ * So for the eight cases three are trivially true, three more are valid casts, and two are special.
+ * The two 'full' checks which otherwise require two comparisons are valid cast checks.
+ * The two remaining checks s -> U [v >= 0] and U -> s [v <= max(s)] can be done with one op.
+ */
+
+template <typename D, typename S>
+static constexpr inline
+typename std::enable_if<(std::is_integral<S>::value || std::is_enum<S>::value) &&
+                        (std::is_integral<D>::value || std::is_enum<D>::value), bool>::type
+/*bool*/ SkTFitsIn(S src) {
+    // Ensure that is_signed and is_unsigned are passed the arithmetic underlyng types of enums.
+    using Sa = typename sk_strip_enum<S>::type;
+    using Da = typename sk_strip_enum<D>::type;
+
+    // SkTFitsIn() is used in public headers, so needs to be written targeting at most C++11.
+    return
+
+    // E.g. (int8_t)(uint8_t) int8_t(-1) == -1, but the uint8_t == 255, not -1.
+    (std::is_signed<Sa>::value && std::is_unsigned<Da>::value && sizeof(Sa) <= sizeof(Da)) ?
+        (S)0 <= src :
+
+    // E.g. (uint8_t)(int8_t) uint8_t(255) == 255, but the int8_t == -1.
+    (std::is_signed<Da>::value && std::is_unsigned<Sa>::value && sizeof(Da) <= sizeof(Sa)) ?
+        src <= (S)std::numeric_limits<Da>::max() :
+
+    // This trips up MSVC's /RTCc run-time checking, which we don't support.
+    (S)(D)src == src;
+}
+
+#endif

package/shared/skia/include/private/SkTLogic.h

@@ -0,0 +1,56 @@
+/*
+ * Copyright 2013 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ *
+ *
+ * This header provides some std:: features early in the skstd namespace
+ * and several Skia-specific additions in the sknonstd namespace.
+ */
+
+#ifndef SkTLogic_DEFINED
+#define SkTLogic_DEFINED
+
+#include <iterator>
+#include <type_traits>
+#include "include/private/SkTo.h"
+
+// The sknonstd namespace contains things we would like to be proposed and feel std-ish.
+namespace sknonstd {
+
+// The name 'copy' here is fraught with peril. In this case it means 'append', not 'overwrite'.
+// Alternate proposed names are 'propagate', 'augment', or 'append' (and 'add', but already taken).
+// std::experimental::propagate_const already exists for other purposes in TSv2.
+// These also follow the <dest, source> pattern used by boost.
+template <typename D, typename S> struct copy_const {
+    using type = std::conditional_t<std::is_const<S>::value, std::add_const_t<D>, D>;
+};
+template <typename D, typename S> using copy_const_t = typename copy_const<D, S>::type;
+
+template <typename D, typename S> struct copy_volatile {
+    using type = std::conditional_t<std::is_volatile<S>::value, std::add_volatile_t<D>, D>;
+};
+template <typename D, typename S> using copy_volatile_t = typename copy_volatile<D, S>::type;
+
+template <typename D, typename S> struct copy_cv {
+    using type = copy_volatile_t<copy_const_t<D, S>, S>;
+};
+template <typename D, typename S> using copy_cv_t = typename copy_cv<D, S>::type;
+
+// The name 'same' here means 'overwrite'.
+// Alternate proposed names are 'replace', 'transfer', or 'qualify_from'.
+// same_xxx<D, S> can be written as copy_xxx<remove_xxx_t<D>, S>
+template <typename D, typename S> using same_const = copy_const<std::remove_const_t<D>, S>;
+template <typename D, typename S> using same_const_t = typename same_const<D, S>::type;
+template <typename D, typename S> using same_volatile =copy_volatile<std::remove_volatile_t<D>,S>;
+template <typename D, typename S> using same_volatile_t = typename same_volatile<D, S>::type;
+template <typename D, typename S> using same_cv = copy_cv<std::remove_cv_t<D>, S>;
+template <typename D, typename S> using same_cv_t = typename same_cv<D, S>::type;
+
+}  // namespace sknonstd
+
+template <typename Container>
+constexpr int SkCount(const Container& c) { return SkTo<int>(std::size(c)); }
+
+#endif

package/shared/skia/include/private/SkTPin.h

@@ -0,0 +1,23 @@
+/*
+ * Copyright 2020 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkTPin_DEFINED
+#define SkTPin_DEFINED
+
+#include <algorithm>
+
+/** @return x pinned (clamped) between lo and hi, inclusively.
+
+    Unlike std::clamp(), SkTPin() always returns a value between lo and hi.
+    If x is NaN, SkTPin() returns lo but std::clamp() returns NaN.
+*/
+template <typename T>
+static constexpr const T& SkTPin(const T& x, const T& lo, const T& hi) {
+    return std::max(lo, std::min(x, hi));
+}
+
+#endif