---

basic_substring.h

Go to the documentation of this file.

// Protect from double-inclusion...
#ifndef basic_substring_h_sdlksldkslkdwelkjsodiuslkeslkduoileiousd
#define basic_substring_h_sdlksldkslkdwelkjsodiuslkeslkduoileiousd

#include <string>
using namespace std;

namespace tvr_std {

template<class Ch>
class basic_substring {
public:
        typedef typename basic_string<Ch>::size_type size_type;

        basic_substring(basic_string<Ch>& s,
                                        size_type start,
                                        size_type len,
                                        bool doReverse=false) : ps(&s), n(len), pos(start) {
                if ((pos + n) > s.length()) {
                        n = s.length();
                }
                this->doReverse = doReverse;
        };

        basic_substring(basic_string<Ch>& s,
                                        const basic_string<Ch>& s2,
                                        bool doReverse=false) : ps(&s), n(s2.length()) {
                if (doReverse)
                        pos = s.rfind(s2);
                else
                        pos = s.find(s2);
                this->doReverse = doReverse;
        };

        basic_substring(basic_string<Ch>& s,
                                        const Ch* p,
                                        bool doReverse=false) : ps(&s) {
                basic_string<Ch> temp(p);
                n = temp.length();
                if (doReverse)
                        pos = s.rfind(temp);
                else
                        pos = s.find(temp);
                this->doReverse = doReverse;
        };


        basic_substring& operator=(const basic_string<Ch>& in) {
                if ((*this) == true) {
                        basic_string<Ch> s = (*this);
                        ps->replace(pos, n, in);
                        if (doReverse)
                                pos = ps->rfind(s, pos-1);
                        else
                                pos = ps->find(s, pos+1);
                }
                return *this;
        };

        basic_substring& operator=(const basic_substring<Ch>& in) {
                ps = in.ps;
                pos = in.pos;
                n = in.n;
                doReverse = in.doReverse;
                return *this;
        };

        basic_substring& operator=(const Ch* in) {
                basic_string<Ch> s(in);
                return (*this) = s;
        };

        basic_substring& operator=(Ch in) {
                basic_string<Ch> s;
                s = in;
                return (*this) = s;
        };


        basic_substring& prepend(const basic_string<Ch>& in) {
                ps->insert(pos, in);
                pos += in.length();
                return *this;
        };

        basic_substring& prepend(const Ch* in) {
                basic_string<Ch> arg(in);
                return prepend(arg);
        };

        basic_substring& append(const basic_string<Ch>& in) {
                size_type tmp = pos + n;
                ps->insert(tmp, in);
                return *this;
        };

        basic_substring& append(const Ch* in) {
                basic_string<Ch> arg(in);
                return append(arg);
        };


        operator const basic_string<Ch> () const {
                return basic_string<Ch> (*ps, pos, n);
        };
        operator const bool () const {
                return pos != basic_string<Ch>::npos;
        };


        basic_substring& operator ++() {
                basic_string<Ch> substring;
                substring = (basic_string<Ch>)*this;
                pos = ps->find(substring, pos+1);
                return *this;
        };

        basic_substring& operator ++(int) {
                return ++(*this);
        };
        
        basic_substring& operator --() {
                basic_string<Ch> substring;
                substring = (basic_string<Ch>)*this;
                if (pos != 0) {
                        pos = ps->rfind(substring, pos-1);
                } else {
                        pos = size_type::npos;
                }
                return *this;
        };

        basic_substring& operator --(int) {
                return --(*this);
        };
private:
        basic_string<Ch>* ps;
        size_type pos;
        size_type n;
        bool doReverse;
};

typedef basic_substring<char> substring;
typedef basic_substring<wchar_t> wsubstring;

}; // namespace tvr_std

#endif // basic_substring_h_sdlksldkslkdwelkjsodiuslkeslkduoileiousd

---