@triniwiz/nativescript-masonkit 1.0.0-alpha.8 → 1.0.0-beta.0

package/src-native/pods/Headers/runtime/StringHasher.h

@@ -1,315 +0,0 @@
-/*
- * Copyright (C) 2005, 2006, 2008, 2010, 2013 Apple Inc. All rights reserved.
- * Copyright (C) 2010 Patrick Gansterer <paroga@paroga.com>
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Library General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Library General Public License for more details.
- *
- * You should have received a copy of the GNU Library General Public License
- * along with this library; see the file COPYING.LIB.  If not, write to
- * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
- * Boston, MA 02110-1301, USA.
- *
- */
-
-#ifndef WTF_StringHasher_h
-#define WTF_StringHasher_h
-
-typedef char LChar;
-typedef wchar_t UChar;
-#define ASSERT(expression) ;
-
-namespace WTF {
-    
-    // Paul Hsieh's SuperFastHash
-    // http://www.azillionmonkeys.com/qed/hash.html
-    
-    // LChar data is interpreted as Latin-1-encoded (zero extended to 16 bits).
-    
-    // NOTE: The hash computation here must stay in sync with the create_hash_table script in
-    // JavaScriptCore and the CodeGeneratorJS.pm script in WebCore.
-    
-    // Golden ratio. Arbitrary start value to avoid mapping all zeros to a hash value of zero.
-    static const unsigned stringHashingStartValue = 0x9E3779B9U;
-    
-    class StringHasher {
-    public:
-        static const unsigned flagCount = 8; // Save 8 bits for StringImpl to use as flags.
-        
-        StringHasher()
-        : m_hash(stringHashingStartValue)
-        , m_hasPendingCharacter(false)
-        , m_pendingCharacter(0)
-        {
-        }
-        
-        // The hasher hashes two characters at a time, and thus an "aligned" hasher is one
-        // where an even number of characters have been added. Callers that always add
-        // characters two at a time can use the "assuming aligned" functions.
-        void addCharactersAssumingAligned(UChar a, UChar b)
-        {
-            ASSERT(!m_hasPendingCharacter);
-            m_hash += a;
-            m_hash = (m_hash << 16) ^ ((b << 11) ^ m_hash);
-            m_hash += m_hash >> 11;
-        }
-        
-        void addCharacter(UChar character)
-        {
-            if (m_hasPendingCharacter) {
-                m_hasPendingCharacter = false;
-                addCharactersAssumingAligned(m_pendingCharacter, character);
-                return;
-            }
-            
-            m_pendingCharacter = character;
-            m_hasPendingCharacter = true;
-        }
-        
-        void addCharacters(UChar a, UChar b)
-        {
-            if (m_hasPendingCharacter) {
-#if !ASSERT_DISABLED
-                m_hasPendingCharacter = false;
-#endif
-                addCharactersAssumingAligned(m_pendingCharacter, a);
-                m_pendingCharacter = b;
-#if !ASSERT_DISABLED
-                m_hasPendingCharacter = true;
-#endif
-                return;
-            }
-            
-            addCharactersAssumingAligned(a, b);
-        }
-        
-        template <typename T, UChar Converter(T)>
-        void addCharactersAssumingAligned(const T* data, unsigned length)
-        {
-            ASSERT(!m_hasPendingCharacter);
-            
-            bool remainder = length & 1;
-            length >>= 1;
-            
-            while (length--) {
-                addCharactersAssumingAligned(Converter(data[0]), Converter(data[1]));
-                data += 2;
-            }
-            
-            if (remainder)
-                addCharacter(Converter(*data));
-        }
-        
-        template <typename T>
-        void addCharactersAssumingAligned(const T* data, unsigned length)
-        {
-            addCharactersAssumingAligned<T, defaultConverter>(data, length);
-        }
-        
-        template <typename T, UChar Converter(T)>
-        void addCharactersAssumingAligned(const T* data)
-        {
-            ASSERT(!m_hasPendingCharacter);
-            
-            while (T a = *data++) {
-                T b = *data++;
-                if (!b) {
-                    addCharacter(Converter(a));
-                    break;
-                }
-                addCharactersAssumingAligned(Converter(a), Converter(b));
-            }
-        }
-        
-        template <typename T>
-        void addCharactersAssumingAligned(const T* data)
-        {
-            addCharactersAssumingAligned<T, defaultConverter>(data);
-        }
-        
-        template <typename T, UChar Converter(T)>
-        void addCharacters(const T* data, unsigned length)
-        {
-            if (m_hasPendingCharacter && length) {
-                m_hasPendingCharacter = false;
-                addCharactersAssumingAligned(m_pendingCharacter, Converter(*data++));
-                --length;
-            }
-            addCharactersAssumingAligned<T, Converter>(data, length);
-        }
-        
-        template <typename T>
-        void addCharacters(const T* data, unsigned length)
-        {
-            addCharacters<T, defaultConverter>(data, length);
-        }
-        
-        template <typename T, UChar Converter(T)>
-        void addCharacters(const T* data)
-        {
-            if (m_hasPendingCharacter && *data) {
-                m_hasPendingCharacter = false;
-                addCharactersAssumingAligned(m_pendingCharacter, Converter(*data++));
-            }
-            addCharactersAssumingAligned<T, Converter>(data);
-        }
-        
-        template <typename T>
-        void addCharacters(const T* data)
-        {
-            addCharacters<T, defaultConverter>(data);
-        }
-        
-        unsigned hashWithTop8BitsMasked() const
-        {
-            unsigned result = avalancheBits();
-            
-            // Reserving space from the high bits for flags preserves most of the hash's
-            // value, since hash lookup typically masks out the high bits anyway.
-            result &= (1U << (sizeof(result) * 8 - flagCount)) - 1;
-            
-            // This avoids ever returning a hash code of 0, since that is used to
-            // signal "hash not computed yet". Setting the high bit maintains
-            // reasonable fidelity to a hash code of 0 because it is likely to yield
-            // exactly 0 when hash lookup masks out the high bits.
-            if (!result)
-                result = 0x80000000 >> flagCount;
-            
-            return result;
-        }
-        
-        unsigned hash() const
-        {
-            unsigned result = avalancheBits();
-            
-            // This avoids ever returning a hash code of 0, since that is used to
-            // signal "hash not computed yet". Setting the high bit maintains
-            // reasonable fidelity to a hash code of 0 because it is likely to yield
-            // exactly 0 when hash lookup masks out the high bits.
-            if (!result)
-                result = 0x80000000;
-            
-            return result;
-        }
-        
-        template <typename T, UChar Converter(T)>
-        static unsigned computeHashAndMaskTop8Bits(const T* data, unsigned length)
-        {
-            StringHasher hasher;
-            hasher.addCharactersAssumingAligned<T, Converter>(data, length);
-            return hasher.hashWithTop8BitsMasked();
-        }
-        
-        template <typename T, UChar Converter(T)>
-        static unsigned computeHashAndMaskTop8Bits(const T* data)
-        {
-            StringHasher hasher;
-            hasher.addCharactersAssumingAligned<T, Converter>(data);
-            return hasher.hashWithTop8BitsMasked();
-        }
-        
-        template <typename T>
-        static unsigned computeHashAndMaskTop8Bits(const T* data, unsigned length)
-        {
-            return computeHashAndMaskTop8Bits<T, defaultConverter>(data, length);
-        }
-        
-        template <typename T>
-        static unsigned computeHashAndMaskTop8Bits(const T* data)
-        {
-            return computeHashAndMaskTop8Bits<T, defaultConverter>(data);
-        }
-        
-        template <typename T, UChar Converter(T)>
-        static unsigned computeHash(const T* data, unsigned length)
-        {
-            StringHasher hasher;
-            hasher.addCharactersAssumingAligned<T, Converter>(data, length);
-            return hasher.hash();
-        }
-        
-        template <typename T, UChar Converter(T)>
-        static unsigned computeHash(const T* data)
-        {
-            StringHasher hasher;
-            hasher.addCharactersAssumingAligned<T, Converter>(data);
-            return hasher.hash();
-        }
-        
-        template <typename T>
-        static unsigned computeHash(const T* data, unsigned length)
-        {
-            return computeHash<T, defaultConverter>(data, length);
-        }
-        
-        template <typename T>
-        static unsigned computeHash(const T* data)
-        {
-            return computeHash<T, defaultConverter>(data);
-        }
-        
-        static unsigned hashMemory(const void* data, unsigned length)
-        {
-            // FIXME: Why does this function use the version of the hash that drops the top 8 bits?
-            // We want that for all string hashing so we can use those bits in StringImpl and hash
-            // strings consistently, but I don't see why we'd want that for general memory hashing.
-            ASSERT(!(length % 2));
-            return computeHashAndMaskTop8Bits<UChar>(static_cast<const UChar*>(data), length / sizeof(UChar));
-        }
-        
-        template <size_t length>
-        static unsigned hashMemory(const void* data)
-        {
-            static_assert(!(length % 2), "length must be a multiple of two!");
-            return hashMemory(data, length);
-        }
-        
-    private:
-        static UChar defaultConverter(UChar character)
-        {
-            return character;
-        }
-        
-        static UChar defaultConverter(LChar character)
-        {
-            return character;
-        }
-        
-        unsigned avalancheBits() const
-        {
-            unsigned result = m_hash;
-            
-            // Handle end case.
-            if (m_hasPendingCharacter) {
-                result += m_pendingCharacter;
-                result ^= result << 11;
-                result += result >> 17;
-            }
-            
-            // Force "avalanching" of final 31 bits.
-            result ^= result << 3;
-            result += result >> 5;
-            result ^= result << 2;
-            result += result >> 15;
-            result ^= result << 10;
-            
-            return result;
-        }
-        
-        unsigned m_hash;
-        bool m_hasPendingCharacter;
-        UChar m_pendingCharacter;
-    };
-    
-} // namespace WTF
-
-using WTF::StringHasher;
-
-#endif // WTF_StringHasher_h

package/src-native/pods/Headers/runtime/SymbolIterator.h

@@ -1,18 +0,0 @@
-#ifndef SymbolIterator_h
-#define SymbolIterator_h
-
-#include "Common.h"
-
-namespace tns {
-
-class SymbolIterator {
-public:
-    static void Set(v8::Local<v8::Context> context, v8::Local<v8::Value> object);
-private:
-    static v8::Local<v8::Object> CreateIteratorObject(v8::Local<v8::Context> context, v8::Local<v8::Value> object);
-    static void NextCallback(const v8::FunctionCallbackInfo<v8::Value>& args);
-};
-
-}
-
-#endif /* SymbolIterator_h */

package/src-native/pods/Headers/runtime/SymbolLoader.h

@@ -1,27 +0,0 @@
-#ifndef SymbolLoader_h
-#define SymbolLoader_h
-
-#include "robin_hood.h"
-#include "Metadata.h"
-
-namespace tns {
-
-class SymbolResolver;
-
-class SymbolLoader {
-public:
-    static SymbolLoader& instance();
-
-    void* loadFunctionSymbol(const ModuleMeta*, const char* symbolName);
-    void* loadDataSymbol(const ModuleMeta*, const char* symbolName);
-    bool ensureModule(const ModuleMeta*);
-
-private:
-    SymbolResolver* resolveModule(const ModuleMeta*);
-
-    robin_hood::unordered_map<const ModuleMeta*, std::unique_ptr<SymbolResolver>> _cache;
-};
-
-}
-
-#endif /* SymbolLoader_h */

package/src-native/pods/Headers/runtime/TNSDerivedClass.h

@@ -1,8 +0,0 @@
-#ifndef TNSDerivedClass_h
-#define TNSDerivedClass_h
-
-@protocol TNSDerivedClass
-
-@end
-
-#endif /* TNSDerivedClass_h */

package/src-native/pods/Headers/runtime/TSHelpers.h

@@ -1,15 +0,0 @@
-#ifndef TSHelpers_h
-#define TSHelpers_h
-
-#include "Common.h"
-
-namespace tns {
-
-class TSHelpers {
-public:
-    static void Init(v8::Local<v8::Context> context);
-};
-
-}
-
-#endif /* TSHelpers_h */

package/src-native/pods/Headers/runtime/Tasks.h

@@ -1,19 +0,0 @@
-#ifndef Tasks_h
-#define Tasks_h
-
-#include <vector>
-#include <functional>
-
-namespace tns {
-
-class Tasks {
-public:
-    static void Register(std::function<void()> task);
-    static void Drain();
-private:
-    static std::vector<std::function<void()>> tasks_;
-};
-
-}
-
-#endif /* Tasks_h */

package/src-native/pods/Headers/runtime/UnmanagedType.h

@@ -1,21 +0,0 @@
-#ifndef UnmanagedType_h
-#define UnmanagedType_h
-
-#include "Common.h"
-#include "DataWrapper.h"
-
-namespace tns {
-
-class UnmanagedType {
-public:
-    static v8::Local<v8::Value> Create(v8::Local<v8::Context> context, UnmanagedTypeWrapper* wrapper);
-private:
-    static void ConstructorCallback(const v8::FunctionCallbackInfo<v8::Value>& info);
-    static void TakeUnretainedValueCallback(const v8::FunctionCallbackInfo<v8::Value>& info);
-    static void TakeRetainedValueCallback(const v8::FunctionCallbackInfo<v8::Value>& info);
-    static v8::Local<v8::Value> TakeValue(const v8::FunctionCallbackInfo<v8::Value>& info, bool retained);
-};
-
-}
-
-#endif /* UnmanagedType_h */

package/src-native/pods/Headers/runtime/WeakRef.h

@@ -1,15 +0,0 @@
-#ifndef WeakRef_h
-#define WeakRef_h
-
-#include "Common.h"
-
-namespace tns {
-
-class WeakRef {
-public:
-    static void Init(v8::Local<v8::Context> context);
-};
-
-}
-
-#endif /* WeakRef_h */

package/src-native/pods/Headers/runtime/Worker.h

@@ -1,26 +0,0 @@
-#ifndef Worker_h
-#define Worker_h
-
-#include "Common.h"
-
-namespace tns {
-
-class Worker {
-public:
-    static void Init(v8::Isolate* isolate, v8::Local<v8::ObjectTemplate> globalTemplate, bool isWorkerThread);
-    static std::vector<std::string> GlobalFunctions;
-private:
-    static void ConstructorCallback(const v8::FunctionCallbackInfo<v8::Value>& info);
-    static void PostMessageCallback(const v8::FunctionCallbackInfo<v8::Value>& info);
-    static void TerminateCallback(const v8::FunctionCallbackInfo<v8::Value>& info);
-    static void OnMessageCallback(v8::Isolate* isolate, v8::Local<v8::Value> receiver, std::string message);
-    static void PostMessageToMainCallback(const v8::FunctionCallbackInfo<v8::Value>& info);
-    static void CloseWorkerCallback(const v8::FunctionCallbackInfo<v8::Value>& info);
-    static v8::Local<v8::String> Serialize(v8::Isolate* isolate, v8::Local<v8::Value> value, v8::Local<v8::Value>& error);
-    static void SetWorkerId(v8::Isolate* isolate, int workerId);
-    static int GetWorkerId(v8::Isolate* isolate, v8::Local<v8::Object> global);
-};
-
-}
-
-#endif /* Worker_h */