PJsonVal TJsonVal::NewArr(const TStrV& StrV) {
PJsonVal Val = TJsonVal::NewArr();
for (int StrN = 0; StrN < StrV.Len(); StrN++) {
Val->AddToArr(TJsonVal::NewStr(StrV[StrN]));
}
return Val;
}
// extend/update the object with values from Val
// this and Val should be an Object and not an array or something else
void TJsonVal::MergeObj(const PJsonVal& Val) {
EAssert(Val->IsObj() && IsObj());
for (int N = 0; N < Val->GetObjKeys(); N++) {
const TStr Key = Val->GetObjKey(N);
AddToObj(Key, Val->GetObjKey(Key));
}
}
PJsonVal TNodeJsStreamAggr::SaveJson(const int& Limit) const {
if (!SaveJsonFun.IsEmpty()) {
v8::Isolate* Isolate = v8::Isolate::GetCurrent();
v8::HandleScope HandleScope(Isolate);
v8::Local<v8::Function> Callback = v8::Local<v8::Function>::New(Isolate, SaveJsonFun);
v8::Local<v8::Object> GlobalContext = Isolate->GetCurrentContext()->Global();
const unsigned Argc = 1;
v8::Local<v8::Value> ArgV[Argc] = { v8::Number::New(Isolate, Limit) };
v8::TryCatch TryCatch;
v8::Local<v8::Value> ReturnVal = Callback->Call(GlobalContext, Argc, ArgV);
if (TryCatch.HasCaught()) {
TryCatch.ReThrow();
return TJsonVal::NewObj();
}
QmAssertR(ReturnVal->IsObject(), "Stream aggr JS callback: saveJson didn't return an object.");
PJsonVal Res = TNodeJsUtil::GetObjJson(ReturnVal->ToObject());
QmAssertR(Res->IsDef(), "Stream aggr JS callback: saveJson didn't return a valid JSON.");
return Res;
}
else {
return TJsonVal::NewObj();
}
}
PJsonVal TJsonVal::NewArr(const TJsonValV& ValV) {
PJsonVal Val = TJsonVal::NewArr();
for (int ValN = 0; ValN < ValV.Len(); ValN++) {
Val->AddToArr(ValV[ValN]);
}
return Val;
}
PJsonVal TJsonVal::NewArr(const TUInt64V& IntV) {
PJsonVal Val = TJsonVal::NewArr();
for (int IntN = 0; IntN < IntV.Len(); IntN++) {
Val->AddToArr(TJsonVal::NewNum((double)IntV[IntN]));
}
return Val;
}
PJsonVal TJsonVal::NewArr(const TFltV& FltV) {
PJsonVal Val = TJsonVal::NewArr();
for (int FltN = 0; FltN < FltV.Len(); FltN++) {
Val->AddToArr(TJsonVal::NewNum(FltV[FltN]));
}
return Val;
}
PJsonVal TBackupLogInfo::GetJson() const
{
PJsonVal RetJson = TJsonVal::NewObj("folderName", FolderName);
RetJson->AddToObj("secsNeeded", SecsNeeded);
RetJson->AddToObj("logInfo", LogInfo);
return RetJson;
}
PJsonVal TJsonVal::NewArr(const TIntFltKdV& IntFltKdV) {
PJsonVal Val = TJsonVal::NewArr();
for (const TIntFltKd& IntFltKd : IntFltKdV) {
Val->AddToArr(TJsonVal::NewArr((double)IntFltKd.Key, IntFltKd.Dat));
}
return Val;
}
void TJsonVal::GetArrNumV(TFltV& FltV) const {
EAssert(IsArr());
for (int FltN = 0; FltN < GetArrVals(); FltN++) {
PJsonVal ArrVal = GetArrVal(FltN);
EAssert(ArrVal->IsNum());
FltV.Add(ArrVal->GetNum());
}
}
void TJsonVal::GetArrUInt64V(TUInt64V& UInt64V) const {
EAssert(IsArr());
for (int IntN = 0; IntN < GetArrVals(); IntN++) {
PJsonVal ArrVal = GetArrVal(IntN);
EAssert(ArrVal->IsNum());
UInt64V.Add(ArrVal->GetUInt64());
}
}
void TJsonVal::GetArrStrV(TStrV& StrV) const {
EAssert(IsArr());
for (int StrN = 0; StrN < GetArrVals(); StrN++) {
PJsonVal ArrVal = GetArrVal(StrN);
EAssert(ArrVal->IsStr());
StrV.Add(ArrVal->GetStr());
}
}
void TJsonVal::GetArrIntV(TIntV& IntV) const {
EAssert(IsArr());
for (int IntN = 0; IntN < GetArrVals(); IntN++) {
PJsonVal ArrVal = GetArrVal(IntN);
EAssert(ArrVal->IsNum());
IntV.Add(ArrVal->GetInt());
}
}
PJsonVal TGraphCascade::GetOrder() const {
PJsonVal OrderArr = TJsonVal::NewArr();
int Len = NIdSweep.Len();
for (int NodeN = 0; NodeN < Len; NodeN++) {
TStr NodeNm = NodeIdNmH.GetDat(NIdSweep[NodeN]);
OrderArr->AddToArr(NodeNm);
}
return OrderArr;
}
void TGraphCascade::ProcessEnabled(const PJsonVal& EnabledList) {
int Len = EnabledList->GetArrVals();
for (int ElN = 0; ElN < Len; ElN++) {
TStr NodeNm = EnabledList->GetArrVal(ElN)->GetStr();
if (NodeNmIdH.IsKey(NodeNm)) {
EnabledNodeIdH.AddKey(NodeNmIdH.GetDat(NodeNm));
}
}
}
// save the logs of the backups to the log file
void TBackupProfile::SaveLogs() const
{
TJsonValV ArrV;
for (int N = 0; N < LogV.Len(); N++)
ArrV.Add(LogV[N].GetJson());
PJsonVal JsonArr = TJsonVal::NewArr(ArrV);
TStr JsonStr = JsonArr->SaveStr();
JsonStr.SaveTxt(ProfileLogFile);
}
v8::Local<v8::Value> TNodeJsYL40Adc::TReadTask::WrapResult() {
v8::Isolate* Isolate = v8::Isolate::GetCurrent();
v8::EscapableHandleScope HandleScope(Isolate);
PJsonVal ResJson = TJsonVal::NewObj();
for (int InputN = 0; InputN < Adc->InputNumNmKdV.Len(); InputN++) {
ResJson->AddToObj(Adc->InputNumNmKdV[InputN].Dat, ValV[InputN]);
}
return HandleScope.Escape(TNodeJsUtil::ParseJson(Isolate, ResJson));
}
PTokenizer THtml::New(const PJsonVal& ParamVal) {
// get stopwords
PSwSet SwSet = ParamVal->IsObjKey("stopwords") ?
TSwSet::ParseJson(ParamVal->GetObjKey("stopwords")) :
TSwSet::New(swstNone);
// get stemmer
PStemmer Stemmer = ParamVal->IsObjKey("stemmer") ?
TStemmer::ParseJson(ParamVal->GetObjKey("stemmer"), false) :
TStemmer::New(stmtNone, false);
const bool ToUcP = ParamVal->GetObjBool("uppercase", true);
return new THtml(SwSet, Stemmer, ToUcP);
}
void TJsonVal::GetArrNumSpV(TIntFltKdV& NumSpV) const {
EAssert(IsArr());
for (int ElN = 0; ElN < GetArrVals(); ElN++) {
PJsonVal ArrVal = GetArrVal(ElN);
EAssert(ArrVal->IsArr());
EAssert(ArrVal->GetArrVals() == 2);
int Idx = ArrVal->GetArrVal(0)->GetInt();
double Val = ArrVal->GetArrVal(1)->GetNum();
NumSpV.Add(TIntFltKd(Idx, Val));
}
NumSpV.Sort();
}
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());
}
PJsonVal TGraphCascade::GetGraph() const {
PJsonVal G = TJsonVal::NewObj();
for (TNGraph::TNodeI NI = Graph.BegNI(); NI < Graph.EndNI(); NI++) {
TStr NodeNm = NodeIdNmH.GetDat(NI.GetId());
PJsonVal ParentsArr = TJsonVal::NewArr();
int InDeg = NI.GetInDeg();
for (int ParentN = 0; ParentN < InDeg; ParentN++) {
TStr ParentNm = NodeIdNmH.GetDat(NI.GetInNId(ParentN));
ParentsArr->AddToArr(ParentNm);
}
G->AddToObj(NodeNm, ParentsArr);
}
return G;
}
TGraphCascade::TGraphCascade(const PJsonVal& Params) {
// build graph and node name-id maps
PJsonVal Dag = Params->GetObjKey("dag");
GenGraph(Dag);
// read enabled (ignore the ones missing from the graph)
PJsonVal EnabledNodeIdH = Params->GetObjKey("enabledNodes");
ProcessEnabled(EnabledNodeIdH);
PruneGraph();
InitTimestamps();
// read models
PJsonVal NodeModels = Params->GetObjKey("nodeModels");
ProcessModels(NodeModels);
TimeUnit = Params->GetObjInt("timeUnit", 1000);
Rnd.PutSeed(Params->GetObjInt("randSeed", 0));
}
void TJsonVal::AddToObj(const PJsonVal& Val) {
EAssert(Val->IsObj());
int KeyId = Val->KeyValH.FFirstKeyId();
while (Val->KeyValH.FNextKeyId(KeyId)) {
AddToObj(Val->KeyValH.GetKey(KeyId), Val->KeyValH[KeyId]);
}
}
TEma::TEma(const PJsonVal& ParamVal) : LastVal(TFlt::Mn), InitP(false) {
// type
TStr TypeStr = ParamVal->GetObjStr("emaType");
if (TypeStr == "previous") {
Type = etPreviousPoint;
} else if (TypeStr == "linear") {
Type = etLinear;
} else if (TypeStr == "next") {
Type = etNextPoint;
} else {
throw TExcept::New("Unknown ema type " + TypeStr);
}
// rest
TmInterval = ParamVal->GetObjNum("interval");
InitMinMSecs = ParamVal->GetObjInt("initWindow", 0);
}
PJsonVal TGraphCascade::GetPosterior(const TStrV& NodeNmV, const TFltV& QuantileV) const {
PJsonVal Result = TJsonVal::NewObj();
TIntV NodeIdV;
if (NodeNmV.Empty()) {
// go over all zero timestamps for which samples exist
TIntV FullNodeIdV; Graph.GetNIdV(FullNodeIdV);
int Nodes = Graph.GetNodes();
for (int NodeN = 0; NodeN < Nodes; NodeN++) {
int NodeId = FullNodeIdV[NodeN];
if (Timestamps.IsKey(NodeId) && Sample.IsKey(NodeId) && !Sample.GetDat(NodeId).Empty() && Timestamps.GetDat(NodeId) == 0) {
NodeIdV.Add(NodeId);
}
}
} else {
int Nodes = NodeNmV.Len();
for (int NodeN = 0; NodeN < Nodes; NodeN++) {
if (!NodeNmIdH.IsKey(NodeNmV[NodeN])) { continue; }
int NodeId = NodeNmIdH.GetDat(NodeNmV[NodeN]);
if (Timestamps.IsKey(NodeId) && Sample.IsKey(NodeId) && !Sample.GetDat(NodeId).Empty() && Timestamps.GetDat(NodeId) == 0) {
NodeIdV.Add(NodeId);
}
}
}
EAssertR(QuantileV.Len() > 0, "TGraphCascade::GetPosterior quantiles should not be empty!");
for (int QuantileN = 0; QuantileN < QuantileV.Len(); QuantileN++) {
EAssertR((QuantileV[QuantileN] >= 0.0) && (QuantileV[QuantileN] <= 1.0), "TGraphCascade::GetPosterior quantiles should be between 0.0 and 1.0");
}
int Nodes = NodeIdV.Len();
for (int NodeN = 0; NodeN < Nodes; NodeN++) {
int NodeId = NodeIdV[NodeN];
TStr NodeNm = NodeIdNmH.GetDat(NodeId);
int Quantiles = QuantileV.Len();
TUInt64V SampleV = Sample.GetDat(NodeId);
SampleV.Sort(true);
int SampleSize = SampleV.Len();
PJsonVal QuantilesArr = TJsonVal::NewArr();
for (int QuantileN = 0; QuantileN < Quantiles; QuantileN++) {
int Idx = (int)floor(QuantileV[QuantileN] * SampleSize);
Idx = MIN(Idx, SampleSize - 1);
uint64 UnixTimestamp = TTm::GetUnixMSecsFromWinMSecs(SampleV[Idx]);
QuantilesArr->AddToArr((double)UnixTimestamp);
}
Result->AddToObj(NodeNm, QuantilesArr);
}
return Result;
}
TNodeJsYL40Adc* TNodeJsYL40Adc::NewFromArgs(const v8::FunctionCallbackInfo<v8::Value>& Args) {
v8::Isolate* Isolate = v8::Isolate::GetCurrent();
v8::HandleScope HandleScope(Isolate);
PJsonVal ParamJson = TNodeJsUtil::GetArgJson(Args, 0);
PJsonVal InputJsonV = ParamJson->GetObjKey("inputs");
const bool Verbose = ParamJson->GetObjBool("verbose", false);
TIntStrKdV InputNumNmKdV(InputJsonV->GetArrVals());
for (int InputN = 0; InputN < InputJsonV->GetArrVals(); InputN++) {
PJsonVal InputJson = InputJsonV->GetArrVal(InputN);
InputNumNmKdV[InputN].Key = InputJson->GetObjInt("number");
InputNumNmKdV[InputN].Dat = InputJson->GetObjStr("id");
}
const PNotify Notify = Verbose ? TNotify::StdNotify : TNotify::NullNotify;
return new TNodeJsYL40Adc(new TYL40Adc(Notify), InputNumNmKdV, Notify);
}
void TNodeJsRpiBase::init(const v8::FunctionCallbackInfo<v8::Value>& Args) {
v8::Isolate* Isolate = v8::Isolate::GetCurrent();
v8::HandleScope HandleScope(Isolate);
PJsonVal ArgJson = Args.Length() > 0 ? TNodeJsUtil::GetArgJson(Args, 1) : TJsonVal::NewObj();
const TStr PinLayoutStr = ArgJson->GetObjStr("pinLayout", "bcmGpio");
TGpioLayout PinLayout;
if (PinLayoutStr == "bcmGpio") {
PinLayout = TGpioLayout::glBcmGpio;
} else if (PinLayoutStr == "wiringPi") {
PinLayout = TGpioLayout::glWiringPi;
} else {
throw TExcept::New("Invalid pin layout: " + PinLayoutStr);
}
TRpiUtil::InitGpio(PinLayout);
Args.GetReturnValue().Set(v8::Undefined(Isolate));
}
void TGraphCascade::GenGraph(const PJsonVal& Dag) {
// Dag is an object, whose props are node names, whose values are arrays of parent node names
Graph.Clr();
int Keys = Dag->GetObjKeys();
for (int KeyN = 0; KeyN < Keys; KeyN++) {
TStr Key = Dag->GetObjKey(KeyN);
if (!NodeNmIdH.IsKey(Key)) {
NodeNmIdH.AddDat(Key, NodeNmIdH.Len());
NodeIdNmH.AddDat(NodeIdNmH.Len(), Key);
}
int DstId = NodeNmIdH.GetDat(Key);
if (!Graph.IsNode(DstId)) {
Graph.AddNode(DstId);
}
PJsonVal Val = Dag->GetObjKey(Key);
int Parents = Val->GetArrVals();
for (int NodeN = 0; NodeN < Parents; NodeN++) {
TStr NodeNm = Val->GetArrVal(NodeN)->GetStr();
if (!NodeNmIdH.IsKey(NodeNm)) {
NodeNmIdH.AddDat(NodeNm, NodeNmIdH.Len());
NodeIdNmH.AddDat(NodeIdNmH.Len(), NodeNm);
}
int SrcId = NodeNmIdH.GetDat(NodeNm);
if (!Graph.IsNode(SrcId)) {
Graph.AddNode(SrcId);
}
if (!Graph.IsEdge(SrcId, DstId)) {
Graph.AddEdge(SrcId, DstId);
}
}
}
}
void TNodeJsRf24Radio::OnMsgMainThread(const uint16& NodeId, const uint8& ValueId,
const int& Val) {
if (!OnValueCallback.IsEmpty()) {
v8::Isolate* Isolate = v8::Isolate::GetCurrent();
v8::HandleScope HandleScope(Isolate);
const int ValId = (int) ValueId;
Notify->OnNotifyFmt(TNotifyType::ntInfo, "Got value for value id %d", ValId);
TIntPr NodeIdValIdPr(NodeId, (int) ValId);
EAssertR(NodeIdValIdPrValNmH.IsKey(NodeIdValIdPr), "Node-valueId pair not stored in the structures!");
const TStr& ValueNm = NodeIdValIdPrValNmH.GetDat(NodeIdValIdPr);
PJsonVal JsonVal = TJsonVal::NewObj();
JsonVal->AddToObj("id", ValueNm);
JsonVal->AddToObj("value", Val);
v8::Local<v8::Function> Callback = v8::Local<v8::Function>::New(Isolate, OnValueCallback);
TNodeJsUtil::ExecuteVoid(Callback, TNodeJsUtil::ParseJson(Isolate, JsonVal));
}
}
void TGraphCascade::ProcessModels(const PJsonVal& NodeModels) {
int Keys = NodeModels->GetObjKeys();
for (int KeyN = 0; KeyN < Keys; KeyN++) {
TStr Key = NodeModels->GetObjKey(KeyN);
if (!NodeNmIdH.IsKey(Key)) {
// skip, we will not need this model
continue;
}
PJsonVal Val = NodeModels->GetObjKey(Key);
TFltV PMF;
Val->GetArrNumV(PMF);
int NodeId = NodeNmIdH.GetDat(Key);
TFltV NodeCDF(PMF.Len());
int Len = NodeCDF.Len();
if (Len > 0) {
NodeCDF[0] = PMF[0];
for (int ElN = 1; ElN < Len; ElN++) {
NodeCDF[ElN] = NodeCDF[ElN - 1] + PMF[ElN];
}
}
CDF.AddDat(NodeId, NodeCDF);
}
}
PJsonVal TEmaSpVec::GetJson() const {
PJsonVal arr = TJsonVal::NewArr();
for (int i = 0; i < Ema.Len(); i++) {
PJsonVal tmp = TJsonVal::NewObj();
tmp->AddToObj("Idx", Ema[i].Key);
tmp->AddToObj("Val", Ema[i].Dat);
arr->AddToArr(tmp);
}
PJsonVal res = TJsonVal::NewObj();
res->AddToObj("Sum", arr);
res->AddToObj("Tm", TmMSecs);
return res;
}
