Src/DasherCore/XMLUtil.cpp

   1
   2 #include "XMLUtil.h"
   3
   4 #include <sys/types.h>
   5 #include <sys/stat.h>
   6
   7 // Track memory leaks on Windows to the line that new'd the memory
   8 #ifdef _WIN32
   9 #ifdef _DEBUG
  10 #define DEBUG_NEW new( _NORMAL_BLOCK, THIS_FILE, __LINE__ )
  11 #define new DEBUG_NEW
  12 #undef THIS_FILE
  13 static char THIS_FILE[] = __FILE__;
  14 #endif
  15 #endif
  16
  17 bool XMLUtil::IsWhiteSpace(char cLetter)
  18 {
  19   if ((cLetter == ' ') ||
  20       (cLetter == '\n') ||
  21       (cLetter == '\r') ||
  22       (cLetter == '\t'))
  23     return true;
  24
  25   return false;
  26 }
  27
  28 // See if a character is 0 - 9
  29 bool XMLUtil::IsDigit(char cLetter)
  30 {
  31   if ((cLetter >= '0') && (cLetter <= '9'))
  32     return true;
  33   return false;
  34 }
  35
  36 // Strip the leading and trailing white space off a string.
  37 string XMLUtil::StripWhiteSpace(const string& strText)
  38 {
  39   string strResult = "";
  40
  41   strResult.reserve(strText.length());
  42
  43   int iStart = 0;
  44   while ((iStart < (int) strText.length()) && (IsWhiteSpace(strText[iStart])))
  45     iStart++;
  46
  47   int iEnd = strText.length() - 1;
  48   while ((iEnd > 0) && (IsWhiteSpace(strText[iEnd])))
  49     iEnd--;
  50
  51   strResult = strText.substr(iStart, iEnd - iStart + 1);
  52
  53   return strResult;
  54 }
  55
  56 // Return a string containing the contents of a file
  57 string XMLUtil::LoadFile(const string& strFilename, unsigned int iSizeHint)
  58 {
  59   string strResult = "";
  60
  61   char szBuffer[XML_UTIL_READ_BUFFER_SIZE];
  62   FILE* fp = NULL;
  63   fp = fopen(strFilename.c_str(), "r");
  64   if (fp != NULL)
  65   {
  66 #ifdef _WIN32
  67     struct __stat64 buf;
  68     int result;
  69     result = _stat64(strFilename.c_str(), &buf);
  70     strResult.reserve((unsigned long) buf.st_size + 256);
  71 #else
  72     // On unix, we default to 128,000 bytes or whatever the caller passed in as a hint
  73     strResult.reserve(iSizeHint);
  74 #endif
  75
  76     while (!feof(fp))
  77     {
  78       memset(szBuffer, 0, XML_UTIL_READ_BUFFER_SIZE);
  79       fread(szBuffer, 1, XML_UTIL_READ_BUFFER_SIZE - 1, fp);
  80       strResult += szBuffer;
  81     }
  82
  83     fclose(fp);
  84     fp = NULL;
  85   }
  86
  87   return strResult;
  88 }
  89
  90
  91 // Returns what is between the given tag in the passed XML.  We only return the first matching
  92 // tag if there are multiple in the XML.  Tags are case sensitive.
  93 string XMLUtil::GetElementString(const string& strTag, const string& strXML, bool bStripWhiteSpace)
  94 {
  95   string strResult = "";
  96   string strStart = "";
  97   string strEnd = "";
  98
  99   strStart += "<";
 100   strStart += strTag;
 101   strStart += ">";
 102
 103   strEnd += "</";
 104   strEnd += strTag;
 105   strEnd += ">";
 106
 107   int iPosStart = strXML.find(strStart);
 108   int iPosEnd = strXML.find(strEnd);
 109
 110   if ((iPosStart != -1) && (iPosEnd != -1))
 111   {
 112     strResult = strXML.substr(iPosStart + strStart.length(), iPosEnd - (iPosStart + strStart.length()));
 113   }
 114
 115   if (bStripWhiteSpace)
 116     strResult = StripWhiteSpace(strResult);
 117
 118   return strResult;
 119 }
 120
 121 // Return the integer representing an element
 122 int XMLUtil::GetElementInt(const string& strTag, const string& strXML, bool* pFound)
 123 {
 124   string strElement = GetElementString(strTag, strXML);
 125
 126   unsigned int i = 0;
 127   for (i = 0; i < strElement.size(); i++)
 128   {
 129     if (i == 0)
 130     {
 131       if ((!IsDigit(strElement[i])) && ((strElement[i] != '-')))
 132         break;
 133     }
 134     else
 135       if (!IsDigit(strElement[i]))
 136         break;
 137   }
 138
 139   // Only try and convert something that is all digits
 140   if (i == strElement.size())
 141   {
 142     if (pFound != NULL)
 143       *pFound = true;
 144     return atoi(strElement.c_str());
 145   }
 146   else
 147   {
 148     if (pFound != NULL)
 149       *pFound = false;
 150     return -1;
 151   }
 152 }
 153
 154 int64 XMLUtil::GetElementLongLong(const string& strTag, const string& strXML, bool* pFound)
 155 {
 156   string strElement = GetElementString(strTag, strXML);
 157
 158   unsigned int i = 0;
 159   for (i = 0; i < strElement.size(); i++)
 160   {
 161     if (i == 0)
 162     {
 163       if ((!IsDigit(strElement[i])) && ((strElement[i] != '-')))
 164         break;
 165     }
 166     else
 167       if (!IsDigit(strElement[i]))
 168         break;
 169   }
 170
 171   // Only try and convert something that is all digits
 172   if ((i > 0) && (i == strElement.size()))
 173   {
 174     if (pFound != NULL)
 175       *pFound = true;
 176 #ifdef _WIN32
 177     return _atoi64(strElement.c_str());
 178 #else
 179     return atoll(strElement.c_str());
 180 #endif
 181   }
 182   else
 183   {
 184     if (pFound != NULL)
 185       *pFound = false;
 186     return -1;
 187   }
 188 }
 189
 190 // Optionally can pass back a bool that tell us if the tag was found
 191 float XMLUtil::GetElementFloat(const string& strTag, const string& strXML, bool* pFound)
 192 {
 193   string strElement = GetElementString(strTag, strXML);
 194
 195   bool bFoundDot = false;
 196
 197   unsigned int i = 0;
 198   for (i = 0; i < strElement.size(); i++)
 199   {
 200     if (i == 0)
 201     {
 202       if ((!IsDigit(strElement[i])) && ((strElement[i] != '-')))
 203         break;
 204     }
 205     else
 206     {
 207       if (!IsDigit(strElement[i]))
 208       {
 209         if ((strElement[i] == '.') && (!bFoundDot))
 210           bFoundDot = true;
 211         else
 212           break;
 213       }
 214     }
 215   }
 216
 217   // Only try and convert something that is all digits
 218   if ((i > 0) && (i == strElement.size()))
 219   {
 220     if (pFound != NULL)
 221       *pFound = true;
 222     return (float) atof(strElement.c_str());
 223   }
 224   else
 225   {
 226     if (pFound != NULL)
 227       *pFound = false;
 228     return (float) 0.0;
 229   }
 230 }
 231
 232 // Return a vector containing all the text inside all tags matching the passed one
 233 VECTOR_STRING XMLUtil::GetElementStrings(const string& strTag, const string& strXML, bool bStripWhiteSpace)
 234 {
 235   VECTOR_STRING vResult;
 236   vResult.reserve(XML_UTIL_DEFAULT_VECTOR_SIZE);
 237
 238   string strStart = "";
 239   string strEnd = "";
 240   string strResult = "";
 241
 242   strStart += "<";
 243   strStart += strTag;
 244   strStart += ">";
 245
 246   strEnd += "</";
 247   strEnd += strTag;
 248   strEnd += ">";
 249
 250   int iPosStart        = strXML.find(strStart);
 251   int iPosEnd          = strXML.find(strEnd);
 252
 253   while ((iPosStart != string::npos) && (iPosEnd != string::npos))
 254   {
 255     // We want to be able to handle having the same tag emedded in itself.
 256     // So between the start tag and the first instance of the end tag,
 257     // we'll count any other instances of the start tag.  If we find some
 258     // then we require that we continue until we get that number more of
 259     // close tags.
 260     int iCurrentStart    = iPosStart + strStart.length();
 261     int iEmbedCount      = 0;
 262     while ((iCurrentStart != string::npos) && (iCurrentStart < iPosEnd))
 263     {
 264       iCurrentStart = strXML.find(strStart, iCurrentStart);
 265       if ((iCurrentStart != string::npos) && (iCurrentStart < iPosEnd))
 266       {
 267         iEmbedCount++;
 268         iCurrentStart += strStart.length();
 269       }
 270     }
 271     // Now look for end tag to balance the start tags
 272     for (int i = 0; i < iEmbedCount; i++)
 273     {
 274       iPosEnd = strXML.find(strEnd, iPosEnd  + strEnd.length());
 275
 276       // Check to make sure we're still matching tags
 277       if (iPosEnd == string::npos)
 278         break;
 279     }
 280
 281     strResult = strXML.substr(iPosStart + strStart.length(), iPosEnd - (iPosStart + strStart.length()));
 282
 283     if (bStripWhiteSpace)
 284       strResult = StripWhiteSpace(strResult);
 285
 286     iPosStart = strXML.find(strStart, iPosEnd + strEnd.length());
 287
 288     if (iPosStart != string::npos)
 289       iPosEnd = strXML.find(strEnd, iPosStart);
 290
 291     vResult.push_back(strResult);
 292   }
 293
 294   return vResult;
 295 }
 296
 297 VECTOR_NAME_VALUE_PAIR XMLUtil::GetNameValuePairs(const string& strXML, bool bStripWhiteSpace)
 298 {
 299   VECTOR_NAME_VALUE_PAIR vResult;
 300   vResult.reserve(XML_UTIL_DEFAULT_VECTOR_SIZE);
 301
 302   bool    bInStartTag = false;
 303   string  strName     = "";
 304   string  strValue    = "";
 305
 306   unsigned int i = 0;
 307   while (i < strXML.length())
 308   {
 309     if ((!bInStartTag) && (strXML[i] == '<'))
 310     {
 311       // Starting a new tag
 312       bInStartTag = true;
 313     }
 314     else if (bInStartTag)
 315     {
 316       if (strXML[i] == '>')
 317       {
 318         // Hit the end of the start tag, get everything
 319         // until we find the end tag.
 320
 321         string strFind = "</";
 322         strFind += strName;
 323         strFind += ">";
 324
 325         int iPos = -1;
 326         iPos = strXML.find(strFind, i);
 327
 328         if (iPos != -1)
 329         {
 330           strValue = strXML.substr(i + 1, iPos - i - 1);
 331
 332           NameValuePair sPair;
 333           sPair.strName    = strName;
 334           sPair.strValue   = strValue;
 335
 336           vResult.push_back(sPair);
 337
 338           i = iPos + strFind.length();
 339
 340         }
 341         else
 342           break;
 343
 344         bInStartTag     = false;
 345         strName         = "";
 346         strValue        = "";
 347       }
 348       else
 349         strName += strXML[i];
 350     }
 351
 352     i++;
 353   }
 354
 355   return vResult;
 356 }
 357
 358
 359