faithtools/faith/string.h

Go to the documentation of this file.

#ifndef KDE__STRING_H
#define KDE__STRING_H

#include <faith/cstring.h>
#include <faith/char.h>
#include <faith/tools.h>

#include <string>

#ifndef U_ICU_NAMESPACE
#define U_ICU_NAMESPACE KDEInternalAwfulHack
#endif

namespace U_ICU_NAMESPACE
{
class UnicodeString; // icu
}


namespace Faith
{

class Char;
class CharRef;

class FAITH_TOOLS_EXPORT String
{
        U_ICU_NAMESPACE::UnicodeString *mUnicode;
        friend class ::Faith::CharRef;
public:
        String();
        
        String(const String &s);
        
        String(const std::string &s);
        
        String(const char *s);

        ~String();

        bool isNull() const;

        bool isEmpty() const { return length() ? false : true; }

        bool operator ==(const String &other) const;

        int compare(const String &text) const;


        bool operator <(const ::Faith::String &b) const
        {
                return compare(b) > 0;
        }

        bool operator >(const ::Faith::String &b) const
        {
                return compare(b) < 0;
        }

        String &operator =(const String &set);
        String &operator =(const Char &set);

        String &operator +=(const String &append);

        String &operator +=(char c);
        
        String &operator +=(const Char &c);

        inline Faith::String operator + (const char *b)
        {
                Faith::String s(*this);
                s += b;
                return s;
        }

        Char operator[] (int at) const;

        CharRef operator[] (int at);

        int find(const String &other, int start=0) const;

        int find(const Char &other, int start=0) const;

        int find(char other, int start=0) const;

        int find(bool (Char::*test)() const, int start=0) const
        {
                return find(true, test, start);
        }

        int find(bool uninverted, bool (Char::*test)() const, int start=0) const;

        String mid(int start, int length=-1) const;

        void insert(int offset, const String &str);

        void replace(int start, int len, const String &str);


        void replace(const String &other, const String &replace, int start=0);

        void replace(const Char &other, const String &replace, int start=0);

        void replace(char other, const String &replace, int start=0);
        
        
        int length() const;

        static String fromLocal8Bit(const char *str)
        {
                return fromLocal8Bit(CString(str));
        }
        static String fromLocal8Bit(const CString &);

        static String fromLatin1(const char *);
        static String fromLatin1(const CString &);

        void setLocal8Bit(const CString &str);
        void setLocal8Bit(const char *str);

        void setUtf8(const CString &str);
        void setUtf8(const char *str);

        static String fromUtf8(const char *str) { String s; s.setUtf8(str); return s; }

        void setLatin1(const CString &str);
        void setLatin1(const char *str);

        CString exportTo(const CString &codepage) const;

        CString local8Bit() const;

        CString latin1() const;

        static String number(int n, int base=10);
        static String number(long n, int base=10) { return number(int(n), base); }
        static String number(double n, char format='g', int precision=6);

        Faith::String left(int n) const;
        
        void setCharAt(int offset, const Char &ch);
        
        int toInt(int base=10) const;
        
        bool beginsWith(const String &str) const;
        
        String simplifiedWhiteSpace() const;
        
        String removedWhiteSpace() const;
};

}

inline std::ostream &operator << (std::ostream &out, const Faith::String &str)
{
        out << str.latin1();
        return out;
}

inline std::istream &operator >> (std::istream &in, Faith::String &str)
{
        std::string s;
        in >> s;
        str = s.c_str();
        return in;
}

inline Faith::String operator + (const Faith::String &a, const Faith::String &b)
{
        Faith::String s(a);
        s += b;
        return s;
}

inline bool operator ==(const char *a, const Faith::String &b)
{
        return b == a;
}


#endif

---