QStringHandler.cc

Go to the documentation of this file.

#include "QStringHandler.hh"
 
#include "QString.hh"
#include "QBool.hh"
 
#include "TRandom.h"
#include "TTimeStamp.h"
 
#include <iomanip>
#include <sstream>
#include <stdlib.h>
 
#include <algorithm>
#include <vector>
#include <list>
#include <ctime>
 
//_____________________________________________________________________________
std::string QStringHandler::RemoveFromString(const std::string &text,const char *chars) {
  std::string ret(text);
  for(size_t i=0;i<strlen(chars);i++) 
    ret.erase(std::remove(ret.begin(),ret.end(),chars[i]),ret.end());
  return ret;
}
 
//_____________________________________________________________________________
std::string QStringHandler::ToLower(const std::string &text) {
  std::string ret(text);
  std::transform(ret.begin(),ret.end(),ret.begin(),(int (*)(int))std::tolower);
  return ret;
}
 
//_____________________________________________________________________________
std::string QStringHandler::ToUpper(const std::string &text) {
  std::string ret(text);
  std::transform(ret.begin(),ret.end(),ret.begin(),(int (*)(int))std::toupper);
  return ret;
}
 
//_____________________________________________________________________________
void QStringHandler::Escape(std::string& text, char toBeEscaped)
{
   size_t position = 0;
   while(1)
   {
      if((position = text.find(toBeEscaped, position)) == std::string::npos)
         break;
      text.insert(position, 1, '\\');
      position += 2;
   }
}
 
 
//_____________________________________________________________________________
void QStringHandler::UnEscape(std::string& text, char escaped)
{
   size_t position = 0;
   while(1)
   {
      if((position = text.find(escaped, position)) == std::string::npos) 
         break;
 
      if( (position > 0) && (text.at(position-1) == '\\') )
         text.erase(position-1, 1);
 
      position++;
   }
}
 
 
//_____________________________________________________________________________
void QStringHandler::Replace(std::string& text, char oldChar, char newChar)
{
   size_t position = 0;
   while(1)
   {
      if( (position = text.find(oldChar, position)) == std::string::npos) 
         break;
 
      // do not replace oldChar if escaped
      if( (position == 0) || (text.at(position-1) != '\\') )
         text.replace(position, 1, 1, newChar);
 
      position++;
   }
}
 
//_____________________________________________________________________________
size_t QStringHandler::Split(std::string source,
                             std::list<std::string>& splitted,
                             char separator)
{
   splitted.clear();
   QStringHandler::DoubleSwallowSpaces(source);
   
   while(1)
   {
      size_t pos = 0;
      while(1)
      { // loop to avoid splitting at escaped separators
         pos = source.find(separator, pos);
         if(std::string::npos == pos)
            break;
         if(pos != 0 && source.at(pos-1) == '\\')
            pos++;
         else
            break;
      }
 
      std::string element = source.substr(0, pos);
 
      QStringHandler::DoubleSwallowSpaces(element);
 
      if( !(element.empty()) )
         splitted.push_back(element);
 
      if(pos == std::string::npos)
         break;
 
      source = source.substr(pos+1);
   }
 
   return splitted.size();
}
 
 
//____________________________________________________________________________
bool QStringHandler::StringToInt(std::string in, int &out, bool strictCheck)
{
   DoubleSwallowSpaces(in);
 
   char *check;
   int base = (("0x" == in.substr(0, 2))? 16 : 10); // hex or decimal format
   const char* cStr = in.c_str();
 
   out = ::strtol(cStr, &check, base);
   
   if(cStr == check) // nothing converted
      return false;
 
   return ( ('\0' == (*check)) || (!strictCheck) );
}
 
 
//____________________________________________________________________________
bool QStringHandler::StringToLong(std::string in, Long64_t &out,
                                  bool strictCheck)
{
   DoubleSwallowSpaces(in);
 
   char *check;
   int base = (("0x" == in.substr(0, 2))? 16 : 10); // hex or decimal format
   const char* cStr = in.c_str();
 
   out = ::strtoll(cStr, &check, base);
   
   if(cStr == check) // nothing converted
      return false;
 
   return ( ('\0' == (*check)) || (!strictCheck) );
}
 
 
//____________________________________________________________________________
bool QStringHandler::StringToBool(std::string in, bool &out)
{
   DoubleSwallowSpaces(in);
 
   if( "true"    == in
       || "t"    == in
       || "TRUE" == in
       || "T"    == in
       || "1"    == in)
   {
      out = true;
      return true;
   }
 
   if("false"    == in
      || "f"     == in
      || "FALSE" == in
      || "F"     == in
      || "0"     == in)
   {
      out = false;
      return true;
   }
 
   return false;                
}
 
//_____________________________________________________________________________
bool QStringHandler::StringToDouble(std::string in,
                                    double      &out,
                                    bool        strictCheck)
{
   DoubleSwallowSpaces(in);
 
   char *check;
   const char* cStr = in.c_str();
   out = ::strtod(cStr, &check);
   
   if(cStr == check) // nothing converted
      return false;
 
   return ( ('\0' == (*check)) || (!strictCheck) );
}
 
 
//_____________________________________________________________________________
bool QStringHandler::StringToChar(const std::string& src, char& dest)
{
   int iVal;
   
   if (!QStringHandler::StringToInt(src,iVal))
      return false;
 
   if(iVal < 0 || iVal > 255)
      return false;
 
   dest = (char)iVal;   
   return true;
}
 
 
//_____________________________________________________________________________
std::string QStringHandler::IntToString(int val, int width, char pad)
{
   std::ostringstream text;
   if(width > 0)
      text << std::setw(width) << std::setfill(pad);
   text << val;
   return text.str();
}
 
std::string QStringHandler::LongToString(Long64_t val, int width, char pad)
{
   std::ostringstream text;
   if(width > 0)
      text << std::setw(width) << std::setfill(pad);
   text << val;
   return text.str();
}
 
std::string QStringHandler::BoolToString(bool val)
{
   return val ? "true" : "false";
}
 
//_____________________________________________________________________________
std::string QStringHandler::DoubleToString(double val, int nDigits, bool scientific)
{
   if(nDigits < 1)
      nDigits = 1;
   std::ostringstream text;
   // set default output format (it is not std::fixed neither std::scientific)
   text.unsetf(std::ios_base::floatfield);
 
   if(scientific)
      text << std::scientific << std::setprecision(nDigits - 1) << val;
   else 
      text << std::setprecision(nDigits) << val;
   return text.str();
}
 
 
//_____________________________________________________________________________
std::string QStringHandler::IntToHexString(int value)
{
   std::ostringstream hexa;
   hexa << "0x" << std::hex << std::setw(4) << std::setfill('0') << value;
   return hexa.str();
}
 
std::string QStringHandler::Resize(const std::string& str, size_t len)
{
        std::string s;
        if (str.size() < len ) {
        s = str;
                int i = len - s.size();
                while(i--) s += " ";
        } else {
        s = str.substr(0,len);
    }
    return s;
}
 
//_____________________________________________________________________________
std::string QStringHandler::TimeFormat(const char *fmt) {
  return TimeFormat(fmt,::time(0));
}
 
//_____________________________________________________________________________
std::string QStringHandler::TimeFormat(const char *fmt,time_t t0) {
  char buffer[512];
  ::strftime(buffer,512,fmt,::localtime(&t0));
  return std::string(buffer);
}
 
 
 
//_____________________________________________________________________________
std::string QStringHandler::SqlString(const Diana::QBool& boolVal,
                                      bool modeSelect)
{
   std::string retString = "";
   
   if(modeSelect)
      retString += "IS ";
   if(boolVal.IsValid())
      retString += ((boolVal == true)?"true":"false");
   else
      retString += "NULL";
   return retString;
}
 
//_____________________________________________________________________________
std::string QStringHandler::SqlString(const std::vector<int>& vecVal, 
                                      bool modeSelect, bool writeEmptyBra)
{
   std::stringstream retString;
   
   //if mode is selection
   if(modeSelect){
      if( !writeEmptyBra && vecVal.size() == 0 )
         retString << "IS ";
      else
         retString << "=";
   }
   //if QStdVector is empty (and want to write NULL)
   if( !writeEmptyBra && vecVal.size() == 0 ) 
      retString << "NULL";
   //if QStdVector is not empty
   else{
      retString << "'{";
      for(uint i = 0; i < vecVal.size(); i++)
         retString << (i!=0 ? "," : "") << vecVal[i];
      retString << "}'";
   }
   return retString.str();
}
 
//_____________________________________________________________________________
std::string QStringHandler::SqlString(const Diana::QString& strVal,
                                      const std::string& selectName)
{
   std::stringstream retString;
   
   if(selectName.empty()) // insert query, just set NULL or strVal value
   {
      if(strVal.IsValid())
         return "'" + strVal.GetValue() + "'";
      else
         return "NULL";
   }
   else // select query, also check empty string for strValue
   {
      if(strVal.IsValid())
         retString << selectName << "='" << (std::string)strVal << "'";
      else
         retString << "(" << selectName << " IS NULL OR "
                   << selectName << "='')";
   }
   return retString.str();
}
 
//_____________________________________________________________________________
std::string QStringHandler::RandomString(UInt_t length,Bool_t caseSensitive,Bool_t startLetter) {
  static TRandom *mRandom = NULL;
  if(mRandom == NULL) {
    TTimeStamp A;
    mRandom = new TRandom(A.GetNanoSec());
  }
  const int dict_length = (caseSensitive ? 62 : 36);
  const char *dictionary = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
  std::string ret;
  if(startLetter){
    ret+=dictionary[(UInt_t)mRandom->Uniform(10,dict_length)];
    length-=1;
  }
  while(length){
    ret+=dictionary[(UInt_t)mRandom->Uniform(0,dict_length)];
    length-=1;
  }
  return ret;
}
 
template std::string QStringHandler::Join(const std::string &,std::vector<std::string>::iterator,std::vector<std::string>::iterator);
template std::string QStringHandler::Join(const std::string &,std::vector<std::string>::const_iterator,std::vector<std::string>::const_iterator);
template std::string QStringHandler::Join(const std::string &,std::list<std::string>::iterator,std::list<std::string>::iterator);
template std::string QStringHandler::Join(const std::string &,std::list<std::string>::const_iterator,std::list<std::string>::const_iterator);
 
template std::string QStringHandler::Join(const std::string &,std::vector<int>::iterator,std::vector<int>::iterator);
template std::string QStringHandler::Join(const std::string &,std::vector<int>::const_iterator,std::vector<int>::const_iterator);
template std::string QStringHandler::Join(const std::string &,std::list<int>::iterator,std::list<int>::iterator);
template std::string QStringHandler::Join(const std::string &,std::list<int>::const_iterator,std::list<int>::const_iterator);
 
template std::string QStringHandler::Join(const std::string &,std::vector<unsigned int>::iterator,std::vector<unsigned int>::iterator);
template std::string QStringHandler::Join(const std::string &,std::vector<unsigned int>::const_iterator,std::vector<unsigned int>::const_iterator);
template std::string QStringHandler::Join(const std::string &,std::list<unsigned int>::iterator,std::list<unsigned int>::iterator);
template std::string QStringHandler::Join(const std::string &,std::list<unsigned int>::const_iterator,std::list<unsigned int>::const_iterator);
 
template std::string QStringHandler::Join(const std::string &,std::vector<long>::iterator,std::vector<long>::iterator);
template std::string QStringHandler::Join(const std::string &,std::vector<long>::const_iterator,std::vector<long>::const_iterator);
template std::string QStringHandler::Join(const std::string &,std::list<long>::iterator,std::list<long>::iterator);
template std::string QStringHandler::Join(const std::string &,std::list<long>::const_iterator,std::list<long>::const_iterator);
 
template std::string QStringHandler::Join(const std::string &,std::vector<unsigned long>::iterator,std::vector<unsigned long>::iterator);
template std::string QStringHandler::Join(const std::string &,std::vector<unsigned long>::const_iterator,std::vector<unsigned long>::const_iterator);
template std::string QStringHandler::Join(const std::string &,std::list<unsigned long>::iterator,std::list<unsigned long>::iterator);
template std::string QStringHandler::Join(const std::string &,std::list<unsigned long>::const_iterator,std::list<unsigned long>::const_iterator);
 
template std::string QStringHandler::Join(const std::string &,std::vector<float>::iterator,std::vector<float>::iterator);
template std::string QStringHandler::Join(const std::string &,std::vector<float>::const_iterator,std::vector<float>::const_iterator);
template std::string QStringHandler::Join(const std::string &,std::list<float>::iterator,std::list<float>::iterator);
template std::string QStringHandler::Join(const std::string &,std::list<float>::const_iterator,std::list<float>::const_iterator);
 
template std::string QStringHandler::Join(const std::string &,std::vector<double>::iterator,std::vector<double>::iterator);
template std::string QStringHandler::Join(const std::string &,std::vector<double>::const_iterator,std::vector<double>::const_iterator);
template std::string QStringHandler::Join(const std::string &,std::list<double>::iterator,std::list<double>::iterator);
template std::string QStringHandler::Join(const std::string &,std::list<double>::const_iterator,std::list<double>::const_iterator);