---

base.StringTools.h

/*----------------------------------------------------------------------------
  SWORD 2000 - Software With Objects for Rapid Development
  Copyright (C) 2003 Eric NICOLAS
  ----------------------------------------------------------------------------
  SWORD is free software; you can redistribute it and/or modify
  it under the terms of the GNU Lesser General Public License as published by
  the Free Software Foundation; either version 2 of the License, or
  (at your option) any later version.

  SWORD is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public License
  along with SWORD; if not, write to the Free Software
  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  --------------------------------------------------------------------------*/
#ifndef _SWORD_BASE_SRINGTOOLS_
#define _SWORD_BASE_SRINGTOOLS_

#include <vector>

namespace sword {

        // Implemented templates are (with standard 'string' basic_string instance)
        //    string &trimLeft (string &str);
        //    string &trimRight(string &str);
        //    string &trim     (string &str);
        //    void strlwr(string &s);
        //    void strupr(string &s);
        //    string strlwr(const string &s);
        //    string strupr(const string &s);
        //    void replace (string &s, char          src, char          dst);
        //    void replace (string &s, const char *  src, const char *  dst);
        //    void replace (string &s, const string &src, const string &dst);
        //    void replacem(string &s, const char *  src, const char *  dst);
        //    void replacem(string &s, const string &src, const string &dst);
        //    void split(const string &str, vector<string> &segments, char separator);
  //    std::string join(vector<string> &segments, char separator);
        //    vector<string> split(const string &str, char separator);
        //    void extractNameValue(const string &line, string &name, string &value);
        //    std::string readLine(const std::string& blob, size_t& offset);

        // Other functions
        //    int stricmp (const char *s1, const char *s2);
        //    int strnicmp(const char *s1, const char *s2, size_t length);
        //    int stricmp (const std::string &s1, const std::string &s2);
        //    int strnicmp(const std::string &s1, const std::string &s2, size_t length);

        SWORDDECL std::string format(float value);

        SWORDDECL std::string format(double value);


        SWORDDECL std::string format(double value, word precision, char decimalChar = '.', char thousandChar = '\0', bool negativeInParenthesis = false);

        // internal functions
        // - work on the provided 'buffer', which has 'bufferLen' characters
        // - returns the address of the built string (which is usually *not* the begining of 'buffer')

        SWORDDECL char *format_(char *buffer, word bufferLen, word64 value, char thousandChar = '\0');
        SWORDDECL char *format_(char *buffer, word bufferLen, int64  value, char thousandChar = '\0', bool negativeInParenthesis = false);
        SWORDDECL char *format_(char *buffer, word bufferLen, double value, word precision, char decimalChar = '.', char thousandChar = '\0', bool negativeInParenthesis = false);

        SWORDDECL std::string format(void *value);

        SWORDDECL std::string format(char value);

        SWORDDECL std::string format(const char *format, ...);

        SWORDDECL int8 parseInt8(const std::string &str);

        SWORDDECL int16 parseInt16(const std::string &str);

        SWORDDECL int32 parseInt32(const std::string &str);

        SWORDDECL int parseInt(const std::string &str);

        SWORDDECL word8 parseWord8(const std::string &str);

        SWORDDECL word16 parseWord16(const std::string &str);

        SWORDDECL word32 parseWord32(const std::string &str);

        SWORDDECL word parseWord(const std::string &str);

        SWORDDECL float parseFloat(const std::string &str);

        SWORDDECL double parseDouble(const std::string &str);

        // Remove spaces (trim)

        template<class charT, class traits, class Allocator>
        inline std::basic_string<charT, traits, Allocator> trimLeft(const std::basic_string<charT, traits, Allocator> &str)
        {
                std::string result = str;
                result.erase(0, result.find_first_not_of(" \t\n\r"));
                return result;
        }

        template<class charT, class traits, class Allocator>
        inline std::basic_string<charT, traits, Allocator> trimRight(const std::basic_string<charT, traits, Allocator> &str)
        {
                std::string result = str;
                result.erase(result.find_last_not_of(" \t\n\r") + 1);
                return result;
        }

        template<class charT, class traits, class Allocator>
        inline std::basic_string<charT, traits, Allocator> trim(const std::basic_string<charT, traits, Allocator> &str)
        {
                return trimLeft( trimRight( str ) );
        }

        // lower/upper case transform (in place)

        template<class charT, class traits, class Allocator>
        void strlwr(std::basic_string<charT, traits, Allocator> &str)
        {
                // scan the string
                for(typename std::basic_string<charT, traits, Allocator>::iterator i=str.begin();
                        i!=str.end(); ++i)
                {
                        // convert current char to lower case
                        *i=(char)tolower(*i);
                }
        }

        template<class charT, class traits, class Allocator>
        void strupr(std::basic_string<charT, traits, Allocator> &str)
        {
                // scan the string
                for(typename std::basic_string<charT, traits, Allocator>::iterator i=str.begin();
                        i!=str.end(); ++i)
                {
                        // convert current char to upper case
                        *i=toupper(*i);
                }
        }

        // lower/upper case transform (copies)

        template<class charT, class traits, class Allocator>
        std::basic_string<charT, traits, Allocator> strlwr(const std::basic_string<charT, traits, Allocator> &str)
        {
                std::basic_string<charT, traits, Allocator> target(str);
                strlwr(target);
                return target;
        }

        template<class charT, class traits, class Allocator>
        std::basic_string<charT, traits, Allocator> strupr(const std::basic_string<charT, traits, Allocator> &str)
        {
                std::basic_string<charT, traits, Allocator> target(str);
                strupr(target);
                return target;
        }

        // String part replacement

        template<class charT, class traits, class Allocator>
        void replace(std::basic_string<charT, traits, Allocator> &str,
                const char *before, const char *after)
        {
                // scan the string
    size_t pos=str.find(before);
                if (pos!=std::string::npos)
                        str=str.substr(0,pos)+after+str.substr(pos+traits::length(before));
        }

        template<class charT, class traits, class Allocator>
        void replace(std::basic_string<charT, traits, Allocator> &str,
                const std::basic_string<charT, traits, Allocator> &before,
                const std::basic_string<charT, traits, Allocator> &after)
        {
                // scan the string
    size_t pos=str.find(before);
                if (pos!=std::string::npos)
                        str=str.substr(0,pos)+after+str.substr(pos+before.size());
        }

        template<class charT, class traits, class Allocator>
        void replacem(std::basic_string<charT, traits, Allocator> &str, char before, char after)
        {
                // scan the string
                for(typename std::basic_string<charT, traits, Allocator>::iterator i=str.begin();
                        i!=str.end(); ++i)
                        // if current character equals the 'before' parameter
                        if (traits::eq(*i,before))
                                // then change it to 'after'
                                traits::assign(*i,after);
        }

        template<class charT, class traits, class Allocator>
        void replacem(std::basic_string<charT, traits, Allocator> &str,
                const char *before, const char *after)
        {
                // scan the string
    size_t pos=str.find(before);
                while(pos!=std::string::npos)
                {
                        str = str.substr(0,pos)+after+str.substr(pos+traits::length(before));
                        pos = str.find(before, pos+traits::length(after));
                }
        }

        template<class charT, class traits, class Allocator>
        void replacem(std::basic_string<charT, traits, Allocator> &str,
                                        const std::basic_string<charT, traits, Allocator> &before,
                                        const std::basic_string<charT, traits, Allocator> &after)
        {
                // scan the string
    size_t pos=str.find(before);
                while(pos!=std::string::npos)
                {
                        str = str.substr(0,pos)+after+str.substr(pos+before.size());
                        pos = str.find(before, pos+after.size());
                }
        }

        // Other manipulations

        template<class charT, class traits, class Allocator>
        void split(const std::basic_string<charT, traits, Allocator> &str,
                                std::vector<std::basic_string<charT, traits, Allocator> > &segments,
                                charT separator)
        {
                std::basic_string<charT, traits, Allocator> remain=str;
                std::basic_string<charT, traits, Allocator> segment;
                for(;;)
                {
                        size_t pos=remain.find(separator);
                        if (pos==std::string::npos) break;
                        //
                        segment=trim(remain.substr(0, pos));
                        remain =remain.substr(pos+1);
                        segments.push_back(segment);
                }
                if (remain.size()) segments.push_back(remain);
        }

        template<class charT, class traits, class Allocator>
        std::vector<std::basic_string<charT, traits, Allocator> >
        split(const std::basic_string<charT, traits, Allocator> &str,
                                charT separator)
        {
                std::basic_string<charT, traits, Allocator> remain=str;
                std::basic_string<charT, traits, Allocator> segment;
                std::vector<std::basic_string<charT, traits, Allocator> > segments;
                for(;;)
                {
                        size_t pos=remain.find(separator);
                        if (pos==std::string::npos) break;
                        //
                        segment=trim(remain.substr(0, pos));
                        remain =remain.substr(pos+1);
                        segments.push_back(segment);
                }
                if (remain.size()) segments.push_back(remain);

                return segments;
        }

  template<class charT, class traits, class Allocator>
  std::basic_string<charT, traits, Allocator> join(const std::vector<std::basic_string<charT, traits, Allocator> > &segments, charT separator)
  {
    std::basic_ostringstream<charT, traits, Allocator> oss;
    bool first = true;
    for(
      std::vector<std::basic_string<charT, traits, Allocator> >::const_iterator i=segments.begin();
      i!=segments.end();
      ++i)
    {
      if (first)
        first = false;
      else
        oss << separator;
      oss << *i;
    }
    return oss.str();
  }

        template<class charT, class traits, class Allocator>
        void extractNameValue(const std::basic_string<charT, traits, Allocator> &line,
                                                        std::basic_string<charT, traits, Allocator> &name,
                                                        std::basic_string<charT, traits, Allocator> &value,
              char separator = '=')
        {
                int i=line.find(separator);
                name =trim(line.substr(0,i));
                value=trim(line.substr(i+1));
        }

        SWORDDECL int stricmp (const std::string &s1, const std::string &s2);
        SWORDDECL int strnicmp(const std::string &s1, const std::string &s2, size_t length);

        // internal function used in streams.File and network.Url
        SWORDDECL void canonize__(const char *src, char *dst);

        SWORDDECL std::string readLine(const std::string& blob, size_t& offset);

} // namespace sword

#ifndef HAVE_STRICMP
SWORDDECL int stricmp (const char *s1, const char *s2);
#endif

#ifndef HAVE_STRNICMP
SWORDDECL int strnicmp(const char *s1, const char *s2, size_t length);
#endif

#include "sword.private/base.StringTools.inl"

#endif // _SWORD_BASE_SRINGTOOLS_

---