MetadataNode.cpp

#include "MetadataNode.h"
#include "RuntimeState.h"
#include "NativeScriptAssert.h"
#include "Constants.h"
#include "Util.h"
#include "V8GlobalHelpers.h"
#include "ArgConverter.h"
#include "V8StringConstants.h"
#include "SimpleProfiler.h"
#include "CallbackHandlers.h"
#include "NativeScriptException.h"
#include "Runtime.h"
#include <sstream>
#include <cctype>
#include <dirent.h>
#include <errno.h>
#include <android/log.h>
#include <unistd.h>
#include "ManualInstrumentation.h"
#include "JSONObjectHelper.h"



#include "v8.h"

using namespace v8;
using namespace std;
using namespace tns;

void MetadataNode::Init(Isolate* isolate) {
    auto key = ArgConverter::ConvertToV8String(isolate, "tns::MetadataKey");
    auto cache = GetMetadataNodeCache(isolate);
    cache->MetadataKey = new Persistent<String>(isolate, key);
    cache->PackageKey = new Persistent<String>(
        isolate, ArgConverter::ConvertToV8String(isolate, "tns::PackageKey"));
}

// Deliberately not V8GetPrivateValue: that one resolves the creation context,
// which hard-crashes on values that have none (a revoked proxy), and throws
// when the lookup comes back Nothing. Callers here take arbitrary values, so a
// failed read must also leave no exception pending for whoever calls next.
static void* TryReadPrivateExternal(Isolate* isolate, const Local<Object>& value, Persistent<String>* key) {
    if (key == nullptr) {
        return nullptr;
    }

    auto context = isolate->GetCurrentContext();
    if (context.IsEmpty()) {
        return nullptr;
    }

    TryCatch tc(isolate);
    Local<Value> hidden;
    auto privateKey = Private::ForApi(isolate, Local<String>::New(isolate, *key));
    if (!value->GetPrivate(context, privateKey).ToLocal(&hidden) || !hidden->IsExternal()) {
        tc.Reset();
        return nullptr;
    }

    return hidden.As<External>()->Value(v8::kExternalPointerTypeTagDefault);
}

bool MetadataNode::TryGetInstanceTypeName(Isolate* isolate, const Local<Object>& value, std::string& out) {
    auto cache = GetMetadataNodeCache(isolate);
    auto node = static_cast<MetadataNode*>(TryReadPrivateExternal(isolate, value, cache->MetadataKey));
    if (node == nullptr) {
        return false;
    }

    out = node->m_name;
    return true;
}

bool MetadataNode::TryGetPackageName(Isolate* isolate, const Local<Object>& value, std::string& out) {
    auto cache = GetMetadataNodeCache(isolate);
    auto node = static_cast<MetadataNode*>(TryReadPrivateExternal(isolate, value, cache->PackageKey));
    if (node == nullptr) {
        return false;
    }

    out = node->m_name;
    return true;
}

Local<ObjectTemplate> MetadataNode::GetOrCreateArrayObjectTemplate(Isolate* isolate) {
    auto cache = GetMetadataNodeCache(isolate);
    if (cache->ArrayObjectTemplate != nullptr) {
        return cache->ArrayObjectTemplate->Get(isolate);
    }

    auto arrayObjectTemplate = ObjectTemplate::New(isolate);
    arrayObjectTemplate->SetInternalFieldCount(static_cast<int>(ObjectManager::MetadataNodeKeys::END));
    arrayObjectTemplate->SetHandler(IndexedPropertyHandlerConfiguration(
            ArrayIndexedPropertyGetterCallback, ArrayIndexedPropertySetterCallback));

    cache->ArrayObjectTemplate = new Persistent<ObjectTemplate>(isolate, arrayObjectTemplate);

    return arrayObjectTemplate;
}

MetadataNode::MetadataNode(MetadataTreeNode* treeNode) :
    m_treeNode(treeNode) {
    uint8_t nodeType = s_metadataReader.GetNodeType(treeNode);

    m_name = s_metadataReader.ReadTypeName(m_treeNode);

    uint8_t parentNodeType = s_metadataReader.GetNodeType(treeNode->parent);

    m_isArray = s_metadataReader.IsNodeTypeArray(parentNodeType);

    bool isInterface = s_metadataReader.IsNodeTypeInterface(nodeType);

    if (!m_isArray && isInterface) {
        bool isPrefix;
        auto impTypeName = s_metadataReader.ReadInterfaceImplementationTypeName(m_treeNode, isPrefix);
        m_implType = isPrefix
                     ? (impTypeName + m_name)
                     :
                     impTypeName;
    }
}

Local<Object> MetadataNode::CreateExtendedJSWrapper(Isolate* isolate, ObjectManager* objectManager, const string& proxyClassName) {
    Local<Object> extInstance;

    auto cacheData = GetCachedExtendedClassData(isolate, proxyClassName);
    if (cacheData.node != nullptr) {
        extInstance = objectManager->GetEmptyObject(isolate);
        extInstance->SetInternalField(static_cast<int>(ObjectManager::MetadataNodeKeys::CallSuper), True(isolate));
        auto extdCtorFunc = Local<Function>::New(isolate, *cacheData.extendedCtorFunction);
        auto context = Runtime::GetRuntime(isolate)->GetContext();
        extInstance->SetPrototype(context, extdCtorFunc->Get(context, V8StringConstants::GetPrototype(isolate)).ToLocalChecked());
        extInstance->Set(context, ArgConverter::ConvertToV8String(isolate, "constructor"), extdCtorFunc);

        SetInstanceMetadata(isolate, extInstance, cacheData.node);
    }

    return extInstance;
}

/*
 * The three caches below are process-wide and reached from every runtime's
 * thread -- GetOrCreate runs on every JS-wrapper creation -- so each access is
 * guarded. The lock covers map access only: it is dropped around the metadata
 * reader, which takes its own lock and, for a type absent from the static
 * metadata, calls into Java to resolve it.
 *
 * Losing the race is therefore possible and handled at the insert: the entry
 * already in the map is the one other threads have been handed, so it wins.
 */
MetadataNode* MetadataNode::GetOrCreate(const string& className) {
    {
        std::lock_guard<std::mutex> lock(s_nodeCacheMutex);
        auto it = s_name2NodeCache.find(className);
        if (it != s_name2NodeCache.end()) {
            return it->second;
        }
    }

    MetadataTreeNode* treeNode = GetOrCreateTreeNodeByName(className);
    MetadataNode* node = GetOrCreateInternal(treeNode);

    std::lock_guard<std::mutex> lock(s_nodeCacheMutex);
    return s_name2NodeCache.emplace(className, node).first->second;
}

MetadataNode* MetadataNode::GetOrCreateInternal(MetadataTreeNode* treeNode) {
    {
        std::lock_guard<std::mutex> lock(s_nodeCacheMutex);
        auto it = s_treeNode2NodeCache.find(treeNode);
        if (it != s_treeNode2NodeCache.end()) {
            return it->second;
        }
    }

    // Constructed outside the lock: the constructor reads type names out of the
    // metadata reader.
    auto* candidate = new MetadataNode(treeNode);

    std::lock_guard<std::mutex> lock(s_nodeCacheMutex);
    auto inserted = s_treeNode2NodeCache.emplace(treeNode, candidate);
    if (!inserted.second) {
        delete candidate;
    }

    return inserted.first->second;
}

MetadataTreeNode* MetadataNode::GetOrCreateTreeNodeByName(const string& className) {
    {
        std::lock_guard<std::mutex> lock(s_nodeCacheMutex);
        auto itFound = s_name2TreeNodeCache.find(className);
        if (itFound != s_name2TreeNodeCache.end()) {
            return itFound->second;
        }
    }

    MetadataTreeNode* result = s_metadataReader.GetOrCreateTreeNodeByName(className);

    std::lock_guard<std::mutex> lock(s_nodeCacheMutex);
    return s_name2TreeNodeCache.emplace(className, result).first->second;
}

string MetadataNode::GetName() {
    return m_name;
}

bool MetadataNode::IsNodeTypeInterface() {
    uint8_t nodeType = s_metadataReader.GetNodeType(m_treeNode);
    return s_metadataReader.IsNodeTypeInterface(nodeType);
}

string MetadataNode::GetTypeMetadataName(Isolate* isolate, Local<Value>& value) {
    auto data = GetTypeMetadata(isolate, value.As<Function>());

    return data->name;
}

Local<Object> MetadataNode::CreateWrapper(Isolate* isolate) {
    EscapableHandleScope handle_scope(isolate);

    Local<Object> obj;

    uint8_t nodeType = s_metadataReader.GetNodeType(m_treeNode);

    bool isClass = s_metadataReader.IsNodeTypeClass(nodeType),
         isInterface = s_metadataReader.IsNodeTypeInterface(nodeType);

    if (isClass || isInterface) {
        obj = GetConstructorFunction(isolate);
    } else if (s_metadataReader.IsNodeTypePackage(nodeType)) {
        obj = CreatePackageObject(isolate);
    } else {
        stringstream ss;
        ss << "(InternalError): Can't create proxy for this type=" << static_cast<int>(nodeType);
        throw NativeScriptException(ss.str());
    }

    return handle_scope.Escape(obj);
}

Local<Object> MetadataNode::CreateJSWrapper(Isolate* isolate, ObjectManager* objectManager) {
    Local<Object> obj;

    if (m_isArray) {
        obj = CreateArrayWrapper(isolate);
    } else {
        obj = objectManager->GetEmptyObject(isolate);
        if (!obj.IsEmpty()) {
            auto ctorFunc = GetConstructorFunction(isolate);
            auto context = isolate->GetCurrentContext();
            obj->Set(context, ArgConverter::ConvertToV8String(isolate, "constructor"), ctorFunc);
            obj->SetPrototype(context, ctorFunc->Get(context, V8StringConstants::GetPrototype(isolate)).ToLocalChecked());
            SetInstanceMetadata(isolate, obj, this);
        }
    }

    return obj;
}

void MetadataNode::ArrayLengthGetterCallack(Local<Name> property, const PropertyCallbackInfo<Value>& info) {
    try {
        auto thiz = info.Holder();
        auto isolate = info.GetIsolate();
        auto length = CallbackHandlers::GetArrayLength(isolate, thiz);
        info.GetReturnValue().Set(length);
    } catch (NativeScriptException& e) {
        e.ReThrowToV8();
    } catch (std::exception e) {
        stringstream ss;
        ss << "Error: c++ exception: " << e.what() << endl;
        NativeScriptException nsEx(ss.str());
        nsEx.ReThrowToV8();
    } catch (...) {
        NativeScriptException nsEx(std::string("Error: c++ exception!"));
        nsEx.ReThrowToV8();
    }
}

Local<Object> MetadataNode::CreateArrayWrapper(Isolate* isolate) {
    auto node = GetOrCreate("java/lang/Object");
    auto ctorFunc = node->GetConstructorFunction(isolate);

    auto arrayObjectTemplate = GetOrCreateArrayObjectTemplate(isolate);

    auto context = isolate->GetCurrentContext();
    auto arr = arrayObjectTemplate->NewInstance(context).ToLocalChecked();
    arr->SetPrototype(context, ctorFunc->Get(context, V8StringConstants::GetPrototype(isolate)).ToLocalChecked());
    arr->SetNativeDataProperty(context, ArgConverter::ConvertToV8String(isolate, "length"),
                               ArrayLengthGetterCallack, nullptr, Local<Value>(),
                               PropertyAttribute::DontDelete).ToChecked();

    SetInstanceMetadata(isolate, arr, this);

    return arr;
}

Local<Object> MetadataNode::CreatePackageObject(Isolate* isolate) {
    auto packageObj = Object::New(isolate);
    auto ctx = isolate->GetCurrentContext();
    auto extData = External::New(isolate, this, v8::kExternalPointerTypeTagDefault);

    // Every child is a native data property, so anything that reads a property
    // descriptor off a package object - console formatting, most notably -
    // would materialize the whole subtree. The marker lets such callers
    // recognize a package and stop.
    auto cache = GetMetadataNodeCache(isolate);
    packageObj->SetPrivate(ctx,
                           Private::ForApi(isolate, Local<String>::New(isolate, *cache->PackageKey)),
                           extData).ToChecked();

    auto ptrChildren = this->m_treeNode->children;
    if (ptrChildren != nullptr) {
        const auto& children = *ptrChildren;
        for (auto childNode: children) {
            packageObj->SetNativeDataProperty(ctx,
                                              ArgConverter::ConvertToV8String(isolate, childNode->name),
                                              PackageGetterCallback,
                                              nullptr,
                                              extData).ToChecked();
        }
    }

    return packageObj;
}

void MetadataNode::SetClassAccessor(Local<Function>& ctorFunction) {
    auto isolate = v8::Isolate::GetCurrent();
    auto classFieldName = ArgConverter::ConvertToV8String(isolate, "class");
    auto context = isolate->GetCurrentContext();
    auto classGetter = FunctionTemplate::New(isolate, ClassAccessorGetterCallback)
                           ->GetFunction(context).ToLocalChecked();
    ctorFunction->SetAccessorProperty(classFieldName, classGetter, Local<Function>(),
                                      PropertyAttribute::DontDelete);
}

void MetadataNode::ClassAccessorGetterCallback(const FunctionCallbackInfo<Value>& info) {
    try {
        auto thiz = info.This();
        auto isolate = info.GetIsolate();
        auto data = GetTypeMetadata(isolate, thiz.As<Function>());

        auto value = CallbackHandlers::FindClass(isolate, data->name);
        info.GetReturnValue().Set(value);
    } catch (NativeScriptException& e) {
        e.ReThrowToV8();
    } catch (std::exception e) {
        stringstream ss;
        ss << "Error: c++ exception: " << e.what() << endl;
        NativeScriptException nsEx(ss.str());
        nsEx.ReThrowToV8();
    } catch (...) {
        NativeScriptException nsEx(std::string("Error: c++ exception!"));
        nsEx.ReThrowToV8();
    }
}

void MetadataNode::NullObjectAccessorGetterCallback(const FunctionCallbackInfo<Value>& info) {
    try {
        DEBUG_WRITE("NullObjectAccessorGetterCallback called");
        auto isolate = info.GetIsolate();

        auto thiz = info.This();
        Local<Value> hiddenVal;
        V8GetPrivateValue(isolate, thiz, V8StringConstants::GetNullNodeName(isolate), hiddenVal);
        if (hiddenVal.IsEmpty()) {
            auto node = reinterpret_cast<MetadataNode*>(info.Data().As<External>()->Value(v8::kExternalPointerTypeTagDefault));
            V8SetPrivateValue(isolate, thiz, V8StringConstants::GetNullNodeName(isolate), External::New(isolate, node, v8::kExternalPointerTypeTagDefault));
            auto funcTemplate = FunctionTemplate::New(isolate, MetadataNode::NullValueOfCallback);
            auto context = isolate->GetCurrentContext();
            thiz->Delete(context, V8StringConstants::GetValueOf(isolate));
            thiz->Set(context, V8StringConstants::GetValueOf(isolate), funcTemplate->GetFunction(context).ToLocalChecked());
        }

        info.GetReturnValue().Set(thiz);
    } catch (NativeScriptException& e) {
        e.ReThrowToV8();
    } catch (std::exception e) {
        stringstream ss;
        ss << "Error: c++ exception: " << e.what() << endl;
        NativeScriptException nsEx(ss.str());
        nsEx.ReThrowToV8();
    } catch (...) {
        NativeScriptException nsEx(std::string("Error: c++ exception!"));
        nsEx.ReThrowToV8();
    }
}

void MetadataNode::NullValueOfCallback(const FunctionCallbackInfo<Value>& args) {
    try {
        auto isolate = args.GetIsolate();
        args.GetReturnValue().SetNull();
    } catch (NativeScriptException& e) {
        e.ReThrowToV8();
    } catch (std::exception e) {
        stringstream ss;
        ss << "Error: c++ exception: " << e.what() << endl;
        NativeScriptException nsEx(ss.str());
        nsEx.ReThrowToV8();
    } catch (...) {
        NativeScriptException nsEx(std::string("Error: c++ exception!"));
        nsEx.ReThrowToV8();
    }
}

void MetadataNode::FieldAccessorGetterCallback(const FunctionCallbackInfo<Value>& info) {
    try {
        auto thiz = info.This();
        auto fieldCallbackData = reinterpret_cast<FieldCallbackData*>(info.Data().As<External>()->Value(v8::kExternalPointerTypeTagDefault));
        auto &fieldCallbackMetadata = fieldCallbackData->metadata;

        auto objectManager =
            Runtime::GetRuntime(info.GetIsolate())->GetObjectManager();
        if ((!fieldCallbackMetadata.isStatic &&
             !objectManager->IsJsRuntimeObject(thiz))
                // check whether there's a declaring type to get the class from it
                || (fieldCallbackMetadata.getDeclaringType() == "")) {
            info.GetReturnValue().SetUndefined();
            return;
        }

        auto isolate = info.GetIsolate();
        auto value = CallbackHandlers::GetJavaField(isolate, thiz, fieldCallbackData);
        info.GetReturnValue().Set(value);
    } catch (NativeScriptException& e) {
        e.ReThrowToV8();
    } catch (std::exception e) {
        stringstream ss;
        ss << "Error: c++ exception: " << e.what() << endl;
        NativeScriptException nsEx(ss.str());
        nsEx.ReThrowToV8();
    } catch (...) {
        NativeScriptException nsEx(std::string("Error: c++ exception!"));
        nsEx.ReThrowToV8();
    }
}
void MetadataNode::FieldAccessorSetterCallback(const FunctionCallbackInfo<Value>& info) {
    auto value = info[0];
    try {
        auto thiz = info.This();
        auto fieldCallbackData = reinterpret_cast<FieldCallbackData*>(info.Data().As<External>()->Value(v8::kExternalPointerTypeTagDefault));
        auto &fieldCallbackMetadata = fieldCallbackData->metadata;

        auto objectManager =
            Runtime::GetRuntime(info.GetIsolate())->GetObjectManager();
        if (!fieldCallbackMetadata.isStatic &&
            !objectManager->IsJsRuntimeObject(thiz)) {
            auto isolate = info.GetIsolate();
            info.GetReturnValue().Set(v8::Undefined(isolate));
            return;
        }

        if (fieldCallbackMetadata.getIsFinal()) {
            stringstream ss;
            ss << "You are trying to set \"" << fieldCallbackMetadata.getName() << "\" which is a final field! Final fields can only be read.";
            string exceptionMessage = ss.str();

            throw NativeScriptException(exceptionMessage);
        } else {
            auto isolate = info.GetIsolate();
            CallbackHandlers::SetJavaField(isolate, thiz, value, fieldCallbackData);
            info.GetReturnValue().Set(value);
        }
    } catch (NativeScriptException& e) {
        e.ReThrowToV8();
    } catch (std::exception e) {
        stringstream ss;
        ss << "Error: c++ exception: " << e.what() << endl;
        NativeScriptException nsEx(ss.str());
        nsEx.ReThrowToV8();
    } catch (...) {
        NativeScriptException nsEx(std::string("Error: c++ exception!"));
        nsEx.ReThrowToV8();
    }
}

void MetadataNode::PropertyAccessorGetterCallback(const FunctionCallbackInfo<Value>& info) {
    try {
        auto isolate = info.GetIsolate();
        auto context = isolate->GetCurrentContext();
        auto thiz = info.This();
        auto propertyCallbackData = reinterpret_cast<PropertyCallbackData*>(info.Data().As<External>()->Value(v8::kExternalPointerTypeTagDefault));

        std::string getterMethodName = propertyCallbackData->getterMethodName;
        if(getterMethodName == ""){
            throw NativeScriptException("Missing getter method for property: " + propertyCallbackData->propertyName);
        }

        auto getter = thiz->Get(context, v8::String::NewFromUtf8(isolate, getterMethodName.c_str()).ToLocalChecked()).ToLocalChecked();
        auto value = getter.As<Function>()->Call(context, thiz, 0, nullptr).ToLocalChecked();
        info.GetReturnValue().Set(value);
    } catch (NativeScriptException& e) {
        e.ReThrowToV8();
    } catch (std::exception e) {
        stringstream ss;
        ss << "Error: c++ exception: " << e.what() << endl;
        NativeScriptException nsEx(ss.str());
        nsEx.ReThrowToV8();
    } catch (...) {
        NativeScriptException nsEx(std::string("Error: c++ exception!"));
        nsEx.ReThrowToV8();
    }
}
void MetadataNode::PropertyAccessorSetterCallback(const FunctionCallbackInfo<Value>& info) {
    Local<Value> value = info[0];
    try {
        auto isolate = info.GetIsolate();
        auto context = isolate->GetCurrentContext();
        auto thiz = info.This();
        auto propertyCallbackData = reinterpret_cast<PropertyCallbackData*>(info.Data().As<External>()->Value(v8::kExternalPointerTypeTagDefault));

        std::string setterMethodName = propertyCallbackData->setterMethodName;
        if(setterMethodName == ""){
            throw NativeScriptException("Missing setter method for property: " + propertyCallbackData->propertyName);
        }

        auto setter = thiz->Get(context, v8::String::NewFromUtf8(isolate, setterMethodName.c_str()).ToLocalChecked()).ToLocalChecked();
        setter.As<Function>()->Call(context, thiz, 1, &value).ToLocalChecked();
        info.GetReturnValue().Set(value);
    } catch (NativeScriptException& e) {
        e.ReThrowToV8();
    } catch (std::exception e) {
        stringstream ss;
        ss << "Error: c++ exception: " << e.what() << endl;
        NativeScriptException nsEx(ss.str());
        nsEx.ReThrowToV8();
    } catch (...) {
        NativeScriptException nsEx(std::string("Error: c++ exception!"));
        nsEx.ReThrowToV8();
    }
}

void MetadataNode::SuperAccessorGetterCallback(const FunctionCallbackInfo<Value>& info) {
    try {
        auto thiz = info.This();
        auto isolate = info.GetIsolate();
        auto key = ArgConverter::ConvertToV8String(isolate, "supervalue");
        Local<Value> hidenVal;
        V8GetPrivateValue(isolate, thiz, key, hidenVal);
        auto superValue = hidenVal.As<Object>();

        if (superValue.IsEmpty()) {
            auto runtime = Runtime::GetRuntime(isolate);
            auto objectManager = runtime->GetObjectManager();
            auto context = isolate->GetCurrentContext();

            superValue = objectManager->GetEmptyObject(isolate);
            superValue->Delete(context, V8StringConstants::GetToString(isolate));
            superValue->Delete(context, V8StringConstants::GetValueOf(isolate));
            superValue->SetInternalField(static_cast<int>(ObjectManager::MetadataNodeKeys::CallSuper), True(isolate));

            superValue->SetPrototype(context, thiz->GetPrototype().As<Object>()->GetPrototype().As<Object>()->GetPrototype());
            V8SetPrivateValue(isolate, thiz, key, superValue);
            objectManager->CloneLink(thiz, superValue);

            DEBUG_WRITE("superValue.GetPrototype=%d", superValue->GetPrototype().As<Object>()->GetIdentityHash());

            auto node = GetInstanceMetadata(isolate, thiz);
            SetInstanceMetadata(isolate, superValue, node);
        }

        info.GetReturnValue().Set(superValue);
    } catch (NativeScriptException& e) {
        e.ReThrowToV8();
    } catch (std::exception e) {
        stringstream ss;
        ss << "Error: c++ exception: " << e.what() << endl;
        NativeScriptException nsEx(ss.str());
        nsEx.ReThrowToV8();
    } catch (...) {
        NativeScriptException nsEx(std::string("Error: c++ exception!"));
        nsEx.ReThrowToV8();
    }
}

class MetadataNode::PrototypeTemplateFiller {
public:
    explicit PrototypeTemplateFiller(Local<ObjectTemplate> protoTemplate)
        : m_protoTemplate(protoTemplate) {}

    void FillPrototypeMethod(Isolate *isolate, const std::string& name,
                             MethodCallbackData* methodInfo) {
        if (m_addedNames.count(name) != 0) {
            DEBUG_WRITE("Not defining method prototype.%s which has already been added", name.c_str());
            return;
        }

        Local<External> funcData = External::New(isolate, methodInfo, v8::kExternalPointerTypeTagDefault);
        Local<FunctionTemplate> funcTemplate = FunctionTemplate::New(isolate, MetadataNode::MethodCallback, funcData);
        Local<String> nameString = ArgConverter::ConvertToV8String(isolate, name);
        m_protoTemplate->Set(nameString, funcTemplate);
        m_addedNames.insert(name);
    }

    void FillPrototypeField(Isolate* isolate, const std::string& name,
                            FieldCallbackData* fieldInfo) {
        if (m_addedNames.count(name) != 0) {
            DEBUG_WRITE("Not defining field prototype.%s which already exists", name.c_str());
            return;
        }

        Local<External> fieldData = External::New(isolate, fieldInfo, v8::kExternalPointerTypeTagDefault);
        Local<Name> nameString = ArgConverter::ConvertToV8String(isolate, name);
        m_protoTemplate->SetAccessorProperty(
                nameString,
                FunctionTemplate::New(isolate, MetadataNode::FieldAccessorGetterCallback, fieldData),
                FunctionTemplate::New(isolate, MetadataNode::FieldAccessorSetterCallback, fieldData),
                PropertyAttribute::DontDelete);
        m_addedNames.insert(name);
    }

    void FillPrototypeProperty(Isolate* isolate, const std::string& name,
                               PropertyCallbackData* propertyInfo) {
        if (m_addedNames.count(name) != 0) {
            DEBUG_WRITE("Not defining property prototype.%s which already exists", name.c_str());
            return;
        }

        Local<External> propertyData = External::New(isolate, propertyInfo, v8::kExternalPointerTypeTagDefault);
        Local<Name> nameString = ArgConverter::ConvertToV8String(isolate, name);
        m_protoTemplate->SetAccessorProperty(
                nameString,
                FunctionTemplate::New(isolate, MetadataNode::PropertyAccessorGetterCallback, propertyData),
                FunctionTemplate::New(isolate, MetadataNode::PropertyAccessorSetterCallback, propertyData),
                PropertyAttribute::DontDelete);
        m_addedNames.insert(name);
    }

private:
    Local<ObjectTemplate> m_protoTemplate;
    std::unordered_set<std::string> m_addedNames;
};

std::vector<MetadataNode::MethodCallbackData*> MetadataNode::SetInstanceMembers(
        Isolate* isolate, Local<FunctionTemplate>& ctorFuncTemplate,
        PrototypeTemplateFiller& protoFiller,
        vector<MethodCallbackData*>& instanceMethodsCallbackData,
        const vector<MethodCallbackData*>& baseInstanceMethodsCallbackData,
        MetadataTreeNode* treeNode, uint8_t* &curPtr) {
    auto hasCustomMetadata = treeNode->metadata != nullptr;

    if (hasCustomMetadata) {
        return SetInstanceMembersFromRuntimeMetadata(
            isolate, protoFiller, instanceMethodsCallbackData,
            baseInstanceMethodsCallbackData, treeNode);
    }

    return SetInstanceMethodsFromStaticMetadata(
        isolate, ctorFuncTemplate, protoFiller, instanceMethodsCallbackData,
        baseInstanceMethodsCallbackData, treeNode, curPtr);
}

vector<MetadataNode::MethodCallbackData *> MetadataNode::SetInstanceMethodsFromStaticMetadata(
        Isolate *isolate, Local<FunctionTemplate> &ctorFuncTemplate,
        PrototypeTemplateFiller& protoFiller,
        vector<MethodCallbackData *> &instanceMethodsCallbackData,
        const vector<MethodCallbackData *> &baseInstanceMethodsCallbackData,
        MetadataTreeNode *treeNode, uint8_t* &curPtr) {
    SET_PROFILER_FRAME();

    std::vector<MethodCallbackData *> instanceMethodData;

    curPtr = s_metadataReader.GetValueData() + treeNode->offsetValue + 1;

    auto nodeType = s_metadataReader.GetNodeType(treeNode);

    auto curType = s_metadataReader.ReadTypeName(treeNode);

    curPtr += sizeof(uint16_t /* baseClassId */);

    if (s_metadataReader.IsNodeTypeInterface(nodeType)) {
        curPtr += sizeof(uint8_t) + sizeof(uint32_t);
    }

    string lastMethodName;
    MethodCallbackData *callbackData = nullptr;

    auto context = isolate->GetCurrentContext();
    auto cache = GetMetadataNodeCache(isolate);

    robin_hood::unordered_map<std::string, MethodCallbackData *> collectedExtensionMethodDatas;

    auto extensionFunctionsCount = *reinterpret_cast<uint16_t *>(curPtr);
    curPtr += sizeof(uint16_t);
    for (auto i = 0; i < extensionFunctionsCount; i++) {
        auto entry = MetadataReader::ReadExtensionFunctionEntry(&curPtr);

        auto &methodName = entry.getName();
        if (methodName!= lastMethodName) {
            //
            callbackData = tryGetExtensionMethodCallbackData(collectedExtensionMethodDatas,
                                                             methodName);
            if (callbackData == nullptr) {
                callbackData = cache->Own<MethodCallbackData>(this);
                protoFiller.FillPrototypeMethod(isolate, methodName, callbackData);

                lastMethodName = methodName;
                std::pair<std::string, MethodCallbackData *> p(methodName, callbackData);
                collectedExtensionMethodDatas.emplace(p);
            }
        }
        callbackData->candidates.push_back(std::move(entry));
    }


    //get candidates from instance methods metadata
    auto instanceMethodCount = *reinterpret_cast<uint16_t *>(curPtr);
    curPtr += sizeof(uint16_t);

    for (auto i = 0; i < instanceMethodCount; i++) {
        auto entry = MetadataReader::ReadInstanceMethodEntry(&curPtr);

        // attach a function to the prototype of a javascript Object
        auto &methodName = entry.getName();
        if (methodName != lastMethodName) {
            // See if we have tracked the callback data before (meaning another version of entry.name exists with different parameters)
            callbackData = tryGetExtensionMethodCallbackData(collectedExtensionMethodDatas,
                                                             methodName);
            if (callbackData == nullptr) {
                callbackData = cache->Own<MethodCallbackData>(this);

                // If we have no tracking of this callback data, create tracking so that we can find it if need be for future itterations where the entry.name is the same...
                std::pair<std::string, MethodCallbackData *> p(methodName, callbackData);
                collectedExtensionMethodDatas.emplace(p);
            }

            instanceMethodData.push_back(callbackData);

            instanceMethodsCallbackData.push_back(callbackData);
            auto itBegin = baseInstanceMethodsCallbackData.begin();
            auto itEnd = baseInstanceMethodsCallbackData.end();
            auto itFound = find_if(itBegin, itEnd, [&methodName](MethodCallbackData *x) {
                return x->candidates.front().name == methodName;
            });
            if (itFound != itEnd) {
                callbackData->parent = *itFound;
            }

            if (s_profilerEnabled.load(std::memory_order_relaxed)) {
                Local<External> funcData = External::New(isolate, callbackData, v8::kExternalPointerTypeTagDefault);
                Local<FunctionTemplate> funcTemplate = FunctionTemplate::New(isolate, MethodCallback, funcData);
                auto func = funcTemplate->GetFunction(context).ToLocalChecked();
                std::string origin = Constants::APP_ROOT_FOLDER_PATH + GetOrCreateInternal(treeNode)->m_name;
                Local<Function> wrapperFunc = Wrap(isolate, func, methodName, origin,
                                                   false /* isCtorFunc */);
                Local<Function> ctorFunc = ctorFuncTemplate->GetFunction(context).ToLocalChecked();
                Local<Value> protoVal;
                ctorFunc->Get(context,
                              ArgConverter::ConvertToV8String(isolate, "prototype")).ToLocal(
                        &protoVal);
                Local<String> funcName = ArgConverter::ConvertToV8String(isolate, methodName);
                if (!protoVal.IsEmpty() && !protoVal->IsUndefined() && !protoVal->IsNull()) {
                    protoVal.As<Object>()->Set(context, funcName, wrapperFunc);
                }
            } else {
                protoFiller.FillPrototypeMethod(isolate, methodName, callbackData);
            }

            lastMethodName = methodName;
        }

        callbackData->candidates.push_back(std::move(entry));
    }

    //get candidates from instance fields metadata
    auto instanceFieldCout = *reinterpret_cast<uint16_t*>(curPtr);
    curPtr += sizeof(uint16_t);
    for (auto i = 0; i < instanceFieldCout; i++) {
        auto entry = MetadataReader::ReadInstanceFieldEntry(&curPtr);
        auto fieldName = entry.getName();
        auto fieldInfo = cache->Own<FieldCallbackData>(entry);
        fieldInfo->metadata.declaringType = curType;
        protoFiller.FillPrototypeField(isolate, fieldName, fieldInfo);
    }

    auto kotlinPropertiesCount = *reinterpret_cast<uint16_t*>(curPtr);
    curPtr += sizeof(uint16_t);
    for (int i = 0; i < kotlinPropertiesCount; ++i) {
        uint32_t nameOffset = *reinterpret_cast<uint32_t*>(curPtr);
        string propertyName = s_metadataReader.ReadName(nameOffset);
        curPtr += sizeof(uint32_t);

        auto hasGetter = *reinterpret_cast<uint16_t*>(curPtr);
        curPtr += sizeof(uint16_t);

        std::string getterMethodName = "";
        if(hasGetter>=1){
            auto entry = MetadataReader::ReadInstanceMethodEntry(&curPtr);
            getterMethodName = entry.getName();
        }

        auto hasSetter = *reinterpret_cast<uint16_t*>(curPtr);
        curPtr += sizeof(uint16_t);

        std::string setterMethodName = "";
        if(hasSetter >= 1){
            auto entry = MetadataReader::ReadInstanceMethodEntry(&curPtr);
            setterMethodName = entry.getName();
        }

        auto propertyInfo = cache->Own<PropertyCallbackData>(propertyName, getterMethodName, setterMethodName);
        protoFiller.FillPrototypeProperty(isolate, propertyName, propertyInfo);
    }

    return instanceMethodData;
}

MetadataNode::MethodCallbackData *MetadataNode::tryGetExtensionMethodCallbackData(
        const robin_hood::unordered_map<std::string, MethodCallbackData *> &collectedMethodCallbackDatas,
        const std::string &lookupName) {

    if (collectedMethodCallbackDatas.empty()) {
        return nullptr;
    }

    auto iter = collectedMethodCallbackDatas.find(lookupName);

    if (iter != collectedMethodCallbackDatas.end()) {
        return iter->second;
    }

    return nullptr;
}


vector<MetadataNode::MethodCallbackData*> MetadataNode::SetInstanceMembersFromRuntimeMetadata(
        Isolate* isolate, PrototypeTemplateFiller& protoFiller,
        vector<MethodCallbackData*>& instanceMethodsCallbackData,
        const vector<MethodCallbackData*>& baseInstanceMethodsCallbackData,
        MetadataTreeNode* treeNode) {
    SET_PROFILER_FRAME();

    NS_DCHECK(treeNode->metadata != nullptr);

    std::vector<MethodCallbackData*> instanceMethodData;

    string line;
    const string& metadata = *treeNode->metadata;
    stringstream s(metadata);

    string kind;
    string name;
    string signature;
    int paramCount;

    getline(s, line); // type line
    getline(s, line); // base class line

    string lastMethodName;
    MethodCallbackData* callbackData = nullptr;
    auto cache = GetMetadataNodeCache(isolate);

    while (getline(s, line)) {
        stringstream tmp(line);
        tmp >> kind >> name >> signature >> paramCount;

        char chKind = kind[0];

        // method or field
        NS_DCHECK((chKind == 'M') || (chKind == 'F'));

        MetadataEntry entry(nullptr, NodeType::Field);

        entry.name = name;
        entry.sig = signature;
        entry.paramCount = paramCount;
        entry.isStatic = false;

        if (chKind == 'M') {
            if (entry.name != lastMethodName) {
                callbackData = cache->Own<MethodCallbackData>(this);
                instanceMethodData.push_back(callbackData);

                instanceMethodsCallbackData.push_back(callbackData);
                auto itBegin = baseInstanceMethodsCallbackData.begin();
                auto itEnd = baseInstanceMethodsCallbackData.end();
                auto itFound = find_if(itBegin, itEnd, [&entry] (MethodCallbackData *x) {
                    return x->candidates.front().name == entry.name;
                });
                if (itFound != itEnd) {
                    callbackData->parent = *itFound;
                }

                protoFiller.FillPrototypeMethod(isolate, entry.name, callbackData);
                lastMethodName = entry.name;
            }
            callbackData->candidates.push_back(std::move(entry));
        } else if (chKind == 'F') {
            auto* fieldInfo = cache->Own<FieldCallbackData>(entry);
            protoFiller.FillPrototypeField(isolate, entry.name, fieldInfo);
        }
    }
    return instanceMethodData;
}


void MetadataNode::SetStaticMembers(Isolate* isolate, Local<Function>& ctorFunction, MetadataTreeNode* treeNode, uint8_t* &curPtr) {
    auto hasCustomMetadata = treeNode->metadata != nullptr;
    auto context = isolate->GetCurrentContext();

    if (!hasCustomMetadata) {
        string lastMethodName;
        MethodCallbackData* callbackData = nullptr;
        auto cache = GetMetadataNodeCache(isolate);

        auto origin = Constants::APP_ROOT_FOLDER_PATH + GetOrCreateInternal(treeNode)->m_name;

        //get candidates from static methods metadata
        auto staticMethodCout = *reinterpret_cast<uint16_t*>(curPtr);
        curPtr += sizeof(uint16_t);
        for (auto i = 0; i < staticMethodCout; i++) {
            auto entry = MetadataReader::ReadStaticMethodEntry(&curPtr);
            auto &methodName = entry.getName();
            if (methodName != lastMethodName) {
                callbackData = cache->Own<MethodCallbackData>(this);
                auto funcData = External::New(isolate, callbackData, v8::kExternalPointerTypeTagDefault);
                auto funcTemplate = FunctionTemplate::New(isolate, MethodCallback, funcData);
                auto func = funcTemplate->GetFunction(context).ToLocalChecked();
                auto funcName = ArgConverter::ConvertToV8String(isolate, methodName);
                ctorFunction->Set(context, funcName, Wrap(isolate, func, methodName, origin, false /* isCtorFunc */));
                lastMethodName = methodName;
            }
            callbackData->candidates.push_back(std::move(entry));
        }

        //attach .extend function
        auto extendFuncName = V8StringConstants::GetExtend(isolate);
        auto extendFuncTemplate = FunctionTemplate::New(isolate, ExtendMethodCallback, External::New(isolate, this, v8::kExternalPointerTypeTagDefault));
        ctorFunction->Set(context, extendFuncName, extendFuncTemplate->GetFunction(context).ToLocalChecked());

        //get candidates from static fields metadata
        auto staticFieldCout = *reinterpret_cast<uint16_t*>(curPtr);
        curPtr += sizeof(uint16_t);
        for (auto i = 0; i < staticFieldCout; i++) {
            auto entry = MetadataReader::ReadStaticFieldEntry(&curPtr);

            auto fieldName = ArgConverter::ConvertToV8String(isolate, entry.getName());
            auto fieldData = External::New(isolate, cache->Own<FieldCallbackData>(entry), v8::kExternalPointerTypeTagDefault);
            auto fieldGetter = FunctionTemplate::New(isolate, FieldAccessorGetterCallback, fieldData)
                                   ->GetFunction(context).ToLocalChecked();
            auto fieldSetter = FunctionTemplate::New(isolate, FieldAccessorSetterCallback, fieldData)
                                   ->GetFunction(context).ToLocalChecked();
            ctorFunction->SetAccessorProperty(fieldName, fieldGetter, fieldSetter,
                                              PropertyAttribute::DontDelete);
        }

        auto nullObjectName = V8StringConstants::GetNullObject(isolate);

        Local<Value> nullObjectData = External::New(isolate, this, v8::kExternalPointerTypeTagDefault);
        auto nullObjectGetter =
            FunctionTemplate::New(isolate, NullObjectAccessorGetterCallback, nullObjectData)
                ->GetFunction(context).ToLocalChecked();
        ctorFunction->SetAccessorProperty(nullObjectName, nullObjectGetter);

        SetClassAccessor(ctorFunction);
    }
}

void MetadataNode::SetInnerTypes(v8::Isolate* isolate, Local<Function>& ctorFunction, MetadataTreeNode *treeNode) {
    if (treeNode->children != nullptr) {
        auto context = isolate->GetCurrentContext();
        const auto &children = *treeNode->children;
        for (auto curChild: children) {
            bool hasOwnProperty = ctorFunction->HasOwnProperty(context, ArgConverter::ConvertToV8String(isolate, curChild->name)).ToChecked();
                // Child is defined as a function already when the inner type is a companion object
                if (!hasOwnProperty) {
                    ctorFunction->SetNativeDataProperty(
                        context,
                        v8::String::NewFromUtf8(isolate, curChild->name.c_str()).ToLocalChecked(),
                        InnerTypeAccessorGetterCallback, nullptr,
                        v8::External::New(isolate, curChild, v8::kExternalPointerTypeTagDefault)
                ).ToChecked();
            }
        }
    }
}

void MetadataNode::InnerTypeAccessorGetterCallback(v8::Local<v8::Name> property, const v8::PropertyCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    v8::HandleScope handleScope(isolate);

    MetadataTreeNode* curChild = static_cast<MetadataTreeNode*>(
        v8::External::Cast(*info.Data())->Value(v8::kExternalPointerTypeTagDefault));
    auto childNode = GetOrCreateInternal(curChild);
    auto innerCache = GetMetadataNodeCache(isolate);
    auto itFound = innerCache->CtorFunctions.find(childNode);
    if (itFound != innerCache->CtorFunctions.end()) {
        info.GetReturnValue().Set(itFound->second->Get(isolate));
        return;
    }
    auto innerTypeCtorFuncTemplate= childNode->GetConstructorFunctionTemplate(isolate, curChild);

    if(innerTypeCtorFuncTemplate.IsEmpty()) {
        info.GetReturnValue().Set(v8::Undefined(isolate));
        return;
    }

    auto innerTypeCtorFunc = Local<Function>::New(isolate, *GetOrCreateInternal(curChild)->GetPersistentConstructorFunction(isolate));
    auto innerTypeName = ArgConverter::ConvertToV8String(isolate, curChild->name);
    // TODO: remove this once we solve https://github.com/NativeScript/android/pull/1771
    // this avoids a crash, but the companion object is still unaccessible
    TryCatch tc(isolate);
    info.GetReturnValue().Set(innerTypeCtorFunc);
}


Local<FunctionTemplate> MetadataNode::GetConstructorFunctionTemplate(Isolate* isolate, MetadataTreeNode* treeNode) {
    std::vector<MethodCallbackData*> instanceMethodsCallbackData;

    v8::HandleScope handleScope(isolate);
    auto ft = GetConstructorFunctionTemplate(isolate, treeNode, instanceMethodsCallbackData);

    return ft;
}

Local<FunctionTemplate> MetadataNode::GetConstructorFunctionTemplate(Isolate* isolate, MetadataTreeNode* treeNode, vector<MethodCallbackData*>& instanceMethodsCallbackData) {
    SET_PROFILER_FRAME();
    tns::instrumentation::Frame frame;

    //try get cached "ctorFuncTemplate"
    Local<FunctionTemplate> ctorFuncTemplate;
    auto cache = GetMetadataNodeCache(isolate);
    auto itFound = cache->CtorFuncCache.find(treeNode);
    if (itFound != cache->CtorFuncCache.end()) {
        auto& ctorCacheItem = itFound->second;
        instanceMethodsCallbackData = ctorCacheItem.instanceMethodCallbacks;
        ctorFuncTemplate = Local<FunctionTemplate>::New(isolate, *ctorCacheItem.ft);
        return ctorFuncTemplate;
    }
    //

    auto node = GetOrCreateInternal(treeNode);

    JEnv env;
    // if we already have an exception (which will be rethrown later)
    // then we don't want to ignore the next exception
    bool ignoreFindClassException = env.ExceptionCheck() == JNI_FALSE;
    auto currentClass = env.FindClass(node->m_name);
    if (ignoreFindClassException && env.ExceptionCheck()) {
        env.ExceptionClear();
        // JNI found an exception looking up this class
        // but we don't care, because this means this class doesn't exist
        // like when you try to get a class that only exists in a higher API level
        ctorFuncTemplate.Clear();
        auto pft = new Persistent<FunctionTemplate>(isolate, ctorFuncTemplate);
        CtorCacheData ctorCacheItem(pft, instanceMethodsCallbackData);
        cache->CtorFuncCache.emplace(treeNode, ctorCacheItem);
        return ctorFuncTemplate;
    }

    auto ctorCallbackData = External::New(isolate, node, v8::kExternalPointerTypeTagDefault);
    auto isInterface = s_metadataReader.IsNodeTypeInterface(treeNode->type);
    auto funcCallback = isInterface ? InterfaceConstructorCallback : ClassConstructorCallback;
    ctorFuncTemplate = FunctionTemplate::New(isolate, funcCallback, ctorCallbackData);
    auto currentNode = treeNode;
    std::string finalName(currentNode->name);
    while (currentNode->parent) {
        if (!currentNode->parent->name.empty()) {
            finalName = currentNode->parent->name + "." + finalName;
        }
        currentNode = currentNode->parent;
    }
    ctorFuncTemplate->SetClassName(v8::String::NewFromUtf8(isolate, finalName.c_str()).ToLocalChecked());
    ctorFuncTemplate->InstanceTemplate()->SetInternalFieldCount(static_cast<int>(ObjectManager::MetadataNodeKeys::END));

    Local<Function> baseCtorFunc;
    std::vector<MethodCallbackData*> baseInstanceMethodsCallbackData;
    auto tmpTreeNode = treeNode;
    std::vector<MetadataTreeNode*> skippedBaseTypes;
    while (true) {
        auto baseTreeNode = s_metadataReader.GetBaseClassNode(tmpTreeNode);
        if (CheckClassHierarchy(env, currentClass, treeNode, baseTreeNode, skippedBaseTypes)) {
            tmpTreeNode = baseTreeNode;
            continue;
        }
        if ((baseTreeNode != treeNode) && (baseTreeNode != nullptr) && (baseTreeNode->offsetValue > 0)) {
            auto baseFuncTemplate = GetConstructorFunctionTemplate(isolate, baseTreeNode, baseInstanceMethodsCallbackData);
            if (!baseFuncTemplate.IsEmpty()) {
                ctorFuncTemplate->Inherit(baseFuncTemplate);
                baseCtorFunc = Local<Function>::New(isolate, *GetOrCreateInternal(baseTreeNode)->GetPersistentConstructorFunction(isolate));
            }
        }
        break;
    }

    PrototypeTemplateFiller protoFiller{ctorFuncTemplate->PrototypeTemplate()};

    uint8_t* curPtr = nullptr;

    auto instanceMethodData = node->SetInstanceMembers(
            isolate, ctorFuncTemplate, protoFiller, instanceMethodsCallbackData,
            baseInstanceMethodsCallbackData, treeNode, curPtr);
    if (!skippedBaseTypes.empty()) {
        node->SetMissingBaseMethods(isolate, skippedBaseTypes, instanceMethodData, protoFiller);
    }

    auto context = isolate->GetCurrentContext();
    auto ctorFunc = ctorFuncTemplate->GetFunction(context).ToLocalChecked();

    auto origin = Constants::APP_ROOT_FOLDER_PATH + node->m_name;

    auto wrappedCtorFunc = Wrap(isolate, ctorFunc, node->m_treeNode->name, origin, true /* isCtorFunc */);

    node->SetStaticMembers(isolate, wrappedCtorFunc, treeNode, curPtr);

    // insert isolate-specific persistent function handle
    cache->CtorFunctions.emplace(node, new Persistent<Function>(isolate, wrappedCtorFunc));
    if (!baseCtorFunc.IsEmpty()) {
        auto currentContext = isolate->GetCurrentContext();
        wrappedCtorFunc->SetPrototype(currentContext, baseCtorFunc);
    }

   //cache "ctorFuncTemplate"
   auto pft = new Persistent<FunctionTemplate>(isolate, ctorFuncTemplate);
   CtorCacheData ctorCacheItem(pft, instanceMethodsCallbackData);
   cache->CtorFuncCache.emplace(treeNode, ctorCacheItem);

    SetInnerTypes(isolate, wrappedCtorFunc, treeNode);

    SetTypeMetadata(isolate, wrappedCtorFunc, cache->Own<TypeMetadata>(s_metadataReader.ReadTypeName(treeNode)));

    if (frame.check()) {
        frame.log("Materializing class: " + node->m_name);
    }

    return ctorFuncTemplate;
}

Local<Function> MetadataNode::GetConstructorFunction(Isolate* isolate) {
    GetConstructorFunctionTemplate(isolate, m_treeNode);
    auto ctorFunc = Local<Function>::New(isolate, *GetPersistentConstructorFunction(isolate));

    return ctorFunc;
}

Persistent<Function>* MetadataNode::GetPersistentConstructorFunction(Isolate* isolate) {
    auto cache = GetMetadataNodeCache(isolate);
    auto itFound = cache->CtorFunctions.find(this);
    if (itFound != cache->CtorFunctions.end()) {
        auto& constrFunction = itFound->second;

        return constrFunction;
    } else {
        throw NativeScriptException("Constructor function not found for node: " + this->m_name);
    }
}

MetadataNode::TypeMetadata* MetadataNode::GetTypeMetadata(Isolate* isolate, const Local<Function>& value) {
    Local<Value> hiddenVal;
    V8GetPrivateValue(isolate, value, String::NewFromUtf8(isolate, "typemetadata").ToLocalChecked(), hiddenVal);

    auto data = reinterpret_cast<TypeMetadata*>(hiddenVal.As<External>()->Value(v8::kExternalPointerTypeTagDefault));
    return data;
}

void MetadataNode::SetTypeMetadata(Isolate* isolate, Local<Function> value, TypeMetadata* data) {
    V8SetPrivateValue(isolate, value, String::NewFromUtf8(isolate, "typemetadata").ToLocalChecked(),  External::New(isolate, data, v8::kExternalPointerTypeTagDefault));
}

MetadataNode* MetadataNode::GetInstanceMetadata(Isolate* isolate, const Local<Object>& value) {
    MetadataNode* node = nullptr;
    auto cache = GetMetadataNodeCache(isolate);
    auto key = Local<String>::New(isolate, *cache->MetadataKey);
    Local<Value> hiddenVal;
    V8GetPrivateValue(isolate, value, key, hiddenVal);
    auto ext = hiddenVal;
    if (!ext.IsEmpty()) {
        node = reinterpret_cast<MetadataNode*>(ext.As<External>()->Value(v8::kExternalPointerTypeTagDefault));
    }

    return node;
}

void MetadataNode::SetInstanceMetadata(Isolate* isolate, Local<Object> object, MetadataNode* node) {
    auto cache = GetMetadataNodeCache(isolate);
    auto key = Local<String>::New(isolate, *cache->MetadataKey);
    V8SetPrivateValue(isolate, object, key, External::New(isolate, node, v8::kExternalPointerTypeTagDefault));
}

void MetadataNode::ExtendedClassConstructorCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TNSPERF();
    try {
        SET_PROFILER_FRAME();

        if (!info.IsConstructCall()) {
            throw NativeScriptException(string("Incorrectly calling a Java class as a method. Class must be created by invoking its constructor with the `new` keyword."));
        }

        auto isolate = info.GetIsolate();
        auto thiz = info.This();
        auto extData = reinterpret_cast<ExtendedClassCallbackData*>(info.Data().As<External>()->Value(v8::kExternalPointerTypeTagDefault));

        v8::HandleScope handleScope(isolate);

        auto implementationObject = Local<Object>::New(isolate, *extData->implementationObject);

        SetInstanceMetadata(isolate, thiz, extData->node);
        thiz->SetInternalField(static_cast<int>(ObjectManager::MetadataNodeKeys::CallSuper), True(isolate));
        V8SetPrivateValue(isolate, thiz, V8StringConstants::GetImplementationObject(isolate), implementationObject);

        ArgsWrapper argWrapper(info, ArgType::Class);

        string fullClassName = extData->fullClassName;

        bool success = CallbackHandlers::RegisterInstance(isolate, thiz, fullClassName, argWrapper, implementationObject, false, extData->node->m_name);
    } catch (NativeScriptException& e) {
        e.ReThrowToV8();
    } catch (std::exception e) {
        stringstream ss;
        ss << "Error: c++ exception: " << e.what() << endl;
        NativeScriptException nsEx(ss.str());
        nsEx.ReThrowToV8();
    } catch (...) {
        NativeScriptException nsEx(std::string("Error: c++ exception!"));
        nsEx.ReThrowToV8();
    }
}

void MetadataNode::InterfaceConstructorCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    tns::instrumentation::Frame frame;
    try {
        SET_PROFILER_FRAME();

        if (!info.IsConstructCall()) {
            throw NativeScriptException(string("Interface implementation must be invoked as a constructor with the `new` keyword."));
        }

        auto isolate = info.GetIsolate();
        auto thiz = info.This();
        auto node = reinterpret_cast<MetadataNode*>(info.Data().As<External>()->Value(v8::kExternalPointerTypeTagDefault));

        v8::HandleScope handleScope(isolate);

        Local<Object> implementationObject;
        Local<String> v8ExtendName;
        auto context = isolate->GetCurrentContext();

        if (info.Length() == 1) {
            if (!info[0]->IsObject()) {
                throw NativeScriptException(string("First argument must be implementation object"));
            }
            implementationObject = info[0]->ToObject(context).ToLocalChecked();
        } else if (info.Length() == 2) {
            if (!info[0]->IsString()) {
                throw NativeScriptException(string("First argument must be string"));
            }
            if (!info[1]->IsObject()) {
                throw NativeScriptException(string("Second argument must be implementation object"));
            }

            v8ExtendName = info[0]->ToString(context).ToLocalChecked();
            implementationObject = info[1]->ToObject(context).ToLocalChecked();
        } else {
            throw NativeScriptException(string("Invalid number of arguments"));
        }

        auto className = node->m_implType;
        SetInstanceMetadata(isolate, thiz, node);

        //@@@ Refactor
        thiz->SetInternalField(static_cast<int>(ObjectManager::MetadataNodeKeys::CallSuper), True(isolate));

        implementationObject->SetPrototype(context, thiz->GetPrototype());
        thiz->SetPrototype(context, implementationObject);
        V8SetPrivateValue(isolate, thiz, V8StringConstants::GetImplementationObject(isolate), implementationObject);

        ArgsWrapper argWrapper(info, ArgType::Interface);

        auto success = CallbackHandlers::RegisterInstance(isolate, thiz, className, argWrapper, implementationObject, true);

        if (frame.check()) {
            frame.log("Interface constructor: " + node->m_name);
        }
    } catch (NativeScriptException& e) {
        e.ReThrowToV8();
    } catch (std::exception e) {
        stringstream ss;
        ss << "Error: c++ exception: " << e.what() << endl;
        NativeScriptException nsEx(ss.str());
        nsEx.ReThrowToV8();
    } catch (...) {
        NativeScriptException nsEx(std::string("Error: c++ exception!"));
        nsEx.ReThrowToV8();
    }
}

void MetadataNode::ClassConstructorCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TNSPERF();
    try {
        SET_PROFILER_FRAME();

        auto thiz = info.This();

        auto isolate = info.GetIsolate();
        auto node = reinterpret_cast<MetadataNode*>(info.Data().As<External>()->Value(v8::kExternalPointerTypeTagDefault));

        string extendName;
        auto className = node->m_name;

        SetInstanceMetadata(isolate, thiz, node);

        ArgsWrapper argWrapper(info, ArgType::Class);

        string fullClassName = CreateFullClassName(className, extendName);
        bool success = CallbackHandlers::RegisterInstance(isolate, thiz, fullClassName, argWrapper, Local<Object>(), false, className);
    } catch (NativeScriptException& e) {
        e.ReThrowToV8();
    } catch (std::exception e) {
        stringstream ss;
        ss << "Error: c++ exception: " << e.what() << endl;
        NativeScriptException nsEx(ss.str());
        nsEx.ReThrowToV8();
    } catch (...) {
        NativeScriptException nsEx(std::string("Error: c++ exception!"));
        nsEx.ReThrowToV8();
    }
}

void MetadataNode::MethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    try {
        SET_PROFILER_FRAME();

        auto e = info.Data().As<External>();

        auto callbackData = reinterpret_cast<MethodCallbackData*>(e->Value(v8::kExternalPointerTypeTagDefault));
        auto initialCallbackData = reinterpret_cast<MethodCallbackData*>(e->Value(v8::kExternalPointerTypeTagDefault));

        // Number of arguments the method is invoked with
        int argLength = info.Length();

        MetadataEntry* entry = nullptr;

        string* className;
        const auto& first = callbackData->candidates.front();
        const auto& methodName = first.name;

        while ((callbackData != nullptr) && (entry == nullptr)) {
            auto& candidates = callbackData->candidates;

            className = &callbackData->node->m_name;

            // Iterates through all methods and finds the best match based on the number of arguments
            auto found = false;
            for (auto& c : candidates) {
                found = (!c.isExtensionFunction && c.getParamCount() == argLength) || (
                        c.isExtensionFunction && c.getParamCount() == argLength + 1);
                if (found) {
                    if(c.isExtensionFunction){
                        className = &c.getDeclaringType();
                    }
                    entry = &c;
                    DEBUG_WRITE("MetaDataEntry Method %s's signature is: %s", entry->name.c_str(), entry->getSig().c_str());
                    break;
                }
            }

            // Iterates through the parent class's methods to find a good match
            if (!found) {
                callbackData = callbackData->parent;
            }
        }

        auto thiz = info.This();

        auto isSuper = false;
        if (!first.isStatic) {
            auto superValue = thiz->GetInternalField(static_cast<int>(ObjectManager::MetadataNodeKeys::CallSuper)).As<Value>();
            isSuper = !superValue.IsEmpty() && superValue->IsTrue();
        }

        if ((argLength == 0) && (methodName == V8StringConstants::VALUE_OF)) {
            info.GetReturnValue().Set(thiz);
        } else {
            bool isFromInterface = initialCallbackData->node->IsNodeTypeInterface();
            CallbackHandlers::CallJavaMethod(thiz, *className, methodName, entry, isFromInterface, first.isStatic, isSuper, info);
        }
    } catch (NativeScriptException& e) {
        e.ReThrowToV8();
    } catch (std::exception e) {
        stringstream ss;
        ss << "Error: c++ exception: " << e.what() << endl;
        NativeScriptException nsEx(ss.str());
        nsEx.ReThrowToV8();
    } catch (...) {
        NativeScriptException nsEx(std::string("Error: c++ exception!"));
        nsEx.ReThrowToV8();
    }
}

Intercepted MetadataNode::ArrayIndexedPropertyGetterCallback(uint32_t index, const PropertyCallbackInfo<Value>& info) {
    try {
        auto thiz = info.Holder();
        auto isolate = info.GetIsolate();
        auto context = isolate->GetCurrentContext();

        auto node = GetNodeFromHandle(thiz);

        auto element = CallbackHandlers::GetArrayElement(context, thiz, index, node->m_name);

        info.GetReturnValue().Set(element);
    } catch (NativeScriptException& e) {
        e.ReThrowToV8();
    } catch (std::exception e) {
        stringstream ss;
        ss << "Error: c++ exception: " << e.what() << endl;
        NativeScriptException nsEx(ss.str());
        nsEx.ReThrowToV8();
    } catch (...) {
        NativeScriptException nsEx(std::string("Error: c++ exception!"));
        nsEx.ReThrowToV8();
    }
    return Intercepted::kYes;
}

Intercepted MetadataNode::ArrayIndexedPropertySetterCallback(uint32_t index, Local<Value> value, const PropertyCallbackInfo<Boolean>& info) {
    try {
        auto thiz = info.Holder();
        auto isolate = info.GetIsolate();
        auto context = isolate->GetCurrentContext();

        auto node = GetNodeFromHandle(thiz);

        CallbackHandlers::SetArrayElement(context, thiz, index, node->m_name, value);
    } catch (NativeScriptException& e) {
        e.ReThrowToV8();
    } catch (std::exception e) {
        stringstream ss;
        ss << "Error: c++ exception: " << e.what() << endl;
        NativeScriptException nsEx(ss.str());
        nsEx.ReThrowToV8();
    } catch (...) {
        NativeScriptException nsEx(std::string("Error: c++ exception!"));
        nsEx.ReThrowToV8();
    }
    return Intercepted::kYes;
}

Local<Object> MetadataNode::GetImplementationObject(Isolate* isolate, const Local<Object>& object) {
    TNSPERF();
    DEBUG_WRITE("GetImplementationObject called  on object:%d", object->GetIdentityHash());

    auto target = object;
    Local<Value> currentPrototype = target;

    Local<Object> implementationObject;

    Local<Value> hiddenVal;
    V8GetPrivateValue(isolate, object, V8StringConstants::GetImplementationObject(isolate), hiddenVal);
    implementationObject = hiddenVal.As<Object>();

    if (!implementationObject.IsEmpty()) {
        return implementationObject;
    }

    auto context = object->GetCreationContext(isolate).ToLocalChecked();
    if (object->HasOwnProperty(context, V8StringConstants::GetIsPrototypeImplementationObject(isolate)).ToChecked()) {
        auto v8Prototype = V8StringConstants::GetPrototype(isolate);
        auto maybeHasOwnProperty = object->HasOwnProperty(context, v8Prototype);
        if (!object->HasOwnProperty(context, v8Prototype).ToChecked()) {
            return Local<Object>();
        }

        DEBUG_WRITE("GetImplementationObject returning the prototype of the object :%d", object->GetIdentityHash());
        Local<Value> result;
        if (object->Get(context, v8Prototype).ToLocal(&result)) {
            return result.As<Object>();
        } else {
            return Local<Object>();
        }
    }

    Local<Value> hiddenValue;
    V8GetPrivateValue(isolate, object, String::NewFromUtf8(isolate, "t::ActivityImplementationObject").ToLocalChecked(), hiddenValue);
    auto obj = hiddenValue.As<Object>();
    if (!obj.IsEmpty()) {
        DEBUG_WRITE("GetImplementationObject returning ActivityImplementationObject property on object: %d", object->GetIdentityHash());
        return obj;
    }

    Local<Value> lastPrototype;
    bool prototypeCycleDetected = false;
    while (implementationObject.IsEmpty()) {
        //
        currentPrototype = currentPrototype.As<Object>()->GetPrototype();

        if (currentPrototype->IsNull()) {
            break;
        }

        //DEBUG_WRITE("GetImplementationObject currentPrototypeObject:%d", (currentPrototype.IsEmpty() || currentPrototype.As<Object>().IsEmpty()) ? -1 :  currentPrototype.As<Object>()->GetIdentityHash());
        //DEBUG_WRITE("GetImplementationObject lastPrototypeObject:%d", (lastPrototype.IsEmpty() || lastPrototype.As<Object>().IsEmpty()) ? -1 :  lastPrototype.As<Object>()->GetIdentityHash());

        if (currentPrototype == lastPrototype) {
            auto abovePrototype = currentPrototype.As<Object>()->GetPrototype();
            prototypeCycleDetected = abovePrototype == currentPrototype;
        }

        if (currentPrototype.IsEmpty() || prototypeCycleDetected) {
            //Local<Value> abovePrototype = currentPrototype.As<Object>()->GetPrototype();
            //DEBUG_WRITE("GetImplementationObject not found since cycle parents reached abovePrototype:%d", (abovePrototype.IsEmpty() || abovePrototype.As<Object>().IsEmpty()) ? -1 :  abovePrototype.As<Object>()->GetIdentityHash());
            return Local<Object>();
        } else {
            Local<Value> _hiddenVal;
            V8GetPrivateValue(isolate, currentPrototype.As<Object>(), V8StringConstants::GetClassImplementationObject(isolate), _hiddenVal);
            auto value = _hiddenVal;

            if (!value.IsEmpty()) {
                implementationObject = currentPrototype.As<Object>();
            }
        }

        lastPrototype = currentPrototype;
    }

    return implementationObject;
}

void MetadataNode::PackageGetterCallback(Local<Name> property, const PropertyCallbackInfo<Value>& info) {
    try {
        if (property.IsEmpty() || !property->IsString()) {
            return;
        }

        auto strProperty = property.As<String>();

        string propName = ArgConverter::ConvertToString(strProperty);

        if (propName.empty()) {
            return;
        }

        auto isolate = info.GetIsolate();

        auto thiz = info.Holder();

        Local<Value> hiddenVal;
        V8GetPrivateValue(isolate, thiz, strProperty, hiddenVal);
        auto cachedItem = hiddenVal;

        if (cachedItem.IsEmpty()) {
            auto node = reinterpret_cast<MetadataNode*>(info.Data().As<External>()->Value(v8::kExternalPointerTypeTagDefault));

            uint8_t nodeType = s_metadataReader.GetNodeType(node->m_treeNode);

            DEBUG_WRITE("MetadataNode::GetterCallback: prop '%s' for node '%s' called, nodeType=%d, hash=%d", propName.c_str(), node->m_treeNode->name.c_str(), nodeType, thiz.IsEmpty() ? -42 : thiz->GetIdentityHash());

            auto child = GetChildMetadataForPackage(node, propName);
            auto foundChild = child.treeNode != nullptr;

            if (foundChild) {
                auto childNode = MetadataNode::GetOrCreateInternal(child.treeNode);
                cachedItem = childNode->CreateWrapper(isolate);

                uint8_t childNodeType = s_metadataReader.GetNodeType(child.treeNode);
                bool isInterface = s_metadataReader.IsNodeTypeInterface(childNodeType);
                if (isInterface) {
                    // For all java interfaces we register the special Symbol.hasInstance property
                    // which is invoked by the instanceof operator (https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol/hasInstance).
                    // For example:
                    //
                    // Object.defineProperty(android.view.animation.Interpolator, Symbol.hasInstance, {
                    //    value: function(obj) {
                    //        return true;
                    //    }
                    // });
                    RegisterSymbolHasInstanceCallback(isolate, child, cachedItem);
                }

                V8SetPrivateValue(isolate, thiz, strProperty, cachedItem);

                if (node->m_name == "org/json" && child.name == "JSONObject") {
                    JSONObjectHelper::RegisterFromFunction(isolate, cachedItem);
                }
            }
        }

        info.GetReturnValue().Set(cachedItem);
    } catch (NativeScriptException& e) {
        e.ReThrowToV8();
    } catch (std::exception e) {
        stringstream ss;
        ss << "Error: c++ exception: " << e.what() << endl;
        NativeScriptException nsEx(ss.str());
        nsEx.ReThrowToV8();
    } catch (...) {
        NativeScriptException nsEx(std::string("Error: c++ exception!"));
        nsEx.ReThrowToV8();
    }
}

bool MetadataNode::ValidateExtendArguments(const FunctionCallbackInfo<Value>& info, bool extendLocationFound, string& extendLocation, v8::Local<v8::String>& extendName, Local<Object>& implementationObject, bool isTypeScriptExtend) {
    auto isolate = info.GetIsolate();

    if (info.Length() == 1) {
        if (!extendLocationFound) {
            stringstream ss;
            ss << "Invalid extend() call. No name specified for extend at location: " << extendLocation.c_str();
            string exceptionMessage = ss.str();

            throw NativeScriptException(exceptionMessage);
        }

        if (!info[0]->IsObject()) {
            stringstream ss;
            ss << "Invalid extend() call. No implementation object specified at location: " << extendLocation.c_str();
            string exceptionMessage = ss.str();

            throw NativeScriptException(exceptionMessage);
        }

        auto context = isolate->GetCurrentContext();
        implementationObject = info[0]->ToObject(context).ToLocalChecked();
    } else if (info.Length() == 2 || isTypeScriptExtend) {
        if (!info[0]->IsString()) {
            stringstream ss;
            ss << "Invalid extend() call. No name for extend specified at location: " << extendLocation.c_str();
            string exceptionMessage = ss.str();

            throw NativeScriptException(exceptionMessage);
        }

        if (!info[1]->IsObject()) {
            stringstream ss;
            ss << "Invalid extend() call. Named extend should be called with second object parameter containing overridden methods at location: " << extendLocation.c_str();
            string exceptionMessage = ss.str();

            throw NativeScriptException(exceptionMessage);
        }

        DEBUG_WRITE("ExtendsCallMethodHandler: getting extend name");
        auto context = isolate->GetCurrentContext();
        extendName = info[0]->ToString(context).ToLocalChecked();
        bool isValidExtendName = IsValidExtendName(extendName);
        if (!isValidExtendName) {
            stringstream ss;
            ss << "The extend name \"" << ArgConverter::ConvertToString(extendName) << "\" you provided contains invalid symbols. Try using the symbols [a-z, A-Z, 0-9, _]." << endl;
            string exceptionMessage = ss.str();

            throw NativeScriptException(exceptionMessage);
        }
        implementationObject = info[1]->ToObject(context).ToLocalChecked();
    } else {
        stringstream ss;
        ss << "Invalid extend() call at location: " << extendLocation.c_str();
        string exceptionMessage = ss.str();

        throw NativeScriptException(exceptionMessage);
    }

    return true;
}

MetadataNode::ExtendedClassCacheData MetadataNode::GetCachedExtendedClassData(Isolate* isolate, const string& proxyClassName) {
    auto cache = GetMetadataNodeCache(isolate);
    ExtendedClassCacheData cacheData;
    auto itFound = cache->ExtendedCtorFuncCache.find(proxyClassName);
    if (itFound != cache->ExtendedCtorFuncCache.end()) {
        cacheData = itFound->second;
    }

    return cacheData;
}

string MetadataNode::CreateFullClassName(const std::string& className, const std::string& extendNameAndLocation = "") {
    string fullClassName = className;

    // create a class name consisting only of the base class name + last file name part + line + column + variable identifier
    if (!extendNameAndLocation.empty()) {
        string tempClassName = className;
        fullClassName = Util::ReplaceAll(tempClassName, "$", "_");
        fullClassName += "_" + extendNameAndLocation;
    }

    return fullClassName;
}

void MetadataNode::ExtendMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    tns::instrumentation::Frame frame;
    try {
        if (info.IsConstructCall()) {
            string exMsg("Can't call 'extend' as constructor");
            throw NativeScriptException(exMsg);
        }

        SET_PROFILER_FRAME();

        Local<Object> implementationObject;
        Local<String> extendName;
        string extendLocation;

        auto hasDot = false;
        auto isTypeScriptExtend = false;
        auto isolate = info.GetIsolate();
        if (info.Length() == 2) {
            if (info[0].IsEmpty() || !info[0]->IsString()) {
                stringstream ss;
                ss << "Invalid extend() call. No name for extend specified at location: " << extendLocation.c_str();
                string exceptionMessage = ss.str();

                throw NativeScriptException(exceptionMessage);
            }
            if (info[1].IsEmpty() || !info[1]->IsObject()) {
                stringstream ss;
                ss << "Invalid extend() call. Named extend should be called with second object parameter containing overridden methods at location: " << extendLocation.c_str();
                string exceptionMessage = ss.str();

                throw NativeScriptException(exceptionMessage);
            }
            string strName = ArgConverter::ConvertToString(info[0].As<String>());
            hasDot = strName.find('.') != string::npos;
        } else if (info.Length() == 3) {
            auto context = isolate->GetCurrentContext();
            if (info[2]->IsBoolean() && info[2]->BooleanValue(isolate)) {
                isTypeScriptExtend = true;
            }
        }

        if (hasDot) {
            extendName = info[0].As<String>();
            implementationObject = info[1].As<Object>();
        } else {
            auto isValidExtendLocation = GetExtendLocation(isolate, extendLocation, isTypeScriptExtend);
            auto validArgs = ValidateExtendArguments(info, isValidExtendLocation, extendLocation, extendName, implementationObject, isTypeScriptExtend);

            if (!validArgs) {
                return;
            }
        }

        auto node = reinterpret_cast<MetadataNode*>(info.Data().As<External>()->Value(v8::kExternalPointerTypeTagDefault));

        DEBUG_WRITE("ExtendsCallMethodHandler: called with %s", ArgConverter::ConvertToString(extendName).c_str());

        string extendNameAndLocation = extendLocation + ArgConverter::ConvertToString(extendName);
        string fullClassName;
        string baseClassName = node->m_name;
        if (!hasDot) {
            fullClassName = TNS_PREFIX + CreateFullClassName(baseClassName, extendNameAndLocation);
        } else {
            fullClassName = ArgConverter::ConvertToString(info[0].As<String>());
        }

        //resolve class (pre-generated or generated runtime from dex generator)
        uint8_t nodeType = s_metadataReader.GetNodeType(node->m_treeNode);
        bool isInterface = s_metadataReader.IsNodeTypeInterface(nodeType);
        auto clazz = CallbackHandlers::ResolveClass(isolate, baseClassName, fullClassName, implementationObject, isInterface);
        auto fullExtendedName = CallbackHandlers::ResolveClassName(isolate, clazz);
        DEBUG_WRITE("ExtendsCallMethodHandler: extend full name %s", fullClassName.c_str());

        auto cachedData = GetCachedExtendedClassData(isolate, fullExtendedName);
        if (cachedData.extendedCtorFunction != nullptr) {
            auto cachedExtendedCtorFunc = Local<Function>::New(isolate, *cachedData.extendedCtorFunction);
            info.GetReturnValue().Set(cachedExtendedCtorFunc);
            return;
        }

        auto implementationObjectPropertyName = V8StringConstants::GetClassImplementationObject(isolate);
        //reuse validation - checks that implementationObject is not reused for different classes
        Local<Value> hiddenVal;
        V8GetPrivateValue(isolate, implementationObject, implementationObjectPropertyName, hiddenVal);
        auto implementationObjectProperty = hiddenVal.As<String>();
        if (implementationObjectProperty.IsEmpty()) {
            //mark the implementationObject as such and set a pointer to it's class node inside it for reuse validation later
            V8SetPrivateValue(isolate, implementationObject, implementationObjectPropertyName, String::NewFromUtf8(isolate, fullExtendedName.c_str()).ToLocalChecked());
        } else {
            string usedClassName = ArgConverter::ConvertToString(implementationObjectProperty);
            stringstream s;
            s << "This object is used to extend another class '" << usedClassName << "'";
            throw NativeScriptException(s.str());
        }

        auto cache = GetMetadataNodeCache(isolate);
        auto baseClassCtorFunc = node->GetConstructorFunction(isolate);
        auto extendData = External::New(isolate, cache->Own<ExtendedClassCallbackData>(node, extendNameAndLocation, implementationObject, fullExtendedName), v8::kExternalPointerTypeTagDefault);
        auto extendFuncTemplate = FunctionTemplate::New(isolate, ExtendedClassConstructorCallback, extendData);
        extendFuncTemplate->InstanceTemplate()->SetInternalFieldCount(static_cast<int>(ObjectManager::MetadataNodeKeys::END));

        auto context = isolate->GetCurrentContext();
        auto extendFunc = extendFuncTemplate->GetFunction(context).ToLocalChecked();
        auto prototypeName = V8StringConstants::GetPrototype(isolate);
        implementationObject->SetPrototype(context, baseClassCtorFunc->Get(context, prototypeName).ToLocalChecked());
        auto superGetter =
            FunctionTemplate::New(isolate, SuperAccessorGetterCallback, implementationObject)
                ->GetFunction(context).ToLocalChecked();
        implementationObject->SetAccessorProperty(V8StringConstants::GetSuper(isolate), superGetter);

        auto extendFuncPrototype = extendFunc->Get(context, prototypeName).ToLocalChecked().As<Object>();
        auto p = extendFuncPrototype->GetPrototype();
        extendFuncPrototype->SetPrototype(context, implementationObject);
        extendFunc->SetPrototype(context, baseClassCtorFunc);

        SetClassAccessor(extendFunc);
        SetTypeMetadata(isolate, extendFunc, cache->Own<TypeMetadata>(fullExtendedName));
        info.GetReturnValue().Set(extendFunc);

        {
            std::lock_guard<std::mutex> lock(s_nodeCacheMutex);
            s_name2NodeCache.emplace(fullExtendedName, node);
        }

        ExtendedClassCacheData cacheData(extendFunc, fullExtendedName, node);
        cache->ExtendedCtorFuncCache.emplace(fullExtendedName, cacheData);

        if (frame.check()) {
            frame.log("Extending: " + node->m_name);
        }
    } catch (NativeScriptException& e) {
        e.ReThrowToV8();
    } catch (std::exception e) {
        stringstream ss;
        ss << "Error: c++ exception: " << e.what() << endl;
        NativeScriptException nsEx(ss.str());
        nsEx.ReThrowToV8();
    } catch (...) {
        NativeScriptException nsEx(std::string("Error: c++ exception!"));
        nsEx.ReThrowToV8();
    }
}

bool MetadataNode::IsValidExtendName(const Local<String>& name) {
    string extendNam = ArgConverter::ConvertToString(name);

    for (int i = 0; i < extendNam.size(); i++) {
        char currentSymbol = extendNam[i];
        bool isValidExtendNameSymbol = isalpha(currentSymbol) ||
                                       isdigit(currentSymbol) ||
                                       currentSymbol == '_';
        if (!isValidExtendNameSymbol) {
            return false;
        }
    }

    return true;
}

bool MetadataNode::GetExtendLocation(v8::Isolate* isolate, string& extendLocation, bool isTypeScriptExtend) {
    stringstream extendLocationStream;
    auto stackTrace = StackTrace::CurrentStackTrace(Isolate::GetCurrent(), 3, StackTrace::kOverview);
    if (!stackTrace.IsEmpty()) {
        Local<StackFrame> frame;
        if (isTypeScriptExtend) {
            frame = stackTrace->GetFrame(isolate, 2); // the _super.apply call to ts_helpers will always be the third call frame
        }  else {
            frame = stackTrace->GetFrame(isolate, 0);
        }

        if (!frame.IsEmpty()) {
            auto scriptName = frame->GetScriptName();
            if (scriptName.IsEmpty()) {
                extendLocationStream << "unknown_location";
                extendLocation = extendLocationStream.str();
                return true;
            }

            string srcFileName = ArgConverter::ConvertToString(scriptName);

            string fullPathToFile;
            if (srcFileName == "<embedded>") {
                // Corner case, extend call is coming from the heap snapshot script
                // This is possible for lazily compiled code - e.g. from the body of a function

                // Replace embedded_script with 'script' as the SBG will emit classes from the
                // embedded_script file as 'Object_script_line_col', getting rid of fragments
                // preceding the underscore (_)
                fullPathToFile = "script";
            } else {
                // srcFileName is not always `file://<APP_ROOT>/<path>.js`:
                // HTTP ESM loading (HMR dev workflow) passes a full URL like
                // `http://<dev-host>/<path>` with no `.js` suffix and no
                // app-root prefix, so naive scheme/app-root/`.js` stripping
                // can yield an empty `fullPathToFile` and crash downstream on
                // an empty token list.
                string normalized = srcFileName;

                auto stripPrefix = [](string& s, const string& prefix) {
                    if (s.size() >= prefix.size() &&
                        s.compare(0, prefix.size(), prefix) == 0) {
                        s.erase(0, prefix.size());
                    }
                };

                stripPrefix(normalized, "file://");
                if (normalized.rfind("http://", 0) == 0 ||
                    normalized.rfind("https://", 0) == 0) {
                    size_t schemeEnd = normalized.find("://");
                    size_t pathStart = normalized.find('/', schemeEnd + 3);
                    if (pathStart == string::npos) {
                        normalized.clear();
                    } else {
                        normalized.erase(0, pathStart + 1);
                    }
                }

                size_t queryOrFragment = normalized.find_first_of("?#");
                if (queryOrFragment != string::npos) {
                    normalized.resize(queryOrFragment);
                }

                const string& appRoot = Constants::APP_ROOT_FOLDER_PATH;
                if (!appRoot.empty()) {
                    stripPrefix(normalized, appRoot);
                }

                auto endsWith = [](const string& s, const string& suffix) {
                    return s.size() >= suffix.size() &&
                           s.compare(s.size() - suffix.size(), suffix.size(), suffix) == 0;
                };
                if (endsWith(normalized, ".mjs")) {
                    normalized.resize(normalized.size() - 4);
                } else if (endsWith(normalized, ".js")) {
                    normalized.resize(normalized.size() - 3);
                }

                fullPathToFile = normalized;

                for (char& ch : fullPathToFile) {
                    const unsigned char c = static_cast<unsigned char>(ch);
                    const bool isIdentifierChar =
                            (c >= 'A' && c <= 'Z') ||
                            (c >= 'a' && c <= 'z') ||
                            (c >= '0' && c <= '9') ||
                            ch == '_';
                    if (!isIdentifierChar) {
                        ch = '_';
                    }
                }

                std::vector<std::string> pathParts;
                Util::SplitString(fullPathToFile, "_", pathParts);

                std::string lastPathPart;
                for (auto it = pathParts.rbegin(); it != pathParts.rend(); ++it) {
                    if (!it->empty()) {
                        lastPathPart = *it;
                        break;
                    }
                }
                if (lastPathPart.empty()) {
                    lastPathPart = "script";
                }
                fullPathToFile = lastPathPart;
            }

            int lineNumber = frame->GetLineNumber();
            if (lineNumber < 0) {
                extendLocationStream << fullPathToFile.c_str() << " unkown line number";
                extendLocation = extendLocationStream.str();
                return false;
            }

            int column = frame->GetColumn();
            if (column < 0) {
                extendLocationStream << fullPathToFile.c_str() << " line:" << lineNumber << " unkown column number";
                extendLocation = extendLocationStream.str();
                return false;
            }

            // Account for the column length offset added by the addition of the Common JS function wrapper
            // See issue https://github.com/NativeScript/android-runtime/issues/975
            if (lineNumber == 1) {
                column = column - ModuleInternal::MODULE_PROLOGUE_LENGTH;
            }

            extendLocationStream << fullPathToFile.c_str() << "_" << lineNumber << "_" << column << "_";
        }
    }

    extendLocation = extendLocationStream.str();
    return true;
}

MetadataNode* MetadataNode::GetNodeFromHandle(const Local<Object>& value) {
    auto node = GetInstanceMetadata(Isolate::GetCurrent(), value);
    return node;
}

MetadataEntry MetadataNode::GetChildMetadataForPackage(MetadataNode *node, const std::string &propName) {
    NS_DCHECK(node->m_treeNode->children != nullptr);

    MetadataEntry child(nullptr, NodeType::Class);

    const auto &children = *node->m_treeNode->children;

    for (auto treeNodeChild: children) {
        if (propName == treeNodeChild->name) {
            child.name = propName;
            child.treeNode = treeNodeChild;
            child.type = static_cast<NodeType>(s_metadataReader.GetNodeType(treeNodeChild));

            if (s_metadataReader.IsNodeTypeInterface((uint8_t) child.type)) {
                bool isPrefix;
                string declaringType = s_metadataReader.ReadInterfaceImplementationTypeName(
                        treeNodeChild, isPrefix);
                child.declaringType = isPrefix
                                      ? (declaringType +
                                         s_metadataReader.ReadTypeName(child.treeNode))
                                      : declaringType;
            }
        }
    }

    return child;
}

void MetadataNode::BuildMetadata(const string& filesPath) {
    timeval time1;
    gettimeofday(&time1, nullptr);

    string baseDir = filesPath;
    baseDir.append("/metadata");

    DIR* dir = opendir(baseDir.c_str());

    if(dir == nullptr){
        stringstream ss;
        ss << "metadata folder couldn't be opened! (Error: ";
        ss << errno;
        ss << ") ";

        // TODO: Is there a way to detect if the screen is locked as verification
        // We assume based on the error that this is the only way to get this specific error here at this point
        if (errno == ENOENT || errno == EACCES) {
            // Log the error with error code
            __android_log_print(ANDROID_LOG_ERROR, "TNS.error", "%s", ss.str().c_str());

            // While the screen is locked after boot; we cannot access our own apps directory on Android 9+
            // So the only thing to do at this point is just exit normally w/o crashing!

            // The only reason we should be in this specific path; is if:
            // 1) android:directBootAware="true" flag is set on receiver
            // 2) android.intent.action.LOCKED_BOOT_COMPLETED intent is set in manifest on above receiver
            // See:  https://developer.android.com/guide/topics/manifest/receiver-element
            //  and: https://developer.android.com/training/articles/direct-boot
            // This specific path occurs if you using the NativeScript-Local-Notification plugin, the
            // receiver code runs fine, but the app actually doesn't need to startup.  The Native code tries to
            // startup because the receiver is triggered.  So even though we are exiting, the receiver will have
            // done its job

            _Exit(0);
        }
        else {
          throw NativeScriptException(ss.str());
        }
    }
    // Only opened to tell a missing folder from a missing file.
    closedir(dir);

    string nodesFile = baseDir + "/treeNodeStream.dat";
    string namesFile = baseDir + "/treeStringsStream.dat";
    string valuesFile = baseDir + "/treeValueStream.dat";

    FILE* f = fopen(nodesFile.c_str(), "rb");
    if (f == nullptr) {
        stringstream ss;
        ss << "metadata file (treeNodeStream.dat) couldn't be opened! (Error: ";
        ss << errno;
        ss << ") ";

        throw NativeScriptException(ss.str());
    }
    fseek(f, 0, SEEK_END);
    int lenNodes = ftell(f);
    if (lenNodes < 0 ||
        (static_cast<size_t>(lenNodes) % sizeof(MetadataTreeNodeRawData)) != 0) {
        fclose(f);
        stringstream ss;
        ss << "Metadata file " << nodesFile << " is " << lenNodes
           << " bytes, which is not a whole number of "
           << sizeof(MetadataTreeNodeRawData)
           << "-byte records. The metadata is truncated or corrupt.";
        throw NativeScriptException(ss.str());
    }
    // Owned until the reader takes them, so a file that fails to open further
    // down does not strand the buffers already read.
    std::unique_ptr<char[]> nodes(new char[lenNodes]);
    rewind(f);
    fread(nodes.get(), 1, lenNodes, f);
    fclose(f);

    const int _512KB = 524288;

    f = fopen(namesFile.c_str(), "rb");
    if (f == nullptr) {
        stringstream ss;
        ss << "metadata file (treeStringsStream.dat) couldn't be opened! (Error: ";
        ss << errno;
        ss << ") ";
        throw NativeScriptException(ss.str());
    }
    fseek(f, 0, SEEK_END);
    int lenNames = ftell(f);
    std::unique_ptr<char[]> names(new char[lenNames + _512KB]);
    rewind(f);
    fread(names.get(), 1, lenNames, f);
    fclose(f);

    f = fopen(valuesFile.c_str(), "rb");
    if (f == nullptr) {
        stringstream ss;
        ss << "metadata file (treeValueStream.dat) couldn't be opened! (Error: ";
        ss << errno;
        ss << ") ";
        throw NativeScriptException(ss.str());
    }
    fseek(f, 0, SEEK_END);
    int lenValues = ftell(f);
    char* values = new char[lenValues + _512KB];
    rewind(f);
    fread(values, 1, lenValues, f);
    fclose(f);

    timeval time2;
    gettimeofday(&time2, nullptr);

    DEBUG_WRITE("lenNodes=%d, lenNames=%d, lenValues=%d", lenNodes, lenNames, lenValues);

    long millis1 = (time1.tv_sec * 1000) + (time1.tv_usec / 1000);
    long millis2 = (time2.tv_sec * 1000) + (time2.tv_usec / 1000);

    DEBUG_WRITE("time=%ld", (millis2 - millis1));

    // The reader keeps the names and values buffers for the life of the
    // process and only reads the nodes buffer while it builds the tree.
    BuildMetadata(lenNodes, reinterpret_cast<uint8_t*>(nodes.get()), lenNames, reinterpret_cast<uint8_t*>(names.release()), lenValues, reinterpret_cast<uint8_t*>(values));
}

void MetadataNode::BuildMetadata(uint32_t nodesLength, uint8_t* nodeData, uint32_t nameLength, uint8_t* nameData, uint32_t valueLength, uint8_t* valueData) {
    s_metadataReader.Initialize(nodesLength, nodeData, nameLength, nameData, valueLength, valueData, CallbackHandlers::GetTypeMetadata);
}

void MetadataNode::CreateTopLevelNamespaces(Isolate* isolate, const Local<Object>& global) {
    auto context = isolate->GetCurrentContext();
    auto root = s_metadataReader.GetRoot();

    const auto& children = *root->children;

    for (auto treeNode : children) {
        uint8_t nodeType = s_metadataReader.GetNodeType(treeNode);

        if (nodeType == MetadataTreeNode::PACKAGE) {
            auto node = GetOrCreateInternal(treeNode);

            auto packageObj = node->CreateWrapper(isolate);
            string nameSpace = node->m_treeNode->name;
            // if the namespaces matches a javascript keyword, prefix it with $ to avoid TypeScript and JavaScript errors
            if (IsJavascriptKeyword(nameSpace)) {
                nameSpace = "$" + nameSpace;
            }
            global->Set(context, ArgConverter::ConvertToV8String(isolate, nameSpace), packageObj);
        }
    }
}

MetadataNode::MetadataNodeCache* MetadataNode::GetMetadataNodeCache(Isolate* isolate) {
    // Per runtime; see RuntimeState.h. Null only once the runtime has begun
    // tearing down, which no caller here can legitimately reach.
    auto* cache = RuntimeState::For<MetadataNodeCache>(isolate);
    if (cache == nullptr) {
        throw NativeScriptException("Metadata cache requested after the runtime was torn down");
    }
    return cache;
}

void MetadataNode::EnableProfiler(bool enableProfiler) {
    s_profilerEnabled.store(enableProfiler, std::memory_order_relaxed);
}

bool MetadataNode::IsJavascriptKeyword(const std::string &word) {
    // Initialized in place rather than filled on first call: every runtime's
    // thread reaches this, and a lazy fill races the reads.
    static const set<string> keywords {
        "abstract", "arguments", "boolean", "break", "byte", "case", "catch", "char", "class", "const", "continue", "debugger", "default", "delete", "do",
        "double", "else", "enum", "eval", "export", "extends", "false", "final", "finally", "float", "for", "function", "goto", "if", "implements",
        "import", "in", "instanceof", "int", "interface", "let", "long", "native", "new", "null", "package", "private", "protected", "public", "return",
        "short", "static", "super", "switch", "synchronized", "this", "throw", "throws", "transient", "true", "try", "typeof", "var", "void", "volatile", "while", "with", "yield"
    };

    return keywords.find(word) != keywords.end();
}

Local<Function> MetadataNode::Wrap(Isolate* isolate, const Local<Function>& function, const string& name, const string& origin, bool isCtorFunc) {
    if (!s_profilerEnabled.load(std::memory_order_relaxed) || name == "<init>") {
        return function;
    }

    string actualName = name;
    while (IsJavascriptKeyword(actualName)) {
        actualName.append("_");
    }

    Local<Function> ret;

    stringstream ss;
    ss << "(function() { ";
    ss << "function " << actualName << "() { ";
    if (isCtorFunc) {
        ss << "var args = [null]; for (var i=0; i<arguments.length; i++) { args.push(arguments[i]); }; ";
        ss << "return new (Function.prototype.bind.apply(" << actualName << ".__func, args)); ";
    } else {
        ss << "return " << actualName << ".__func.apply(this, arguments); ";
    }
    ss << "} ";
    ss << "return " << actualName << "; ";
    ss << "})()";

    auto str = ss.str();
    auto source = ArgConverter::ConvertToV8String(isolate, str);
    auto context = isolate->GetCurrentContext();

    TryCatch tc(isolate);

    Local<Script> script;
    ScriptOrigin jsOrigin(ArgConverter::ConvertToV8String(isolate, origin));
    auto maybeScript = Script::Compile(context, source, &jsOrigin).ToLocal(&script);

    if (tc.HasCaught()) {
        throw NativeScriptException(tc, "Cannot compile wrapper");
    }

    if (!script.IsEmpty()) {
        Local<Value> result;
        auto maybeResult = script->Run(context).ToLocal(&result);

        if (!result.IsEmpty()) {
            ret = result.As<Function>();
            ret->Set(context, ArgConverter::ConvertToV8String(isolate, "__func"), function);
            ret->SetName(ArgConverter::ConvertToV8String(isolate, actualName));

            auto prototypePropName = V8StringConstants::GetPrototype(isolate);
            ret->Set(context, prototypePropName, function->Get(context, prototypePropName).ToLocalChecked());
        } else {
            throw NativeScriptException("Cannot create wrapper function");
        }
    } else {
        throw NativeScriptException(str);
    }

    return ret;
}

bool MetadataNode::CheckClassHierarchy(JEnv& env, jclass currentClass, MetadataTreeNode* curentTreeNode, MetadataTreeNode* baseTreeNode, std::vector<MetadataTreeNode*>& skippedBaseTypes) {
    auto shouldSkipBaseClass = false;
    if ((currentClass != nullptr) && (baseTreeNode != curentTreeNode) && (baseTreeNode != nullptr) &&
            (baseTreeNode->offsetValue > 0)) {
        auto baseNode = GetOrCreateInternal(baseTreeNode);
        auto baseClass = env.FindClass(baseNode->m_name);
        if (baseClass != nullptr) {
            auto isBaseClass = env.IsAssignableFrom(currentClass, baseClass) == JNI_TRUE;
            if (!isBaseClass) {
                skippedBaseTypes.push_back(baseTreeNode);
                shouldSkipBaseClass = true;
            }
        }
    }
    return shouldSkipBaseClass;
}

/*
 * This method handles scenrios like Bundle/BaseBundle class hierarchy change in API level 21.
 * See https://github.com/NativeScript/android-runtime/issues/628
 */
void MetadataNode::SetMissingBaseMethods(
        Isolate* isolate, const vector<MetadataTreeNode*>& skippedBaseTypes,
        const vector<MethodCallbackData*>& instanceMethodData,
        PrototypeTemplateFiller& protoFiller) {
    auto cache = GetMetadataNodeCache(isolate);
    for (auto treeNode: skippedBaseTypes) {
        uint8_t* curPtr = s_metadataReader.GetValueData() + treeNode->offsetValue + 1;

        auto nodeType = s_metadataReader.GetNodeType(treeNode);

        auto curType = s_metadataReader.ReadTypeName(treeNode);

        curPtr += sizeof(uint16_t /* baseClassId */);

        if (s_metadataReader.IsNodeTypeInterface(nodeType)) {
            curPtr += sizeof(uint8_t) + sizeof(uint32_t);
        }

        //get candidates from instance methods metadata
        auto instanceMethodCount = *reinterpret_cast<uint16_t*>(curPtr);
        curPtr += sizeof(uint16_t);
        MethodCallbackData* callbackData = nullptr;

        for (auto i = 0; i < instanceMethodCount; i++) {
            auto entry = MetadataReader::ReadInstanceMethodEntry(&curPtr);

            auto isConstructor = entry.getName() == "<init>";
            if (isConstructor) {
                continue;
            }

            for (auto data: instanceMethodData) {
                if (data->candidates.front().getName() == entry.getName()) {
                    callbackData = data;
                    break;
                }
            }

            if (callbackData == nullptr) {
                callbackData = cache->Own<MethodCallbackData>(this);
                protoFiller.FillPrototypeMethod(isolate, entry.getName(), callbackData);
            }

            bool foundSameSig = false;
            for (auto &m: callbackData->candidates) {
                foundSameSig = m.sig == entry.getSig();
                if (foundSameSig) {
                    break;
                }
            }

            if (!foundSameSig) {
                callbackData->candidates.push_back(std::move(entry));
            }
        }
    }
}

void MetadataNode::RegisterSymbolHasInstanceCallback(Isolate* isolate, MetadataEntry& entry, Local<Value> interface) {
    if (interface->IsNullOrUndefined()) {
        return;
    }

    JEnv env;
    auto className = GetJniClassName(entry);
    auto clazz = env.FindClass(className);
    if (clazz == nullptr) {
        return;
    }

    auto extData = External::New(isolate, clazz, v8::kExternalPointerTypeTagDefault);
    auto hasInstanceTemplate = FunctionTemplate::New(isolate, MetadataNode::SymbolHasInstanceCallback, extData);
    auto context = isolate->GetCurrentContext();
    auto hasInstanceFunc = hasInstanceTemplate->GetFunction(context).ToLocalChecked();
    PropertyDescriptor descriptor(hasInstanceFunc, false);
    auto hasInstanceSymbol = Symbol::GetHasInstance(isolate);
    interface->ToObject(context).ToLocalChecked()->DefineProperty(context, hasInstanceSymbol, descriptor);
}

void MetadataNode::SymbolHasInstanceCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    auto length = info.Length();
    if (length != 1) {
        throw NativeScriptException(string("Symbol.hasInstance must take exactly 1 argument"));
    }

    auto arg = info[0];
    if (arg->IsNullOrUndefined()) {
        info.GetReturnValue().Set(false);
        return;
    }

    auto clazz = reinterpret_cast<jclass>(info.Data().As<External>()->Value(v8::kExternalPointerTypeTagDefault));

    auto isolate = info.GetIsolate();
    auto context = isolate->GetCurrentContext();
    auto runtime = Runtime::GetRuntime(isolate);

    auto objectManager = runtime->GetObjectManager();
    auto obj = objectManager->GetJavaObjectByJsObject(arg->ToObject(context).ToLocalChecked());

    if (obj.IsNull()) {
        // Couldn't find a corresponding java instance counterpart. This could happen
        // if the "instanceof" operator is invoked on a pure javascript instance
        info.GetReturnValue().Set(false);
        return;
    }

    JEnv env;
    auto isInstanceOf = env.IsInstanceOf(obj, clazz);

    info.GetReturnValue().Set(isInstanceOf);
}

std::string MetadataNode::GetJniClassName(MetadataEntry& entry) {
    std::stack<string> s;
    MetadataTreeNode* n = entry.treeNode;
    while (n != nullptr && n->name != "") {
        s.push(n->name);
        n = n->parent;
    }

    string fullClassName;
    while (!s.empty()) {
        auto top = s.top();
        fullClassName = (fullClassName == "") ? top : fullClassName + "/" + top;
        s.pop();
    }

    return fullClassName;
}

MetadataReader* MetadataNode::getMetadataReader() {
    return &MetadataNode::s_metadataReader;
}

string MetadataNode::TNS_PREFIX = "com/tns/gen/";
MetadataReader MetadataNode::s_metadataReader;
robin_hood::unordered_map<std::string, MetadataNode*> MetadataNode::s_name2NodeCache;
robin_hood::unordered_map<std::string, MetadataTreeNode*> MetadataNode::s_name2TreeNodeCache;
robin_hood::unordered_map<MetadataTreeNode*, MetadataNode*> MetadataNode::s_treeNode2NodeCache;
std::mutex MetadataNode::s_nodeCacheMutex;
std::atomic<bool> MetadataNode::s_profilerEnabled{false};