TStr TNotify::GetTypeStr(
const TNotifyType& Type, const bool& Brief){
static TStr InfoSStr="I"; static TStr InfoLStr="Information";
static TStr WarnSStr="W"; static TStr WarnLStr="Warning";
static TStr ErrSStr="E"; static TStr ErrLStr="Error";
static TStr StatSStr=""; static TStr StatLStr="Status";
switch (Type){
case ntInfo: if (Brief){return InfoSStr;} else {return InfoLStr;}
case ntWarn: if (Brief){return WarnSStr;} else {return WarnLStr;}
case ntErr: if (Brief){return ErrSStr;} else {return ErrLStr;}
case ntStat: if (Brief){return StatSStr;} else {return StatLStr;}
default: Fail; return TStr();
}
}
TEST(TNEANet, GetSAttrIdN) {
PNEANet Graph;
Graph = TNEANet::New();
TInt AttrId;
Graph->AddSAttrN("TestInt", atInt, AttrId);
Graph->AddSAttrN("TestFlt", atFlt, AttrId);
Graph->AddSAttrN("TestStr", atStr, AttrId);
TAttrType AttrType;
int status = Graph->GetSAttrIdN(TStr("TestInt"), AttrId, AttrType);
EXPECT_EQ(0, status);
EXPECT_EQ(atInt, AttrType);
EXPECT_EQ(0, AttrId.Val);
status = Graph->GetSAttrIdN(TStr("TestFlt"), AttrId, AttrType);
EXPECT_EQ(0, status);
EXPECT_EQ(atFlt, AttrType);
EXPECT_EQ(1, AttrId.Val);
status = Graph->GetSAttrIdN(TStr("TestStr"), AttrId, AttrType);
EXPECT_EQ(0, status);
EXPECT_EQ(atStr, AttrType);
EXPECT_EQ(2, AttrId.Val);
status = Graph->GetSAttrIdN(TStr("TestError"), AttrId, AttrType);
EXPECT_EQ(-1, status);
}
int TBTb::AddTup(const TStr& Nm){
Assert(GetVars()>0);
TStr UniqNm=Nm;
if (UniqNm.Empty()){UniqNm=TStr("E")+TInt::GetStr(TupV.Len());}
if (TupNmToNH.IsKey(UniqNm)){
int CopyN=2;
while (TupNmToNH.IsKey(UniqNm+" ("+TInt::GetStr(CopyN)+")")){CopyN++;}
UniqNm=UniqNm+" ("+TInt::GetStr(CopyN)+")";
}
Assert(!TupNmToNH.IsKey(UniqNm));
int TupN=0;//TupV.Add(PTbTup(new TBTbTup(UniqNm, GetVars())));
TupNmToNH.AddDat(UniqNm, TupN);
return TupN;
}
void TSession::SaveValue(
const TStr &Cookie,
const TStr &Name,
TSessionValue *p)
{
TStr s;
m_ssi::TStringList sl;
p->SaveValues(sl);
for( int i = 0; i < sl.Count(); i++ )
{
TStr l(sl.Names(i) + "=" + sl.Values(i));
s += TStr(l.Length()) + "-" + l;
}
SaveValue(Cookie,Name,s.c_str(),s.Length());
}
void TNodeJsUtil::ExecuteVoid(const v8::Handle<v8::Function>& Fun,
const v8::Local<v8::Object>& Arg1, const v8::Local<v8::Object>& Arg2) {
v8::Isolate* Isolate = v8::Isolate::GetCurrent();
v8::HandleScope HandleScope(Isolate);
v8::TryCatch TryCatch;
const int ArgC = 2;
v8::Handle<v8::Value> ArgV[ArgC] = { Arg1, Arg2 };
Fun->Call(Isolate->GetCurrentContext()->Global(), 2, ArgV);
if (TryCatch.HasCaught()) {
v8::String::Utf8Value Msg(TryCatch.Message()->Get());
throw TExcept::New("Exception while executing VOID: " + TStr(*Msg));
}
}
/////////////////////////////////////////////////
// Generic-Table
int TGTb::AddVar(const PTbVar& TbVar){
Assert(GetTups()==0);
// generate unique name
TStr UniqNm=TbVar->GetNm();
if (UniqNm.Empty()){UniqNm=TStr("A")+TInt::GetStr(VarV.Len());}
if (VarNmToNH.IsKey(UniqNm)){
int CopyN=2;
while (VarNmToNH.IsKey(UniqNm+" ("+TInt::GetStr(CopyN)+")")){CopyN++;}
UniqNm=UniqNm+" ("+TInt::GetStr(CopyN)+")";
}
Assert(!VarNmToNH.IsKey(UniqNm));
int VarN=VarV.Add(PTbVar(new TGTbVar(UniqNm, TbVar->GetVarType())));
VarNmToNH.AddDat(UniqNm, VarN);
return VarN;
}
void TGStat::Plot(const TGStatDistr& Distr, const TStr& FNmPref, TStr Desc, bool PowerFit) const {
if (Desc.Empty()) Desc = FNmPref.GetUc();
if (! HasDistr(Distr) || Distr==gsdUndef || Distr==gsdMx) { return; }
TPlotInfo Info = GetPlotInfo(Distr);
TGnuPlot GnuPlot(Info.Val1+TStr(".")+FNmPref, TStr::Fmt("%s. G(%d, %d)", Desc.CStr(), GetNodes(),GetEdges()));
GnuPlot.SetXYLabel(Info.Val2, Info.Val3);
GnuPlot.SetScale(Info.Val4);
const int plotId = GnuPlot.AddPlot(GetDistr(Distr), gpwLinesPoints, "");
if (PowerFit) { GnuPlot.AddPwrFit(plotId, gpwLines); }
#ifdef GLib_MACOSX
GnuPlot.SaveEps();
#else
GnuPlot.SavePng();
#endif
}
/// For every quote, add it to corresponding bucket for each hashed x-character shingle of the quote
// (Shingles by characters)
void LSH::HashShingles(TQuoteBase *QuoteBase, TClusterBase *CB, TInt ShingleLen,
THash<TMd5Sig, TShingleIdSet>& ShingleToQuoteIds) {
Err("Hashing shingles...\n");
TIntV QuoteIds;
QuoteBase->GetAllQuoteIds(QuoteIds);
for (int qt = 0; qt < QuoteIds.Len(); qt++) {
if (qt % 1000 == 0) {
fprintf(stderr, "%d out of %d completed\n", qt, QuoteIds.Len());
}
if (CB->IsQuoteInArchivedCluster(QuoteIds[qt]))
continue;
TQuote Q;
QuoteBase->GetQuote(QuoteIds[qt], Q);
// Put x-character (or x-word) shingles into hash table; x is specified by ShingleLen parameter
TStr QContentStr;
Q.GetParsedContentString(QContentStr);
TChA QContentChA = TChA(QContentStr);
int CurWord = 0;
for (int i = 0; i < QContentChA.Len() - ShingleLen + 1; i++) {
TChA ShingleChA = TChA();
for (int j = 0; j < ShingleLen; j++) {
ShingleChA.AddCh(QContentChA.GetCh(i + j));
}
TStr Shingle = TStr(ShingleChA);
const TMd5Sig ShingleMd5(Shingle);
TShingleIdSet ShingleQuoteIds;
if (ShingleToQuoteIds.IsKey(ShingleMd5)) {
ShingleQuoteIds = ShingleToQuoteIds.GetDat(ShingleMd5);
}
for (int j = CurWord; j > CurWord - WordWindow && j >= 0; j--) {
ShingleQuoteIds.AddKey(TShingleId(QuoteIds[qt], j));
}
ShingleToQuoteIds.AddDat(ShingleMd5, ShingleQuoteIds);
// up the current word index if we see a space
if (QContentChA.GetCh(i + ShingleLen - 1) == ' ') {
CurWord++;
}
}
}
Err("Done hashing!\n");
}
TStr TTsMd::GetTsMdEstDNm(const TTsMdEst& Est){
switch (Est){
case tmeAcc: return "Accuracy";
case tmePrbAcc: return "Probability-Accuracy";
case tmeInfScore: return "Information-Score";
case tmeGeoPrecision: return "Geometric-Precision";
case tmeGeoRecall: return "Geometric-Recall";
case tmePrecision: return "Precision";
case tmeRecall: return "Recall";
case tmePrbPrecision: return "Probability-Precision";
case tmePrbRecall: return "Probability-Recall";
case tmeSec: return "Square-Error-In-Counting";
case tmeF2: return "F-Measure";
default: Fail; return TStr();
}
}
PTb TTb::LoadTxtTab(const TStr& FNm, const PTb& Tb){
// open file
PSIn SIn=TFIn::New(FNm);
TILx Lx(SIn, TFSet()|iloTabSep);
// read variable names
Lx.GetStr();
bool IsTupNm=(Lx.UcStr=="NAME")||(Lx.UcStr=="ID");
if (IsTupNm){Lx.GetSym(syTab); Lx.GetStr();}
do {
PTbVarType VarType=PTbVarType(new TTbVarType());
PTbVar Var=PTbVar(new TGTbVar(Lx.Str, VarType));
Tb->AddVar(Var);
if (Lx.GetSym(syTab, syEoln, syEof)==syTab){
Lx.GetSym(syStr);}
} while (Lx.Sym==syStr);
// read tuples
if (Lx.Sym!=syEof){
Lx.GetSym(syStr, syEof);}
while (Lx.Sym!=syEof){
int TupN;
if (IsTupNm){
TupN=Tb->AddTup(Lx.GetSymStr());
Lx.GetSym(syTab); Lx.GetStr();}
else {TupN=Tb->AddTup();}
for (int VarN=0; VarN<Tb->GetVars(); VarN++){
if (VarN>0){Lx.GetSym(syTab); Lx.GetStr();}
if (Lx.Str=='?'){Tb->PutVal(TupN, VarN, TTbVal(tvtUnknw));}
else if (Lx.Str=='*'){Tb->PutVal(TupN, VarN, TTbVal(tvtUnimp));}
else if (Lx.Str=='/'){Tb->PutVal(TupN, VarN, TTbVal(tvtUnapp));}
else {
double Flt;
if (TStr(Lx.Str).IsFlt(Flt)){
Tb->PutFlt(TupN, VarN, Flt);
} else {
Tb->PutDsc(TupN, VarN, Lx.Str);
}
}
}
//printf("Tups: %d\r", Tb->GetTups());
Lx.GetSym(syEoln, syEof);
while (Lx.Sym==syEoln){Lx.GetSym(syStr, syEoln, syEof);}
}
Tb->DefVarTypes();
return Tb;
}
void TNodeJsUtil::ExecuteErr(const v8::Handle<v8::Function>& Fun, const PExcept& Except) {
v8::Isolate* Isolate = v8::Isolate::GetCurrent();
v8::HandleScope HandleScope(Isolate);
v8::TryCatch TryCatch;
const TStr& Msg = Except->GetMsgStr();
v8::Local<v8::String> V8Msg = v8::String::NewFromUtf8(Isolate, Msg.CStr());
v8::Local<v8::Value> Err = v8::Exception::Error(V8Msg);
const int ArgC = 1;
v8::Handle<v8::Value> ArgV[ArgC] = { Err };
Fun->Call(Isolate->GetCurrentContext()->Global(), ArgC, ArgV);
if (TryCatch.HasCaught()) {
v8::String::Utf8Value Msg(TryCatch.Message()->Get());
throw TExcept::New("Exception while executin JSON: " + TStr(*Msg));
}
}
void THtml::GetTokens(const PSIn& SIn, TStrV& TokenV) const {
THtmlLx HtmlLx(SIn, false);
// traverse html string symbols
while (HtmlLx.Sym!=hsyEof){
if (HtmlLx.Sym==hsyStr){
TStr UcStr = HtmlLx.UcChA;
// check if stop word
if ((SwSet.Empty()) || (!SwSet->IsIn(UcStr))) {
TStr TokenStr = ToUcP ? UcStr : TStr(HtmlLx.ChA);
if (!Stemmer.Empty()) {
TokenStr = Stemmer->GetStem(TokenStr); }
TokenV.Add(TokenStr.GetLc());
}
}
// get next symbol
HtmlLx.GetSym();
}
}
/////////////////////////////////////////////////
// Binary-Table
int TBTb::AddVar(const PTbVar& TbVar){
Assert(GetTups()==0);
// generate unique name
TStr UniqNm=TbVar->GetNm();
if (UniqNm.Empty()){UniqNm=TStr("A")+TInt::GetStr(VarNmToNH.Len());}
if (VarNmToNH.IsKey(UniqNm)){
int CopyN=2;
while (VarNmToNH.IsKey(UniqNm+" ("+TInt::GetStr(CopyN)+")")){CopyN++;}
UniqNm=UniqNm+" ("+TInt::GetStr(CopyN)+")";
}
Assert(!VarNmToNH.IsKey(UniqNm));
// check binary type
IAssert(TbVar->GetVarType()==TTbVarType::GetDscBoolVarType());
// create variable
int VarN=VarNmToNH.Len();
VarNmToNH.AddDat(UniqNm, VarN);
return VarN;
}
void TStrFeatureSpace::FromAddStr(const TStr& Serialized, TIntFltKdV& Vec, char Sep) {
TStrV Toks;
Serialized.SplitOnAllCh(Sep, Toks, true);
Vec.Gen(Toks.Len());
for (int i = 0; i < Toks.Len(); i++) {
TStr Key, Value;
Toks[i].SplitOnCh(Key, ':', Value);
int FeatureId = GetAddId(Key);
double FeatureWgt;
if (Value.IsFlt(FeatureWgt)) {
Vec[i].Key = FeatureId;
Vec[i].Dat = FeatureWgt;
} else {
EFailR((Value + TStr(" is not a valid floating point number.")).CStr());
}
}
Vec.Sort();
}
uint64 TNodeJsUtil::GetTmMSecs(v8::Handle<v8::Value>& Value) {
v8::Isolate* Isolate = v8::Isolate::GetCurrent();
v8::HandleScope HandleScope(Isolate);
if (Value->IsDate()) {
v8::Local<v8::Date> Date = v8::Handle<v8::Date>::Cast(Value);
return GetTmMSecs(Date);
}
else if (Value->IsString()) {
v8::String::Utf8Value Utf8(Value);
TTm Tm = TTm::GetTmFromWebLogDateTimeStr(TStr(*Utf8), '-', ':', '.', 'T');
return TTm::GetMSecsFromTm(Tm);
}
else {
EAssertR(Value->IsNumber(), "Date is not in a representation of a string, date or number!");
return GetCppTimestamp(int64(Value->NumberValue()));
}
}
TStr TLxSymStr::GetSymStr(const TLxSym& Sym){
switch (Sym){
case syUndef: return UndefStr;
case syLn: return LnStr;
case syTab: return TabStr;
case syInt: return IntStr;
case syFlt: return FltStr;
case syStr: return StrStr;
case syIdStr: return IdStrStr;
case syQStr: return QStrStr;
case syPeriod: return PeriodStr;
case syDPeriod: return DPeriodStr;
case syComma: return CommaStr;
case syColon: return ColonStr;
case syDColon: return DColonStr;
case sySemicolon: return SemicolonStr;
case syPlus: return PlusStr;
case syMinus: return MinusStr;
case syAsterisk: return AsteriskStr;
case sySlash: return SlashStr;
case syPercent: return PercentStr;
case syExclamation: return ExclamationStr;
case syVBar: return VBarStr;
case syAmpersand: return AmpersandStr;
case syQuestion: return QuestionStr;
case syHash: return HashStr;
case syEq: return EqStr;
case syNEq: return NEqStr;
case syLss: return LssStr;
case syGtr: return GtrStr;
case syLEq: return LEqStr;
case syGEq: return GEqStr;
case syLParen: return LParenStr;
case syRParen: return RParenStr;
case syLBracket: return LBracketStr;
case syRBracket: return RBracketStr;
case syLBrace: return LBraceStr;
case syRBrace: return RBraceStr;
case syEoln: return EolnStr;
case syEof: return EofStr;
default: Fail; return TStr();
}
}
TStr TTbVal::GetValTagStr(const int& ValTag) {
switch (ValTag) {
case tvtUndef:
return "<Undef>";
case tvtUnknw:
return "<Unknw>";
case tvtUnimp:
return "<Unimp>";
case tvtUnapp:
return "<Unapp>";
case tvtDsc:
return "<Dsc>";
case tvtFlt:
return "<Flt>";
default:
Fail;
return TStr();
}
}
TLxChDef::TLxChDef(const TLxChDefTy& ChDefTy):
ChTyV(TCh::Vals), UcChV(TCh::Vals){
if (ChDefTy==lcdtUsAscii){
// Character-Types
ChTyV.PutAll(TInt(lctSpace));
SetChTy(lctNum, "0123456789");
SetChTy(lctAlpha, "ABCDEFGHIJKLMNOPQRSTUVWXYZ");
SetChTy(lctAlpha, "abcdefghijklmnopqrstuvwxyz");
SetChTy(lctAlpha, "@_");
SetChTy(lctSSym, "\"'.,:;+-*/%!#|&<=>?()[]{}");
SetChTy(lctTerm, TStr(TCh::CrCh));
SetChTy(lctTerm, TStr(TCh::LfCh));
SetChTy(lctTerm, TStr(TCh::EofCh));
// Upper-Case
for (int Ch=TCh::Mn; Ch<=TCh::Mx; Ch++){UcChV[Ch-TCh::Mn]=TCh(char(Ch));}
SetUcCh("Aa"); SetUcCh("Bb"); SetUcCh("Cc"); SetUcCh("Dd"); SetUcCh("Ee");
SetUcCh("Ff"); SetUcCh("Gg"); SetUcCh("Hh"); SetUcCh("Ii"); SetUcCh("Jj");
SetUcCh("Kk"); SetUcCh("Ll"); SetUcCh("Mm"); SetUcCh("Nn"); SetUcCh("Oo");
SetUcCh("Pp"); SetUcCh("Qq"); SetUcCh("Rr"); SetUcCh("Ss"); SetUcCh("Tt");
SetUcCh("Uu"); SetUcCh("Vv"); SetUcCh("Ww"); SetUcCh("Xx"); SetUcCh("Yy");
SetUcCh("Zz");
} else
if (ChDefTy==lcdtYuAscii){
// Character-Types
ChTyV.PutAll(TInt(lctSpace));
SetChTy(lctNum, "0123456789");
SetChTy(lctAlpha, "ABC^]D\\EFGHIJKLMNOPQRS[TUVWXYZ@");
SetChTy(lctAlpha, "abc~}d|efghijklmnopqrs{tuvwxyz`");
SetChTy(lctAlpha, "_");
SetChTy(lctSSym, "\".,:;+-*/%!#&<=>?()");
SetChTy(lctTerm, TStr(TCh::CrCh));
SetChTy(lctTerm, TStr(TCh::LfCh));
SetChTy(lctTerm, TStr(TCh::EofCh));
// Upper-Case
for (int Ch=TCh::Mn; Ch<=TCh::Mx; Ch++){UcChV[Ch-TCh::Mn]=TCh(char(Ch));}
SetUcCh("Aa"); SetUcCh("Bb"); SetUcCh("Cc"); SetUcCh("^~"); SetUcCh("]}");
SetUcCh("Dd"); SetUcCh("\\|"); SetUcCh("Ee"); SetUcCh("Ff"); SetUcCh("Gg");
SetUcCh("Hh"); SetUcCh("Ii"); SetUcCh("Jj"); SetUcCh("Kk"); SetUcCh("Ll");
SetUcCh("Mm"); SetUcCh("Nn"); SetUcCh("Oo"); SetUcCh("Pp"); SetUcCh("Qq");
SetUcCh("Rr"); SetUcCh("Ss"); SetUcCh("[{"); SetUcCh("Tt"); SetUcCh("Uu");
SetUcCh("Vv"); SetUcCh("Ww"); SetUcCh("Xx"); SetUcCh("Yy"); SetUcCh("Zz");
SetUcCh("@`");
} else {
Fail;
}
}
void TWebTxtBs::FetchStart(
const TStr& Nm, const TStr& FPath,
const TStr& WebFilterFNm, const bool& IndexTxtBsP){
if (IsTxtBsActive()){
if (IsFetchActive()){
SendToStatusAndTrm("Web-Fetch already active.");
} else {
PWebFilter WebFilter=TWebFilter::LoadTxt(WebFilterFNm);
if (WebFilter.Empty()){
SendToStatusAndTrm(TStr("Web-Filter '")+WebFilterFNm+"' does not exist.");
} else {
WebBsFetch=PWebBsFetch(new
TWebBsFetch(Nm, FPath, faCreate, this, WebFilter, IndexTxtBsP));
WebBsFetch->GoFetch();
}
}
} else {
SendToStatusAndTrm("Web-Base not active.");
}
}
TStr THttp::GetReasonPhrase(const int& StatusCd){
switch (StatusCd){
case 200: return "OK";
case 201: return "Created";
case 202: return "Accepted";
case 204: return "No Content";
case 300: return "Multiple Choices";
case 301: return "Moved Permanently";
case 302: return "Moved Temporarily";
case 304: return "Not Modified";
case 400: return "Bad Request";
case 401: return "Unauthorized";
case 403: return "Forbidden";
case 404: return "Not Found";
case 500: return "Internal Server Error";
case 501: return "Not Implemented";
case 502: return "Bad Gateway";
case 503: return "Service Unavailable";
default: return TStr("Unknown Status Code ")+TInt::GetStr(StatusCd);
}
}
TStr TSockSys::GetLocalIpNum(const uint64& SockId) {
// make sure it's a valid socket
IAssert(IsSock(SockId));
uv_tcp_t* SockHnd = SockIdToHndH.GetDat(SockId);
// get peer IP
struct sockaddr SockName;
int NameLen = sizeof(SockName);
const int ResCd = uv_tcp_getsockname(SockHnd, &SockName, &NameLen);
EAssertR(ResCd == 0, "SockSys.GetLocalIpNum: " + SockSys.GetLastErr());
// decode IP
char SockIpNum[64];
if (SockName.sa_family == AF_INET) {
uv_ip4_name((sockaddr_in*)&SockName, SockIpNum, sizeof(SockIpNum));
} else if (SockName.sa_family == AF_INET6) {
uv_ip6_name((sockaddr_in6*)&SockName, SockIpNum, sizeof(SockIpNum));
} else {
throw TExcept::New("SockSys.GetLocalIpNum: unkown address family");
}
// return
return TStr(SockIpNum);
}
void TWebTravelHomeNet::StartTravel(){
PutConstrs();
TStrV UrlStrV(300000, 0);
TIntIntH UserIdToDocsH(1000);
PSIn SIn=PSIn(new TFIn(InFNm));
TILx Lx(SIn, TFSet()|iloRetEoln);
TChA UrlStr;
Lx.GetSym(syInt, syEof);
while ((Lx.Sym!=syEof)&&(Lx.SymLnN<200000)){
// while (Lx.Sym!=syEof){
int UserId=Lx.Int; Lx.GetSym(syComma);
Lx.GetInt(); Lx.GetSym(syComma);
Lx.GetInt(); Lx.GetSym(syComma);
Lx.GetInt(); Lx.GetSym(syComma);
Lx.GetInt(); Lx.GetSym(syComma);
TStr Method=Lx.GetIdStr(); Lx.GetSym(syComma); // GET, POST
UrlStr.Clr(); UrlStr+=Lx.GetIdStr(); Lx.GetSym(syComma); // http, ftp
UrlStr+="://";
UrlStr+=Lx.GetStrToCh(','); Lx.GetSym(syComma); // domain name
UrlStr+=Lx.GetStrToEoln(); Lx.GetEoln(); // path
if ((UserId==TgUserId)&&IsUrlOk(UrlStr)&&(Method=="GET")){
UserIdToDocsH.AddDat(UserId)++;
UrlStrV.Add(UrlStr);
}
Lx.GetSym(syInt, syEof);
if (Lx.SymLnN%100000==0){OnNotify(TInt::GetStr(Lx.SymLnN)+ " docs");}
}
int UserIdToDocsP=UserIdToDocsH.FFirstKeyId();
while (UserIdToDocsH.FNextKeyId(UserIdToDocsP)){
int UserId=UserIdToDocsH.GetKey(UserIdToDocsP);
int Docs=UserIdToDocsH[UserIdToDocsP];
TStr MsgStr=TStr("User ")+TInt::GetStr(UserId)+": "+
TInt::GetStr(Docs)+" Docs.";
OnNotify(MsgStr);
}
UrlStrV.Shuffle(TRnd());
for (int UrlStrN=0; UrlStrN<UrlStrV.Len(); UrlStrN++){
Go(UrlStrV[UrlStrN]);
}
}
TStr TTmInfo::GetTmUnitStr(const TTmUnit& TmUnit) {
switch(TmUnit) {
case tmuYear : return "Year";
case tmuMonth : return "Month";
case tmuWeek : return "Week";
case tmuDay : return "Day";
case tmu12Hour : return "12 Hours";
case tmu6Hour : return "6 Hours";
case tmu4Hour : return "4 Hours";
case tmu2Hour : return "2 Hours";
case tmu1Hour : return "1 Hour";
case tmu30Min : return "30 Minutes";
case tmu15Min : return "15 Minutes";
case tmu10Min : return "10 Minutes";
case tmu1Min : return "Minute";
case tmu1Sec : return "Second";
case tmuNodes : return "Nodes";
case tmuEdges : return "Edges";
default: Fail;
}
return TStr();
}
void TStrFeatureSpace::FromStr(const TStr& Serialized, TIntFltKdV& Vec, char Sep) const {
TStrV Toks;
Serialized.SplitOnAllCh(Sep, Toks, true);
Vec.Gen(Toks.Len(),0);
for (int i = 0; i < Toks.Len(); i++) {
TStr Key, Value;
Toks[i].SplitOnCh(Key, ':', Value);
TStrFSSize FeatureId;
if (GetIfExistsId(Key, FeatureId)) {
double FeatureWgt;
if (Value.IsFlt(FeatureWgt)) {
TIntFltKd& Kv = Vec[Vec.Add()];
Kv.Key = FeatureId;
Kv.Dat = FeatureWgt;
} else {
EFailR((Value + TStr(" is not a valid floating point number.")).CStr());
}
}
}
Vec.Sort();
}
PSs TSs::LoadTxt(
const TSsFmt& SsFmt, const TStr& FNm,
const PNotify& Notify, const bool& IsExcelEoln,
const int& MxY, const TIntV& AllowedColNV, const bool& IsQStr) {
TNotify::OnNotify(Notify, ntInfo, TStr("Loading File ")+FNm+" ...");
PSIn SIn=TFIn::New(FNm);
PSs Ss=TSs::New();
if (!SIn->Eof()) {
int X=0;
int Y=0;
int PrevX=-1;
int PrevY=-1;
char Ch=SIn->GetCh();
TChA ChA;
while (!SIn->Eof()) {
// compose value
ChA.Clr();
if (IsQStr&&(Ch=='"')) {
// quoted string ('""' sequence means '"')
Ch=SIn->GetCh();
forever {
while ((!SIn->Eof())&&(Ch!='"')) {
ChA+=Ch;
Ch=SIn->GetCh();
}
if (Ch=='"') {
Ch=SIn->GetCh();
if (Ch=='"') {
ChA+=Ch;
Ch=SIn->GetCh();
}
else {
break;
}
}
}
} else {
if (SsFmt==ssfTabSep) {
void TNodeJsFs::listFile(const v8::FunctionCallbackInfo<v8::Value>& Args) {
v8::Isolate* Isolate = v8::Isolate::GetCurrent();
v8::HandleScope HandleScope(Isolate);
EAssertR(Args.Length() >= 1 && Args[0]->IsString(),
"Expected directory path as the first argument.");
// Read parameters
TStr FPath(*v8::String::Utf8Value(Args[0]->ToString()));
TStrV FExtV;
if (Args.Length() >= 2 && Args[1]->IsString()) {
FExtV.Add(TStr(*v8::String::Utf8Value(Args[1]->ToString())));
}
const bool RecurseP = Args.Length() >= 3 && Args[2]->IsBoolean() && Args[2]->BooleanValue();
// Get file list
TStrV FNmV;
TFFile::GetFNmV(FPath, FExtV, RecurseP, FNmV);
FNmV.Sort();
v8::Handle<v8::Array> FNmArr = v8::Array::New(Isolate, FNmV.Len());
for(int FldN = 0; FldN < FNmV.Len(); ++FldN) {
FNmArr->Set(v8::Integer::New(Isolate, FldN), v8::String::NewFromUtf8(Isolate, FNmV.GetVal(FldN).CStr()));
}
Args.GetReturnValue().Set(FNmArr);
}
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);
}
void TGStatVec::ImposeDistr(const TGStatDistr& Distr, const TStr& FNmPref, TStr Desc, const bool& ExpBin,
const bool& PowerFit, const TGpSeriesTy& PlotWith, const TStr& Style) const {
if (Desc.Empty()) Desc = FNmPref.GetUc();
if (! At(0)->HasDistr(Distr) || Distr==gsdUndef || Distr==gsdMx) { return; }
TGStat::TPlotInfo Info = At(0)->GetPlotInfo(Distr);
TGnuPlot GnuPlot(Info.Val1+TStr(".")+FNmPref, TStr::Fmt("%s. G(%d, %d) --> G(%d, %d)", Desc.CStr(),
At(0)->GetNodes(), At(0)->GetEdges(), Last()->GetNodes(), Last()->GetEdges()));
GnuPlot.SetXYLabel(Info.Val2, Info.Val3);
GnuPlot.SetScale(Info.Val4);
int plotId;
for (int at = 0; at < Len(); at++) {
TStr Legend = At(at)->GetNm();
if (Legend.Empty()) { Legend = At(at)->GetTmStr(); }
if (! ExpBin) {
plotId = GnuPlot.AddPlot(At(at)->GetDistr(Distr), PlotWith, Legend, Style); }
else {
TFltPrV ExpBinV;
TGnuPlot::MakeExpBins(At(at)->GetDistr(Distr), ExpBinV, 2, 0);
plotId = GnuPlot.AddPlot(ExpBinV, PlotWith, Legend, Style);
}
if (PowerFit) { GnuPlot.AddPwrFit(plotId, gpwLines); }
}
GnuPlot.SavePng();
}
///// Split on all occurrences of SplitCh, write to StrV, optionally don't create empy strings (default true)
//void SplitOnAllCh(const char& SplitCh, TStrV& StrV, const bool& SkipEmpty = true) const;
TEST(TStr, SplitOnAllCh) {
TStr Str = "abcabca";
TStrV StrV;
Str.SplitOnAllCh('a', StrV, true);
EXPECT_EQ(2, StrV.Len());
EXPECT_EQ(TStr("bc"), StrV[0]);
EXPECT_EQ(TStr("bc"), StrV[1]);
Str.SplitOnAllCh('a', StrV, false);
EXPECT_EQ(4, StrV.Len());
EXPECT_EQ(TStr(), StrV[0]);
EXPECT_EQ(TStr("bc"), StrV[1]);
EXPECT_EQ(TStr("bc"), StrV[2]);
EXPECT_EQ(TStr(), StrV[3]);
// edge cases
Str = "a";
Str.SplitOnAllCh('a', StrV, true);
EXPECT_EQ(0, StrV.Len());
Str.SplitOnAllCh('a', StrV, false);
EXPECT_EQ(2, StrV.Len());
Str = "aa";
Str.SplitOnAllCh('a', StrV, true);
EXPECT_EQ(0, StrV.Len());
Str.SplitOnAllCh('a', StrV, false);
EXPECT_EQ(3, StrV.Len());
Str = "";
Str.SplitOnAllCh('a', StrV, true);
EXPECT_EQ(0, StrV.Len());
Str.SplitOnAllCh('a', StrV, false);
EXPECT_EQ(1, StrV.Len());
// non match
Str = "abc";
Str.SplitOnAllCh('x', StrV, true);
EXPECT_EQ(1, StrV.Len());
Str.SplitOnAllCh('x', StrV, false);
EXPECT_EQ(1, StrV.Len());
}
void TFRnd::Flush(){
EAssertR(fflush(FileId)==0, "Can not flush file '"+TStr(FNm)+"'.");
}
