strutils.h

/*
 * strutils.h
 * This file is part of dbPager Classes Library (DCL)
 *
 * Copyright (c) 2008 Dennis Prochko <wolfsoft@mail.ru>
 *
 * DCL 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 version 3.
 *
 * DCL 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 DCL; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor,
 * Boston, MA  02110-1301  USA
 */

#ifndef STRUTILS_H_
#define STRUTILS_H_

#include <string>
#include <vector>
#include <sstream>
#include <locale>
#include <cwchar>

#include <dcl/exception.h>
#include <dcl/i18n.h>

namespace dbp {

typedef std::vector<std::string> strings;

const std::string nullstr;


class trim: public std::binary_function<std::string, char*, std::string> {
public:

        std::string operator()(const std::string &source,
          const char *delims = " \t\r\n") const;
};


class char_compare: public std::binary_function<char, char, bool> {
public:
        char_compare(const std::ctype<char> &c): _ct(c) {};

        bool operator()(char x, char y) const {
                return _ct.toupper(x) == _ct.toupper(y);
        };
private:
        const std::ctype<char> &_ct;
};


class compare: public std::binary_function<std::string, std::string, bool> {
public:

        compare(const std::locale &L = std::locale::classic()): loc(L),
          ct(std::use_facet<std::ctype<char> >(loc)) { };

        bool operator()(const std::string &x, const std::string &y) const;
private:
        std::locale loc;
        const std::ctype<char> &ct;
};


class tokenize {
public:

        strings operator()(const std::string &source,
          const char *delims = ",;");

        void operator()(const std::string &source, std::string &left,
          std::string &right, const char *delims = "/\\");
};


class format {
private:
        std::string str_;
        strings params_;
public:

        format(const std::string &source): str_(source) {};

        std::string str() const;

        template<class T>
        format& operator%(const T& x) {
                std::stringstream s;
                s << x;
                params_.push_back(s.str());
                return *this;
        }

        friend std::ostream& operator<<(std::ostream&, format&);
};

/*
Regular expression string iterator
class regexp {
public:
        class iterator: public std::iterator<std::input_iterator_tag,
          int> {
        public:
                int pos;
                std::string found;
                explicit iterator(regexp &expression): expr(expression) { };
        private:
                regexp &expr;
        };
        iterator operator()(const std::string &source,
          const std::string &expression) {
                _source = source;
                _expression = expression;
                return iterator(*this);
        };
private:
        strings _regexp;
        std::string _source, _expression;
};
*/


class string2wstring: public std::binary_function<std::string, std::locale const &,
  std::wstring> {
public:

        std::wstring operator()(const std::string &source,
          std::locale const &loc = std::locale()) const;
};


class wstring2string: public std::binary_function<std::wstring, std::locale const &,
  std::string> {
public:

        std::string operator()(const std::wstring &text,
          std::locale const &loc = std::locale()) const;
};


class char_length: public std::binary_function<std::string, std::locale&,
  std::size_t> {
public:

        std::size_t operator()(std::string const &text,
          std::locale const &loc = std::locale("")) const;
};


class type_conversion_exception: public dbp::exception { };


template <class TYPE>
std::string to_string(const TYPE value) throw(type_conversion_exception) {
        std::ostringstream s;
        s.imbue(std::locale::classic());
        try {
                s << value;
        }
        catch (...) {
                throw type_conversion_exception();
        }
        return s.str();
}

template <>
std::string to_string<const char*>(const char *value) throw(type_conversion_exception);

template <>
std::string to_string<const std::string&>(const std::string &value) throw(type_conversion_exception);


template <class TYPE>
TYPE from_string(const std::string &value) throw(type_conversion_exception) {
        std::istringstream s(value);
        s.imbue(std::locale::classic());
        TYPE rslt;
        try {
                if (!(s >> rslt))
                        throw type_conversion_exception();
        }
        catch (...) {
                throw type_conversion_exception();
        }
        return rslt;
}

template <>
const char* from_string<const char*>(const std::string &value)
  throw(type_conversion_exception);

template <>
std::string from_string<std::string>(const std::string &value)
  throw(type_conversion_exception);

} // namespace

#endif /*STRUTILS_H_*/