string.h

Go to the documentation of this file.

// -*- Mode: C++; tab-width: 2; -*-
// vi: set ts=2:
//

#ifndef BALL_DATATYPE_STRING_H
#define BALL_DATATYPE_STRING_H

#ifndef BALL_CONFIG_CONFIG_H
# include <BALL/CONFIG/config.h>
#endif
#ifndef BALL_COMMON_GLOBAL_H
# include <BALL/COMMON/global.h>
#endif
#ifndef BALL_COMMON_CREATE_H
# include <BALL/COMMON/create.h>
#endif
#ifndef BALL_COMMON_MACROS_H
# include <BALL/COMMON/macros.h>
#endif
#ifndef BALL_COMMON_EXCEPTION_H
# include <BALL/COMMON/exception.h>
#endif
#ifndef BALL_COMMON_DEBUG_H
# include <BALL/COMMON/debug.h>
#endif

#include <string>
#include <cctype>
#include <cerrno>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <vector>

#ifdef BALL_HAS_SSTREAM
# include <sstream>
#else
# include <strstream>
#endif

using std::string;

class QString;
class QByteArray;

namespace BALL 
{
  // forward declaration
  class Substring;

        
  class BALL_EXPORT String
  {
    friend class Substring;

    public:
        
    // String has no copy constructor taking String&, bool as arguments.
    // the compiler would confuse it with another copy constructor,
    // cast true to 1 and copy only the string from the second character
    // on! We could use BALL_CREATE_NODEEP, but this leads to trouble with
    // inline constructors, so we code it by hand (here and in string.C)
    virtual void* create(bool /* deep */ = true, bool empty = false) const;
  

    enum CompareMode
    { 
      CASE_SENSITIVE   = 0, 

      CASE_INSENSITIVE = 1 
    };

    static const Size EndPos;

    static const size_t npos = -1;



    static const char* CHARACTER_CLASS__ASCII_ALPHA;

    static const char* CHARACTER_CLASS__ASCII_ALPHANUMERIC;

    static const char* CHARACTER_CLASS__ASCII_LOWER;

    static const char* CHARACTER_CLASS__ASCII_UPPER;

    static const char* CHARACTER_CLASS__ASCII_NUMERIC;

    static const char* CHARACTER_CLASS__ASCII_FLOAT;

    static const char* CHARACTER_CLASS__WHITESPACE;

    static const char* CHARACTER_CLASS__QUOTES;



    String();

    String(const string& string);

    String(const String& s);

#ifdef BALL_STD_STRING_HAS_RVALUE_REFERENCES
    String(String&& s);

    String(string&& s);

    String& operator=(String&& s);

    String& operator=(string&& s);
#endif

    explicit String(const QString& string);

    explicit String(const QByteArray& string);

    String(const String& s, Index from, Size len = EndPos);
  
    String(const char* char_ptr, Index from = 0, Size len = EndPos);

    String(Size buffer_size, const char* format, ... );

#ifdef BALL_HAS_SSTREAM
    String(std::stringstream& s);
#else
    String(std::strstream& s);
#endif

    String(const char c, Size len = 1);

    String(const unsigned char uc);

    String(short s);

    String(unsigned short us);

    String(int i);

    String(unsigned int ui);

    String(long l);

    String(unsigned long);

#ifdef BALL_ALLOW_LONG64_TYPE_OVERLOADS
    String(LongIndex l);

    String(LongSize);
#endif

    String(float f);

    String(double d);

    operator string&();

    operator string const&() const;

    virtual ~String();

    void destroy();



    void set(const String& s);

    void set(const String& string, Index from, Size len = EndPos);

    void set(const char* char_ptr, Index from = 0, Size len = EndPos);
  
    void set(Size buffer_size, const char *format, ...);

#ifdef BALL_HAS_SSTREAM
    void set(std::stringstream& s);
#else
    void set(std::strstream& s);
#endif

    void set(char c, Size len = 1);

    void set(unsigned char uc);

    void set(short s);

    void set(unsigned short us);

    void set(int i);

    void set(unsigned int ui);

    void set(long l);

    void set(unsigned long ul);

#ifdef BALL_ALLOW_LONG64_TYPE_OVERLOADS
    void set(LongIndex l);

    void set(LongSize ul);
#endif

    void set(float f);

    void set(double d);

    void get(char* char_ptr, Index from = 0, Size len = EndPos) const;

    const String& operator = (const String& s);

    const String& operator = (const char* pc);

#ifdef BALL_HAS_SSTREAM
    const String& operator = (std::stringstream& s);
#else
    const String& operator = (std::strstream& s);
#endif

    const String& operator = (char c);

    const String& operator = (unsigned char uc);

    const String& operator = (short s);

    const String& operator = (unsigned short us);

    const String& operator = (int i);

    const String& operator = (unsigned int ui);

    const String& operator = (long l);

    const String& operator = (unsigned long ul);

#ifdef BALL_ALLOW_LONG64_TYPE_OVERLOADS
    const String& operator = (LongIndex l);

    const String& operator = (LongSize ul);
#endif

    const String& operator = (float f);

    const String& operator = (double d);

    static void setCompareMode(CompareMode compare_mode);

    static CompareMode getCompareMode();


    bool toBool() const;

    char toChar() const;

    unsigned char toUnsignedChar() const;

    short toShort() const;

    unsigned short toUnsignedShort() const;

    int toInt() const;

    unsigned int toUnsignedInt() const;

    long toLong() const;

    unsigned long toUnsignedLong() const;

    float toFloat() const;

    double toDouble() const;



    void toLower(Index from = 0, Size len = EndPos);
      
    void toUpper(Index from = 0, Size len = EndPos);



    Substring getSubstring(Index from = 0, Size len = EndPos) const;

    Substring operator () (Index from, Size len = EndPos) const;

    Substring before(const String& s, Index from = 0) const;
 
    Substring through(const String& s, Index from = 0) const;
 
    Substring from(const String& s, Index from = 0) const;

    Substring after(const String& s, Index from = 0) const;



    Size countFields(const char* delimiters = CHARACTER_CLASS__WHITESPACE) const;

    Size countFieldsQuoted(const char* delimiters = CHARACTER_CLASS__WHITESPACE, 
                           const char* quotes = CHARACTER_CLASS__QUOTES) const;

    String getField(Index index, const char* delimiters = CHARACTER_CLASS__WHITESPACE, Index* from = 0) const;

    String getFieldQuoted(Index index, const char* delimiters = CHARACTER_CLASS__WHITESPACE, 
                          const char* quotes = CHARACTER_CLASS__QUOTES, Index* from = 0) const;

    Size split(String string_array[], Size array_size, const char* delimiters = CHARACTER_CLASS__WHITESPACE, Index from = 0) const;

    Size split(std::vector<String>& strings, const char* delimiters = CHARACTER_CLASS__WHITESPACE, Index from = 0) const;

    Size splitQuoted(std::vector<String>& strings, const char* delimiters = CHARACTER_CLASS__WHITESPACE, 
               const char* quotes = CHARACTER_CLASS__QUOTES, Index from = 0) const;



    String& trimLeft(const char* trimmed = CHARACTER_CLASS__WHITESPACE);

    String& trimRight(const char* trimmed = CHARACTER_CLASS__WHITESPACE);

    String& trim(const char* trimmed = CHARACTER_CLASS__WHITESPACE);

    // ?????
    String trim(const char* trimmed = CHARACTER_CLASS__WHITESPACE) const;

    String& truncate(Size size);

    Substring left(Size len) const;

    Substring right(Size len) const;

    Substring instr(const String& pattern, Index from = 0) const;


    
    // NOTE: please, please, pretty please, only try to optimize away operator+ definitions
    //       if you *really* know what you are doing. We didn't, and we definitely don't want
    //       to touch this stinking heap of C++ garbage ever again!
    //       (dstoeckel & anhi)
    BALL_EXPORT
    friend String operator + (const String& s1, const string& s2);
    
    BALL_EXPORT
    friend String operator + (const string& s1, const String& s2);

    BALL_EXPORT
    friend String operator + (const String& s1, const String& s2);
    
    BALL_EXPORT
    friend String operator + (const String& s1, const char* char_ptr);

    BALL_EXPORT
    friend String operator + (const char* char_ptr, const String& s);

    BALL_EXPORT
    friend String operator + (const String& s, char c);
    
    BALL_EXPORT
    friend String operator + (char c, const String& s);

#ifdef BALL_STD_STRING_HAS_RVALUE_REFERENCES
    BALL_EXPORT
    friend String operator + (String&& s1, const string& s2);
  
    BALL_EXPORT
    friend String operator + (String&& s1, const String& s2);
  
    BALL_EXPORT
    friend String operator + (String&& s1, String&& s2);

    BALL_EXPORT
    friend String operator + (const String& s1, string&& s2);

    BALL_EXPORT
    friend String operator + (string&& s1, const String& s2);

    BALL_EXPORT
    friend String operator + (const string& s1, String&& s2);

    BALL_EXPORT
    friend String operator + (const String& s1, String&& s2);

    BALL_EXPORT
    friend String operator + (String&& s1, const char* char_ptr);

    BALL_EXPORT
    friend String operator + (const char* char_ptr, String&& s);

    BALL_EXPORT
    friend String operator + (String&& s, char c);
    
    BALL_EXPORT
    friend String operator + (char c, String&& s);
#endif

    void swap(String& s);

    String& reverse(Index from = 0, Size len = EndPos);

    Size substitute(const String& to_replace, const String& replacing);

    void substituteAll(const String& to_replace, const String& replacing);



    bool has(char c) const;

    bool hasSubstring(const String& s, Index from = 0) const;

    bool hasPrefix(const String& s) const;

    bool hasSuffix(const String& s) const;

    bool isEmpty() const;

    bool isAlpha() const;

    bool isAlnum() const;

    bool isDigit() const;

    bool isFloat() const;

    bool isSpace() const;

    bool isWhitespace() const;

    static bool isAlpha(char c);
  
    static bool isAlnum(char c);

    static bool isDigit(char c);

    static bool isSpace(char c);

    static bool isWhitespace(char c);
    

    
    String encodeBase64();

    String decodeBase64();
    


    int compare(const String& string, Index from = 0) const;

    int compare(const String& string, Index from, Size len) const;


    int compare(const char* char_ptr, Index from = 0) const;

    int compare(const char* char_ptr, Index from, Size len) const;

    int compare(char c, Index from = 0) const;

    BALL_EXPORT
    friend bool operator == (const String& s1, const String& s2);

    BALL_EXPORT
    friend bool operator != (const String& s1, const String& s2);

    BALL_EXPORT
    friend bool operator < (const String& s1, const String& s2);

    BALL_EXPORT
    friend bool operator <= (const String& s1, const String& s2);

    BALL_EXPORT
    friend bool operator > (const String& s1, const String& s2);

    BALL_EXPORT
    friend bool operator >= (const String& s1, const String& s2);

    BALL_EXPORT
    friend bool operator == (const char* char_ptr, const String& string);

    BALL_EXPORT
    friend bool operator != (const char* char_ptr, const String& string);

    BALL_EXPORT
    friend bool operator < (const char* char_ptr, const String& string);

    BALL_EXPORT
    friend bool operator <= (const char* char_ptr, const String& string);
    
    BALL_EXPORT
    friend bool operator > (const char* char_ptr, const String& string);

    BALL_EXPORT
    friend bool operator >= (const char* char_ptr, const String& string);

    bool operator == (const char* char_ptr) const;

    bool operator != (const char* char_ptr) const;

    bool operator < (const char* char_ptr) const;

    bool operator <= (const char* char_ptr) const;

    bool operator > (const char* char_ptr) const;

    bool operator >= (const char* char_ptr) const;

    BALL_EXPORT
    friend bool operator == (char c, const String& string);

    BALL_EXPORT
    friend bool operator != (char c, const String& string);

    BALL_EXPORT
    friend bool operator < (char c, const String& string);

    BALL_EXPORT
    friend bool operator <= (char c, const String& string);
    
    BALL_EXPORT
    friend bool operator > (char c, const String& string);

    friend bool operator >= (char c, const String& string);

    bool operator == (char c) const;

    bool operator != (char c) const;

    bool operator < (char c) const;

    bool operator <= (char c) const;

    bool operator > (char c) const;

    bool operator >= (char c) const;



    bool isValid() const;

    void dump(std::ostream& s = std::cout, Size depth = 0) const;



    std::istream& getline(std::istream& s = std::cin, char delimiter = '\n');

//    BALL_EXPORT
//    friend std::istream& getline(std::istream& s,  String& string,  char delimiter);


    static const String EMPTY;


    typedef string::value_type             valuetype;
    typedef string::traits_type            traits_type;
    typedef string::allocator_type         allocator_type;
    typedef string::reference              reference;
    typedef string::const_reference        const_reference;
    typedef string::pointer                pointer;
    typedef string::const_pointer          const_pointer;
    typedef string::iterator               iterator;
    typedef string::const_iterator         const_iterator;
    typedef string::reverse_iterator       reverse_iterator;
    typedef string::const_reverse_iterator const_reverse_iterator;
    typedef string::difference_type        difference_type;
    typedef string::size_type              size_type;


    iterator begin() BALL_NOEXCEPT;
    const_iterator begin() const BALL_NOEXCEPT;
    iterator end() BALL_NOEXCEPT;
    const_iterator end() const BALL_NOEXCEPT;
    reverse_iterator rbegin() BALL_NOEXCEPT;
    const_reverse_iterator rbegin() const BALL_NOEXCEPT;
    reverse_iterator rend() BALL_NOEXCEPT;
    const_reverse_iterator rend() const BALL_NOEXCEPT;

#ifdef BALL_HAS_STD_STRING_CONST_ITERATORS
    const_iterator cbegin() const BALL_NOEXCEPT;
    const_iterator cend() const BALL_NOEXCEPT;
    const_reverse_iterator crbegin() const BALL_NOEXCEPT;
    const_reverse_iterator crend() const BALL_NOEXCEPT;
#endif



    size_t size() const BALL_NOEXCEPT;
    size_t length() const BALL_NOEXCEPT;
    size_t max_size() const BALL_NOEXCEPT;
    void resize(size_t n);
    void resize(size_t n, char c);
    size_t capacity() const BALL_NOEXCEPT;
    void reserve(size_t n = 0);
    void clear() BALL_NOEXCEPT;
    bool empty() const BALL_NOEXCEPT;

#ifdef BALL_HAS_STD_STRING_SHRINK_TO_FIT
    void shrink_to_fit();
#endif



    char& operator[] (size_t pos);
    const char& operator[] (size_t pos) const;
    char& at(size_t pos);
    const char& at(size_t pos) const;

#ifdef BALL_HAS_STD_STRING_FRONT_BACK
    char& front();
    const char& front() const;
    char& back();
    const char& back() const;
#endif


    String& operator += (const String& str);
    String& operator += (const string& str);
    String& operator += (const char* s);
    String& operator += (char c);
#ifdef BALL_HAS_INITIALIZER_LISTS
    String& operator += (std::initializer_list<char> il);
#endif
    String& append(const String& str);
    String& append(const string& str);
    String& append(const string& str, size_t subpos, size_t sublen);
    String& append(const char* s);
    String& append(const char* s, size_t n);
    String& append(size_t n, char c);
    template <class InputIterator>
    String& append(InputIterator first, InputIterator last);
#ifdef BALL_HAS_INITIALIZER_LISTS
    String& append(std::initializer_list<char> li);
#endif
    void push_back(char c);
    String& assign(const String& str);
    String& assign(const string& str);
    String& assign(const string& str, size_t subpos, size_t sublen);
    String& assign(const char* s);
    String& assign(const char* s, size_t n);
    String& assign(size_t n, char c);
    template <class InputIterator>
    String& assign(InputIterator first, InputIterator last);
#ifdef BALL_HAS_INITIALIZER_LISTS
    String& assign(std::initializer_list<char> li);
#endif
#ifdef BALL_STD_STRING_HAS_RVALUE_REFERENCES
    String& assign(string&& str) BALL_NOEXCEPT;
#endif

    String& insert(size_t pos, const string& str);
    String& insert(size_t pos, const string& str, size_t subpos, size_t sublen);
    String& insert(size_t pos, const char* s);
    String& insert(size_t pos, const char* s, size_t n);
    String& insert(size_t pos, size_t n, char c);
#ifdef BALL_HAS_STD_STRING_CONST_ITERATOR_FUNCTIONS
    iterator insert(const_iterator p, size_t n, char c);
    iterator insert(const_iterator p, char c);
#else
    void insert(iterator p, size_t n, char c);
    iterator insert(iterator p, char c);
#endif
    template <class InputIterator>
    iterator insert(iterator p, InputIterator first, InputIterator last);
#if defined(BALL_HAS_INITIALIZER_LISTS) && defined(BALL_HAS_STD_STRING_CONST_ITERATOR_FUNCTIONS)
    String& insert(const_iterator p, std::initializer_list<char> li);
#endif

    String& erase(size_t pos = 0, size_t len = npos);
#ifdef BALL_HAS_STD_STRING_CONST_ITERATOR_FUNCTIONS
    iterator erase(const_iterator p);
    iterator erase(const_iterator first, const_iterator last);
#else
    iterator erase(iterator p);
    iterator erase(iterator first, iterator last);
#endif

    String& replace(size_t pos, size_t len, const string& str);
    String& replace(size_t pos, size_t len, const string& str, size_t subpos, size_t sublen);
    String& replace(size_t pos, size_t len, const char* s);
    String& replace(size_t pos, size_t len, const char* s, size_t n);
    String& replace(size_t pos, size_t len, size_t n, char c);
#ifdef BALL_HAS_STD_STRING_CONST_ITERATOR_FUNCTIONS
    String& replace(const_iterator i1, const_iterator i2, const string& str);
    String& replace(const_iterator i1, const_iterator i2, const char* s);
    String& replace(const_iterator i1, const_iterator i2, const char* s, size_t n);
    String& replace(const_iterator i1, const_iterator i2, size_t n, char c);
    template <class InputIterator>
    String& replace(const_iterator i1, const_iterator i2, InputIterator first, InputIterator last);
#else
    String& replace(iterator i1, iterator i2, const string& str);
    String& replace(iterator i1, iterator i2, const char* s);
    String& replace(iterator i1, iterator i2, const char* s, size_t n);
    String& replace(iterator i1, iterator i2, size_t n, char c);
    template <class InputIterator>
    String& replace(iterator i1, iterator i2, InputIterator first, InputIterator last);
#endif
#if defined(BALL_HAS_INITIALIZER_LISTS) && defined(BALL_HAS_STD_STRING_CONST_ITERATOR_FUNCTIONS)
    String& replace(const_iterator i1, const_iterator i2, std::initializer_list<char> li);
#endif

    void swap(string& str);

#ifdef BALL_HAS_STD_STRING_POP_BACK
    void pop_back();
#endif



    const char* c_str() const BALL_NOEXCEPT;
    const char* data() const BALL_NOEXCEPT;
    allocator_type get_allocator() const BALL_NOEXCEPT;
    size_t copy(char* s, size_t len, size_t pos = 0) const;

    size_t find(const string& str, size_t pos = 0) const BALL_NOEXCEPT;
    size_t find(const char* s, size_t pos = 0) const;
    size_t find(const char* s, size_t pos, size_t n) const;
    size_t find(char c, size_t pos = 0) const BALL_NOEXCEPT;

    size_t rfind(const string& str, size_t pos = npos) const BALL_NOEXCEPT;
    size_t rfind(const char* s, size_t pos = npos) const;
    size_t rfind(const char* s, size_t pos, size_t n) const;
    size_t rfind(char c, size_t pos = npos) const BALL_NOEXCEPT;
    
    size_t find_first_of(const string& str, size_t pos = 0) const BALL_NOEXCEPT;
    size_t find_first_of(const char* s, size_t pos = 0) const;
    size_t find_first_of(const char* s, size_t pos, size_t n) const;
    size_t find_first_of(char c, size_t pos = 0) const BALL_NOEXCEPT;

    size_t find_last_of(const string& str, size_t pos = npos) const BALL_NOEXCEPT;
    size_t find_last_of(const char* s, size_t pos = npos) const;
    size_t find_last_of(const char* s, size_t pos, size_t n) const;
    size_t find_last_of(char c, size_t pos = npos) const BALL_NOEXCEPT;

    size_t find_first_not_of(const string& str, size_t pos = 0) const BALL_NOEXCEPT;
    size_t find_first_not_of(const char* s, size_t pos = 0) const;
    size_t find_first_not_of(const char* s, size_t pos, size_t n) const;
    size_t find_first_not_of(char c, size_t pos = 0) const BALL_NOEXCEPT;

    size_t find_last_not_of(const string& str, size_t pos = npos) const BALL_NOEXCEPT;
    size_t find_last_not_of(const char* s, size_t pos = npos) const;
    size_t find_last_not_of(const char* s, size_t pos, size_t n) const;
    size_t find_last_not_of(char c, size_t pos = npos) const BALL_NOEXCEPT;

    string substr(size_t pos = 0, size_t len = npos) const;

    int compare(const string& str) const BALL_NOEXCEPT;
    int compare(size_t pos, size_t len, const string& str) const;
    int compare(size_t pos, size_t len, const string& str, size_t subpos, size_t sublen) const;
    //int compare(const char* s) const;
    int compare(size_t pos, size_t len, const char* s) const;
    int compare(size_t pos, size_t len, const char* s, size_t n) const;

    

    protected:
  
    // the validate...  methods check perform a thorough
    // index checking and an index translation
    // Indices below zero are interpreted as indices
    // relative to the end of the string
    // All methods throw IndexUnder|Overflow exceptions
    //
    void validateIndex_(Index& index) const;
  
    void validateRange_(Index& from, Size& len) const; 

    static void validateCharPtrRange_(Index& from, Size& len, const char* char_ptr);
    
    static void valudateCharPtrIndex_(Index& index);
    
    private:

    string str_;

    static int compareAscendingly_(const char* a,  const char* b);

    static int compareDescendingly_(const char* a,  const char* b);

    static CompareMode compare_mode_;

    static char B64Chars_[64];

    static int Index_64_[128];
  };

  class BALL_EXPORT Substring
  {
    friend class String;

    public:

    BALL_CREATE_DEEP(Substring)

    

    class BALL_EXPORT UnboundSubstring
      : public Exception::GeneralException
    {
      public:
      UnboundSubstring(const char* file, int line); 
    };

    class BALL_EXPORT InvalidSubstring
      : public Exception::GeneralException
    {
      public:
      InvalidSubstring(const char* file, int line); 
    };



    Substring();

    Substring(const Substring& substring, bool deep = true);

    Substring(const String& string, Index from = 0, Size len = String::EndPos);

    virtual ~Substring();

    void destroy();

    virtual void clear();



    operator String() const;

    //explicit operator string() const;

    String toString() const;


    
    Substring& bind(const String& string, Index from = 0, Size len = String::EndPos);

    Substring& bind(const Substring& substring, Index from = 0, Size len = String::EndPos);

    void unbind();

    String* getBoundString();

    const String* getBoundString() const
;


  
    void set(const String& string);

    void set(const Substring& s);

    void set(const char* char_ptr, Size size = String::EndPos);

    const Substring& operator = (const String& string);

    const Substring& operator = (const Substring& substring);

    const Substring& operator = (const char* char_ptr);


    
    char* c_str();

    const char* c_str() const;

    Index getFirstIndex() const;

    Index getLastIndex() const;

    Size size() const;

    char& operator [] (Index index);

    char operator [] (Index index) const;

    Substring& toLower();

    Substring& toUpper();
      


    bool isBound() const;
    
    bool isEmpty() const;



    bool operator == (const Substring& substring) const;

    bool operator != (const Substring& substring) const;

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

    bool operator != (const String& string) const;

    BALL_EXPORT
    friend bool operator == (const String& string, const Substring& substring);

    BALL_EXPORT
    friend bool operator != (const String& string, const Substring& substring);

    bool operator == (const char* char_ptr) const;

    bool operator != (const char* char_ptr) const;

    bool operator == (char c) const;

    bool operator != (char c) const;



    BALL_EXPORT
    friend std::ostream& operator << (std::ostream& s, const Substring& substring);



    bool isValid() const;

    void dump(std::ostream& s = std::cout, Size depth = 0) const;

    
    protected:
      
    // throws IndexUnderflow|IndexOverflow
    void validateRange_(Index& from, Size& len) const;

    private:
    
    /*_ @name Attributes
    */
    //_@{

    //_ pointer to the bound String
    String*   bound_;

    //_ start index in the bound String
    Index     from_;

    //_ end index in the bound String
    Index     to_;
    //_@}
  };
  
  // non-member functions of String

  BALL_EXPORT
  bool operator == (const String& s1, const String& s2);

  BALL_EXPORT
  bool operator != (const String& s1, const String& s2);

  BALL_EXPORT
  bool operator < (const String& s1, const String& s2);

  BALL_EXPORT
  bool operator <= (const String& s1, const String& s2);

  BALL_EXPORT
  bool operator > (const String& s1, const String& s2);

  BALL_EXPORT
  bool operator >= (const String& s1, const String& s2);

  BALL_EXPORT
  String operator + (const String& s1, const string& s2);
    
  BALL_EXPORT
  String operator + (const string& s1, const String& s2);

  BALL_EXPORT
  String operator + (const String& s1, const String& s2);
    
  BALL_EXPORT
  String operator + (const String& s1, const char* char_ptr);

  BALL_EXPORT
  String operator + (const char* char_ptr, const String& s);

  BALL_EXPORT
  String operator + (const String& s, char c);
    
  BALL_EXPORT
  String operator + (char c, const String& s);

#ifdef BALL_STD_STRING_HAS_RVALUE_REFERENCES
  BALL_EXPORT
  String operator + (String&& s1, const string& s2);
  
  BALL_EXPORT
  String operator + (String&& s1, const String& s2);
  
  BALL_EXPORT
  String operator + (String&& s1, String&& s2);

  BALL_EXPORT
  String operator + (const String& s1, string&& s2);

  BALL_EXPORT
  String operator + (string&& s1, const String& s2);

  BALL_EXPORT
  String operator + (const string& s1, String&& s2);

  BALL_EXPORT
  String operator + (const String& s1, String&& s2);

  BALL_EXPORT
  String operator + (String&& s1, const char* char_ptr);

  BALL_EXPORT
  String operator + (const char* char_ptr, String&& s);

  BALL_EXPORT
  String operator + (String&& s, char c);
    
  BALL_EXPORT
  String operator + (char c, String&& s);
#endif
} // namespace BALL

namespace std
{
  // Non-member functions for string

  istream& operator>> (istream& is, BALL::String& str);

  ostream& operator<< (ostream& os, BALL::String const& str);

  istream& getline(istream& is, BALL::String& str, char delim);
  istream& getline(istream& is, BALL::String& str);


#ifdef BALL_STD_STRING_HAS_RVALUE_REFERENCES
  istream& getline(istream& is, BALL::String&& str, char delim);
  istream& getline(istream& is, BALL::String&& str);
#endif
}


# ifndef BALL_NO_INLINE_FUNCTIONS
#   include <BALL/DATATYPE/string.iC>
# endif

#endif // BALL_DATATYPE_STRING_H