@shopify/react-native-skia 0.1.192 → 0.1.193

package/cpp/skia/include/sksl/SkSLPosition.h

@@ -1,104 +0,0 @@
-/*
- * Copyright 2021 Google LLC.
- *
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-
-#ifndef SKSL_POSITION
-#define SKSL_POSITION
-
-#include "include/core/SkTypes.h"
-
-#include <cstdint>
-#include <string_view>
-
-namespace SkSL {
-
-class Position {
-public:
-    Position()
-        : fStartOffset(-1)
-        , fLength(0) {}
-
-    static Position Range(int startOffset, int endOffset) {
-        SkASSERT(startOffset <= endOffset);
-        SkASSERT(startOffset <= 0xFFFFFF);
-        int length = endOffset - startOffset;
-        Position result;
-        result.fStartOffset = startOffset;
-        result.fLength = length <= 0xFF ? length : 0xFF;
-        return result;
-    }
-
-    bool valid() const {
-        return fStartOffset != -1;
-    }
-
-    int line(std::string_view source) const;
-
-    int startOffset() const {
-        SkASSERT(this->valid());
-        return fStartOffset;
-    }
-
-    int endOffset() const {
-        SkASSERT(this->valid());
-        return fStartOffset + fLength;
-    }
-
-    // Returns the position from this through, and including the entirety of, end.
-    Position rangeThrough(Position end) const {
-        if (fStartOffset == -1 || end.fStartOffset == -1) {
-            return *this;
-        }
-        SkASSERTF(this->startOffset() <= end.startOffset() && this->endOffset() <= end.endOffset(),
-                "Invalid range: (%d-%d) - (%d-%d)\n", this->startOffset(), this->endOffset(),
-                end.startOffset(), end.endOffset());
-        return Range(this->startOffset(), end.endOffset());
-    }
-
-    // Returns a position representing the character immediately after this position
-    Position after() const {
-        int endOffset = this->endOffset();
-        return Range(endOffset, endOffset + 1);
-    }
-
-    bool operator==(const Position& other) const {
-        return fStartOffset == other.fStartOffset && fLength == other.fLength;
-    }
-
-    bool operator!=(const Position& other) const {
-        return !(*this == other);
-    }
-
-    bool operator>(const Position& other) const {
-        return fStartOffset > other.fStartOffset;
-    }
-
-    bool operator>=(const Position& other) const {
-        return fStartOffset >= other.fStartOffset;
-    }
-
-    bool operator<(const Position& other) const {
-        return fStartOffset < other.fStartOffset;
-    }
-
-    bool operator<=(const Position& other) const {
-        return fStartOffset <= other.fStartOffset;
-    }
-
-private:
-    int32_t fStartOffset : 24;
-    uint32_t fLength : 8;
-};
-
-struct ForLoopPositions {
-    Position initPosition = Position();
-    Position conditionPosition = Position();
-    Position nextPosition = Position();
-};
-
-} // namespace SkSL
-
-#endif

package/cpp/skia/include/utils/SkRandom.h

@@ -1,169 +0,0 @@
-/*
- * 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 SkRandom_DEFINED
-#define SkRandom_DEFINED
-
-#include "include/core/SkScalar.h"
-#include "include/private/SkFixed.h"
-#include "include/private/SkFloatBits.h"
-
-/** \class SkRandom
-
- Utility class that implements pseudo random 32bit numbers using Marsaglia's
- multiply-with-carry "mother of all" algorithm. Unlike rand(), this class holds
- its own state, so that multiple instances can be used with no side-effects.
-
- Has a large period and all bits are well-randomized.
- */
-class SkRandom {
-public:
-    SkRandom() { init(0); }
-    SkRandom(uint32_t seed) { init(seed); }
-    SkRandom(const SkRandom& rand) : fK(rand.fK), fJ(rand.fJ) {}
-
-    SkRandom& operator=(const SkRandom& rand) {
-        fK = rand.fK;
-        fJ = rand.fJ;
-
-        return *this;
-    }
-
-    /** Return the next pseudo random number as an unsigned 32bit value.
-     */
-    uint32_t nextU() {
-        fK = kKMul*(fK & 0xffff) + (fK >> 16);
-        fJ = kJMul*(fJ & 0xffff) + (fJ >> 16);
-        return (((fK << 16) | (fK >> 16)) + fJ);
-    }
-
-    /** Return the next pseudo random number as a signed 32bit value.
-     */
-    int32_t nextS() { return (int32_t)this->nextU(); }
-
-    /**
-     *  Returns value [0...1) as an IEEE float
-     */
-    float nextF() {
-        int floatint = 0x3f800000 | (int)(this->nextU() >> 9);
-        float f = SkBits2Float(floatint) - 1.0f;
-        return f;
-    }
-
-    /**
-     *  Returns value [min...max) as a float
-     */
-    float nextRangeF(float min, float max) {
-        return min + this->nextF() * (max - min);
-    }
-
-    /** Return the next pseudo random number, as an unsigned value of
-     at most bitCount bits.
-     @param bitCount The maximum number of bits to be returned
-     */
-    uint32_t nextBits(unsigned bitCount) {
-        SkASSERT(bitCount > 0 && bitCount <= 32);
-        return this->nextU() >> (32 - bitCount);
-    }
-
-    /** Return the next pseudo random unsigned number, mapped to lie within
-     [min, max] inclusive.
-     */
-    uint32_t nextRangeU(uint32_t min, uint32_t max) {
-        SkASSERT(min <= max);
-        uint32_t range = max - min + 1;
-        if (0 == range) {
-            return this->nextU();
-        } else {
-            return min + this->nextU() % range;
-        }
-    }
-
-    /** Return the next pseudo random unsigned number, mapped to lie within
-     [0, count).
-     */
-    uint32_t nextULessThan(uint32_t count) {
-        SkASSERT(count > 0);
-        return this->nextRangeU(0, count - 1);
-    }
-
-    /** Return the next pseudo random number expressed as a SkScalar
-     in the range [0..SK_Scalar1).
-     */
-    SkScalar nextUScalar1() { return SkFixedToScalar(this->nextUFixed1()); }
-
-    /** Return the next pseudo random number expressed as a SkScalar
-     in the range [min..max).
-     */
-    SkScalar nextRangeScalar(SkScalar min, SkScalar max) {
-        return this->nextUScalar1() * (max - min) + min;
-    }
-
-    /** Return the next pseudo random number expressed as a SkScalar
-     in the range [-SK_Scalar1..SK_Scalar1).
-     */
-    SkScalar nextSScalar1() { return SkFixedToScalar(this->nextSFixed1()); }
-
-    /** Return the next pseudo random number as a bool.
-     */
-    bool nextBool() { return this->nextU() >= 0x80000000; }
-
-    /** A biased version of nextBool().
-     */
-    bool nextBiasedBool(SkScalar fractionTrue) {
-        SkASSERT(fractionTrue >= 0 && fractionTrue <= SK_Scalar1);
-        return this->nextUScalar1() <= fractionTrue;
-    }
-
-    /** Reset the random object.
-     */
-    void setSeed(uint32_t seed) { init(seed); }
-
-private:
-    // Initialize state variables with LCG.
-    // We must ensure that both J and K are non-zero, otherwise the
-    // multiply-with-carry step will forevermore return zero.
-    void init(uint32_t seed) {
-        fK = NextLCG(seed);
-        if (0 == fK) {
-            fK = NextLCG(fK);
-        }
-        fJ = NextLCG(fK);
-        if (0 == fJ) {
-            fJ = NextLCG(fJ);
-        }
-        SkASSERT(0 != fK && 0 != fJ);
-    }
-    static uint32_t NextLCG(uint32_t seed) { return kMul*seed + kAdd; }
-
-    /** Return the next pseudo random number expressed as an unsigned SkFixed
-     in the range [0..SK_Fixed1).
-     */
-    SkFixed nextUFixed1() { return this->nextU() >> 16; }
-
-    /** Return the next pseudo random number expressed as a signed SkFixed
-     in the range [-SK_Fixed1..SK_Fixed1).
-     */
-    SkFixed nextSFixed1() { return this->nextS() >> 15; }
-
-    //  See "Numerical Recipes in C", 1992 page 284 for these constants
-    //  For the LCG that sets the initial state from a seed
-    enum {
-        kMul = 1664525,
-        kAdd = 1013904223
-    };
-    // Constants for the multiply-with-carry steps
-    enum {
-        kKMul = 30345,
-        kJMul = 18000,
-    };
-
-    uint32_t fK;
-    uint32_t fJ;
-};
-
-#endif

package/cpp/skia/src/core/SkLRUCache.h

@@ -1,126 +0,0 @@
-/*
- * Copyright 2016 Google Inc.
- *
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-
-#ifndef SkLRUCache_DEFINED
-#define SkLRUCache_DEFINED
-
-#include "include/private/SkChecksum.h"
-#include "include/private/SkTHash.h"
-#include "src/core/SkTInternalLList.h"
-
-/**
- * A generic LRU cache.
- */
-template <typename K, typename V, typename HashK = SkGoodHash>
-class SkLRUCache : public SkNoncopyable {
-private:
-    struct Entry {
-        Entry(const K& key, V&& value)
-        : fKey(key)
-        , fValue(std::move(value)) {}
-
-        K fKey;
-        V fValue;
-
-        SK_DECLARE_INTERNAL_LLIST_INTERFACE(Entry);
-    };
-
-public:
-    explicit SkLRUCache(int maxCount)
-    : fMaxCount(maxCount) {}
-
-    ~SkLRUCache() {
-        Entry* node = fLRU.head();
-        while (node) {
-            fLRU.remove(node);
-            delete node;
-            node = fLRU.head();
-        }
-    }
-
-    V* find(const K& key) {
-        Entry** value = fMap.find(key);
-        if (!value) {
-            return nullptr;
-        }
-        Entry* entry = *value;
-        if (entry != fLRU.head()) {
-            fLRU.remove(entry);
-            fLRU.addToHead(entry);
-        } // else it's already at head position, don't need to do anything
-        return &entry->fValue;
-    }
-
-    V* insert(const K& key, V value) {
-        SkASSERT(!this->find(key));
-
-        Entry* entry = new Entry(key, std::move(value));
-        fMap.set(entry);
-        fLRU.addToHead(entry);
-        while (fMap.count() > fMaxCount) {
-            this->remove(fLRU.tail()->fKey);
-        }
-        return &entry->fValue;
-    }
-
-    V* insert_or_update(const K& key, V value) {
-        if (V* found = this->find(key)) {
-            *found = std::move(value);
-            return found;
-        } else {
-            return this->insert(key, std::move(value));
-        }
-    }
-
-    int count() {
-        return fMap.count();
-    }
-
-    template <typename Fn>  // f(K*, V*)
-    void foreach(Fn&& fn) {
-        typename SkTInternalLList<Entry>::Iter iter;
-        for (Entry* e = iter.init(fLRU, SkTInternalLList<Entry>::Iter::kHead_IterStart); e;
-             e = iter.next()) {
-            fn(&e->fKey, &e->fValue);
-        }
-    }
-
-    void reset() {
-        fMap.reset();
-        for (Entry* e = fLRU.head(); e; e = fLRU.head()) {
-            fLRU.remove(e);
-            delete e;
-        }
-    }
-
-private:
-    struct Traits {
-        static const K& GetKey(Entry* e) {
-            return e->fKey;
-        }
-
-        static uint32_t Hash(const K& k) {
-            return HashK()(k);
-        }
-    };
-
-    void remove(const K& key) {
-        Entry** value = fMap.find(key);
-        SkASSERT(value);
-        Entry* entry = *value;
-        SkASSERT(key == entry->fKey);
-        fMap.remove(key);
-        fLRU.remove(entry);
-        delete entry;
-    }
-
-    int                             fMaxCount;
-    SkTHashTable<Entry*, K, Traits> fMap;
-    SkTInternalLList<Entry>         fLRU;
-};
-
-#endif

package/cpp/skia/src/core/SkTInternalLList.h

@@ -1,302 +0,0 @@
-/*
- * Copyright 2012 Google Inc.
- *
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-
-#ifndef SkTInternalLList_DEFINED
-#define SkTInternalLList_DEFINED
-
-#include "include/core/SkTypes.h"
-
-/**
- * This macro creates the member variables required by the SkTInternalLList class. It should be
- * placed in the private section of any class that will be stored in a double linked list.
- */
-#define SK_DECLARE_INTERNAL_LLIST_INTERFACE(ClassName)              \
-    friend class SkTInternalLList<ClassName>;                       \
-    /* back pointer to the owning list - for debugging */           \
-    SkDEBUGCODE(SkTInternalLList<ClassName>* fList = nullptr;)      \
-    ClassName* fPrev = nullptr;                                     \
-    ClassName* fNext = nullptr
-
-/**
- * This class implements a templated internal doubly linked list data structure.
- */
-template <class T> class SkTInternalLList {
-public:
-    SkTInternalLList() {}
-
-    void reset() {
-        fHead = nullptr;
-        fTail = nullptr;
-    }
-
-    void remove(T* entry) {
-        SkASSERT(fHead && fTail);
-        SkASSERT(this->isInList(entry));
-
-        T* prev = entry->fPrev;
-        T* next = entry->fNext;
-
-        if (prev) {
-            prev->fNext = next;
-        } else {
-            fHead = next;
-        }
-        if (next) {
-            next->fPrev = prev;
-        } else {
-            fTail = prev;
-        }
-
-        entry->fPrev = nullptr;
-        entry->fNext = nullptr;
-
-#ifdef SK_DEBUG
-        entry->fList = nullptr;
-#endif
-    }
-
-    void addToHead(T* entry) {
-        SkASSERT(nullptr == entry->fPrev && nullptr == entry->fNext);
-        SkASSERT(nullptr == entry->fList);
-
-        entry->fPrev = nullptr;
-        entry->fNext = fHead;
-        if (fHead) {
-            fHead->fPrev = entry;
-        }
-        fHead = entry;
-        if (nullptr == fTail) {
-            fTail = entry;
-        }
-
-#ifdef SK_DEBUG
-        entry->fList = this;
-#endif
-    }
-
-    void addToTail(T* entry) {
-        SkASSERT(nullptr == entry->fPrev && nullptr == entry->fNext);
-        SkASSERT(nullptr == entry->fList);
-
-        entry->fPrev = fTail;
-        entry->fNext = nullptr;
-        if (fTail) {
-            fTail->fNext = entry;
-        }
-        fTail = entry;
-        if (nullptr == fHead) {
-            fHead = entry;
-        }
-
-#ifdef SK_DEBUG
-        entry->fList = this;
-#endif
-    }
-
-    /**
-     * Inserts a new list entry before an existing list entry. The new entry must not already be
-     * a member of this or any other list. If existingEntry is NULL then the new entry is added
-     * at the tail.
-     */
-    void addBefore(T* newEntry, T* existingEntry) {
-        SkASSERT(newEntry);
-
-        if (nullptr == existingEntry) {
-            this->addToTail(newEntry);
-            return;
-        }
-
-        SkASSERT(this->isInList(existingEntry));
-        newEntry->fNext = existingEntry;
-        T* prev = existingEntry->fPrev;
-        existingEntry->fPrev = newEntry;
-        newEntry->fPrev = prev;
-        if (nullptr == prev) {
-            SkASSERT(fHead == existingEntry);
-            fHead = newEntry;
-        } else {
-            prev->fNext = newEntry;
-        }
-#ifdef SK_DEBUG
-        newEntry->fList = this;
-#endif
-    }
-
-    /**
-     * Inserts a new list entry after an existing list entry. The new entry must not already be
-     * a member of this or any other list. If existingEntry is NULL then the new entry is added
-     * at the head.
-     */
-    void addAfter(T* newEntry, T* existingEntry) {
-        SkASSERT(newEntry);
-
-        if (nullptr == existingEntry) {
-            this->addToHead(newEntry);
-            return;
-        }
-
-        SkASSERT(this->isInList(existingEntry));
-        newEntry->fPrev = existingEntry;
-        T* next = existingEntry->fNext;
-        existingEntry->fNext = newEntry;
-        newEntry->fNext = next;
-        if (nullptr == next) {
-            SkASSERT(fTail == existingEntry);
-            fTail = newEntry;
-        } else {
-            next->fPrev = newEntry;
-        }
-#ifdef SK_DEBUG
-        newEntry->fList = this;
-#endif
-    }
-
-    void concat(SkTInternalLList&& list) {
-        if (list.isEmpty()) {
-            return;
-        }
-
-        list.fHead->fPrev = fTail;
-        if (!fHead) {
-            SkASSERT(!list.fHead->fPrev);
-            fHead = list.fHead;
-        } else {
-            SkASSERT(fTail);
-            fTail->fNext = list.fHead;
-        }
-        fTail = list.fTail;
-
-#ifdef SK_DEBUG
-        for (T* node = list.fHead; node; node = node->fNext) {
-            SkASSERT(node->fList == &list);
-            node->fList = this;
-        }
-#endif
-
-        list.fHead = list.fTail = nullptr;
-    }
-
-    bool isEmpty() const {
-        SkASSERT(SkToBool(fHead) == SkToBool(fTail));
-        return !fHead;
-    }
-
-    T* head() const { return fHead; }
-    T* tail() const { return fTail; }
-
-    class Iter {
-    public:
-        enum IterStart {
-            kHead_IterStart,
-            kTail_IterStart
-        };
-
-        Iter() : fCurr(nullptr) {}
-        Iter(const Iter& iter) : fCurr(iter.fCurr) {}
-        Iter& operator= (const Iter& iter) { fCurr = iter.fCurr; return *this; }
-
-        T* init(const SkTInternalLList& list, IterStart startLoc) {
-            if (kHead_IterStart == startLoc) {
-                fCurr = list.fHead;
-            } else {
-                SkASSERT(kTail_IterStart == startLoc);
-                fCurr = list.fTail;
-            }
-
-            return fCurr;
-        }
-
-        T* get() { return fCurr; }
-
-        /**
-         * Return the next/previous element in the list or NULL if at the end.
-         */
-        T* next() {
-            if (nullptr == fCurr) {
-                return nullptr;
-            }
-
-            fCurr = fCurr->fNext;
-            return fCurr;
-        }
-
-        T* prev() {
-            if (nullptr == fCurr) {
-                return nullptr;
-            }
-
-            fCurr = fCurr->fPrev;
-            return fCurr;
-        }
-
-        /**
-         * C++11 range-for interface.
-         */
-        bool operator!=(const Iter& that) { return fCurr != that.fCurr; }
-        T* operator*() { return this->get(); }
-        void operator++() { this->next(); }
-
-    private:
-        T* fCurr;
-    };
-
-    Iter begin() const {
-        Iter iter;
-        iter.init(*this, Iter::kHead_IterStart);
-        return iter;
-    }
-
-    Iter end() const { return Iter(); }
-
-#ifdef SK_DEBUG
-    void validate() const {
-        SkASSERT(!fHead == !fTail);
-        Iter iter;
-        for (T* item = iter.init(*this, Iter::kHead_IterStart); item; item = iter.next()) {
-            SkASSERT(this->isInList(item));
-            if (nullptr == item->fPrev) {
-                SkASSERT(fHead == item);
-            } else {
-                SkASSERT(item->fPrev->fNext == item);
-            }
-            if (nullptr == item->fNext) {
-                SkASSERT(fTail == item);
-            } else {
-                SkASSERT(item->fNext->fPrev == item);
-            }
-        }
-    }
-
-    /**
-     * Debugging-only method that uses the list back pointer to check if 'entry' is indeed in 'this'
-     * list.
-     */
-    bool isInList(const T* entry) const {
-        return entry->fList == this;
-    }
-
-    /**
-     * Debugging-only method that laboriously counts the list entries.
-     */
-    int countEntries() const {
-        int count = 0;
-        for (T* entry = fHead; entry; entry = entry->fNext) {
-            ++count;
-        }
-        return count;
-    }
-#endif // SK_DEBUG
-
-private:
-    T* fHead = nullptr;
-    T* fTail = nullptr;
-
-    SkTInternalLList(const SkTInternalLList&) = delete;
-    SkTInternalLList& operator=(const SkTInternalLList&) = delete;
-};
-
-#endif