string_util.h

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2008 by Kutumov Alexey                                  *
 *   ru.pixel@gmail.com                                                    *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program 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 General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/

#ifndef __string_util__header__
#define __string_util__header__

#include "gpucalc/data.h"


namespace gpucalc
{



 typedef std::vector<std::string> StringList;
    typedef std::map<std::string, std::string> StringMap;



 namespace auxillary
 {
  class _GpuCalcExport StringUtil
  {


   OBJ_DISABLE_COPY(StringUtil)

    StringUtil();
    ~StringUtil();
   
   
   
   
   public:


    template <typename T> static std::string toString(const T & Value)
    {
     std::ostringstream s;
     s << Value;
     return s.str();
    }


    static std::string toString(const bool & Value)
    {
     if (Value)
     {
      return std::string("true");
     }
     else
     {
      return std::string("false");
     }
    }


    template <typename T> static void fromString(const std::string & str, T & Value)
    {
     std::istringstream s(str);
     //s.get(str.c_str(), str.length());
     s >> Value;
    }


    static std::string toString(const ValueType & Value)
    {
     switch (Value)
     {
      case FloatType:
       return "Single precision floating point type";
       break;

      case DoubleType:
       return "Double precision floating point type";
       break;

      case IntType:
       return "Signed integer type";
       break;

      case UnsignedIntType:
       return "Unsigned integer type";
       break;

      case CharType:
       return "Signed character type";
       break;

      case UnsignedCharType:
       return "Unsigned character type";
       break;

      default:
       return "Not correct type";
       break;
     }
    }


    static std::string toString(const Object & Value)
    {
     return "Object with class name: \"" + Value.getClassName() + "\". And with object name: \"" + Value.getObjectName() + "\"";
    }


    static std::string toLower(const std::string & Value)
    {
     std::string result(Value);
     std::transform(Value.begin(), Value.end(), result.begin(), tolower);
     return result;
    }


    static std::string toUpper(const std::string & Value)
    {
     std::string result(Value);
     std::transform(Value.begin(), Value.end(), result.begin(), toupper);
     return result;
    }


    static std::string getLine(const std::string & Source, size_t Line)
    {
     std::string::size_type i_old = 0;
     std::string::size_type i_new = Source.find("\n");
     unsigned int Counter = 0;
     while (i_new != std::string::npos)
     {
      if (Line == Counter)
      {
       return std::string(Source, i_old, i_new - i_old);
      }
      i_old = i_new + 1;
      i_new = Source.find("\n", i_old);
      ++Counter;
     }
     Except<ERR_ITEM_NOT_FOUND>(Object("StringUtil", "StringUtil"), "Line number is not correct",
      "StringUtil::getLineFromSource", __FILE__, __LINE__);
    }


    static StringList split(const std::string & String, const std::string & Delimiter = "\n")
    {
     StringList result;
     std::string::size_type i_old = 0;
     std::string::size_type i_new = String.find(Delimiter);
     while (i_new != std::string::npos)
     {
      std::string temp(String, i_old, i_new - i_old);
      result.push_back(temp);
      i_old = i_new + Delimiter.length();
      i_new = String.find(Delimiter, i_old);
     }
     std::string temp(String, i_old, i_new - i_old);
     result.push_back(temp);

     return result;
    }


    static std::string concatenate(const StringList & sList, const std::string & Delimiter = "\n")
    {
     std::ostringstream s;
     std::copy(sList.begin(), sList.end(), std::ostream_iterator<std::string>(s, Delimiter.c_str()));
     return s.str();
    }


                static std::string getFixedString(const std::string & String, unsigned int FixedStrLength, const std::string & Prefix = "", const std::string & Suffix = "")
                {
                    std::string result;
                    unsigned int length = String.length();
                    if (length < (FixedStrLength - 1))
                    {
                        result = String + std::string(FixedStrLength - length, ' ');
                    }
                    else
                    {
                        result = std::string(String, 0, FixedStrLength - 4) + "... ";
                    }
                    return Prefix + result + Suffix;
                }
  };
 }
}

#endif