root/rxstring/trunk/rxstring.h @ 689

/* $Id$ $URL$ */
#ifndef RXSTRING_DOT_AITCH
#define RXSTRING_DOT_AITCH
/**\file rxstring.h
 * Declaration of the RxString class.
 * \ingroup rxstring
 * \author Trent Apted <tapted@it.usyd.edu.au>
 * $Revision$
 * $Date$
 */

#include <vector>
#include <string>
#include <iostream>
#include <algorithm>
#include <sstream>
#include <cctype>

/* for flags */
#include <sys/types.h>

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#ifdef const
#undef const
#endif

extern "C" {
#ifdef HAVE_SYSREGEX_H
#include <regex.h>
#else
#include "myregex.h"
#endif
}

/**
 * A Regular Expression std::string. This class currently has no data members,
 * so it is just a convenient subclass for extending the functionality of a 
 * std::string to include sugar functions from algoritm and regular expression
 * matching within the string.
 */
class RxString {
public:
    typedef std::string S; ///< STL string class to mimic
    //@{
    /// Mimicry of std::string
    typedef S::traits_type traits_type;
    typedef S::allocator_type allocator_type;
    typedef S::iterator iterator;
    typedef S::const_iterator const_iterator;
    typedef S::size_type size_type;
    typedef S::difference_type difference_type;
    typedef S::const_reverse_iterator const_reverse_iterator;
    typedef S::reverse_iterator reverse_iterator;
    typedef allocator_type::pointer pointer;
    typedef allocator_type::const_pointer const_pointer;
    typedef allocator_type::reference reference;
    typedef allocator_type::const_reference const_reference;
    typedef allocator_type::value_type value_type;
    static const size_type npos = static_cast<size_type>(-1);
    //@}
private:
    S s; ///< The instance of std::string we wrap
public:
    enum {
        DEFAULT_RE_MAX_MATCH = 10 ///< Default maximum number of matches
    };

    //@{
    /// Mimicry of regex_t
    struct my_regex_t {
        regex_t rx;      ///< The regular expression
        unsigned nmatch; ///< The number of '(' characters in the expression
    };
    //@}
    class Regex : public my_regex_t {
    public:
        Regex(const RxString& regstr, RxString *err_string = 0, int cflags = REG_EXTENDED);
    };

    //always use std:: here
    typedef std::vector<RxString> match_vec_type; ///< Type for substring matches
    static const RxString NO_MATCH; ///< The RxString corresponding to NO_MATCH

    /** Create an empty RxString */
    RxString() : s() {}
    /** Create an RxString from the std::string \a s */
    RxString(const S &ss) : s(ss) {}
    /** Create an RxString from the c-style string \a s */
    RxString(const value_type *ss) : s(ss) {}

    /** Convert to a std::string */
    operator S() const {return s;}
    //std::string str() const {return s;}
    //operator std::string() {return s;}

    /** Remove spaces from \a this RxString and return \a *this */
    RxString &trim();

    //@{
    /**
     * Perform a regular expression matching of this RxString.
     *
     * \param regex The regular expression to match (conforming to Posix regex(7))
     * \param matches If non-null, append all substring matches to this using push_back()
     * \param err_string If non-null and an error occurs, set to the regex error description
     * \param cflags Regular expression compilation flags (see regcomp(3))
     * \param eflags Regular expression execution flags (see regexec(3))
     * \return the number of substring matches
     */
    size_t match(const RxString &regex,
                 match_vec_type *matches = 0,
                 RxString *err_string = 0,
                 int cflags = REG_EXTENDED,
                 int eflags = 0
                ) const;

    size_t match(const my_regex_t &regex,
                 match_vec_type *matches = 0,
                 RxString *err_string = 0,
                 int eflags = 0
                ) const;

    RxString matchn(const RxString &regex, unsigned n = 0, RxString *err_string = 0, int cflags = REG_EXTENDED, int eflags = 0) const;
    RxString matchn(const my_regex_t  &regex, unsigned n = 0, RxString *err_string = 0, int eflags = 0) const;
    //@}

    /** Compile a regular expression, that can be cached for matchn */
    static bool compile(my_regex_t &regex, const RxString &regstr, RxString *err_string = 0, int cflags = REG_EXTENDED);
    /** Release resources used by a precompiled regular expression */
    static void release(my_regex_t &regex);

    /**
     * Match, ignoring case of the string.
     *\copydoc RxString::match()
     */     
    size_t match_icase(const RxString &regex,
                     RxString::match_vec_type *matches = 0,
                     RxString *err_string = 0,
                     int cflags = REG_EXTENDED|REG_ICASE,
                     int eflags = 0
                    ) const {
        return match(regex, matches, err_string, cflags | REG_ICASE, eflags);
    }

    /**
     * Append to this string, characters read from \a in, until an \a eol
     * character is encountered. The \a eol character is not appended.
     *
     * \param in The std::istream to read from
     * \param eol The termination character to use
     * \return \a *this
     */
    RxString &append_line(std::istream& in = std::cin, const char eol = '\n');
    
    /** Convert \a this RxString to upper case and return \a *this */
    RxString &toUpper();
    /** Convert \a this RxString to lower case and return \a *this */
    RxString &toLower();
    /** Convert characters in this string occuring after white space to uppercase */
    RxString &toTitleCase();

    /** Return the number of occurences of \a val in \a this */
    size_type count_char(value_type val) const;
    //@{
    /** Return the position of the last occurence of \a val in \a this */
    iterator find_last(value_type val);
    std::string::const_iterator find_last(value_type val) const;
    //@}
    //@{
    /** Return the character after the last one for which \a p is true */
    template <class Pred>
        std::string::iterator find_last_not_if(Pred p);
    template <class Pred>
        std::string::const_iterator find_last_not_if(Pred p) const;
    //@}
    //@{
    /** Return the first character for which \a p is true */
    template <class Pred>
        std::string::iterator find_if(Pred p);
    template <class Pred>
        std::string::const_iterator find_if(Pred p) const;
    //@}

    /** Removes all characters from \a this for which \a p is true */
    template <class Pred>
        void remove_if(Pred p);
    /** Replace all characters for whic \a p is true with \a val */
    template <class Pred>
        void replace_if(Pred p, value_type val);
        
    /**
     * Assign to \a t the value of \a this when converted to the type T.
     *
     * \param t the variable to assign to, and format determiner
     * \return false if the conversion failed, otherwise true
     */
    template <class T>
        bool convertTo(T &t) const;

    /**
     * Assign to \a this the value of \a val converted to a string.
     *
     * \param val the value to assign, and format determiner
     * \return \a *this (the conversion should never fail
     */
    template <class T>
        RxString &convertFrom(const T &val);

    /*==STRING FUNCTIONS==*/
    //@{
    /// More mimicry of std::string
    explicit RxString(const allocator_type& al) : s(al) {}
    //RxString (const S& right);
    RxString(const RxString& right, size_type roff, size_type count = npos) : s(right.s, roff, count) {}
    RxString(const RxString& right, size_type roff, size_type count, const allocator_type& al) : s(right.s, roff, count, al) {}
    RxString(const value_type *ptr, size_type count) : s(ptr, count) {}
    RxString(const value_type *ptr, size_type count, const allocator_type& al) : s(ptr, count, al) {}
    //RxString(const value_type *ptr) : s(ptr) {}
    RxString(const value_type *ptr, const allocator_type& al) : s(ptr, al) {}
    RxString(size_type count, value_type ch) : s(count, ch) {}
    RxString(size_type count, value_type ch, const allocator_type& al) : s(count, ch, al) {}
    template <class InIt> RxString(InIt first, InIt last) : s(first, last) {}
    template <class InIt> RxString(InIt first, InIt last, const allocator_type& al) : s(first, last, al) {}
    RxString& operator=(const RxString& right) {s = right.s; return *this;}
    RxString& operator=(const value_type *ptr) {s = ptr; return *this;}
    RxString& operator=(value_type ch) {s = ch; return *this;}
    iterator begin() {return s.begin();}
    const_iterator begin() const {return s.begin();}
    iterator end() {return s.end();}
    const_iterator end() const {return s.end();}
    reverse_iterator rbegin() {return s.rbegin();}
    const_reverse_iterator rbegin() const {return s.rbegin();}
    reverse_iterator rend() {return s.rend();}
    const_reverse_iterator rend() const {return s.rend();}
    const_reference at(size_type off) const {return s.at(off);}
    reference at(size_type off) {return s.at(off);}
    const_reference operator[](size_type off) const {return s[off];}
    reference operator[](size_type off) {return s[off];}
    void push_back(value_type ch) {s.push_back(ch);}
    const value_type *c_str() const {return s.c_str();}
    const value_type *data() const {return s.data();}
    size_type length() const {return s.length();}
    size_type size() const {return s.size();}
    size_type max_size() const {return s.max_size();}
    void resize(size_type newsize, value_type ch = value_type()) {s.resize(newsize, ch);}
    size_type capacity() const {return s.capacity();}
    void reserve(size_type count = 0) {s.reserve(count);}
    bool empty() const {return s.empty();}
    RxString& operator+=(const RxString& right) {s += right.s; return *this;}
    RxString& operator+=(const value_type *ptr) {s += ptr; return *this;}
    RxString& operator+=(value_type ch) {s += ch; return *this;}
    RxString& append(const RxString& right) {s.append(right.s); return *this;}
    RxString& append(const RxString& right, size_type roff, size_type count) {s.append(right.s, roff, count); return *this;}
    RxString& append(const value_type *ptr, size_type count) {s.append(ptr, count); return *this;}
    RxString& append(const value_type *ptr) {s.append(ptr); return *this;}
    RxString& append(size_type count, value_type ch) {s.append(count, ch); return *this;}
    template<class InIt> RxString& append(InIt first, InIt last) {s.append(first, last); return *this;}
    RxString& assign(const RxString& right) {s.assign(right.s); return *this;}
    RxString& assign(const RxString& right, size_type roff, size_type count) {s.assign(right.s, roff, count); return *this;}
    RxString& assign(const value_type *ptr, size_type count) {s.assign(ptr, count); return *this;}
    RxString& assign(const value_type *ptr) {s.assign(ptr); return *this;}
    RxString& assign(size_type count, value_type ch) {s.assign(count, ch); return *this;}
    template<class InIt> RxString& assign(InIt first, InIt last) {s.assign(first, last); return *this;}
    RxString& insert(size_type off, const RxString& right) {s.insert(off, right.s); return *this;}
    RxString& insert(size_type off, const RxString& right, size_type roff, size_type count) {s.insert(off, right.s, roff, count); return *this;}
    RxString& insert(size_type off, const value_type *ptr, size_type count) {s.insert(off, ptr, count); return *this;}
    RxString& insert(size_type off, const value_type *ptr) {s.insert(off, ptr); return *this;}
    RxString& insert(size_type off, size_type count, value_type ch) {s.insert(off, count, ch); return *this;}
    iterator insert(iterator where, value_type ch = value_type()) {return s.insert(where, ch);}
    void insert(iterator where, size_type count, value_type ch) {s.insert(where, count, ch);}
    template<class InIt> void insert(iterator where, InIt first, InIt last) {s.insert(where, first, last);}
    RxString& erase(size_type off = 0, size_type count = npos) {s.erase(off, count); return *this;}
    iterator erase(iterator where) {return s.erase(where);}
    iterator erase(iterator first, iterator last) {return s.erase(first, last);}
    void clear() {s.clear();}
    RxString& replace(size_type off, size_type n0, const RxString& right) {s.replace(off, n0, right.s); return *this;}
    RxString& replace(size_type off, size_type n0, const RxString& right, size_type roff, size_type count) {
        s.replace(off, n0, right.s, roff, count); return *this;}
    RxString& replace(size_type off, size_type n0, const value_type *ptr, size_type count) {s.replace(off, n0, ptr, count); return *this;}
    RxString& replace(size_type off, size_type n0, const value_type *ptr) {s.replace(off, n0, ptr); return *this;}
    RxString& replace(size_type off, size_type n0, size_type count, value_type ch) {s.replace(off, n0, count, ch); return *this;}
    RxString& replace(iterator first, iterator last, const RxString& right) {s.replace(first, last, right.s); return *this;}
    RxString& replace(iterator first, iterator last, const value_type *ptr, size_type count) {s.replace(first, last, ptr, count); return *this;}
    RxString& replace(iterator first, iterator last, const value_type *ptr) {s.replace(first, last, ptr); return *this;}
    RxString& replace(iterator first, iterator last, size_type count, value_type ch) {s.replace(first, last, count, ch); return *this;}
    template<class InIt> RxString&  replace(iterator first, iterator last, InIt first2, InIt last2) {
        s.replace(first, last, first2, last2); return *this;}
    size_type copy(value_type *ptr, size_type count, size_type off = 0) const {return s.copy(ptr, count, off);}
    void swap(RxString& right) {s.swap(right.s);}
    size_type find(const RxString& right, size_type off = 0) const {return s.find(right.s, off);}
    size_type find(const value_type *ptr, size_type off, size_type count) const {return s.find(ptr, off, count);}
    size_type find(const value_type *ptr, size_type off = 0) const {return s.find(ptr, off);}
    size_type find(value_type ch, size_type off = 0) const {return s.find(ch, off);}
    size_type rfind(const RxString& right, size_type off = npos) const {return s.rfind(right.s, off);}
    size_type rfind(const value_type *ptr, size_type off, size_type count = npos) const {return s.rfind(ptr, off, count);}
    size_type rfind(const value_type *ptr, size_type off = npos) const {return s.rfind(ptr, off);}
    size_type rfind(value_type ch, size_type off = npos) const {return s.rfind(ch, off);}
    size_type find_first_of(const RxString& right, size_type off = 0) const {return s.find_first_of(right.s, off);}
    size_type find_first_of(const value_type *ptr, size_type off, size_type count) const {return s.find_first_of(ptr, off, count);}
    size_type find_first_of(const value_type *ptr, size_type off = 0) const {return s.find_first_of(ptr, off);}
    size_type find_first_of(value_type ch, size_type off = 0) const {return s.find_first_of(ch, off);}
    size_type find_last_of(const RxString& right, size_type off = npos) const {return s.find_last_of(right.s, off);}
    size_type find_last_of(const value_type *ptr, size_type off, size_type count = npos) const {return s.find_last_of(ptr, off, count);}
    size_type find_last_of(const value_type *ptr, size_type off = npos) const {return s.find_last_of(ptr, off);}
    size_type find_last_of(value_type ch, size_type off = npos) const {return s.find_last_of(ch, off);}
    size_type find_first_not_of(const RxString& right, size_type off = 0) const {return s.find_first_not_of(right.s, off);}
    size_type find_first_not_of(const value_type *ptr, size_type off, size_type count) const {return s.find_first_not_of(ptr, off, count);}
    size_type find_first_not_of(const value_type *ptr, size_type off = 0) const {return s.find_first_not_of(ptr, off);}
    size_type find_first_not_of(value_type ch, size_type off = 0) const {return s.find_first_not_of(ch, off);}
    size_type find_last_not_of(const RxString& right, size_type off = npos) const {return s.find_last_not_of(right.s, off);}
    size_type find_last_not_of(const value_type *ptr, size_type off, size_type count) const {return s.find_last_not_of(ptr, off, count);}
    size_type find_last_not_of(const value_type *ptr, size_type off = npos) const {return s.find_last_not_of(ptr, off);}
    size_type find_last_not_of(value_type ch, size_type off = npos) const {return s.find_last_not_of(ch, off);}
    RxString substr(size_type off = 0, size_type count = npos) const {return s.substr(off, count);}
    int compare(const RxString& right) const {return s.compare(right.s);}
    int compare(size_type off, size_type n0, const RxString& right) {return s.compare(off, n0, right.s);}
    int compare(size_type off, size_type n0, const RxString& right, size_type roff, size_type count) {return s.compare(off, n0, right.s, roff, count);}
    int compare(const value_type *ptr) const {return s.compare(ptr);}
    int compare(size_type off, size_type n0, const value_type *ptr) const {return s.compare(off, n0, ptr);}
    int compare(size_type off, size_type n0, const value_type *ptr, size_type roff) const {return s.compare(off, n0, ptr, roff);}
    allocator_type get_allocator() const {return s.get_allocator();}
    //@}
};

/** Formatted output operator for RxString */
inline std::ostream& operator<<(std::ostream &o, const RxString &rs) {
    return o << static_cast<std::string>(rs);
}

/** Adds \a rhs and \a lhs, after converting \a rhs to a string, returns the result */
template <class T>
RxString operator+ (const RxString& lhs, T rhs) {
    RxString l(lhs);
    RxString r; r.convertFrom(rhs);
    return l += r;
}

/** compare two RxStrings for equality */
inline bool operator==(const RxString &lhs, const RxString &rhs) {
    return lhs.compare(rhs) == 0;
}
/** compare two RxStrings for equality */
inline bool operator!=(const RxString &lhs, const RxString &rhs) {
    return lhs.compare(rhs) != 0;
}

template <class Pred>
RxString::iterator RxString::find_if(Pred p) {
    return std::find_if(begin(), end(), p);
}

template <class Pred>
RxString::const_iterator RxString::find_if(Pred p) const {
    return std::find_if(begin(), end(), p);
}

template <class Pred>
void RxString::remove_if(Pred p) {
    erase(std::remove_if(begin(), end(), p), end());
}

template <class Pred>
void RxString::replace_if(Pred p, value_type val) {
    std::replace_if(begin(), end(), p, val);
}

template <class Pred>
RxString::iterator RxString::find_last_not_if(Pred p) {
    iterator b = begin(), e = end();
    iterator tail = b;
    while (b != e)
        if (p(*b++))
            tail = b;
    return tail;
}

template <class Pred>
RxString::const_iterator RxString::find_last_not_if(Pred p) const {
    const_iterator b = begin(), e = end();
    const_iterator tail = b;
    while (b != e)
        if (p(*b++))
            tail = b;
    return tail;
}

template <class T>
bool RxString::convertTo(T &t) const {
    std::istringstream iss(*this);
    return (iss >> t);
}

template <class T>
RxString &RxString::convertFrom(const T &val) {
    std::ostringstream oss;
    oss << val;
    *this = oss.str();
    return *this;
}

template<class IN>
IN& getline(IN& in, RxString& str, const char eol = '\n') {
    str.append_line(in, eol);
    return in;
}

#endif