@triniwiz/nativescript-masonkit 1.0.0-alpha.0 → 1.0.0-alpha.10

package/platforms/new_native_src/cpp/Helpers.h

@@ -0,0 +1,364 @@
+//
+// Created by Osei Fortune on 01/01/2024.
+//
+#pragma once
+#ifndef MASON_HELPERS_H
+#define MASON_HELPERS_H
+
+#include "Common.h"
+
+
+class Helpers {
+public:
+
+    static const char *LOG_TAG;
+
+    static int m_maxLogcatObjectSize;
+
+#ifdef __ANDROID__
+
+    static void sendToADBLogcat(const std::string &message, android_LogPriority logPriority);
+
+#endif
+
+    static void LogToConsole(const std::string &message);
+
+    static void ThrowIllegalConstructor(v8::Isolate *isolate);
+
+    static v8::Local<v8::String> ConvertToV8String(v8::Isolate *isolate, const std::string &string);
+
+    static std::string ConvertFromV8String(v8::Isolate *isolate, const v8::Local<v8::Value> &value);
+
+    static void
+    SetPrivate(v8::Isolate *isolate, v8::Local<v8::Object> object, const std::string &property,
+               v8::Local<v8::Value> value);
+
+    static v8::Local<v8::Value>
+    GetPrivate(v8::Isolate *isolate, v8::Local<v8::Object> object, const std::string &property);
+};
+
+inline static v8::Local<v8::Value>
+gridPlacementToJS(v8::Isolate *isolate, CMasonGridPlacement placement) {
+    switch (placement.value_type) {
+        case CMasonGridPlacementType::MasonGridPlacementTypeAuto: {
+            v8::Local<v8::Object> object = v8::Object::New((isolate));
+            object->Set(isolate->GetCurrentContext(), Helpers::ConvertToV8String(isolate, "value"),
+                        v8::Number::New(isolate, placement.value))
+                    .Check();
+            object->Set(isolate->GetCurrentContext(), Helpers::ConvertToV8String(isolate, "type"),
+                        v8::Number::New(isolate, 0))
+                    .Check();
+            return object;
+        }
+        case CMasonGridPlacementType::MasonGridPlacementTypeLine: {
+
+            v8::Local<v8::Object> object = v8::Object::New((isolate));
+            object->Set(isolate->GetCurrentContext(), Helpers::ConvertToV8String(isolate, "value"),
+                        v8::Number::New(isolate, placement.value))
+                    .Check();
+            object->Set(isolate->GetCurrentContext(), Helpers::ConvertToV8String(isolate, "type"),
+                        v8::Number::New(isolate, 1))
+                    .Check();
+            return object;
+        }
+        case CMasonGridPlacementType::MasonGridPlacementTypeSpan: {
+            v8::Local<v8::Object> object = v8::Object::New((isolate));
+            object->Set(isolate->GetCurrentContext(), Helpers::ConvertToV8String(isolate, "value"),
+                        v8::Number::New(isolate, placement.value))
+                    .Check();
+            object->Set(isolate->GetCurrentContext(), Helpers::ConvertToV8String(isolate, "type"),
+                        v8::Number::New(isolate, 2))
+                    .Check();
+            return object;
+        }
+        default:
+            return v8::Undefined(isolate);
+    }
+}
+
+inline static CMasonGridPlacement jsToGridPlacement(short value, int value_type) {
+    switch ((CMasonGridPlacementType) value_type) {
+        case CMasonGridPlacementType::MasonGridPlacementTypeAuto: {
+            return CMasonGridPlacement{0, CMasonGridPlacementType::MasonGridPlacementTypeAuto};
+        }
+        case CMasonGridPlacementType::MasonGridPlacementTypeLine: {
+            return CMasonGridPlacement{value, CMasonGridPlacementType::MasonGridPlacementTypeLine};
+        }
+        case CMasonGridPlacementType::MasonGridPlacementTypeSpan: {
+            return CMasonGridPlacement{value, CMasonGridPlacementType::MasonGridPlacementTypeSpan};
+        }
+        default:
+            // assert ??
+            return CMasonGridPlacement{0, CMasonGridPlacementType::MasonGridPlacementTypeAuto};
+    }
+}
+
+inline static v8::Local<v8::Value>
+lengthPercentageToJS(v8::Isolate *isolate, CMasonLengthPercentage length) {
+    switch (length.value_type) {
+        case CMasonLengthPercentageType::MasonLengthPercentagePercent: {
+            v8::Local<v8::Object> object = v8::Object::New((isolate));
+            object->Set(isolate->GetCurrentContext(), Helpers::ConvertToV8String(isolate, "value"),
+                        v8::Number::New(isolate, length.value / 100))
+                    .Check();
+            object->Set(isolate->GetCurrentContext(), Helpers::ConvertToV8String(isolate, "unit"),
+                        Helpers::ConvertToV8String(isolate, "%"))
+                    .Check();
+            return object;
+        }
+        case CMasonLengthPercentageType::MasonLengthPercentagePoints: {
+
+            v8::Local<v8::Object> object = v8::Object::New((isolate));
+            object->Set(isolate->GetCurrentContext(), Helpers::ConvertToV8String(isolate, "value"),
+                        v8::Number::New(isolate, length.value))
+                    .Check();
+            object->Set(isolate->GetCurrentContext(), Helpers::ConvertToV8String(isolate, "unit"),
+                        Helpers::ConvertToV8String(isolate, "px"))
+                    .Check();
+            return object;
+        }
+        default:
+            return v8::Undefined(isolate);
+    }
+}
+
+inline static CMasonLengthPercentage jsToLengthPercentage(float value, int value_type) {
+    switch ((CMasonLengthPercentageType) value_type) {
+        case CMasonLengthPercentageType::MasonLengthPercentagePercent: {
+            return CMasonLengthPercentage{value,
+                                          CMasonLengthPercentageType::MasonLengthPercentagePercent};
+        }
+        case CMasonLengthPercentageType::MasonLengthPercentagePoints: {
+            return CMasonLengthPercentage{value,
+                                          CMasonLengthPercentageType::MasonLengthPercentagePoints};
+        }
+        default:
+            // assert ??
+            return CMasonLengthPercentage{0,
+                                          CMasonLengthPercentageType::MasonLengthPercentagePoints};
+    }
+}
+
+inline static CMasonLengthPercentageType jsToLengthPercentageType(int value_type) {
+    switch ((CMasonLengthPercentageType) value_type) {
+        case CMasonLengthPercentageType::MasonLengthPercentagePercent: {
+            return CMasonLengthPercentageType::MasonLengthPercentagePercent;
+        }
+        case CMasonLengthPercentageType::MasonLengthPercentagePoints: {
+            return CMasonLengthPercentageType::MasonLengthPercentagePoints;
+        }
+        default:
+            // assert invalid type ???
+            return CMasonLengthPercentageType::MasonLengthPercentagePoints;
+    }
+}
+
+inline static v8::Local<v8::Value>
+lengthPercentageAutoToJS(v8::Isolate *isolate, CMasonLengthPercentageAuto length) {
+    switch (length.value_type) {
+        case CMasonLengthPercentageAutoType::MasonLengthPercentageAutoAuto:
+            return Helpers::ConvertToV8String(isolate, "auto");
+        case CMasonLengthPercentageAutoType::MasonLengthPercentageAutoPercent: {
+            v8::Local<v8::Object> object = v8::Object::New((isolate));
+            object->Set(isolate->GetCurrentContext(), Helpers::ConvertToV8String(isolate, "value"),
+                        v8::Number::New(isolate, length.value / 100))
+                    .Check();
+            object->Set(isolate->GetCurrentContext(), Helpers::ConvertToV8String(isolate, "unit"),
+                        Helpers::ConvertToV8String(isolate, "%"))
+                    .Check();
+            return object;
+        }
+        case CMasonLengthPercentageAutoType::MasonLengthPercentageAutoPoints: {
+            v8::Local<v8::Object> object = v8::Object::New((isolate));
+            object->Set(isolate->GetCurrentContext(), Helpers::ConvertToV8String(isolate, "value"),
+                        v8::Number::New(isolate, length.value))
+                    .Check();
+            object->Set(isolate->GetCurrentContext(), Helpers::ConvertToV8String(isolate, "unit"),
+                        Helpers::ConvertToV8String(isolate, "px"))
+                    .Check();
+
+            return object;
+        }
+        default:
+            return v8::Undefined(isolate);
+    }
+}
+
+inline static CMasonLengthPercentageAuto jsToLengthPercentageAuto(float value, int value_type) {
+    switch ((CMasonLengthPercentageAutoType) value_type) {
+        case CMasonLengthPercentageAutoType::MasonLengthPercentageAutoAuto:
+            return CMasonLengthPercentageAuto{value,
+                                              CMasonLengthPercentageAutoType::MasonLengthPercentageAutoAuto};
+        case CMasonLengthPercentageAutoType::MasonLengthPercentageAutoPercent: {
+            return CMasonLengthPercentageAuto{value,
+                                              CMasonLengthPercentageAutoType::MasonLengthPercentageAutoPercent};
+        }
+        case CMasonLengthPercentageAutoType::MasonLengthPercentageAutoPoints: {
+            return CMasonLengthPercentageAuto{value,
+                                              CMasonLengthPercentageAutoType::MasonLengthPercentageAutoPoints};
+        }
+        default:
+            // assert invalid type ???
+            return CMasonLengthPercentageAuto{0,
+                                              CMasonLengthPercentageAutoType::MasonLengthPercentageAutoPoints};
+    }
+}
+
+inline static CMasonLengthPercentageAutoType jsToLengthPercentageAutoType(int value_type) {
+    return (CMasonLengthPercentageAutoType) value_type;
+}
+
+inline static v8::Local<v8::Value> dimensionToJS(v8::Isolate *isolate, CMasonDimension dimension) {
+    switch ((CMasonDimensionType) dimension.value_type) {
+        case CMasonDimensionType::MasonDimensionAuto:
+            return Helpers::ConvertToV8String(isolate, "auto");
+        case CMasonDimensionType::MasonDimensionPercent: {
+
+            v8::Local<v8::Object> object = v8::Object::New((isolate));
+            object->Set(isolate->GetCurrentContext(), Helpers::ConvertToV8String(isolate, "value"),
+                        v8::Number::New(isolate, dimension.value / 100))
+                    .Check();
+            object->Set(isolate->GetCurrentContext(), Helpers::ConvertToV8String(isolate, "unit"),
+                        Helpers::ConvertToV8String(isolate, "%"))
+                    .Check();
+            return object;
+        }
+        case CMasonDimensionType::MasonDimensionPoints: {
+            v8::Local<v8::Object> object = v8::Object::New((isolate));
+            object->Set(isolate->GetCurrentContext(), Helpers::ConvertToV8String(isolate, "value"),
+                        v8::Number::New(isolate, dimension.value))
+                    .Check();
+            object->Set(isolate->GetCurrentContext(), Helpers::ConvertToV8String(isolate, "unit"),
+                        Helpers::ConvertToV8String(isolate, "px"))
+                    .Check();
+            return object;
+        }
+        default:
+            return v8::Undefined(isolate);
+    }
+}
+
+inline static CMasonDimension jsToDimension(float value, int value_type) {
+    switch ((CMasonDimensionType) value_type) {
+        case CMasonDimensionType::MasonDimensionAuto:
+            return CMasonDimension{value, CMasonDimensionType::MasonDimensionAuto};
+        case CMasonDimensionType::MasonDimensionPercent: {
+            return CMasonDimension{value, CMasonDimensionType::MasonDimensionPercent};
+        }
+        case CMasonDimensionType::MasonDimensionPoints: {
+            return CMasonDimension{value, CMasonDimensionType::MasonDimensionPoints};
+        }
+        default:
+            // assert invalid type ???
+            return CMasonDimension{0, CMasonDimensionType::MasonDimensionPoints};
+    }
+}
+
+inline static CMasonDimensionType jsToDimensionType(int value_type) {
+    return (CMasonDimensionType) value_type;
+}
+
+/*
+inline static v8::Local<v8::Value> sizeToJS(v8::Isolate *isolate, CMasonDimensionSize size)
+{
+    v8::Local<v8::Object> object = v8::Object::New((isolate));
+    object->Set(isolate->GetCurrentContext(), Helpers::ConvertToV8String(isolate,"width"),
+                dimensionToJS(isolate, size.width))
+            .Check();
+    object->Set(isolate->GetCurrentContext(), Helpers::ConvertToV8String(isolate,"height"),
+                dimensionToJS(isolate, size.width))
+            .Check();
+    return object;
+}
+
+inline static v8::Local<v8::Object>
+sizeToJS(v8::Isolate *isolate, CMasonLengthPercentageSize size)
+{
+
+    v8::Local<v8::Object> object = v8::Object::New((isolate));
+    object->Set(isolate->GetCurrentContext(), Helpers::ConvertToV8String(isolate,"width"),
+                lengthPercentageToJS(isolate, size.width))
+            .Check();
+    object->Set(isolate->GetCurrentContext(), Helpers::ConvertToV8String(isolate,"height"),
+                lengthPercentageToJS(isolate, size.width))
+            .Check();
+    return object;
+}
+
+inline static v8::Local<v8::Object>
+sizeToJS(v8::Isolate *isolate, CMasonLengthPercentageAutoSize size)
+{
+
+    v8::Local<v8::Object> object = v8::Object::New((isolate));
+    object->Set(isolate->GetCurrentContext(), Helpers::ConvertToV8String(isolate,"width"),
+                lengthPercentageAutoToJS(isolate, size.width))
+            .Check();
+    object->Set(isolate->GetCurrentContext(), Helpers::ConvertToV8String(isolate,"height"),
+                lengthPercentageAutoToJS(isolate, size.width))
+            .Check();
+    return object;
+}
+
+inline static v8::Local<v8::Object> rectToJS(v8::Isolate *isolate, CMasonDimensionRect rect)
+{
+
+    v8::Local<v8::Object> object = v8::Object::New((isolate));
+    object->Set(isolate->GetCurrentContext(), Helpers::ConvertToV8String(isolate,"left"),
+                dimensionToJS(isolate, rect.left))
+            .Check();
+    object->Set(isolate->GetCurrentContext(), Helpers::ConvertToV8String(isolate,"right"),
+                dimensionToJS(isolate, rect.right))
+            .Check();
+    object->Set(isolate->GetCurrentContext(), Helpers::ConvertToV8String(isolate,"top"),
+                dimensionToJS(isolate, rect.top))
+            .Check();
+    object->Set(isolate->GetCurrentContext(), Helpers::ConvertToV8String(isolate,"bottom"),
+                dimensionToJS(isolate, rect.bottom))
+            .Check();
+    return object;
+}
+
+inline static v8::Local<v8::Object>
+rectToJS(v8::Isolate *isolate, CMasonLengthPercentageRect rect)
+{
+
+    v8::Local<v8::Object> object = v8::Object::New((isolate));
+    object->Set(isolate->GetCurrentContext(), Helpers::ConvertToV8String(isolate,"left"),
+                lengthPercentageToJS(isolate, rect.left))
+            .Check();
+    object->Set(isolate->GetCurrentContext(), Helpers::ConvertToV8String(isolate,"right"),
+                lengthPercentageToJS(isolate, rect.right))
+            .Check();
+    object->Set(isolate->GetCurrentContext(), Helpers::ConvertToV8String(isolate,"top"),
+                lengthPercentageToJS(isolate, rect.top))
+            .Check();
+    object->Set(isolate->GetCurrentContext(), Helpers::ConvertToV8String(isolate,"bottom"),
+                lengthPercentageToJS(isolate, rect.bottom))
+            .Check();
+    return object;
+}
+
+inline static v8::Local<v8::Object>
+rectToJS(v8::Isolate *isolate, CMasonLengthPercentageAutoRect rect)
+{
+    v8::Local<v8::Object> object = v8::Object::New((isolate));
+    object->Set(isolate->GetCurrentContext(), Helpers::ConvertToV8String(isolate,"left"),
+                lengthPercentageAutoToJS(isolate, rect.left))
+            .Check();
+    object->Set(isolate->GetCurrentContext(), Helpers::ConvertToV8String(isolate,"right"),
+                lengthPercentageAutoToJS(isolate, rect.right))
+            .Check();
+    object->Set(isolate->GetCurrentContext(), Helpers::ConvertToV8String(isolate,"top"),
+                lengthPercentageAutoToJS(isolate, rect.top))
+            .Check();
+    object->Set(isolate->GetCurrentContext(), Helpers::ConvertToV8String(isolate,"bottom"),
+                lengthPercentageAutoToJS(isolate, rect.bottom))
+            .Check();
+    return object;
+}
+
+*/
+
+
+
+#endif //MASON_HELPERS_H

package/platforms/new_native_src/cpp/MasonImpl.cpp

@@ -0,0 +1,68 @@
+//
+// Created by Osei Fortune on 01/01/2024.
+//
+
+#include "MasonImpl.h"
+#include "Caches.h"
+
+
+void MasonImpl::Init(v8::Isolate *isolate) {
+    v8::Locker locker(isolate);
+    v8::Isolate::Scope isolate_scope(isolate);
+    v8::HandleScope handle_scope(isolate);
+
+    auto ctor = GetCtor(isolate);
+    auto context = isolate->GetCurrentContext();
+    auto global = context->Global();
+    auto func = ctor->GetFunction(context).ToLocalChecked();
+
+    global->Set(context, Helpers::ConvertToV8String(isolate, "NSCMason"), func);
+}
+
+MasonImpl *MasonImpl::GetPointer(v8::Local<v8::Object> object) {
+    auto ptr = object->GetInternalField(0).As<v8::External>()->Value();
+    if (ptr == nullptr) {
+        return nullptr;
+    }
+    return static_cast<MasonImpl *>(ptr);
+}
+
+v8::Local<v8::FunctionTemplate> MasonImpl::GetCtor(v8::Isolate *isolate) {
+    auto cache = Caches::Get(isolate);
+    auto ctor = cache->MasonTmpl.get();
+    if (ctor != nullptr) {
+        return ctor->Get(isolate);
+    }
+
+    v8::Local<v8::FunctionTemplate> ctorTmpl = v8::FunctionTemplate::New(isolate, nullptr);
+
+    ctorTmpl->InstanceTemplate()->SetInternalFieldCount(1);
+    ctorTmpl->SetClassName(Helpers::ConvertToV8String(isolate, "NSCMason"));
+
+    auto tmpl = ctorTmpl->InstanceTemplate();
+    tmpl->SetInternalFieldCount(1);
+
+
+    tmpl->Set(
+            Helpers::ConvertToV8String(isolate, "clear"),
+            v8::FunctionTemplate::New(isolate, &Clear));
+
+
+    cache->MasonTmpl =
+            std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
+
+    return ctorTmpl;
+
+}
+
+MasonImpl::MasonImpl(void *mason) : mason_(mason) {}
+
+
+void MasonImpl::Clear(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    auto ptr = GetPointer(args.This());
+    if (ptr != nullptr) {
+        mason_clear(ptr->mason_);
+    }
+}
+
+

package/platforms/new_native_src/cpp/MasonImpl.h

@@ -0,0 +1,40 @@
+//
+// Created by Osei Fortune on 01/01/2024.
+//
+
+#ifndef MASON_IMPL_H
+#define MASON_IMPL_H
+
+#include "Common.h"
+#include "Helpers.h"
+
+class MasonImpl {
+private:
+    void *mason_;
+
+public:
+
+    ~MasonImpl() {
+        if (mason_ != nullptr) {
+            mason_destroy(mason_);
+            mason_ = nullptr;
+        }
+    }
+
+    void *GetMason() {
+        return mason_;
+    }
+
+    MasonImpl(void *mason);
+
+    static void Init(v8::Isolate *isolate);
+
+    static MasonImpl *GetPointer(v8::Local<v8::Object> object);
+
+    static v8::Local<v8::FunctionTemplate> GetCtor(v8::Isolate *isolate);
+
+    static void Clear(const v8::FunctionCallbackInfo<v8::Value> &args);
+};
+
+
+#endif //MASON_IMPL_H

package/platforms/new_native_src/cpp/MasonNodeImpl.cpp

@@ -0,0 +1,89 @@
+//
+// Created by Osei Fortune on 01/01/2024.
+//
+
+#include "MasonNodeImpl.h"
+#include "Caches.h"
+#include "MasonStyleImpl.h"
+
+void MasonNodeImpl::Init(v8::Isolate *isolate) {
+    v8::Locker locker(isolate);
+    v8::Isolate::Scope isolate_scope(isolate);
+    v8::HandleScope handle_scope(isolate);
+
+    auto ctor = GetCtor(isolate);
+    auto context = isolate->GetCurrentContext();
+    auto global = context->Global();
+    auto func = ctor->GetFunction(context).ToLocalChecked();
+
+    global->Set(context, Helpers::ConvertToV8String(isolate, "NSCMasonNode"), func);
+}
+
+MasonNodeImpl *MasonNodeImpl::GetPointer(v8::Local<v8::Object> object) {
+    auto ptr = object->GetInternalField(0).As<v8::External>()->Value();
+    if (ptr == nullptr) {
+        return nullptr;
+    }
+    return static_cast<MasonNodeImpl *>(ptr);
+}
+
+v8::Local<v8::FunctionTemplate> MasonNodeImpl::GetCtor(v8::Isolate *isolate) {
+    auto cache = Caches::Get(isolate);
+    auto ctor = cache->MasonNodeTmpl.get();
+    if (ctor != nullptr) {
+        return ctor->Get(isolate);
+    }
+
+    v8::Local<v8::FunctionTemplate> ctorTmpl = v8::FunctionTemplate::New(isolate, nullptr);
+
+    ctorTmpl->InstanceTemplate()->SetInternalFieldCount(1);
+    ctorTmpl->SetClassName(Helpers::ConvertToV8String(isolate, "NSCMasonNode"));
+
+    auto tmpl = ctorTmpl->InstanceTemplate();
+    tmpl->SetInternalFieldCount(1);
+
+    tmpl->SetAccessor(
+            Helpers::ConvertToV8String(isolate, "style"),
+            &GetStyle,
+            &SetStyle
+    );
+
+    cache->MasonNodeTmpl =
+            std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
+
+    return ctorTmpl;
+
+}
+
+MasonNodeImpl::MasonNodeImpl(void *node) : node_(node) {}
+
+
+void MasonNodeImpl::GetStyle(v8::Local<v8::String> property,
+                                        const v8::PropertyCallbackInfo<v8::Value> &info) {
+    auto isolate = info.GetIsolate();
+    MasonNodeImpl *ptr = GetPointer(info.This());
+    if (ptr == nullptr) {
+        info.GetReturnValue().SetNull();
+        return;
+    }
+
+    auto value = mason_node_get_style(ptr->node_);
+   auto style = new MasonStyleImpl( )
+    auto ret = ;
+    info.GetReturnValue().Set(Helpers::ConvertToV8String(isolate, parsed));
+}
+
+void MasonNodeImpl::SetStyle(v8::Local<v8::String> property,
+                                        v8::Local<v8::Value> value,
+                                        const v8::PropertyCallbackInfo<void> &info) {
+    MasonNodeImpl *ptr = GetPointer(info.This());
+    if (ptr == nullptr) {
+        return;
+    }
+    auto isolate = info.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+    auto val = value->Int32Value(context).ToChecked();
+    mason_style_set_grid_auto_columns(ptr->style_, val);
+}
+
+

package/platforms/new_native_src/cpp/MasonNodeImpl.h

@@ -0,0 +1,47 @@
+//
+// Created by Osei Fortune on 01/01/2024.
+//
+
+#ifndef MASON_NODEIMPL_H
+#define MASON_NODEIMPL_H
+
+#include "Common.h"
+#include "Helpers.h"
+
+class MasonNodeImpl {
+private:
+    void *node_;
+    void *style_;
+
+public:
+
+    void *GetNode() const {
+        return node_;
+    }
+
+    ~MasonNodeImpl() {
+        if (node_ != nullptr) {
+            mason_node_destroy(node_);
+            node_ = nullptr;
+        }
+    }
+
+    MasonNodeImpl(void *node);
+
+    static void Init(v8::Isolate *isolate);
+
+    static MasonNodeImpl *GetPointer(v8::Local<v8::Object> object);
+
+    static v8::Local<v8::FunctionTemplate> GetCtor(v8::Isolate *isolate);
+
+    static void GetStyle(v8::Local<v8::String> property,
+                                       const v8::PropertyCallbackInfo<v8::Value> &info);
+
+    static void SetStyle(v8::Local<v8::String> property,
+                                       v8::Local<v8::Value> value,
+                                       const v8::PropertyCallbackInfo<void> &info);
+
+};
+
+
+#endif //MASON_NODEIMPL_H