@nativescript/canvas 2.0.0-alpha.10 → 2.0.0-alpha.12

package/pods/Headers/runtime/Metadata.h

@@ -1,981 +0,0 @@
-#ifndef Metadata_h
-#define Metadata_h
-
-#include <stack>
-#include <string>
-#include <type_traits>
-#include "robin_hood.h"
-#include <map>
-#include <set>
-#include <vector>
-#include "KnownUnknownClassPair.h"
-
-namespace tns {
-
-static const int MetaTypeMask = 0b00000111;
-
-template <typename V>
-static const V& getProperFunctionFromContainer(const std::vector<V>& container, int argsCount, std::function<int(const V&)> paramsCounter) {
-    const V* callee = nullptr;
-
-    for (const V& func : container) {
-        auto candidateArgs = paramsCounter(func);
-        auto calleeArgs = 0;
-        if (candidateArgs == argsCount) {
-            callee = &func;
-            break;
-        } else if (!callee) {
-            // no candidates so far, take it whatever it is
-            callee = &func;
-            calleeArgs = candidateArgs;
-        } else if (argsCount < candidateArgs && (calleeArgs < argsCount || candidateArgs < calleeArgs)) {
-            // better candidate - looking for the least number of arguments which is more than the amount actually passed
-            callee = &func;
-            calleeArgs = candidateArgs;
-        } else if (calleeArgs < candidateArgs) {
-            // better candidate - looking for the maximum number of arguments which less than the amount actually passed (if one with more cannot be found)
-            callee = &func;
-            calleeArgs = candidateArgs;
-        }
-    }
-
-    return *callee;
-}
-
-inline uint8_t encodeVersion(uint8_t majorVersion, uint8_t minorVersion) {
-    return (majorVersion << 3) | minorVersion;
-}
-
-inline uint8_t getMajorVersion(uint8_t encodedVersion) {
-    return encodedVersion >> 3;
-}
-
-inline uint8_t getMinorVersion(uint8_t encodedVersion) {
-    return encodedVersion & 0b111;
-}
-
-// Bit indices in flags section
-enum MetaFlags {
-    HasDemangledName = 8,
-    HasName = 7,
-    // IsIosAppExtensionAvailable = 6, the flag exists in metadata generator but we never use it in the runtime
-    FunctionReturnsUnmanaged = 3,
-    FunctionIsVariadic = 5,
-    FunctionOwnsReturnedCocoaObject = 4,
-    MemberIsOptional = 0, // Mustn't equal any Method or Property flag since it can be applicable to both
-    MethodIsInitializer = 1,
-    MethodIsVariadic = 2,
-    MethodIsNullTerminatedVariadic = 3,
-    MethodOwnsReturnedCocoaObject = 4,
-    MethodHasErrorOutParameter = 5,
-    PropertyHasGetter = 2,
-    PropertyHasSetter = 3,
-
-};
-
-/// This enum describes the possible ObjectiveC entity types.
-enum MetaType {
-    Undefined = 0,
-    Struct = 1,
-    Union = 2,
-    Function = 3,
-    JsCode = 4,
-    Var = 5,
-    Interface = 6,
-    ProtocolType = 7,
-    Vector = 8
-};
-
-enum MemberType {
-    InstanceMethod = 0,
-    StaticMethod = 1,
-    InstanceProperty = 2,
-    StaticProperty = 3
-};
-
-enum BinaryTypeEncodingType : uint8_t {
-    VoidEncoding,
-    BoolEncoding,
-    ShortEncoding,
-    UShortEncoding,
-    IntEncoding,
-    UIntEncoding,
-    LongEncoding,
-    ULongEncoding,
-    LongLongEncoding,
-    ULongLongEncoding,
-    CharEncoding,
-    UCharEncoding,
-    UnicharEncoding,
-    CharSEncoding,
-    CStringEncoding,
-    FloatEncoding,
-    DoubleEncoding,
-    InterfaceDeclarationReference,
-    StructDeclarationReference,
-    UnionDeclarationReference,
-    PointerEncoding,
-    VaListEncoding,
-    SelectorEncoding,
-    ClassEncoding,
-    ProtocolEncoding,
-    InstanceTypeEncoding,
-    IdEncoding,
-    ConstantArrayEncoding,
-    IncompleteArrayEncoding,
-    FunctionPointerEncoding,
-    BlockEncoding,
-    AnonymousStructEncoding,
-    AnonymousUnionEncoding,
-    ExtVectorEncoding
-};
-
-#pragma pack(push, 1)
-
-template <typename T>
-struct PtrTo;
-struct Meta;
-struct InterfaceMeta;
-struct ProtocolMeta;
-struct ModuleMeta;
-struct LibraryMeta;
-struct TypeEncoding;
-
-typedef std::vector<const ProtocolMeta*> ProtocolMetas;
-
-typedef int32_t ArrayCount;
-
-static const void* offset(const void* from, ptrdiff_t offset) {
-    return reinterpret_cast<const char*>(from) + offset;
-}
-
-template <typename T>
-struct Array {
-    class iterator {
-    private:
-        const T* current;
-
-    public:
-        iterator(const T* item)
-            : current(item) {
-        }
-        bool operator==(const iterator& other) const {
-            return current == other.current;
-        }
-        bool operator!=(const iterator& other) const {
-            return !(*this == other);
-        }
-        iterator& operator++() {
-            current++;
-            return *this;
-        }
-        iterator operator++(int) {
-            iterator tmp(current);
-            operator++();
-            return tmp;
-        }
-        const T& operator*() const {
-            return *current;
-        }
-    };
-
-    ArrayCount count;
-
-    const T* first() const {
-        return reinterpret_cast<const T*>(&count + 1);
-    }
-
-    const T& operator[](int index) const {
-        return *(first() + index);
-    }
-
-    Array<T>::iterator begin() const {
-        return first();
-    }
-
-    Array<T>::iterator end() const {
-        return first() + count;
-    }
-
-    template <typename V>
-    const Array<V>& castTo() const {
-        return *reinterpret_cast<const Array<V>*>(this);
-    }
-
-    int sizeInBytes() const {
-        return sizeof(Array<T>) + sizeof(T) * count;
-    }
-
-    int binarySearch(std::function<int(const T&)> comparer) const {
-        int left = 0, right = count - 1, mid;
-        while (left <= right) {
-            mid = (right + left) / 2;
-            const T& current = (*this)[mid];
-            int comparisonResult = comparer(current);
-            if (comparisonResult < 0) {
-                left = mid + 1;
-            } else if (comparisonResult > 0) {
-                right = mid - 1;
-            } else {
-                return mid;
-            }
-        }
-        return -(left + 1);
-    }
-
-    int binarySearchLeftmost(std::function<int(const T&)> comparer) const {
-        int mid = binarySearch(comparer);
-        while (mid > 0 && comparer((*this)[mid - 1]) == 0) {
-            mid -= 1;
-        }
-        return mid;
-    }
-};
-
-template <typename T>
-using ArrayOfPtrTo = Array<PtrTo<T>>;
-using String = PtrTo<char>;
-
-enum GlobalTableType {
-    ByJsName,
-    ByNativeName,
-};
-
-template <GlobalTableType TYPE>
-struct GlobalTable {
-    class iterator {
-    private:
-        const GlobalTable<TYPE>* _globalTable;
-        int _topLevelIndex;
-        int _bucketIndex;
-
-        void findNext();
-
-        const Meta* getCurrent();
-
-    public:
-        iterator(const GlobalTable<TYPE>* globalTable)
-            : iterator(globalTable, 0, 0) {
-            findNext();
-        }
-
-        iterator(const GlobalTable<TYPE>* globalTable, int32_t topLevelIndex, int32_t bucketIndex)
-            : _globalTable(globalTable)
-            , _topLevelIndex(topLevelIndex)
-            , _bucketIndex(bucketIndex) {
-            findNext();
-        }
-
-        bool operator==(const iterator& other) const;
-
-        bool operator!=(const iterator& other) const;
-
-        iterator& operator++();
-
-        iterator operator++(int) {
-            iterator tmp(_globalTable, _topLevelIndex, _bucketIndex);
-            operator++();
-            return tmp;
-        }
-
-        const Meta* operator*();
-    };
-
-    iterator begin() const {
-        return iterator(this);
-    }
-
-    iterator end() const {
-        return iterator(this, this->buckets.count, 0);
-    }
-
-    ArrayOfPtrTo<ArrayOfPtrTo<Meta>> buckets;
-
-    const InterfaceMeta* findInterfaceMeta(const char* identifierString) const;
-
-    const InterfaceMeta* findInterfaceMeta(const char* identifierString, size_t length, unsigned hash) const;
-
-    const ProtocolMeta* findProtocol(const char* identifierString) const;
-
-    const ProtocolMeta* findProtocol(const char* identifierString, size_t length, unsigned hash) const;
-
-    const Meta* findMeta(const char* identifierString, bool onlyIfAvailable = true) const;
-
-    const Meta* findMeta(const char* identifierString, size_t length, unsigned hash, bool onlyIfAvailable = true) const;
-
-    int sizeInBytes() const {
-        return buckets.sizeInBytes();
-    }
-
-    static bool compareName(const Meta& meta, const char* identifierString, size_t length);
-};
-
-struct ModuleTable {
-    ArrayOfPtrTo<ModuleMeta> modules;
-
-    int sizeInBytes() const {
-        return modules.sizeInBytes();
-    }
-};
-
-struct MetaFile {
-private:
-    GlobalTable<GlobalTableType::ByJsName> _globalTableJs;
-
-public:
-    static MetaFile* instance();
-
-    static MetaFile* setInstance(void* metadataPtr);
-
-    const GlobalTable<GlobalTableType::ByJsName>* globalTableJs() const {
-        return &this->_globalTableJs;
-    }
-
-    const GlobalTable<GlobalTableType::ByNativeName>* globalTableNativeProtocols() const {
-        const GlobalTable<GlobalTableType::ByJsName>* gt = this->globalTableJs();
-        return reinterpret_cast<const GlobalTable<GlobalTableType::ByNativeName>*>(offset(gt, gt->sizeInBytes()));
-    }
-
-    const GlobalTable<GlobalTableType::ByNativeName>* globalTableNativeInterfaces() const {
-        const GlobalTable<GlobalTableType::ByNativeName>* gt = this->globalTableNativeProtocols();
-        return reinterpret_cast<const GlobalTable<GlobalTableType::ByNativeName>*>(offset(gt, gt->sizeInBytes()));
-    }
-
-    const ModuleTable* topLevelModulesTable() const {
-        const GlobalTable<GlobalTableType::ByNativeName>* gt = this->globalTableNativeInterfaces();
-        return reinterpret_cast<const ModuleTable*>(offset(gt, gt->sizeInBytes()));
-    }
-
-    const void* heap() const {
-        const ModuleTable* mt = this->topLevelModulesTable();
-        return offset(mt, mt->sizeInBytes());
-    }
-};
-
-template <typename T>
-struct PtrTo {
-    int32_t offset;
-
-    bool isNull() const {
-        return offset == 0;
-    }
-    PtrTo<T> operator+(int value) const {
-        return add(value);
-    }
-    const T* operator->() const {
-        return valuePtr();
-    }
-    PtrTo<T> add(int value) const {
-        return PtrTo<T>{ .offset = this->offset + value * sizeof(T) };
-    }
-    PtrTo<T> addBytes(int bytes) const {
-        return PtrTo<T>{ .offset = this->offset + bytes };
-    }
-    template <typename V>
-    PtrTo<V>& castTo() const {
-        return reinterpret_cast<PtrTo<V>>(this);
-    }
-    const T* valuePtr() const {
-        return isNull() ? nullptr : reinterpret_cast<const T*>(tns::offset(MetaFile::instance()->heap(), this->offset));
-    }
-    const T& value() const {
-        return *valuePtr();
-    }
-};
-
-template <typename T>
-struct TypeEncodingsList {
-    T count;
-
-    const TypeEncoding* first() const {
-        return reinterpret_cast<const TypeEncoding*>(this + 1);
-    }
-};
-
-union TypeEncodingDetails {
-    struct IdDetails {
-        PtrTo<Array<String>> _protocols;
-    } idDetails;
-    struct IncompleteArrayDetails {
-        const TypeEncoding* getInnerType() const {
-            return reinterpret_cast<const TypeEncoding*>(this);
-        }
-    } incompleteArray;
-    struct ConstantArrayDetails {
-        int32_t size;
-        const TypeEncoding* getInnerType() const {
-            return reinterpret_cast<const TypeEncoding*>(this + 1);
-        }
-    } constantArray;
-    struct ExtVectorDetails {
-        int32_t size;
-        const TypeEncoding* getInnerType() const {
-            return reinterpret_cast<const TypeEncoding*>(this + 1);
-        }
-    } extVector;
-    struct DeclarationReferenceDetails {
-        String name;
-    } declarationReference;
-    struct InterfaceDeclarationReferenceDetails {
-        String name;
-        PtrTo<Array<String>> _protocols;
-    } interfaceDeclarationReference;
-    struct PointerDetails {
-        const TypeEncoding* getInnerType() const {
-            return reinterpret_cast<const TypeEncoding*>(this);
-        }
-    } pointer;
-    struct BlockDetails {
-        TypeEncodingsList<uint8_t> signature;
-    } block;
-    struct FunctionPointerDetails {
-        TypeEncodingsList<uint8_t> signature;
-    } functionPointer;
-    struct AnonymousRecordDetails {
-        uint8_t fieldsCount;
-        const String* getFieldNames() const {
-            return reinterpret_cast<const String*>(this + 1);
-        }
-        const TypeEncoding* getFieldsEncodings() const {
-            return reinterpret_cast<const TypeEncoding*>(getFieldNames() + this->fieldsCount);
-        }
-    } anonymousRecord;
-};
-
-struct TypeEncoding {
-    BinaryTypeEncodingType type;
-    TypeEncodingDetails details;
-
-    const TypeEncoding* next() const {
-        const TypeEncoding* afterTypePtr = reinterpret_cast<const TypeEncoding*>(offset(this, sizeof(type)));
-
-        switch (this->type) {
-        case BinaryTypeEncodingType::IdEncoding: {
-            return reinterpret_cast<const TypeEncoding*>(offset(afterTypePtr, sizeof(TypeEncodingDetails::IdDetails)));
-        }
-        case BinaryTypeEncodingType::ConstantArrayEncoding: {
-            return this->details.constantArray.getInnerType()->next();
-        }
-        case BinaryTypeEncodingType::ExtVectorEncoding: {
-            return this->details.extVector.getInnerType()->next();
-        }
-        case BinaryTypeEncodingType::IncompleteArrayEncoding: {
-            return this->details.incompleteArray.getInnerType()->next();
-        }
-        case BinaryTypeEncodingType::PointerEncoding: {
-            return this->details.pointer.getInnerType()->next();
-        }
-        case BinaryTypeEncodingType::BlockEncoding: {
-            const TypeEncoding* current = this->details.block.signature.first();
-            for (int i = 0; i < this->details.block.signature.count; i++) {
-                current = current->next();
-            }
-            return current;
-        }
-        case BinaryTypeEncodingType::FunctionPointerEncoding: {
-            const TypeEncoding* current = this->details.functionPointer.signature.first();
-            for (int i = 0; i < this->details.functionPointer.signature.count; i++) {
-                current = current->next();
-            }
-            return current;
-        }
-        case BinaryTypeEncodingType::InterfaceDeclarationReference: {
-            return reinterpret_cast<const TypeEncoding*>(offset(afterTypePtr, sizeof(TypeEncodingDetails::InterfaceDeclarationReferenceDetails)));
-        }
-        case BinaryTypeEncodingType::StructDeclarationReference:
-        case BinaryTypeEncodingType::UnionDeclarationReference: {
-            return reinterpret_cast<const TypeEncoding*>(offset(afterTypePtr, sizeof(TypeEncodingDetails::DeclarationReferenceDetails)));
-        }
-        case BinaryTypeEncodingType::AnonymousStructEncoding:
-        case BinaryTypeEncodingType::AnonymousUnionEncoding: {
-            const TypeEncoding* current = this->details.anonymousRecord.getFieldsEncodings();
-            for (int i = 0; i < this->details.anonymousRecord.fieldsCount; i++) {
-                current = current->next();
-            }
-            return current;
-        }
-        default: {
-            return afterTypePtr;
-        }
-        }
-    }
-};
-
-struct ModuleMeta {
-public:
-    uint8_t flags;
-    String name;
-    PtrTo<ArrayOfPtrTo<LibraryMeta>> libraries;
-
-    const char* getName() const {
-        return name.valuePtr();
-    }
-
-    bool isFramework() const {
-        return (flags & 1) > 0;
-    }
-
-    bool isSystem() const {
-        return (flags & 2) > 0;
-    }
-};
-
-struct LibraryMeta {
-public:
-    uint8_t flags;
-    String name;
-
-    const char* getName() const {
-        return name.valuePtr();
-    }
-
-    bool isFramework() const {
-        return (flags & 1) > 0;
-    }
-};
-
-enum NameIndex {
-    JsName,
-    Name,
-    DemangledName,
-    NameIndexCount,
-};
-
-struct JsNameAndNativeNames {
-    String strings[NameIndexCount];
-};
-
-union MetaNames {
-    String name;
-    PtrTo<JsNameAndNativeNames> names;
-};
-
-struct Meta {
-
-private:
-    MetaNames _names;
-    PtrTo<ModuleMeta> _topLevelModule;
-    uint16_t _flags;
-    uint8_t _introduced;
-
-public:
-    MetaType type() const {
-        return (MetaType)(this->_flags & MetaTypeMask);
-    }
-
-    const char* typeName() const {
-        switch (type()) {
-            case Undefined:
-                return "Undefined";
-            case Struct:
-                return "Struct";
-            case Union:
-                return "Union";
-            case Function:
-                return "Function";
-            case JsCode:
-                return "JsCode";
-            case Var:
-                return "Var";
-            case Interface:
-                return "Interface";
-            case ProtocolType:
-                return "ProtocolType";
-            case Vector:
-                return "Vector";
-            default:
-                return "Unknown";
-        }
-    }
-    
-    const ModuleMeta* topLevelModule() const {
-        return this->_topLevelModule.valuePtr();
-    }
-
-    bool hasName() const {
-        return this->flag(MetaFlags::HasName);
-    }
-
-    bool hasDemangledName() const {
-        return this->flag(MetaFlags::HasDemangledName);
-    }
-
-    bool flag(int index) const {
-        return (this->_flags & (1 << index)) > 0;
-    }
-
-    const char* jsName() const {
-        return this->getNameByIndex(JsName);
-    }
-
-    const char* name() const {
-        return this->getNameByIndex(Name);
-    }
-
-    const char* demangledName() const {
-        return this->getNameByIndex(DemangledName);
-    }
-
-    /**
-     * \brief The version number in which this entity was introduced.
-     */
-    uint8_t introducedIn() const {
-        return this->_introduced;
-    }
-
-    /**
-    * \brief Checks if the specified object is callable
-    * from the current device.
-    *
-    * To be callable, an object must either:
-    * > not have platform availability specified;
-    * > have been introduced in this or prior version;
-    */
-    bool isAvailable() const;
-
-private:
-    const char* getNameByIndex(enum NameIndex index) const {
-        int i = index;
-        if (!this->hasName() && !this->hasDemangledName()) {
-            return this->_names.name.valuePtr();
-        }
-
-        if (!this->hasDemangledName() && i >= DemangledName) {
-            i--;
-        }
-
-        if (!this->hasName() && i >= Name) {
-            i--;
-        }
-
-        return this->_names.names.value().strings[i].valuePtr();
-    }
-};
-
-struct RecordMeta : Meta {
-
-private:
-    PtrTo<Array<String>> _fieldsNames;
-    PtrTo<TypeEncodingsList<ArrayCount>> _fieldsEncodings;
-
-public:
-    const Array<String>& fieldNames() const {
-        return _fieldsNames.value();
-    }
-
-    size_t fieldsCount() const {
-        return fieldNames().count;
-    }
-
-    const TypeEncodingsList<ArrayCount>* fieldsEncodings() const {
-        return _fieldsEncodings.valuePtr();
-    }
-};
-
-struct StructMeta : RecordMeta {
-};
-
-struct UnionMeta : RecordMeta {
-};
-
-struct FunctionMeta : Meta {
-
-private:
-    PtrTo<TypeEncodingsList<ArrayCount>> _encoding;
-
-public:
-    bool isVariadic() const {
-        return this->flag(MetaFlags::FunctionIsVariadic);
-    }
-
-    const TypeEncodingsList<ArrayCount>* encodings() const {
-        return _encoding.valuePtr();
-    }
-
-    bool ownsReturnedCocoaObject() const {
-        return this->flag(MetaFlags::FunctionOwnsReturnedCocoaObject);
-    }
-
-    bool returnsUnmanaged() const {
-        return this->flag(MetaFlags::FunctionReturnsUnmanaged);
-    }
-};
-
-struct JsCodeMeta : Meta {
-
-private:
-    String _jsCode;
-
-public:
-    const char* jsCode() const {
-        return _jsCode.valuePtr();
-    }
-};
-
-struct VarMeta : Meta {
-
-private:
-    PtrTo<TypeEncoding> _encoding;
-
-public:
-    const TypeEncoding* encoding() const {
-        return _encoding.valuePtr();
-    }
-};
-
-struct MemberMeta : Meta {
-    bool isOptional() const {
-        return this->flag(MetaFlags::MemberIsOptional);
-    }
-};
-
-struct MethodMeta : MemberMeta {
-
-private:
-    PtrTo<TypeEncodingsList<ArrayCount>> _encodings;
-    String _constructorTokens;
-
-public:
-    bool isVariadic() const {
-        return this->flag(MetaFlags::MethodIsVariadic);
-    }
-
-    bool isVariadicNullTerminated() const {
-        return this->flag(MetaFlags::MethodIsNullTerminatedVariadic);
-    }
-
-    bool hasErrorOutParameter() const {
-        return this->flag(MetaFlags::MethodHasErrorOutParameter);
-    }
-
-    bool isInitializer() const {
-        return this->flag(MetaFlags::MethodIsInitializer);
-    }
-
-    bool ownsReturnedCocoaObject() const {
-        return this->flag(MetaFlags::MethodOwnsReturnedCocoaObject);
-    }
-
-    SEL selector() const {
-        return sel_registerName(this->selectorAsString());
-    }
-
-    // just a more convenient way to get the selector of method
-    const char* selectorAsString() const {
-        return this->name();
-    }
-
-    const TypeEncodingsList<ArrayCount>* encodings() const {
-        return this->_encodings.valuePtr();
-    }
-
-    const char* constructorTokens() const {
-        return this->_constructorTokens.valuePtr();
-    }
-
-    bool isImplementedInClass(Class klass, bool isStatic) const;
-    bool isAvailableInClass(Class klass, bool isStatic) const {
-        return this->isAvailable() && this->isImplementedInClass(klass, isStatic);
-    }
-    bool isAvailableInClasses(KnownUnknownClassPair klasses, bool isStatic) const {
-        return this->isAvailableInClass(klasses.known, isStatic) || (klasses.unknown != nullptr && this->isAvailableInClass(klasses.unknown, isStatic));
-    }
-};
-
-typedef std::set<const MemberMeta*> MembersCollection;
-
-robin_hood::unordered_map<std::string, MembersCollection> getMetasByJSNames(MembersCollection methods);
-
-struct PropertyMeta : MemberMeta {
-    PtrTo<MethodMeta> method1;
-    PtrTo<MethodMeta> method2;
-
-public:
-    bool hasGetter() const {
-        return this->flag(MetaFlags::PropertyHasGetter);
-    }
-
-    bool hasSetter() const {
-        return this->flag(MetaFlags::PropertyHasSetter);
-    }
-
-    const MethodMeta* getter() const {
-        return this->hasGetter() ? method1.valuePtr() : nullptr;
-    }
-
-    const MethodMeta* setter() const {
-        return (this->hasSetter()) ? (this->hasGetter() ? method2.valuePtr() : method1.valuePtr()) : nullptr;
-    }
-
-    bool isImplementedInClass(Class klass, bool isStatic) const {
-        bool getterAvailable = this->hasGetter() && this->getter()->isImplementedInClass(klass, isStatic);
-        bool setterAvailable = this->hasSetter() && this->setter()->isImplementedInClass(klass, isStatic);
-        return getterAvailable || setterAvailable;
-    }
-
-    bool isAvailableInClass(Class klass, bool isStatic) const {
-        return this->isAvailable() && this->isImplementedInClass(klass, isStatic);
-    }
-
-    bool isAvailableInClasses(KnownUnknownClassPair klasses, bool isStatic) const {
-        return this->isAvailableInClass(klasses.known, isStatic) || (klasses.unknown != nullptr && this->isAvailableInClass(klasses.unknown, isStatic));
-    }
-};
-
-struct BaseClassMeta : Meta {
-
-    PtrTo<ArrayOfPtrTo<MethodMeta>> instanceMethods;
-    PtrTo<ArrayOfPtrTo<MethodMeta>> staticMethods;
-    PtrTo<ArrayOfPtrTo<PropertyMeta>> instanceProps;
-    PtrTo<ArrayOfPtrTo<PropertyMeta>> staticProps;
-    PtrTo<Array<String>> protocols;
-    int16_t initializersStartIndex;
-
-    template <typename T>
-    void forEachProtocol(const T& fun, const ProtocolMetas* additionalProtocols) const {
-        for (Array<String>::iterator it = this->protocols->begin(); it != this->protocols->end(); ++it) {
-            if (const ProtocolMeta* protocolMeta = MetaFile::instance()->globalTableJs()->findProtocol((*it).valuePtr())) {
-                fun(protocolMeta);
-            }
-        }
-
-        if (additionalProtocols) {
-            for (const ProtocolMeta* protocolMeta : *additionalProtocols) {
-                fun(protocolMeta);
-            }
-        }
-    }
-
-    std::set<const ProtocolMeta*> protocolsSet() const;
-
-    std::set<const ProtocolMeta*> deepProtocolsSet() const;
-
-    void deepProtocolsSet(std::set<const ProtocolMeta*>& protocols) const;
-
-    const MemberMeta* member(const char* identifier, size_t length, MemberType type, bool includeProtocols, bool onlyIfAvailable, const ProtocolMetas& additionalProtocols) const;
-
-    const MethodMeta* member(const char* identifier, size_t length, MemberType type, size_t paramsCount, bool includeProtocols, bool onlyIfAvailable, const ProtocolMetas& additionalProtocols) const;
-
-    const MembersCollection members(const char* identifier, size_t length, MemberType type, bool includeProtocols, bool onlyIfAvailable, const ProtocolMetas& additionalProtocols) const;
-
-    const MemberMeta* member(const char* identifier, MemberType type, bool includeProtocols, const ProtocolMetas& additionalProtocols) const {
-        return this->member(identifier, strlen(identifier), type, includeProtocols, /*onlyIfAvailable*/ true, additionalProtocols);
-    }
-
-    /// instance methods
-
-    // Remove all optional methods/properties which are not implemented in the class
-    template <typename TMemberMeta>
-    static void filterUnavailableMembers(MembersCollection& members, KnownUnknownClassPair klasses, bool isStatic) {
-        for (auto it{members.begin()}, end{members.end()}; it != end;) {
-            const MemberMeta* memberMeta = *it;
-            bool isAvailable = static_cast<const TMemberMeta*>(memberMeta)->isAvailableInClasses(klasses, isStatic);
-            if (!isAvailable) {
-                it = members.erase(it);
-            }
-            else {
-                ++it;
-            }
-        }
-    }
-
-    /// instance properties
-    const PropertyMeta* instanceProperty(const char* identifier, KnownUnknownClassPair klasses, bool includeProtocols, const ProtocolMetas& additionalProtocols) const {
-        auto propMeta = static_cast<const PropertyMeta*>(this->member(identifier, MemberType::InstanceProperty, includeProtocols, additionalProtocols));
-        return propMeta && propMeta->isAvailableInClasses(klasses, /*isStatic*/ false) ? propMeta : nullptr;
-    }
-
-    /// static properties
-    const PropertyMeta* staticProperty(const char* identifier, KnownUnknownClassPair klasses, bool includeProtocols, const ProtocolMetas& additionalProtocols) const {
-        auto propMeta = static_cast<const PropertyMeta*>(this->member(identifier, MemberType::StaticProperty, includeProtocols, additionalProtocols));
-        return propMeta && propMeta->isAvailableInClasses(klasses, /*isStatic*/ true) ? propMeta : nullptr;
-    }
-
-    /// vectors
-    std::vector<const PropertyMeta*> instanceProperties(KnownUnknownClassPair klasses) const {
-        std::vector<const PropertyMeta*> properties;
-        return this->instanceProperties(properties, klasses);
-    }
-
-    std::vector<const PropertyMeta*> instancePropertiesWithProtocols(KnownUnknownClassPair klasses, const ProtocolMetas& additionalProtocols) const {
-        std::vector<const PropertyMeta*> properties;
-        return this->instancePropertiesWithProtocols(properties, klasses, additionalProtocols);
-    }
-
-    std::vector<const PropertyMeta*> instanceProperties(std::vector<const PropertyMeta*>& container, KnownUnknownClassPair klasses) const {
-        for (Array<PtrTo<PropertyMeta>>::iterator it = this->instanceProps->begin(); it != this->instanceProps->end(); it++) {
-            if ((*it)->isAvailableInClasses(klasses, /*isStatic*/ false)) {
-                container.push_back((*it).valuePtr());
-            }
-        }
-        return container;
-    }
-
-    std::vector<const PropertyMeta*> instancePropertiesWithProtocols(std::vector<const PropertyMeta*>& container, KnownUnknownClassPair klasses, const ProtocolMetas& additionalProtocols) const;
-
-    std::vector<const PropertyMeta*> staticProperties(KnownUnknownClassPair klasses) const {
-        std::vector<const PropertyMeta*> properties;
-        return this->staticProperties(properties, klasses);
-    }
-
-    std::vector<const PropertyMeta*> staticPropertiesWithProtocols(KnownUnknownClassPair klasses, const ProtocolMetas& additionalProtocols) const {
-        std::vector<const PropertyMeta*> properties;
-        return this->staticPropertiesWithProtocols(properties, klasses, additionalProtocols);
-    }
-
-    std::vector<const PropertyMeta*> staticProperties(std::vector<const PropertyMeta*>& container, KnownUnknownClassPair klasses) const {
-        for (Array<PtrTo<PropertyMeta>>::iterator it = this->staticProps->begin(); it != this->staticProps->end(); it++) {
-            if ((*it)->isAvailableInClasses(klasses, /*isStatic*/ true)) {
-                container.push_back((*it).valuePtr());
-            }
-        }
-        return container;
-    }
-
-    std::vector<const PropertyMeta*> staticPropertiesWithProtocols(std::vector<const PropertyMeta*>& container, KnownUnknownClassPair klasses, const ProtocolMetas& additionalProtocols) const;
-
-    std::vector<const MethodMeta*> initializers(KnownUnknownClassPair klasses) const {
-        std::vector<const MethodMeta*> initializers;
-        return this->initializers(initializers, klasses);
-    }
-
-    std::vector<const MethodMeta*> initializersWithProtocols(KnownUnknownClassPair klasses, const ProtocolMetas& additionalProtocols) const {
-        std::vector<const MethodMeta*> initializers;
-        return this->initializersWithProtocols(initializers, klasses, additionalProtocols);
-    }
-
-    std::vector<const MethodMeta*> initializers(std::vector<const MethodMeta*>& container, KnownUnknownClassPair klasses) const;
-
-    std::vector<const MethodMeta*> initializersWithProtocols(std::vector<const MethodMeta*>& container, KnownUnknownClassPair klasses, const ProtocolMetas& additionalProtocols) const;
-};
-
-struct ProtocolMeta : BaseClassMeta {
-};
-
-struct InterfaceMeta : BaseClassMeta {
-
-private:
-    String _baseName;
-
-public:
-    const char* baseName() const {
-        return _baseName.valuePtr();
-    }
-
-    const InterfaceMeta* baseMeta() const {
-        if (this->baseName() != nullptr) {
-            const InterfaceMeta* baseMeta = MetaFile::instance()->globalTableJs()->findInterfaceMeta(this->baseName());
-            return baseMeta;
-        }
-
-        return nullptr;
-    }
-};
-
-#pragma pack(pop)
-
-} // namespace tns
-
-#include "MetadataInlines.h"
-
-#endif /* Metadata_h */