@shopify/react-native-skia 0.1.157 → 0.1.159

package/cpp/skia/include/private/SkTHash.h

@@ -98,7 +98,7 @@ public:
             if (s.empty()) {
                 return nullptr;
             }
-            if (hash == s.hash && key == Traits::GetKey(*s)) {
+            if (hash == s.fHash && key == Traits::GetKey(*s)) {
                 return &*s;
             }
             index = this->next(index);
@@ -125,7 +125,7 @@ public:
         for (int n = 0; n < fCapacity; n++) {
             Slot& s = fSlots[index];
             SkASSERT(s.has_value());
-            if (hash == s.hash && key == Traits::GetKey(*s)) {
+            if (hash == s.fHash && key == Traits::GetKey(*s)) {
                this->removeSlot(index);
                if (4 * fCount <= fCapacity && fCapacity > 4) {
                    this->resize(fCapacity / 2);
@@ -269,7 +269,7 @@ private:
                 fCount++;
                 return &*s;
             }
-            if (hash == s.hash && key == Traits::GetKey(*s)) {
+            if (hash == s.fHash && key == Traits::GetKey(*s)) {
                 // Overwrite previous entry.
                 // Note: this triggers extra copies when adding the same value repeatedly.
                 s.emplace(std::move(val), hash);
@@ -304,7 +304,7 @@ private:
                     emptySlot.reset();
                     return;
                 }
-                originalIndex = s.hash & (fCapacity - 1);
+                originalIndex = s.fHash & (fCapacity - 1);
             } while ((index <= originalIndex && originalIndex < emptyIndex)
                      || (originalIndex < emptyIndex && emptyIndex < index)
                      || (emptyIndex < index && index <= originalIndex));
@@ -325,7 +325,8 @@ private:
         return hash ? hash : 1;  // We reserve hash 0 to mark empty.
     }
 
-    struct Slot {
+    class Slot {
+    public:
         Slot() = default;
         ~Slot() { this->reset(); }
 
@@ -334,17 +335,17 @@ private:
             if (this == &that) {
                 return *this;
             }
-            if (hash) {
-                if (that.hash) {
-                    val.storage = that.val.storage;
-                    hash = that.hash;
+            if (fHash) {
+                if (that.fHash) {
+                    fVal.fStorage = that.fVal.fStorage;
+                    fHash = that.fHash;
                 } else {
                     this->reset();
                 }
             } else {
-                if (that.hash) {
-                    new (&val.storage) T(that.val.storage);
-                    hash = that.hash;
+                if (that.fHash) {
+                    new (&fVal.fStorage) T(that.fVal.fStorage);
+                    fHash = that.fHash;
                 } else {
                     // do nothing, no value on either side
                 }
@@ -357,17 +358,17 @@ private:
             if (this == &that) {
                 return *this;
             }
-            if (hash) {
-                if (that.hash) {
-                    val.storage = std::move(that.val.storage);
-                    hash = that.hash;
+            if (fHash) {
+                if (that.fHash) {
+                    fVal.fStorage = std::move(that.fVal.fStorage);
+                    fHash = that.fHash;
                 } else {
                     this->reset();
                 }
             } else {
-                if (that.hash) {
-                    new (&val.storage) T(std::move(that.val.storage));
-                    hash = that.hash;
+                if (that.fHash) {
+                    new (&fVal.fStorage) T(std::move(that.fVal.fStorage));
+                    fHash = that.fHash;
                 } else {
                     // do nothing, no value on either side
                 }
@@ -375,37 +376,37 @@ private:
             return *this;
         }
 
-        T& operator*() & { return val.storage; }
-        const T& operator*() const& { return val.storage; }
-        T&& operator*() && { return std::move(val.storage); }
-        const T&& operator*() const&& { return std::move(val.storage); }
+        T& operator*() & { return fVal.fStorage; }
+        const T& operator*() const& { return fVal.fStorage; }
+        T&& operator*() && { return std::move(fVal.fStorage); }
+        const T&& operator*() const&& { return std::move(fVal.fStorage); }
 
         Slot& emplace(T&& v, uint32_t h) {
             this->reset();
-            new (&val.storage) T(std::move(v));
-            hash = h;
+            new (&fVal.fStorage) T(std::move(v));
+            fHash = h;
             return *this;
         }
 
-        bool has_value() const { return hash != 0; }
+        bool has_value() const { return fHash != 0; }
         explicit operator bool() const { return this->has_value(); }
         bool empty() const { return !this->has_value(); }
 
         void reset() {
-            if (hash) {
-                val.storage.~T();
-                hash = 0;
+            if (fHash) {
+                fVal.fStorage.~T();
+                fHash = 0;
             }
         }
 
-        uint32_t hash = 0;
+        uint32_t fHash = 0;
 
     private:
         union Storage {
-            T storage;
+            T fStorage;
             Storage() {}
             ~Storage() {}
-        } val;
+        } fVal;
     };
 
     int fCount    = 0,

package/cpp/skia/include/private/SkTemplates.h

@@ -393,32 +393,6 @@ private:
 
 //////////////////////////////////////////////////////////////////////////////////////////////////
 
-/**
- *  Pass the object and the storage that was offered during SkInPlaceNewCheck, and this will
- *  safely destroy (and free if it was dynamically allocated) the object.
- */
-template <typename T> void SkInPlaceDeleteCheck(T* obj, void* storage) {
-    if (storage == obj) {
-        obj->~T();
-    } else {
-        delete obj;
-    }
-}
-
-/**
- *  Allocates T, using storage if it is large enough, and allocating on the heap (via new) if
- *  storage is not large enough.
- *
- *      obj = SkInPlaceNewCheck<Type>(storage, size);
- *      ...
- *      SkInPlaceDeleteCheck(obj, storage);
- */
-template<typename T, typename... Args>
-T* SkInPlaceNewCheck(void* storage, size_t size, Args&&... args) {
-    return (sizeof(T) <= size) ? new (storage) T(std::forward<Args>(args)...)
-                               : new T(std::forward<Args>(args)...);
-}
-
 template <int N, typename T> class SkAlignedSTStorage {
 public:
     SkAlignedSTStorage() {}
@@ -450,4 +424,28 @@ template<size_t N, typename C> constexpr auto SkMakeArray(C c)
     return SkMakeArrayFromIndexSequence(c, std::make_index_sequence<N>{});
 }
 
+/**
+ * Trait for identifying types which are relocatable via memcpy, for container optimizations.
+ *
+ */
+template<typename, typename = void>
+struct sk_has_trivially_relocatable_member : std::false_type {};
+
+// Types can declare themselves trivially relocatable with a public
+//    using sk_is_trivially_relocatable = std::true_type;
+template<typename T>
+struct sk_has_trivially_relocatable_member<T, std::void_t<typename T::sk_is_trivially_relocatable>>
+        : T::sk_is_trivially_relocatable {};
+
+// By default, all trivially copyable types are trivially relocatable.
+template <typename T>
+struct sk_is_trivially_relocatable
+        : std::disjunction<std::is_trivially_copyable<T>, sk_has_trivially_relocatable_member<T>
+>{};
+
+// Here be some dragons: while technically not guaranteed, we count on all sane unique_ptr
+// implementations to be trivially relocatable.
+template <typename T>
+struct sk_is_trivially_relocatable<std::unique_ptr<T>> : std::true_type {};
+
 #endif