bool TNEANetMP::IsOk(const bool& ThrowExcept) const {
bool RetVal = true;
for (int N = NodeH.FFirstKeyId(); NodeH.FNextKeyId(N); ) {
const TNode& Node = NodeH[N];
if (! Node.OutEIdV.IsSorted()) {
const TStr Msg = TStr::Fmt("Out-edge list of node %d is not sorted.", Node.GetId());
if (ThrowExcept) { EAssertR(false, Msg); } else { ErrNotify(Msg.CStr()); } RetVal=false;
}
if (! Node.InEIdV.IsSorted()) {
const TStr Msg = TStr::Fmt("In-edge list of node %d is not sorted.", Node.GetId());
if (ThrowExcept) { EAssertR(false, Msg); } else { ErrNotify(Msg.CStr()); } RetVal=false;
}
// check out-edge ids
int prevEId = -1;
for (int e = 0; e < Node.GetOutDeg(); e++) {
if (! IsEdge(Node.GetOutEId(e))) {
const TStr Msg = TStr::Fmt("Out-edge id %d of node %d does not exist.", Node.GetOutEId(e), Node.GetId());
if (ThrowExcept) { EAssertR(false, Msg); } else { ErrNotify(Msg.CStr()); } RetVal=false;
}
if (e > 0 && prevEId == Node.GetOutEId(e)) {
const TStr Msg = TStr::Fmt("Node %d has duplidate out-edge id %d.", Node.GetId(), Node.GetOutEId(e));
if (ThrowExcept) { EAssertR(false, Msg); } else { ErrNotify(Msg.CStr()); } RetVal=false;
}
prevEId = Node.GetOutEId(e);
}
// check in-edge ids
prevEId = -1;
for (int e = 0; e < Node.GetInDeg(); e++) {
if (! IsEdge(Node.GetInEId(e))) {
const TStr Msg = TStr::Fmt("Out-edge id %d of node %d does not exist.", Node.GetInEId(e), Node.GetId());
if (ThrowExcept) { EAssertR(false, Msg); } else { ErrNotify(Msg.CStr()); } RetVal=false;
}
if (e > 0 && prevEId == Node.GetInEId(e)) {
const TStr Msg = TStr::Fmt("Node %d has duplidate out-edge id %d.", Node.GetId(), Node.GetInEId(e));
if (ThrowExcept) { EAssertR(false, Msg); } else { ErrNotify(Msg.CStr()); } RetVal=false;
}
prevEId = Node.GetInEId(e);
}
}
for (int E = EdgeH.FFirstKeyId(); EdgeH.FNextKeyId(E); ) {
const TEdge& Edge = EdgeH[E];
if (! IsNode(Edge.GetSrcNId())) {
const TStr Msg = TStr::Fmt("Edge %d source node %d does not exist.", Edge.GetId(), Edge.GetSrcNId());
if (ThrowExcept) { EAssertR(false, Msg); } else { ErrNotify(Msg.CStr()); } RetVal=false;
}
if (! IsNode(Edge.GetDstNId())) {
const TStr Msg = TStr::Fmt("Edge %d destination node %d does not exist.", Edge.GetId(), Edge.GetDstNId());
if (ThrowExcept) { EAssertR(false, Msg); } else { ErrNotify(Msg.CStr()); } RetVal=false;
}
}
return RetVal;
}
void TNodeJsFs::openRead(const v8::FunctionCallbackInfo<v8::Value>& Args) {
v8::Isolate* Isolate = v8::Isolate::GetCurrent();
v8::HandleScope HandleScope(Isolate);
EAssertR(Args.Length() == 1 && Args[0]->IsString(), "Expected file path.");
TStr FNm(*v8::String::Utf8Value(Args[0]->ToString()));
// file exist check is done by TFIn
Args.GetReturnValue().Set(
TNodeJsUtil::NewInstance<TNodeJsFIn>(new TNodeJsFIn(FNm)));
}
void TFtrGenSparseNumeric::Add(const TStr& Str, TIntFltKdV& SpV, int& Offset) const {
TStrV EltV; Str.SplitOnAllCh(';', EltV); TIntH UsedIdH;
for (int EltN = 0; EltN < EltV.Len(); EltN++) {
int Id; TStr Val; Split(EltV[EltN], Id, Val);
EAssertR(!UsedIdH.IsKey(Id), "Field ID repeated in '" + Str + "'!");
int TmpOffset = Offset + Id;
FtrGen->Add(Val, SpV, TmpOffset);
UsedIdH.AddKey(Id);
}
Offset += GetVals();
}
v8::Local<v8::Function> TNodeJsUtil::GetFldFun(v8::Local<v8::Object> Obj, const TStr& FldNm) {
v8::Isolate* Isolate = v8::Isolate::GetCurrent();
v8::HandleScope HandleScope(Isolate);
EAssertR(IsFldFun(Obj, FldNm), "The field is not a function!");
v8::Local<v8::Value> FldVal = Obj->Get(v8::String::NewFromUtf8(Isolate, FldNm.CStr()));
v8::Local<v8::Function> RetFun = v8::Handle<v8::Function>::Cast(FldVal);
return RetFun;
}
v8::Local<v8::Object> TNodeJsSA::New(TWPt<TQm::TStreamAggr> _SA) {
v8::Isolate* Isolate = v8::Isolate::GetCurrent();
v8::EscapableHandleScope HandleScope(Isolate);
EAssertR(!constructor.IsEmpty(), "TNodeJsSA::New: constructor is empty. Did you call TNodeJsSA::Init(exports); in this module's init function?");
v8::Local<v8::Function> cons = v8::Local<v8::Function>::New(Isolate, constructor);
v8::Local<v8::Object> Instance = cons->NewInstance();
TNodeJsSA* JsSA = new TNodeJsSA(_SA);
JsSA->Wrap(Instance);
return HandleScope.Escape(Instance);
}
TFOut::TFOut(const TStr& FNm, const bool& Append):
TSBase(FNm.CStr()), TSOut(FNm), FileId(NULL), Bf(NULL), BfL(0){
if (FNm.GetUc()=="CON"){
FileId=stdout;
} else {
if (Append){FileId=fopen(FNm.CStr(), "a+b");}
else {FileId=fopen(FNm.CStr(), "w+b");}
EAssertR(FileId!=NULL, "Can not open file '"+FNm+"'.");
Bf=new char[MxBfL]; BfL=0;
}
}
void TNodeJsFOut::write(const v8::FunctionCallbackInfo<v8::Value>& Args) {
v8::Isolate* Isolate = v8::Isolate::GetCurrent();
v8::HandleScope HandleScope(Isolate);
EAssertR(Args.Length() == 1, "Invalid number of arguments to fout.write()");
TNodeJsFOut* JsFOut = ObjectWrap::Unwrap<TNodeJsFOut>(Args.This());
EAssertR(!JsFOut->SOut.Empty(), "Output stream already closed!");
if (Args[0]->IsString()) {
JsFOut->SOut->PutStr(*v8::String::Utf8Value(Args[0]->ToString()));
} else if (Args[0]->IsInt32()) {
JsFOut->SOut->PutStr(TInt::GetStr(Args[0]->Int32Value()));
} else if (Args[0]->IsNumber()) {
JsFOut->SOut->PutStr(TFlt::GetStr(Args[0]->NumberValue()));
} else if (TNodeJsUtil::IsArgJson(Args, 0)) {
JsFOut->SOut->PutStr(TJsonVal::GetStrFromVal(TNodeJsUtil::GetArgJson(Args, 0)));
} else {
EFailR("Invalid type passed to fout.write() function.");
}
Args.GetReturnValue().Set(Args.Holder());
}
void TGraphCascade::ObserveNode(const TStr& NodeNm, const uint64& Time) {
if (!NodeNmIdH.IsKey(NodeNm)) {
// skip, we do not use this node
return;
}
int NodeId = NodeNmIdH.GetDat(NodeNm);
if (!Graph.IsNode(NodeId)) { return; } // skip, we do not use this node
// Assert that causality is OK, throw exception if it's violated
EAssertR(Timestamps.GetDat(NodeId) < Time, "TGraphCascade::ObserveNode: the node `" + NodeNm + "` was observed too late given causal constraints");
Timestamps.AddDat(NodeId, Time);
}
void TNodeJsFOut::New(const v8::FunctionCallbackInfo<v8::Value>& Args) {
EAssertR(Args.IsConstructCall(), "TNodeJsFOut: not a constructor call (you forgot to use the new operator)");
v8::Isolate* Isolate = v8::Isolate::GetCurrent();
v8::EscapableHandleScope HandleScope(Isolate);
// set hidden class id
v8::Local<v8::Object> Instance = Args.This();
v8::Handle<v8::String> key = v8::String::NewFromUtf8(Isolate, "class");
v8::Handle<v8::String> value = v8::String::NewFromUtf8(Isolate, GetClassId().CStr());
Instance->SetHiddenValue(key, value);
// empty constructor call just forwards the instance
if (Args.Length() == 0) { Args.GetReturnValue().Set(Instance); return; }
// parse arguments
EAssertR(Args.Length() >= 1 && Args[0]->IsString(),
"Expected file path.");
TStr FNm(*v8::String::Utf8Value(Args[0]->ToString()));
bool AppendP = Args.Length() >= 2 && Args[1]->IsBoolean() && Args[1]->BooleanValue();
// Args.This() is an instance, wrap our C++ object
TNodeJsFOut* Obj = new TNodeJsFOut(FNm, AppendP);
Obj->Wrap(Instance);
Args.GetReturnValue().Set(Instance);
}
void TNodeJsFOut::writeLine(const v8::FunctionCallbackInfo<v8::Value>& Args) {
v8::Isolate* Isolate = v8::Isolate::GetCurrent();
v8::HandleScope HandleScope(Isolate);
write(Args);
TNodeJsFOut* JsFOut = ObjectWrap::Unwrap<TNodeJsFOut>(Args.This());
EAssertR(!JsFOut->SOut.Empty(), "Output stream already closed!");
JsFOut->SOut->PutLn();
Args.GetReturnValue().Set(Args.Holder());
}
void TBagOfWords::GetFtr(const TStr& Str, TStrV& TokenStrV) const {
// outsource to tokenizer
EAssertR(!Tokenizer.Empty(), "Missing tokenizer in TFtrGen::TBagOfWords");
Tokenizer->GetTokens(Str, TokenStrV);
// counting average token length
/*static int Count = 0, LenStr = 0, LenVec = 0;
Count++; LenStr += Str.Len(); LenVec += TokenStrV.Len();
if (Count % 1000 == 0) {
printf("Average token length[docs=%d chars=%d words=%d length=%.4f\n",
Count, LenStr, LenVec, (double)LenStr / (double)LenVec);
}*/
}
TNearestNeighbor::TNearestNeighbor(const double& Rate, const int& _WindowSize):
WindowSize(_WindowSize) {
// assert rate parameter range
EAssertR(0.0 < Rate && Rate < 1.0, "TAnomalyDetection::TNearestNeighbor: Rate parameter not > 0.0 and < 1.0");
// remember the rate
RateV.Add(Rate);
// initialize all vectors to window size
Mat.Gen(WindowSize, 0);
DistV.Gen(WindowSize, 0);
DistColV.Gen(WindowSize, 0);
IDVec.Gen(WindowSize, 0);
}
double TLinear::Interpolate(const uint64& Tm) const {
AssertR(CanInterpolate(Tm), "TLinear::Interpolate: Time not in the desired interval!");
const TUInt64FltPr& PrevRec = Buff.GetOldest();
if (Tm == PrevRec.Val1) { return PrevRec.Val2; }
const TUInt64FltPr& NextRec = Buff.GetOldest(1);
// don't need to check if the times of the previous rec and next rec are equal since if
// that is true Tm will be equal to PrevRec.Tm and the correct result will be returned
const double Result = PrevRec.Val2 + ((double) (Tm - PrevRec.Val1) / (NextRec.Val1 - PrevRec.Val1)) * (NextRec.Val2 - PrevRec.Val2);
EAssertR(!TFlt::IsNan(Result), "TLinear: result of interpolation is NaN!");
return Result;
}
void TNodeJsFOut::writeJson(const v8::FunctionCallbackInfo<v8::Value>& Args) {
v8::Isolate* Isolate = v8::Isolate::GetCurrent();
v8::HandleScope HandleScope(Isolate);
PJsonVal JsonVal = TNodeJsUtil::GetArgJson(Args, 0);
TStr JsonStr = JsonVal->SaveStr();
TNodeJsFOut* JsFOut = ObjectWrap::Unwrap<TNodeJsFOut>(Args.This());
EAssertR(!JsFOut->SOut.Empty(), "Output stream already closed!");
JsonStr.Save(*JsFOut->SOut);
Args.GetReturnValue().Set(Args.Holder());
}
TNearestNeighbor::TNearestNeighbor(const TFltV& _RateV, const int& _WindowSize):
RateV(_RateV), WindowSize(_WindowSize) {
// assert rate parameter range
for (const double Rate : RateV) {
EAssertR(0.0 < Rate && Rate < 1.0, "TAnomalyDetection::TNearestNeighbor: Rate parameter not > 0.0 and < 1.0");
}
// initialize all vectors to window size
Mat.Gen(WindowSize, 0);
DistV.Gen(WindowSize, 0);
DistColV.Gen(WindowSize, 0);
DatV.Gen(WindowSize, 0);
}
TStr TNodeJsUtil::GetArgStr(const v8::FunctionCallbackInfo<v8::Value>& Args, const int& ArgN, const TStr& Property, const TStr& DefVal) {
v8::Isolate* Isolate = v8::Isolate::GetCurrent();
v8::HandleScope HandleScope(Isolate);
if (Args.Length() > ArgN) {
if (Args[ArgN]->IsObject() && Args[ArgN]->ToObject()->Has(v8::String::NewFromUtf8(Isolate, Property.CStr()))) {
v8::Handle<v8::Value> Val = Args[ArgN]->ToObject()->Get(v8::String::NewFromUtf8(Isolate, Property.CStr()));
EAssertR(Val->IsString(), TStr::Fmt("Argument %d, property %s expected to be string", ArgN, Property.CStr()));
v8::String::Utf8Value Utf8(Val);
return TStr(*Utf8);
}
}
return DefVal;
}
bool TNodeJsUtil::IsArgWrapObj(const v8::FunctionCallbackInfo<v8::Value>& Args, const int& ArgN, const TStr& ClassNm) {
v8::Isolate* Isolate = v8::Isolate::GetCurrent();
v8::HandleScope HandleScope(Isolate);
// check we have enough arguments
EAssertR(Args.Length() > ArgN, TStr::Fmt("Missing argument %d of class %s", ArgN, ClassNm.CStr()));
// check argument is an object
if (!Args[ArgN]->IsObject()) return false;
// check it's class name
v8::Handle<v8::Value> Val = Args[ArgN];
v8::Handle<v8::Object> Data = v8::Handle<v8::Object>::Cast(Val);
TStr ClassStr = GetClass(Data);
return ClassStr.EqI(ClassNm);
}
void TCurrentPoint::SetNextInterpTm(const uint64& Tm) {
// at least one past (or current time) record needs to be in the buffer
bool Change = false;
while (Buff.Len() >= 2 && Buff.GetOldest(1).Val1 <= Tm) {
Buff.DelOldest();
Change = true;
}
if (Change) {
EAssertR(CanInterpolate(Tm), "WTF!? Current point interpolator cannot intrpolate after setting new time!");
}
// when the loop finishes we have at least 1 record in the buffer
// with a timestamp <= Tm
}
TFIn::TFIn(const TStr& FNm, bool& OpenedP, const bool IgnoreBOMIfExistsP):
TSBase(FNm.CStr()), TSIn(FNm), FileId(NULL), Bf(NULL), BfC(0), BfL(0){
EAssertR(!FNm.Empty(), "Empty file-name.");
FileId=fopen(FNm.CStr(), "rb");
OpenedP=(FileId!=NULL);
if (OpenedP){
Bf=new char[MxBfL]; BfC=BfL=-1; FillBf();
if (IgnoreBOMIfExistsP && BfL >= 3) {
// https://en.wikipedia.org/wiki/Byte_order_mark
if (Bf[0] == (char)0xEF && Bf[1] == (char)0xBB && Bf[2] == (char)0xBF)
BfC = 3;
}
}
}
int TNodeJsUtil::GetFldInt(v8::Local<v8::Object> Obj, const TStr& FldNm) {
v8::Isolate* Isolate = v8::Isolate::GetCurrent();
v8::HandleScope HandleScope(Isolate);
EAssertR(IsFldInt(Obj, FldNm), "The field is not an integer!");
v8::Local<v8::Value> FldVal = Obj->Get(v8::String::NewFromUtf8(Isolate, FldNm.CStr()));
if (FldVal->IsInt32()) {
return FldVal->Int32Value();
} else { // FldVal->IsUint32()
return FldVal->Uint32Value();
}
}
TZipIn::TZipIn(const TStr& FNm, bool& OpenedP) : TSBase(), TSIn(), ZipStdoutRd(NULL), ZipStdoutWr(NULL), SNm(FNm.CStr()),
FLen(0), CurFPos(0), Bf(NULL), BfC(0), BfL(0) {
EAssertR(! FNm.Empty(), "Empty file-name.");
FLen = TZipIn::GetFLen(FNm);
OpenedP = TFile::Exists(FNm);
if (OpenedP) {
#ifdef GLib_WIN
SECURITY_ATTRIBUTES saAttr;
saAttr.nLength = sizeof(SECURITY_ATTRIBUTES);
saAttr.bInheritHandle = TRUE;
saAttr.lpSecurityDescriptor = NULL;
// Create a pipe for the child process's STDOUT.
EAssertR(CreatePipe(&ZipStdoutRd, &ZipStdoutWr, &saAttr, 0), "Stdout pipe creation failed");
// Ensure the read handle to the pipe for STDOUT is not inherited.
SetHandleInformation(ZipStdoutRd, HANDLE_FLAG_INHERIT, 0);
#else
// no implementation needed
#endif
CreateZipProcess(GetCmd(FNm.GetFExt()), FNm);
Bf = new char[MxBfL]; BfC = BfL=-1;
FillBf();
}
}
void TNodeJsFs::fileInfo(const v8::FunctionCallbackInfo<v8::Value>& Args) {
v8::Isolate* Isolate = v8::Isolate::GetCurrent();
v8::HandleScope HandleScope(Isolate);
EAssertR(Args.Length() == 1 && Args[0]->IsString(),
"Expected a file path as the only argument.");
TStr FNm(*v8::String::Utf8Value(Args[0]->ToString()));
EAssertR(TFile::Exists(FNm), TStr("File '" + FNm + "' does not exist").CStr());
const uint64 CreateTm = TFile::GetCreateTm(FNm);
const uint64 LastAccessTm = TFile::GetLastAccessTm(FNm);
const uint64 LastWriteTm = TFile::GetLastWriteTm(FNm);
const uint64 Size = TFile::GetSize(FNm);
v8::Handle<v8::Object> Obj = v8::Object::New(Isolate);
Obj->Set(v8::String::NewFromUtf8(Isolate, "createTime"),
v8::String::NewFromUtf8(Isolate, TTm::GetTmFromMSecs(CreateTm).GetWebLogDateTimeStr().CStr()));
Obj->Set(v8::String::NewFromUtf8(Isolate, "lastAccessTime"),
v8::String::NewFromUtf8(Isolate, TTm::GetTmFromMSecs(LastAccessTm).GetWebLogDateTimeStr().CStr()));
Obj->Set(v8::String::NewFromUtf8(Isolate, "lastWriteTime"),
v8::String::NewFromUtf8(Isolate, TTm::GetTmFromMSecs(LastWriteTm).GetWebLogDateTimeStr().CStr()));
Obj->Set(v8::String::NewFromUtf8(Isolate, "size"),
v8::Number::New(Isolate, static_cast<double>(Size)));
Args.GetReturnValue().Set(Obj);
}
v8::Local<v8::Object> TNodeJsFOut::New(const TStr& FNm, const bool& AppendP) {
// called from C++
v8::Isolate* Isolate = v8::Isolate::GetCurrent();
v8::EscapableHandleScope HandleScope(Isolate);
// create an instance using the constructor
EAssertR(!constructor.IsEmpty(), "TNodeJsFOut::New: constructor is empty. Did you call TNodeJsFOut::Init(exports); in this module's init function?");
v8::Local<v8::Function> cons = v8::Local<v8::Function>::New(Isolate, constructor);
// no arguments to constructor
v8::Local<v8::Object> Instance = cons->NewInstance();
// wrap our C++ object
TNodeJsFOut* Obj = new TNodeJsFOut(FNm, AppendP);
Obj->Wrap(Instance);
return HandleScope.Escape(Instance);
}
const char* TJsonObj::ParseArrayVal(const char* JsonStr) {
const char *c = JsonStr;
bool Nested = false;
TChA ValStr;
Clr();
while (*c && TCh::IsWs(*c)) { c++; }
if (*c == '"') { c = GetStr(c, ValStr); } // string
else if (TCh::IsNum(*c) || (*c=='-' && TCh::IsNum(*(c+1)))) { // number
while (*c && *c!=',' && *c!='}' && *c!=']' && ! TCh::IsWs(*c)) { ValStr.Push(*c); c++; } }
else if (*c=='t' || *c=='f' || *c=='n') { // true, false, null
while (*c && *c!=',' && *c!='}' && *c!=']') { ValStr.Push(*c); c++; } }
else if (*c=='{') { // nested object
EAssertR(! KeyArrayH.IsKey("key"), "JSON error: object with key 'key' already exists");
TJsonObj& Obj = KeyObjH.AddDat("key");
c = Obj.Parse(c) + 1; Nested = true;
}
else if (*c=='[') { // array
EAssertR(! KeyArrayH.IsKey("key"), "JSON error: array with key 'key' already exists");
TVec<TJsonObj>& Array = KeyArrayH.AddDat("key");
c++;
while (*c && *c!=']') {
while (*c && TCh::IsWs(*c)) { c++; }
Array.Add();
if (*c=='{') { c = Array.Last().Parse(c) + 1; } // nested object
else { c = Array.Last().ParseArrayVal(c); }
if (*c && *c==',') { c++; }
}
c++; Nested = true;
}
if (! Nested) {
EAssertR(! KeyArrayH.IsKey("key"), "JSON error: object with key 'key' already exists");
KeyValH.AddDat("key", ValStr);
}
while (*c && TCh::IsWs(*c)) { c++; }
return c;
}
void TSockSys::Listen(const uint64& SockId, const int& PortN, const bool& IPv6P) {
// make sure it's a valid socket
IAssert(IsSock(SockId));
uv_tcp_t* SockHnd = SockIdToHndH.GetDat(SockId);
// special handling for v4 and v6 when binding
if (!IPv6P) {
// get address
struct sockaddr_in Addr = uv_ip4_addr("0.0.0.0", PortN);
// bind socket to port
const int BindResCd = uv_tcp_bind(SockHnd, Addr);
EAssertR(BindResCd == 0, "SockSys.Listen: Error bidning socket to port: " + SockSys.GetLastErr());
} else {
// get address
struct sockaddr_in6 Addr = uv_ip6_addr("::", PortN);
// bind socket to port
const int BindResCd = uv_tcp_bind6(SockHnd, Addr);
EAssertR(BindResCd == 0, "SockSys.Listen: Error bidning socket to port: " + SockSys.GetLastErr());
}
// make sure we have backlog of at least 128
const int BacklogQueue = (SOMAXCONN < 128) ? 128 : SOMAXCONN;
// enable callbacks
const int ListenResCd = uv_listen((uv_stream_t*)SockHnd, BacklogQueue, TSockSys::OnAccept);
EAssertR(ListenResCd == 0, "SockSys.Listen: Error setting listener on socket: " + SockSys.GetLastErr());
}
void TNodeTask::AfterRun() {
v8::Isolate* Isolate = v8::Isolate::GetCurrent();
v8::HandleScope HandleScope(Isolate);
EAssertR(!Callback.IsEmpty(), "The callback was not defined!");
v8::Local<v8::Function> Fun = v8::Local<v8::Function>::New(Isolate, Callback);
if (!Except.Empty()) {
TNodeJsUtil::ExecuteErr(Fun, Except);
} else {
const int ArgC = 2;
v8::Handle<v8::Value> ArgV[ArgC] = { v8::Undefined(Isolate), WrapResult() };
TNodeJsUtil::ExecuteVoid(Fun, ArgC, ArgV);
}
}
double TNodeJsUtil::ExecuteFlt(const v8::Handle<v8::Function>& Fun, const v8::Local<v8::Object>& Arg) {
v8::Isolate* Isolate = v8::Isolate::GetCurrent();
v8::HandleScope HandleScope(Isolate);
v8::Handle<v8::Value> Argv[1] = { Arg };
v8::TryCatch TryCatch;
v8::Handle<v8::Value> RetVal = Fun->Call(Isolate->GetCurrentContext()->Global(), 1, Argv);
if (TryCatch.HasCaught()) {
TryCatch.ReThrow();
return 0;
}
EAssertR(RetVal->IsNumber(), "Return type expected to be number");
return RetVal->NumberValue();
}
// parse from json configuration file
TJsParam(const TStr& RootFNm, const PJsonVal& JsVal) {
EAssertR(JsVal->IsObj(), "Unsupported type: " + TJsonVal::GetStrFromVal(JsVal));
// we must have at least the script name
EAssert(JsVal->IsObjKey("file"));
// get script name
FNm = JsVal->GetObjStr("file");
// get namespace (get from script name if not available)
Nm = JsVal->IsObjKey("name") ? JsVal->GetObjStr("name") : FNm.GetFMid();
// get initialization parameters (if available)
InitVal = JsVal->IsObjKey("init") ? JsVal->GetObjKey("init") : TJsonVal::NewObj();
// get library include folders
if (JsVal->IsObjKey("include")) {
PJsonVal IncludesVal = JsVal->GetObjKey("include");
EAssertR(IncludesVal->IsArr(), "Expected array of strings, not: " + TJsonVal::GetStrFromVal(IncludesVal));
for (int IncludeN = 0; IncludeN < IncludesVal->GetArrVals(); IncludeN++) {
PJsonVal IncludeVal = IncludesVal->GetArrVal(IncludeN);
EAssertR(IncludeVal->IsStr(), "Expected string, not: " + TJsonVal::GetStrFromVal(IncludeVal));
IncludeFPathV.Add(IncludeVal->GetStr());
}
}
// handle default includes
AddLocalLibFPath();
AddQMinerLibFPath();
// get folders with access permissions
if (JsVal->IsObjKey("dirs")) {
PJsonVal DirsVal = JsVal->GetObjKey("dirs");
EAssertR(DirsVal->IsArr(), "Expected array of strings, not: " + TJsonVal::GetStrFromVal(DirsVal));
for (int DirN = 0; DirN < DirsVal->GetArrVals(); DirN++) {
PJsonVal DirVal = DirsVal->GetArrVal(DirN);
EAssertR(DirVal->IsStr(), "Expected string, not: " + TJsonVal::GetStrFromVal(DirVal));
AccessFPathV.Add(DirVal->GetStr());
}
}
// add sandbox access
AddSandboxAccessFPath(RootFNm);
}
int TNodeJsUtil::GetArgInt32(const v8::FunctionCallbackInfo<v8::Value>& Args, const int& ArgN, const TStr& Property, const int& DefVal) {
v8::Isolate* Isolate = v8::Isolate::GetCurrent();
v8::HandleScope HandleScope(Isolate);
if (Args.Length() > ArgN) {
if (Args[ArgN]->IsObject() && Args[ArgN]->ToObject()->Has(v8::String::NewFromUtf8(Isolate, Property.CStr()))) {
v8::Handle<v8::Value> Val = Args[ArgN]->ToObject()->Get(v8::String::NewFromUtf8(Isolate, Property.CStr()));
bool IsInt = Val->IsInt32();
EAssertR(IsInt,
TStr::Fmt("Argument %d, property %s expected to be int32", ArgN, Property.CStr()).CStr());
return Val->ToNumber()->Int32Value();
}
}
return DefVal;
}
bool TNodeJsUtil::GetArgBool(const v8::FunctionCallbackInfo<v8::Value>& Args, const int& ArgN, const TStr& Property, const bool& DefVal) {
v8::Isolate* Isolate = v8::Isolate::GetCurrent();
v8::HandleScope HandleScope(Isolate);
if (Args.Length() > ArgN) {
if (Args[ArgN]->IsObject() && Args[ArgN]->ToObject()->Has(v8::String::NewFromUtf8(Isolate, Property.CStr()))) {
v8::Handle<v8::Value> Val = Args[ArgN]->ToObject()->Get(v8::String::NewFromUtf8(Isolate, Property.CStr()));
EAssertR(Val->IsBoolean(),
TStr::Fmt("Argument %d, property %s expected to be boolean", ArgN, Property.CStr()).CStr());
v8::Local<v8::BooleanObject> BoolObj = v8::Local<v8::BooleanObject>::Cast(Val->ToObject());
return static_cast<bool>(BoolObj->ValueOf());
}
}
return DefVal;
}
