{

// Make GC aware of device memory.

// Event it's VRAM this should keep the usage on low (few hundred megabytes),

// so we won't triggrer out of memory errors.

return static_cast<int>(sizeof(af::array)) + static_cast<int>(sizeof(ArrayWrapper)) + static_cast<int>(array->bytes());

_array(array)

{

assert(array);

Nan::AdjustExternalMemory(GetMemSize(array));

{

if (_array)

{

Nan::AdjustExternalMemory(-GetMemSize(_array));

delete _array;

_array = nullptr;

}

{

Nan::HandleScope scope;

auto tmpl = Nan::New<FunctionTemplate>(New);

tmpl->SetClassName(Nan::New("AFArray").ToLocalChecked());

int noOfMethods = 21;

tmpl->InstanceTemplate()->SetInternalFieldCount(noOfMethods);

Nan::SetPrototypeTemplate(tmpl, Nan::New("free").ToLocalChecked(), Nan::New<FunctionTemplate>(V8Free), v8::None);

Nan::SetPrototypeTemplate(tmpl, Nan::New("elements").ToLocalChecked(), Nan::New<FunctionTemplate>(Elements), v8::None);

Nan::SetPrototypeTemplate(tmpl, Nan::New("host").ToLocalChecked(), Nan::New<FunctionTemplate>(Host), v8::None);

Nan::SetPrototypeTemplate(tmpl, Nan::New("copyToHost").ToLocalChecked(), Nan::New<FunctionTemplate>(Host), v8::None);

Nan::SetPrototypeTemplate(tmpl, Nan::New("scalar").ToLocalChecked(), Nan::New<FunctionTemplate>(Scalar), v8::None);

Nan::SetPrototypeTemplate(tmpl, Nan::New("value").ToLocalChecked(), Nan::New<FunctionTemplate>(Scalar), v8::None);

Nan::SetPrototypeTemplate(tmpl, Nan::New("write").ToLocalChecked(), Nan::New<FunctionTemplate>(Write), v8::None);

Nan::SetPrototypeTemplate(tmpl, Nan::New("type").ToLocalChecked(), Nan::New<FunctionTemplate>(Type), v8::None);

Nan::SetPrototypeTemplate(tmpl, Nan::New("dims").ToLocalChecked(), Nan::New<FunctionTemplate>(Dims), v8::None);

Nan::SetPrototypeTemplate(tmpl, Nan::New("numdims").ToLocalChecked(), Nan::New<FunctionTemplate>(NumDims), v8::None);

Nan::SetPrototypeTemplate(tmpl, Nan::New("numDims").ToLocalChecked(), Nan::New<FunctionTemplate>(NumDims), v8::None);

Nan::SetPrototypeTemplate(tmpl, Nan::New("bytes").ToLocalChecked(), Nan::New<FunctionTemplate>(Bytes), v8::None);

Nan::SetPrototypeTemplate(tmpl, Nan::New("copy").ToLocalChecked(), Nan::New<FunctionTemplate>(Copy), v8::None);

Nan::SetPrototypeTemplate(tmpl, Nan::New("isempty").ToLocalChecked(), Nan::New<FunctionTemplate>(IsEmpty), v8::None);

Nan::SetPrototypeTemplate(tmpl, Nan::New("isEmpty").ToLocalChecked(), Nan::New<FunctionTemplate>(IsEmpty), v8::None);

Nan::SetPrototypeTemplate(tmpl, Nan::New("isscalar").ToLocalChecked(), Nan::New<FunctionTemplate>(IsScalar), v8::None);

Nan::SetPrototypeTemplate(tmpl, Nan::New("isScalar").ToLocalChecked(), Nan::New<FunctionTemplate>(IsScalar), v8::None);

Nan::SetPrototypeTemplate(tmpl, Nan::New("isvector").ToLocalChecked(), Nan::New<FunctionTemplate>(IsVector), v8::None);

Nan::SetPrototypeTemplate(tmpl, Nan::New("isVector").ToLocalChecked(), Nan::New<FunctionTemplate>(IsVector), v8::None);

Nan::SetPrototypeTemplate(tmpl, Nan::New("isrow").ToLocalChecked(), Nan::New<FunctionTemplate>(IsRow), v8::None);

Nan::SetPrototypeTemplate(tmpl, Nan::New("isRow").ToLocalChecked(), Nan::New<FunctionTemplate>(IsRow), v8::None);

Nan::SetPrototypeTemplate(tmpl, Nan::New("iscolumn").ToLocalChecked(), Nan::New<FunctionTemplate>(IsColumn), v8::None);

Nan::SetPrototypeTemplate(tmpl, Nan::New("isColumn").ToLocalChecked(), Nan::New<FunctionTemplate>(IsColumn), v8::None);

Nan::SetPrototypeTemplate(tmpl, Nan::New("iscomplex").ToLocalChecked(), Nan::New<FunctionTemplate>(IsComplex), v8::None);

Nan::SetPrototypeTemplate(tmpl, Nan::New("isComplex").ToLocalChecked(), Nan::New<FunctionTemplate>(IsComplex), v8::None);

Nan::SetPrototypeTemplate(tmpl, Nan::New("isreal").ToLocalChecked(), Nan::New<FunctionTemplate>(IsReal), v8::None);

Nan::SetPrototypeTemplate(tmpl, Nan::New("isReal").ToLocalChecked(), Nan::New<FunctionTemplate>(IsReal), v8::None);

Nan::SetPrototypeTemplate(tmpl, Nan::New("isdouble").ToLocalChecked(), Nan::New<FunctionTemplate>(IsDouble), v8::None);

Nan::SetPrototypeTemplate(tmpl, Nan::New("isDouble").ToLocalChecked(), Nan::New<FunctionTemplate>(IsDouble), v8::None);

Nan::SetPrototypeTemplate(tmpl, Nan::New("issingle").ToLocalChecked(), Nan::New<FunctionTemplate>(IsSingle), v8::None);

Nan::SetPrototypeTemplate(tmpl, Nan::New("isSingle").ToLocalChecked(), Nan::New<FunctionTemplate>(IsSingle), v8::None);

Nan::SetPrototypeTemplate(tmpl, Nan::New("isrealfloating").ToLocalChecked(), Nan::New<FunctionTemplate>(IsRealFloating), v8::None);

Nan::SetPrototypeTemplate(tmpl, Nan::New("isRealFloating").ToLocalChecked(), Nan::New<FunctionTemplate>(IsRealFloating), v8::None);

Nan::SetPrototypeTemplate(tmpl, Nan::New("isfloating").ToLocalChecked(), Nan::New<FunctionTemplate>(IsFloating), v8::None);

Nan::SetPrototypeTemplate(tmpl, Nan::New("isFloating").ToLocalChecked(), Nan::New<FunctionTemplate>(IsFloating), v8::None);

Nan::SetPrototypeTemplate(tmpl, Nan::New("isinteger").ToLocalChecked(), Nan::New<FunctionTemplate>(IsInteger), v8::None);

Nan::SetPrototypeTemplate(tmpl, Nan::New("isInteger").ToLocalChecked(), Nan::New<FunctionTemplate>(IsInteger), v8::None);

Nan::SetPrototypeTemplate(tmpl, Nan::New("isbool").ToLocalChecked(), Nan::New<FunctionTemplate>(IsBool), v8::None);

Nan::SetPrototypeTemplate(tmpl, Nan::New("isBool").ToLocalChecked(), Nan::New<FunctionTemplate>(IsBool), v8::None);

Nan::SetPrototypeTemplate(tmpl, Nan::New("afEval").ToLocalChecked(), Nan::New<FunctionTemplate>(Eval), v8::None);

Nan::SetPrototypeTemplate(tmpl, Nan::New("at").ToLocalChecked(), Nan::New<FunctionTemplate>(At), v8::None);

Nan::SetPrototypeTemplate(tmpl, Nan::New("row").ToLocalChecked(), Nan::New<FunctionTemplate>(Row), v8::None);

Nan::SetPrototypeTemplate(tmpl, Nan::New("col").ToLocalChecked(), Nan::New<FunctionTemplate>(Col), v8::None);

Nan::SetPrototypeTemplate(tmpl, Nan::New("slice").ToLocalChecked(), Nan::New<FunctionTemplate>(Slice), v8::None);

Nan::SetPrototypeTemplate(tmpl, Nan::New("rows").ToLocalChecked(), Nan::New<FunctionTemplate>(Rows), v8::None);

Nan::SetPrototypeTemplate(tmpl, Nan::New("cols").ToLocalChecked(), Nan::New<FunctionTemplate>(Cols), v8::None);

Nan::SetPrototypeTemplate(tmpl, Nan::New("slices").ToLocalChecked(), Nan::New<FunctionTemplate>(Slices), v8::None);

Nan::SetPrototypeTemplate(tmpl, Nan::New("as").ToLocalChecked(), Nan::New<FunctionTemplate>(As), v8::None);

Nan::SetPrototypeTemplate(tmpl, Nan::New("assign").ToLocalChecked(), Nan::New<FunctionTemplate>(Assign), v8::None);

Nan::SetPrototypeTemplate(tmpl, Nan::New("set").ToLocalChecked(), Nan::New<FunctionTemplate>(Assign), v8::None);

Nan::SetPrototypeTemplate(tmpl, Nan::New("add").ToLocalChecked(), Nan::New<FunctionTemplate>(Add), v8::None);

Nan::SetPrototypeTemplate(tmpl, Nan::New("addAssign").ToLocalChecked(), Nan::New<FunctionTemplate>(AddAssign), v8::None);

Nan::SetPrototypeTemplate(tmpl, Nan::New("sub").ToLocalChecked(), Nan::New<FunctionTemplate>(Sub), v8::None);

Nan::SetPrototypeTemplate(tmpl, Nan::New("subAssign").ToLocalChecked(), Nan::New<FunctionTemplate>(SubAssign), v8::None);

Nan::SetPrototypeTemplate(tmpl, Nan::New("mul").ToLocalChecked(), Nan::New<FunctionTemplate>(Mul), v8::None);

Nan::SetPrototypeTemplate(tmpl, Nan::New("mulAssign").ToLocalChecked(), Nan::New<FunctionTemplate>(MulAssign), v8::None);

Nan::SetPrototypeTemplate(tmpl, Nan::New("div").ToLocalChecked(), Nan::New<FunctionTemplate>(Div), v8::None);

Nan::SetPrototypeTemplate(tmpl, Nan::New("divAssign").ToLocalChecked(), Nan::New<FunctionTemplate>(DivAssign), v8::None);

Nan::SetPrototypeTemplate(tmpl, Nan::New("bitshiftl").ToLocalChecked(), Nan::New<FunctionTemplate>(BitShiftL), v8::None);

Nan::SetPrototypeTemplate(tmpl, Nan::New("bitShiftL").ToLocalChecked(), Nan::New<FunctionTemplate>(BitShiftL), v8::None);

Nan::SetPrototypeTemplate(tmpl, Nan::New("bitshiftr").ToLocalChecked(), Nan::New<FunctionTemplate>(BitShiftR), v8::None);

Nan::SetPrototypeTemplate(tmpl, Nan::New("bitShiftR").ToLocalChecked(), Nan::New<FunctionTemplate>(BitShiftR), v8::None);

Nan::SetPrototypeTemplate(tmpl, Nan::New("lt").ToLocalChecked(), Nan::New<FunctionTemplate>(Lt), v8::None);

Nan::SetPrototypeTemplate(tmpl, Nan::New("gt").ToLocalChecked(), Nan::New<FunctionTemplate>(Gt), v8::None);

Nan::SetPrototypeTemplate(tmpl, Nan::New("le").ToLocalChecked(), Nan::New<FunctionTemplate>(Le), v8::None);

Nan::SetPrototypeTemplate(tmpl, Nan::New("ge").ToLocalChecked(), Nan::New<FunctionTemplate>(Ge), v8::None);

Nan::SetPrototypeTemplate(tmpl, Nan::New("eq").ToLocalChecked(), Nan::New<FunctionTemplate>(Eq), v8::None);

Nan::SetPrototypeTemplate(tmpl, Nan::New("neq").ToLocalChecked(), Nan::New<FunctionTemplate>(Neq), v8::None);

Nan::SetPrototypeTemplate(tmpl, Nan::New("and").ToLocalChecked(), Nan::New<FunctionTemplate>(And), v8::None);

Nan::SetPrototypeTemplate(tmpl, Nan::New("or").ToLocalChecked(), Nan::New<FunctionTemplate>(Or), v8::None);

Nan::SetPrototypeTemplate(tmpl, Nan::New("bitAnd").ToLocalChecked(), Nan::New<FunctionTemplate>(BitAnd), v8::None);

Nan::SetPrototypeTemplate(tmpl, Nan::New("bitOr").ToLocalChecked(), Nan::New<FunctionTemplate>(BitOr), v8::None);

Nan::SetPrototypeTemplate(tmpl, Nan::New("bitXor").ToLocalChecked(), Nan::New<FunctionTemplate>(BitXor), v8::None);

Nan::SetPrototypeTemplate(tmpl, Nan::New("rhsAdd").ToLocalChecked(), Nan::New<FunctionTemplate>(RhsAdd), v8::None);

Nan::SetPrototypeTemplate(tmpl, Nan::New("rhsSub").ToLocalChecked(), Nan::New<FunctionTemplate>(RhsSub), v8::None);

Nan::SetPrototypeTemplate(tmpl, Nan::New("rhsMul").ToLocalChecked(), Nan::New<FunctionTemplate>(RhsMul), v8::None);

Nan::SetPrototypeTemplate(tmpl, Nan::New("rhsDiv").ToLocalChecked(), Nan::New<FunctionTemplate>(RhsDiv), v8::None);

Nan::SetPrototypeTemplate(tmpl, Nan::New("rhsBitshiftl").ToLocalChecked(), Nan::New<FunctionTemplate>(RhsBitShiftL), v8::None);

Nan::SetPrototypeTemplate(tmpl, Nan::New("rhsBitShiftL").ToLocalChecked(), Nan::New<FunctionTemplate>(RhsBitShiftL), v8::None);

Nan::SetPrototypeTemplate(tmpl, Nan::New("rhsBitshiftr").ToLocalChecked(), Nan::New<FunctionTemplate>(RhsBitShiftR), v8::None);

Nan::SetPrototypeTemplate(tmpl, Nan::New("rhsBitShiftR").ToLocalChecked(), Nan::New<FunctionTemplate>(RhsBitShiftR), v8::None);

Nan::SetPrototypeTemplate(tmpl, Nan::New("rhsLt").ToLocalChecked(), Nan::New<FunctionTemplate>(RhsLt), v8::None);

Nan::SetPrototypeTemplate(tmpl, Nan::New("rhsGt").ToLocalChecked(), Nan::New<FunctionTemplate>(RhsGt), v8::None);

Nan::SetPrototypeTemplate(tmpl, Nan::New("rhsLe").ToLocalChecked(), Nan::New<FunctionTemplate>(RhsLe), v8::None);

Nan::SetPrototypeTemplate(tmpl, Nan::New("rhsGe").ToLocalChecked(), Nan::New<FunctionTemplate>(RhsGe), v8::None);

Nan::SetPrototypeTemplate(tmpl, Nan::New("rhsEq").ToLocalChecked(), Nan::New<FunctionTemplate>(RhsEq), v8::None);

Nan::SetPrototypeTemplate(tmpl, Nan::New("rhsNeq").ToLocalChecked(), Nan::New<FunctionTemplate>(RhsNeq), v8::None);

Nan::SetPrototypeTemplate(tmpl, Nan::New("rhsAnd").ToLocalChecked(), Nan::New<FunctionTemplate>(RhsAnd), v8::None);

Nan::SetPrototypeTemplate(tmpl, Nan::New("rhsOr").ToLocalChecked(), Nan::New<FunctionTemplate>(RhsOr), v8::None);

Nan::SetPrototypeTemplate(tmpl, Nan::New("rhsBitAnd").ToLocalChecked(), Nan::New<FunctionTemplate>(RhsBitAnd), v8::None);

Nan::SetPrototypeTemplate(tmpl, Nan::New("rhsBitOr").ToLocalChecked(), Nan::New<FunctionTemplate>(RhsBitOr), v8::None);

Nan::SetPrototypeTemplate(tmpl, Nan::New("rhsBitXor").ToLocalChecked(), Nan::New<FunctionTemplate>(RhsBitXor), v8::None);

Nan::SetPrototypeTemplate(tmpl, Nan::New("neg").ToLocalChecked(), Nan::New<FunctionTemplate>(Neg), v8::None);

Nan::SetPrototypeTemplate(tmpl, Nan::New("not").ToLocalChecked(), Nan::New<FunctionTemplate>(Not), v8::None);

Nan::SetPrototypeTemplate(tmpl, Nan::New("T").ToLocalChecked(), Nan::New<FunctionTemplate>(AFT), v8::None);

Nan::SetPrototypeTemplate(tmpl, Nan::New("S").ToLocalChecked(), Nan::New<FunctionTemplate>(AFH), v8::None);

auto f = tmpl->GetFunction();

f->Set(Nan::New("create").ToLocalChecked(), Nan::New<FunctionTemplate>(Create)->GetFunction());

constructor.Reset(f);

Nan::Set(target, Nan::New<String>("AFArray").ToLocalChecked(), f);

{

Nan::EscapableHandleScope scope;

assert(array);

Local<Value> info[] = { WrapPointer(array) };

auto c = Nan::New(constructor);

auto inst = c->NewInstance(1, info);

assert(ObjectWrap::Unwrap<ArrayWrapper>(inst)->_array == array);

return scope.Escape(inst);

{

if (info.Length() >= 1 && info[info.Length() - 1]->IsFunction())

{

auto callback = new Nan::Callback(info[info.Length() - 1].As<Function>());

auto worker = new Worker<af::array*>(callback, arrayFactory, [](Worker<af::array*>* w, af::array* a){ return ArrayWrapper::New(a); });

Nan::AsyncQueueWorker(worker);

info.GetReturnValue().SetUndefined();

}

else

{

NAN_THROW("Last argument have to be a callback!");

}

{

try

{

ArrayWrapper* instance = nullptr;

try

{

if (info.Length() == 0)

{

Guard guard;

instance = new ArrayWrapper(new af::array());

}

else if (info.Length() == 1)

{

if (Buffer::HasInstance(info[0]))

{

instance = new ArrayWrapper(reinterpret_cast<af::array*>(Buffer::Data(info[0])));

}

}

else

{

Guard guard;

auto arr = TryGetArrayAt(info, 0);

if (arr)

{

auto dims = ToDim4(info[1]);

instance = new ArrayWrapper(new af::array(*arr, dims));

}

else

{

auto dimAndType = ParseDimAndTypeArgs(info);

instance = new ArrayWrapper(new af::array(dimAndType.first, dimAndType.second));

}

}

}

catch (...)

{

delete instance;

throw;

}

if (!instance)

{

return NAN_THROW("Invalid arguments.");

}

instance->Wrap(info.Holder());

RegisterInTmp(info.Holder());

info.GetReturnValue().Set(info.Holder());

}

ARRAYFIRE_CATCH

{

auto self = ObjectWrap::Unwrap<ArrayWrapper>(info.This());

self->Free();

info.GetReturnValue().SetUndefined();

{

try

{

int buffIdx = -1;

function<af::array*()> factory;

for (int i = 0; i < info.Length(); i++)

{

if (Buffer::HasInstance(info[i]))

{

buffIdx = i;

break;

}

}

if (buffIdx == -1)

{

return NAN_THROW("Buffer argument expected.");

}

else if (buffIdx + 1 < info.Length())

{

// Copy / wrap ptr

// info: dim0..dimn, dtype, ptr[, source]

af_source src = afHost;

if (buffIdx + 1 < info.Length() && info[buffIdx + 1]->IsNumber())

{

src = (af_source)(info[buffIdx + 2]->Int32Value());

}

auto buffObj = info[buffIdx]->ToObject();

char* ptr = Buffer::Data(buffObj);

auto dimAndType = ParseDimAndTypeArgs(info, buffIdx);

switch (dimAndType.second)

{

case f32:

factory = [=]() { return CreateArray<float>(ptr, src, dimAndType.first); };

break;

case f64:

factory = [=]() { return CreateArray<double>(ptr, src, dimAndType.first); };

break;

case s32:

factory = [=]() { return CreateArray<int>(ptr, src, dimAndType.first); };

break;

case u32:

factory = [=]() { return CreateArray<unsigned>(ptr, src, dimAndType.first); };

break;

case u8:

factory = [=]() { return CreateArray<unsigned char>(ptr, src, dimAndType.first ); };

break;

case c32:

factory = [=]() { return CreateArray<af::cfloat>(ptr, src, dimAndType.first); };

break;

case c64:

factory = [=]() { return CreateArray<af::cdouble>(ptr, src, dimAndType.first); };

break;

case b8:

factory = [=]() { return CreateArray<char>(ptr, src, dimAndType.first); };

break;

case s64:

factory = [=]() { return CreateArray<int64_t>(ptr, src, dimAndType.first); };

break;

case u64:

factory = [=]() { return CreateArray<uint64_t>(ptr, src, dimAndType.first); };

break;

default:

assert(false);

}

}

if (!factory)

{

return NAN_THROW_INVALID_ARGS();

}

auto conv = [](Worker<af::array*>* w, af::array* a)

{

return New(a);

};

auto worker = new Worker<af::array*>(GetCallback(info), move(factory), move(conv));

worker->SaveToPersistent("data", info[buffIdx]->ToObject());

Nan::AsyncQueueWorker(worker);

info.GetReturnValue().SetUndefined();

}

ARRAYFIRE_CATCH

{

Local<Value> args[] = { instance };

auto scope = Nan::New(constructor)->Get(Nan::New("scope").ToLocalChecked()).As<Object>();

auto reg = scope->Get(Nan::New("register").ToLocalChecked());

auto regF = reg.As<Object>().As<Function>();

regF->Call(scope, 1, args);

{

try

{

Guard guard;

info.GetReturnValue().Set(Nan::New<Number>(GetArray(info.This())->elements()));

}

ARRAYFIRE_CATCH

{

try

{

ARGS_LEN(1)

char* buffData;

auto pArray = GetArray(info.This());

if (Buffer::HasInstance(info[0]))

{

buffData = Buffer::Data(info[0]);

if (Buffer::Length(info[0]) < pArray->bytes())

{

return NAN_THROW("Buffer is too small to hold values.");

}

af::array array(*pArray);

auto exec = [=]()

{

Guard guard;

array.host(buffData);

};

auto worker = new Worker<void>(GetCallback(info), move(exec));

worker->SaveToPersistent("data", info[0]->ToObject());

Nan::AsyncQueueWorker(worker);

info.GetReturnValue().SetUndefined();

}

else

{

size_t size = pArray->elements() * GetDTypeInfo(pArray->type()).second;

buffData = new char[size];

try

{

af::array array(*pArray);

auto exec = [=]()

{

Guard guard;

array.host(buffData);

return buffData;

};

auto conv = [=](Worker<char*>* w, char* data)

{

Nan::EscapableHandleScope scope;

return scope.Escape(Nan::NewBuffer(data, size, [](char* data, void* hint) { delete[] data; }, nullptr).ToLocalChecked());

};

auto worker = new Worker<char*>(GetCallback(info), move(exec), move(conv));

Nan::AsyncQueueWorker(worker);

info.GetReturnValue().SetUndefined();

}

catch (...)

{

delete[] buffData;

throw;

}

}

}

ARRAYFIRE_CATCH

{

try

{

Guard guard;

auto pArray = GetArray(info.This());

switch (pArray->type())

{

case f32:

info.GetReturnValue().Set(Nan::New(pArray->scalar<float>()));

break;

case f64:

info.GetReturnValue().Set(Nan::New(pArray->scalar<double>()));

break;

case s32:

info.GetReturnValue().Set(Nan::New(pArray->scalar<int>()));

break;

case u32:

info.GetReturnValue().Set(Nan::New(pArray->scalar<unsigned>()));

break;

case u8:

info.GetReturnValue().Set(Nan::New(pArray->scalar<unsigned char>()));

break;

case b8:

info.GetReturnValue().Set(Nan::New(pArray->scalar<char>()));

break;

case c32:

info.GetReturnValue().Set(ToV8Complex(pArray->scalar<af::cfloat>()));

break;

case c64:

info.GetReturnValue().Set(ToV8Complex(pArray->scalar<af::cdouble>()));

break;

case s64:

info.GetReturnValue().Set(Nan::New(to_string(pArray->scalar<long long>()).c_str()).ToLocalChecked());

break;

case u64:

info.GetReturnValue().Set(Nan::New(to_string(pArray->scalar<unsigned long long>()).c_str()).ToLocalChecked());

break;

default:

NAN_THROW_INVALID_ARGS();

}

}

ARRAYFIRE_CATCH

}

NAN_METHOD(ArrayWrapper::Write)

{

try

{

ARGS_LEN(3)

char* buffData;

auto pArray = GetArray(info.This());

if (Buffer::HasInstance(info[0]))

{

buffData = Buffer::Data(info[0]);

}

else

{

return NAN_THROW("First argument is no a Buffer.");

}

unsigned bytes = info[1]->Uint32Value();

af_source src = afHost;

if (info.Length() > 3)

{

src = (af_source)(info[2]->Int32Value());

}

af::array array(*pArray);

auto exec = [=]()

{

Guard guard;

af_write_array(array.get(), buffData, bytes, src);

};

auto worker = new Worker<void>(GetCallback(info), move(exec));

worker->SaveToPersistent("data", info[0]->ToObject());

Nan::AsyncQueueWorker(worker);

info.GetReturnValue().SetUndefined();

{

try

{

info.GetReturnValue().Set(GetArray(info.This())->type());

}

ARRAYFIRE_CATCH

{

try

{

auto pArray = GetArray(info.This());

if (!info.Length())

{

auto dims = pArray->dims();

auto jsDims = Nan::New<Object>();

jsDims->Set(Nan::New(Symbols::Elements), Nan::New<Number>(dims.elements()));

jsDims->Set(Nan::New(Symbols::Ndims), Nan::New<Number>(dims.ndims()));

jsDims->Set(Nan::New(Symbols::NDims), Nan::New<Number>(dims.ndims()));

auto pDims = Nan::New<Array>(4);

pDims->Set(0, Nan::New<Number>(dims[0]));

pDims->Set(1, Nan::New<Number>(dims[1]));

pDims->Set(2, Nan::New<Number>(dims[2]));

pDims->Set(3, Nan::New<Number>(dims[3]));

jsDims->Set(Nan::New(Symbols::Values), pDims);

info.GetReturnValue().Set(jsDims);

}

else

{

info.GetReturnValue().Set(Nan::New<Number>(pArray->dims(info[0]->Uint32Value())));

}

}

ARRAYFIRE_CATCH

{

try

{

info.GetReturnValue().Set(Nan::New<Number>(GetArray(info.This())->numdims()));

}

ARRAYFIRE_CATCH

{

try

{

info.GetReturnValue().Set(Nan::New<Number>((unsigned)GetArray(info.This())->bytes()));

}

ARRAYFIRE_CATCH

{

try

{

Guard guard;

info.GetReturnValue().Set(New(GetArray(info.This())->copy()));

}

ARRAYFIRE_CATCH

{

try

{

info.GetReturnValue().Set(Nan::New(GetArray(info.This())->isempty()));

}

ARRAYFIRE_CATCH

{

try

{

info.GetReturnValue().Set(Nan::New(GetArray(info.This())->isscalar()));

}

ARRAYFIRE_CATCH

{

try

{

info.GetReturnValue().Set(Nan::New(GetArray(info.This())->isvector()));

}

ARRAYFIRE_CATCH

{

try

{

info.GetReturnValue().Set(Nan::New(GetArray(info.This())->isrow()));

}

ARRAYFIRE_CATCH

{

try

{

info.GetReturnValue().Set(Nan::New(GetArray(info.This())->iscolumn()));

}

ARRAYFIRE_CATCH

{

try

{

info.GetReturnValue().Set(Nan::New(GetArray(info.This())->iscomplex()));

}

ARRAYFIRE_CATCH

{

try

{

info.GetReturnValue().Set(Nan::New(GetArray(info.This())->isreal()));

}

ARRAYFIRE_CATCH

{

try

{

info.GetReturnValue().Set(Nan::New(GetArray(info.This())->isdouble()));

}

ARRAYFIRE_CATCH

{

try

{

info.GetReturnValue().Set(Nan::New(GetArray(info.This())->issingle()));

}

ARRAYFIRE_CATCH

{

try

{

info.GetReturnValue().Set(Nan::New(GetArray(info.This())->isrealfloating()));

}

ARRAYFIRE_CATCH

{

try

{

info.GetReturnValue().Set(Nan::New(GetArray(info.This())->isfloating()));

}

ARRAYFIRE_CATCH

{

try

{

info.GetReturnValue().Set(Nan::New(GetArray(info.This())->isinteger()));

}

ARRAYFIRE_CATCH

{

try

{

info.GetReturnValue().Set(Nan::New(GetArray(info.This())->type() == b8));

}

ARRAYFIRE_CATCH

{

try

{

Guard guard;

GetArray(info.This())->eval();

info.GetReturnValue().SetUndefined();

}

ARRAYFIRE_CATCH

{

// Aka "indexing"

try

{

ARGS_LEN(1)

Guard guard;

if (info.Length() == 1)

{

auto ri = ToRegionIndex(info[0]);

switch (get<0>(ri))

{

case Region::Row:

info.GetReturnValue().Set(New(GetArray(info.This())->row(get<1>(ri))));

break;

case Region::Rows:

info.GetReturnValue().Set(New(GetArray(info.This())->rows(get<1>(ri), get<2>(ri))));

break;

case Region::Col:

info.GetReturnValue().Set(New(GetArray(info.This())->col(get<1>(ri))));

break;

case Region::Cols:

info.GetReturnValue().Set(New(GetArray(info.This())->cols(get<1>(ri), get<2>(ri))));

break;

case Region::Slice:

info.GetReturnValue().Set(New(GetArray(info.This())->slice(get<1>(ri))));

break;

case Region::Slices:

info.GetReturnValue().Set(New(GetArray(info.This())->slices(get<1>(ri), get<2>(ri))));

break;

default:

info.GetReturnValue().Set(New(GetArray(info.This())->operator()(ToIndex(info[0]))));

break;

}

}

else if (info.Length() == 2)

{

info.GetReturnValue().Set(New(GetArray(info.This())->operator()(ToIndex(info[0]), ToIndex(info[1]))));

}

else if (info.Length() == 3)

{

info.GetReturnValue().Set(New(GetArray(info.This())->operator()(ToIndex(info[0]), ToIndex(info[1]), ToIndex(info[2]))));

}

else

{

info.GetReturnValue().Set(New(GetArray(info.This())->operator()(ToIndex(info[0]), ToIndex(info[1]), ToIndex(info[2]), ToIndex(info[3]))));

}

}

ARRAYFIRE_CATCH

{

try

{

ARGS_LEN(1);

af::dtype type = GetDTypeInfo(info[0]->Uint32Value()).first;

Guard guard;

info.GetReturnValue().Set(New(GetArray(info.This())->as(type)));

}

ARRAYFIRE_CATCH