util/StringTrim.h

Go to the documentation of this file.

/*-----------------------------------------------------------------------------
Name:      StringTrim.h
Project:   xmlBlaster.org
Copyright: xmlBlaster.org, see xmlBlaster-LICENSE file
Comment:   Helper to emulate the java String.trim() method
Author:    <Michele Laghi> laghi@swissinfo.org
-----------------------------------------------------------------------------*/

#ifndef _UTIL_STRINGTRIM_H
#define _UTIL_STRINGTRIM_H

#include <util/XmlBCfg.h>
#include <ctype.h>  // ::tolower
#include <string>
#include <util/lexical_cast.h>

#define  EMPTY_STRING std::string("")



namespace org { namespace xmlBlaster {
namespace util {
   
   class Dll_Export StringTrim
   {
   public:
      
      StringTrim()
      {
      }

      static std::string& toLowerCase(std::string& ref)
      {
         std::string::iterator iter = ref.begin();
         while (iter != ref.end()) {
            *iter = ::tolower(*iter);
            iter++;
         }
         return ref;
      }

      static std::string replaceAll(const std::string &str, const std::string &from, const std::string &to) {
         if (str.empty() || from.empty() || to.empty())
            return str;
         if (str.find(from) == std::string::npos)
            return str;

         std::string buf;
         std::string tail = str;
         while (true) {
            std::string::size_type index = tail.find(from);
            if (index != std::string::npos) {
               if (index > 0)
                  buf += tail.substr(0, index);
               buf += to;
               tail = tail.substr(index + from.size());
            }
            else
               break;
         }
         buf += tail;
         return buf;
      }

      static bool isTrue(const std::string& str) {
         std::string tmp = trim(str.c_str());
         return lexical_cast<bool>(tmp);
      }

      static bool isTrue(const std::string& str, bool def) {
         std::string value = trim(str);
         if (value.length() == 0) return def;
         if (isTrue(value) == true) return true;
         if ((value=="0")||(value=="false")||(value=="FALSE")) return false;
         return def;
      }

      static bool isTrueTrim(std::string& str) {
         trim(str);
         if (str.length() == 0) return true;
         return lexical_cast<bool>(str);
      }

       /*
      static int std::stringLength(const char *str)
      {
         int count = 0;
         while (str[count] != (char)0) count++;
         return count;
      }
        */

      static std::string trimStart(const char *str)
      {
         if (str == static_cast<const char *>(0)) return EMPTY_STRING;

         int start = 0;
         while (str[start] != 0)
            if (isspace(str[start++]))
               continue;
            else
               return std::string(str + (start-1));

         return EMPTY_STRING;
      }
      

      static std::string& trimStart(std::string &str)
      {
         if (str.capacity() < 1) return str;

         if (str.length() < 1)
            return str;
         if (!isspace(str[0]))
            return str;

         for (std::string::size_type ii=1; ii<str.length(); ii++) {
            if (!isspace(str[ii])) {
               str = str.substr(ii);
               return str;
            }
         }

         return str;
      }

      static std::string trimEnd(const char *str)
      {
         if (str == static_cast<const char *>(0) || *str == 0) return EMPTY_STRING;
         std::string strip(str);
         trimEnd(strip);
         return strip;
      }      

      static std::string& trimEnd(std::string &str)
      {
         if (str.capacity() < 1) return str;

         int i;
         for (i=(int)str.length()-1; i >= 0; i--) {
             if (!isspace(str[i])) {
                 str = str.substr(0, i+1);
                 return str;
             }
         }
         if (i<0) str = EMPTY_STRING;
         return str;
      }
      

      static std::string trim(const char *str)
      {
         std::string buffer = trimStart(str);
         if (buffer.empty()) return EMPTY_STRING;
         return trimEnd(buffer.c_str());
      }

      static void trim(std::string &str)
      {
         if (str.capacity() < 1 || str.size() < 1) return;

         int jj=0;
         if (isspace(str[str.size()-1])) {
            for (jj=(int)str.size()-2; jj >= 0; jj--) {
                if (!isspace(str[jj])) {
                   str.resize(jj+1);
                   break;
                }
            }
         }
         if (jj<0) {
            str = EMPTY_STRING;
            return;
         }

         if (!isspace(str[0]))
            return;
         for (std::string::size_type ii=1; ii<str.size(); ii++) {
            if (!isspace(str[ii])) {
               str = str.substr(ii);
               return;
            }
         }
      }

      static std::string trim(const std::string &str) {
         std::string tmp = str;
         trim(tmp);
         return tmp;
      }

   };

}}} // namespace

#endif