C++ PJsonVal类代码示例

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 TBackupLogInfo::GetJson() const
{
    PJsonVal RetJson = TJsonVal::NewObj("folderName", FolderName);
    RetJson->AddToObj("secsNeeded", SecsNeeded);
    RetJson->AddToObj("logInfo", LogInfo);
    return RetJson;
}

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());
    }
}

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 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);
}