SNAP Library 2.1, User Reference  2013-09-25 10:47:25
SNAP, a general purpose, high performance system for analysis and manipulation of large networks
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines
Public Member Functions | Static Public Member Functions | Static Private Member Functions | Private Attributes | Friends
TXmlDoc Class Reference

#include <xml.h>

List of all members.

Public Member Functions

 TXmlDoc ()
 TXmlDoc (const PXmlTok &_Tok)
 TXmlDoc (TSIn &)
void Save (TSOut &)
TXmlDoc & operator= (const TXmlDoc &)
bool IsOk () const
TStr GetMsgStr () const
PXmlTok GetTok () const
bool IsTagTok (const TStr &TagPath, PXmlTok &TagTok) const
bool IsTagTok (const TStr &TagPath) const
PXmlTok GetTagTok (const TStr &TagPath) const
void PutTagTokStr (const TStr &TagPath, const TStr &TokStr) const
TStr GetTagTokStr (const TStr &TagPath) const
void GetTagTokV (const TStr &TagPath, TXmlTokV &XmlTokV) const
void GetTagValV (const TStr &TagNm, const bool &XmlP, TStrV &ValV) const
TStr GetTagVal (const TStr &TagNm, const bool &XmlP) const
bool GetTagTokBoolArgVal (const TStr &TagPath, const TStr &ArgNm, const bool &DfVal=false) const
int GetTagTokIntArgVal (const TStr &TagPath, const TStr &ArgNm, const int &DfVal=0) const
double GetTagTokFltArgVal (const TStr &TagPath, const TStr &ArgNm, const double &DfVal=0) const
TStr GetTagTokStrArgVal (const TStr &TagPath, const TStr &ArgNm, const TStr &DfVal=TStr()) const
void SaveTxt (const PSOut &SOut)
void SaveTxt (const TStr &FNm, const bool &Append=false)
void SaveStr (TStr &Str)

Static Public Member Functions

static PXmlDoc New ()
static PXmlDoc New (const PXmlTok &Tok)
static PXmlDoc Load (TSIn &SIn)
static TStr GetXmlStr (const TStr &Str)
static bool SkipTopTag (const PSIn &SIn)
static PXmlDoc LoadTxt (TXmlLx &Lx)
static PXmlDoc LoadTxt (const PSIn &SIn, const TXmlSpacing &Spacing=xspIntact)
static PXmlDoc LoadTxt (const TStr &FNm, const TXmlSpacing &Spacing=xspIntact)
static void LoadTxt (const TStr &FNm, TXmlDocV &XmlDocV, const TXmlSpacing &Spacing=xspIntact)
static PXmlDoc LoadStr (const TStr &Str)

Static Private Member Functions

static void LoadTxtMiscStar (TXmlLx &Lx)
static PXmlTok LoadTxtElement (TXmlLx &Lx)

Private Attributes

TCRef CRef
bool Ok
TStr MsgStr
PXmlTok Tok

Friends

class TPt< TXmlDoc >

Detailed Description

Definition at line 326 of file xml.h.

Constructor & Destructor Documentation

TXmlDoc::TXmlDoc ( ) [inline]

Definition at line 334 of file xml.h.

: Ok(false), MsgStr(), Tok(){}
TXmlDoc::TXmlDoc ( const PXmlTok &  _Tok) [inline]

Definition at line 336 of file xml.h.

: Ok(!_Tok.Empty()), MsgStr(), Tok(_Tok){}
TXmlDoc::TXmlDoc ( TSIn &  ) [inline]

Definition at line 338 of file xml.h.

{Fail;}

Member Function Documentation

TStr TXmlDoc::GetMsgStr ( ) const [inline]

Definition at line 346 of file xml.h.

{return MsgStr;}
PXmlTok TXmlDoc::GetTagTok ( const TStr &  TagPath) const

Definition at line 1298 of file xml.cpp.

                                                    {
  if (TagPath.Empty()){
    return Tok;
  } else {
    TStr TagNm; TStr RestTagPath; TagPath.SplitOnCh(TagNm, '|', RestTagPath);
    if ((Tok->GetSym()==xsyTag)&&(Tok->GetStr()==TagNm)){
      if (RestTagPath.Empty()){return Tok;}
      else {return Tok->GetTagTok(RestTagPath);}
    } else {
      return NULL;
    }
  }
}
bool TXmlDoc::GetTagTokBoolArgVal ( const TStr &  TagPath,
const TStr &  ArgNm,
const bool &  DfVal = false 
) const

Definition at line 1332 of file xml.cpp.

                                                                  {
  PXmlTok TagTok;
  if (IsTagTok(TagPath, TagTok)){
    return TagTok->GetBoolArgVal(ArgNm, DfVal);}
  else {return DfVal;}
}
double TXmlDoc::GetTagTokFltArgVal ( const TStr &  TagPath,
const TStr &  ArgNm,
const double &  DfVal = 0 
) const

Definition at line 1348 of file xml.cpp.

                                                                    {
  PXmlTok TagTok;
  if (IsTagTok(TagPath, TagTok)){
    return TagTok->GetFltArgVal(ArgNm, DfVal);}
  else {return DfVal;}
}
int TXmlDoc::GetTagTokIntArgVal ( const TStr &  TagPath,
const TStr &  ArgNm,
const int &  DfVal = 0 
) const

Definition at line 1340 of file xml.cpp.

                                                                 {
  PXmlTok TagTok;
  if (IsTagTok(TagPath, TagTok)){
    return TagTok->GetIntArgVal(ArgNm, DfVal);}
  else {return DfVal;}
}
TStr TXmlDoc::GetTagTokStr ( const TStr &  TagPath) const [inline]

Definition at line 356 of file xml.h.

                                               {
    return GetTagTok(TagPath)->GetTokStr(false);}
TStr TXmlDoc::GetTagTokStrArgVal ( const TStr &  TagPath,
const TStr &  ArgNm,
const TStr &  DfVal = TStr() 
) const

Definition at line 1356 of file xml.cpp.

                                                                  {
  PXmlTok TagTok;
  if (IsTagTok(TagPath, TagTok)){
    return TagTok->GetStrArgVal(ArgNm, DfVal);}
  else {return DfVal;}
}
void TXmlDoc::GetTagTokV ( const TStr &  TagPath,
TXmlTokV &  XmlTokV 
) const

Definition at line 1319 of file xml.cpp.

                                                                     {
  XmlTokV.Clr();
  TStr PreTagPath; TStr TagNm; TagPath.SplitOnLastCh(PreTagPath, '|', TagNm);
  PXmlTok Tok=GetTagTok(PreTagPath);
  if (!Tok.Empty()){
    for (int SubTokN=0; SubTokN<Tok->GetSubToks(); SubTokN++){
      PXmlTok SubTok=Tok->GetSubTok(SubTokN);
      if ((SubTok->GetSym()==xsyTag)&&(SubTok->GetStr()==TagNm)){
        XmlTokV.Add(SubTok);}
    }
  }
}
TStr TXmlDoc::GetTagVal ( const TStr &  TagNm,
const bool &  XmlP 
) const [inline]

Definition at line 361 of file xml.h.

                                                            {
    TStrV ValV; GetTagValV(TagNm, XmlP, ValV);
    if (ValV.Len()>0){return ValV[0];} else {return "";}}
void TXmlDoc::GetTagValV ( const TStr &  TagNm,
const bool &  XmlP,
TStrV &  ValV 
) const [inline]

Definition at line 359 of file xml.h.

                                                                          {
    IAssert(Ok); Tok->GetTagValV(TagNm, XmlP, ValV);}
PXmlTok TXmlDoc::GetTok ( ) const [inline]

Definition at line 347 of file xml.h.

{IAssert(Ok); return Tok;}
TStr TXmlDoc::GetXmlStr ( const TStr &  Str) [static]

Definition at line 1364 of file xml.cpp.

                                      {
  TChA ChA=Str;
  TChA XmlChA;
  for (int ChN=0; ChN<ChA.Len(); ChN++){
    uchar Ch=ChA[ChN];
    if ((' '<=Ch)&&(Ch<='~')){
      if (Ch=='&'){XmlChA+="&amp;";}
      else if (Ch=='>'){XmlChA+="&lt;";}
      else if (Ch=='<'){XmlChA+="&gt;";}
      else if (Ch=='\''){XmlChA+="&apos;";}
      else if (Ch=='\"'){XmlChA+="&quot;";}
      else {XmlChA+=Ch;}
    } else {
      XmlChA+="&#"; XmlChA+=TUInt::GetStr(Ch); XmlChA+=";";
    }
  }
  return XmlChA;
}
bool TXmlDoc::IsOk ( ) const [inline]

Definition at line 345 of file xml.h.

{return Ok;}
bool TXmlDoc::IsTagTok ( const TStr &  TagPath,
PXmlTok &  TagTok 
) const [inline]

Definition at line 350 of file xml.h.

                                                            {
    IAssert(Ok); TagTok=GetTagTok(TagPath); return !TagTok.Empty();}
bool TXmlDoc::IsTagTok ( const TStr &  TagPath) const [inline]

Definition at line 352 of file xml.h.

                                           {
    PXmlTok TagTok; return IsTagTok(TagPath, TagTok);}
static PXmlDoc TXmlDoc::Load ( TSIn &  SIn) [inline, static]

Definition at line 339 of file xml.h.

{return new TXmlDoc(SIn);}
PXmlDoc TXmlDoc::LoadStr ( const TStr &  Str) [static]

Definition at line 1443 of file xml.cpp.

                                       {
  PSIn SIn=TStrIn::New(Str);
  return LoadTxt(SIn);
}
PXmlDoc TXmlDoc::LoadTxt ( TXmlLx &  Lx) [static]

Definition at line 1401 of file xml.cpp.

                                  {
  PXmlDoc Doc=TXmlDoc::New();
  // [1]  document ::=  prolog element Misc*
  try {
    Lx.GetSym();
    // [22] prolog ::=  XMLDecl? Misc* (doctypedecl Misc*)?
    if (Lx.Sym==xsyXmlDecl){Lx.GetSym();}
    LoadTxtMiscStar(Lx);
    if (Lx.Sym==xsyDocTypeDecl){Lx.GetSym();}
    LoadTxtMiscStar(Lx);
    Doc->Tok=LoadTxtElement(Lx);
    LoadTxtMiscStar(Lx);
    Doc->Ok=true; Doc->MsgStr="Ok";
  }
  catch (PExcept& Except){
    Doc->Ok=false; Doc->MsgStr=Except->GetMsgStr();
  }
  return Doc;
}
PXmlDoc TXmlDoc::LoadTxt ( const PSIn &  SIn,
const TXmlSpacing &  Spacing = xspIntact 
) [static]

Definition at line 1421 of file xml.cpp.

                                                                   {
  TXmlLx Lx(SIn, Spacing); return LoadTxt(Lx);
}
PXmlDoc TXmlDoc::LoadTxt ( const TStr &  FNm,
const TXmlSpacing &  Spacing = xspIntact 
) [static]

Definition at line 1425 of file xml.cpp.

                                                                   {
  PSIn SIn=TFIn::New(FNm); return LoadTxt(SIn, Spacing);
}
void TXmlDoc::LoadTxt ( const TStr &  FNm,
TXmlDocV &  XmlDocV,
const TXmlSpacing &  Spacing = xspIntact 
) [static]

Definition at line 1429 of file xml.cpp.

                                                                {
  XmlDocV.Clr();
  PSIn SIn=TFIn::New(FNm);
  TXmlLx Lx(SIn, Spacing);
  PXmlDoc XmlDoc;
  forever {
    Lx.SkipWs();
    XmlDoc=LoadTxt(Lx);
    if (XmlDoc->IsOk()){XmlDocV.Add(XmlDoc);}
    else {break;}
  }
}
PXmlTok TXmlDoc::LoadTxtElement ( TXmlLx &  Lx) [static, private]

Definition at line 1249 of file xml.cpp.

                                         {
  // [39]  element ::=  EmptyElemTag | STag content ETag
  PXmlTok Tok;
  if (Lx.Sym==xsySETag){
    Tok=TXmlTok::GetTok(Lx);
  } else
  if (Lx.Sym==xsySTag){
    Tok=TXmlTok::GetTok(Lx);
    forever {
      Lx.GetSym();
      if (Lx.Sym==xsyETag){
        if (Tok->GetStr()==Lx.TagNm){
          break;
        } else {
          TStr MsgStr=TStr("Invalid End-Tag '")+Lx.TagNm+
           "' ('"+Tok->GetStr()+"' expected).";
          Lx.EThrow(MsgStr);
        }
      } else {
        PXmlTok SubTok;
        switch (Lx.Sym){
          case xsySTag:
            SubTok=LoadTxtElement(Lx); break;
          case xsySETag:
          case xsyStr:
          case xsyQStr:
          case xsyWs:
            SubTok=TXmlTok::GetTok(Lx); break;
          case xsyPI:
          case xsyComment:
            break;
          default: Lx.EThrow("Content or End-Tag expected.");
        }
        if (!SubTok.Empty()){
          Tok->AddSubTok(SubTok);}
      }
    }
  } else
  if (Lx.Sym==xsyETag){
    TStr MsgStr=
     TStr("Xml-Element (Start-Tag or Empty-Element-Tag) required.")+
     TStr::GetStr(Lx.TagNm, " End-Tag </%s> encountered.");
    Lx.EThrow(MsgStr);
  } else {
    Lx.EThrow("Xml-Element (Start-Tag or Empty-Element-Tag) required.");
  }
  return Tok;
}
void TXmlDoc::LoadTxtMiscStar ( TXmlLx &  Lx) [static, private]

Definition at line 1243 of file xml.cpp.

                                       {
  // [27] Misc ::=  Comment | PI |  S
  while ((Lx.Sym==xsyComment)||(Lx.Sym==xsyPI)||(Lx.Sym==xsyWs)){
    Lx.GetSym();}
}
static PXmlDoc TXmlDoc::New ( ) [inline, static]

Definition at line 335 of file xml.h.

{return PXmlDoc(new TXmlDoc());}
static PXmlDoc TXmlDoc::New ( const PXmlTok &  Tok) [inline, static]

Definition at line 337 of file xml.h.

{return PXmlDoc(new TXmlDoc(Tok));}
TXmlDoc& TXmlDoc::operator= ( const TXmlDoc &  ) [inline]

Definition at line 342 of file xml.h.

{Fail; return *this;}
void TXmlDoc::PutTagTokStr ( const TStr &  TagPath,
const TStr &  TokStr 
) const

Definition at line 1312 of file xml.cpp.

                                                                        {
  PXmlTok Tok=GetTagTok(TagPath);
  Tok->ClrSubTok();
  PXmlTok StrTok=TXmlTok::New(xsyStr, TokStr);
  Tok->AddSubTok(StrTok);
}
void TXmlDoc::Save ( TSOut &  ) [inline]

Definition at line 340 of file xml.h.

{Fail;}
void TXmlDoc::SaveStr ( TStr &  Str)

Definition at line 1448 of file xml.cpp.

                              {
  PSOut SOut=TMOut::New(); TMOut& MOut=*(TMOut*)SOut();
  SaveTxt(SOut);
  Str=MOut.GetAsStr();
}
void TXmlDoc::SaveTxt ( const PSOut &  SOut) [inline]

Definition at line 383 of file xml.h.

                                 {
    SOut->PutStr(GetTok()->GetTokStr());}
void TXmlDoc::SaveTxt ( const TStr &  FNm,
const bool &  Append = false 
) [inline]

Definition at line 385 of file xml.h.

                                                         {
    PSOut SOut=TFOut::New(FNm, Append); SaveTxt(SOut);}
bool TXmlDoc::SkipTopTag ( const PSIn &  SIn) [static]

Definition at line 1383 of file xml.cpp.

                                       {
  bool Ok=true;
  TXmlLx Lx(SIn, xspIntact);
  try {
    Lx.GetSym();
    // [22] prolog ::=  XMLDecl? Misc* (doctypedecl Misc*)?
    if (Lx.Sym==xsyXmlDecl){Lx.GetSym();}
    LoadTxtMiscStar(Lx);
    if (Lx.Sym==xsyDocTypeDecl){Lx.GetSym();}
    LoadTxtMiscStar(Lx);
    Ok=true;
  }
  catch (PExcept Except){
    Ok=false;
  }
  return Ok;
}

Friends And Related Function Documentation

friend class TPt< TXmlDoc > [friend]

Definition at line 326 of file xml.h.

Member Data Documentation

TCRef TXmlDoc::CRef [private]

Definition at line 326 of file xml.h.

TStr TXmlDoc::MsgStr [private]

Definition at line 329 of file xml.h.

bool TXmlDoc::Ok [private]

Definition at line 328 of file xml.h.

PXmlTok TXmlDoc::Tok [private]

Definition at line 330 of file xml.h.

The documentation for this class was generated from the following files: