String.h

/*
 * GDevelop Core
 * Copyright 2015 Victor Levasseur ([email protected]).
 * This project is released under the MIT License.
 */
 
// NOLINTBEGIN
 
#ifndef GDCORE_UTF8_STRING_H
#define GDCORE_UTF8_STRING_H
 
#include <functional>
#include <iostream>
#include <iterator>
#include <sstream>
#include <string>
#include <vector>
 
#include "GDCore/Utf8/utf8.h"
 
namespace gd
{
 
class String;
 
class GD_CORE_API String
{
 
public:
 
    using value_type = char32_t;
    using reference = char32_t&;
    using const_reference = const char32_t&;
    using pointer = char32_t*;
    using const_pointer = const char32_t*;
 
    using size_type = std::string::size_type;
    using difference_type = std::string::difference_type;
 
    static constexpr size_type npos = -1;
 
    template<class T>
    class GD_CORE_API StringIterator : public std::iterator<std::bidirectional_iterator_tag, String::value_type, String::difference_type>
    {
        friend class String;
        friend class StringIterator<const T>;
 
    public:
        StringIterator() : strIt() {};
 
        StringIterator(const StringIterator<T> &other) : strIt(other.strIt) {}
        template<class U> StringIterator(const StringIterator<U> &other) : strIt(other.strIt) {} //Convert from const_iterator to iterator
 
        StringIterator<T>& operator=(const StringIterator<T> &other) { strIt = other.strIt; return *this; }
 
        String::value_type operator*() {return ::utf8::unchecked::peek_next(strIt);}
 
        StringIterator<T>& operator++() { ::utf8::unchecked::next(strIt); return *this; }
        StringIterator<T> operator++(int) { StringIterator<T> tmp(*this); operator++(); return tmp; }
        StringIterator<T>& operator--() { ::utf8::unchecked::prior(strIt); return *this; }
        StringIterator<T> operator--(int) { StringIterator<T> tmp(*this); operator--(); return tmp; }
 
        bool operator==(const StringIterator<T> &other) { return (strIt == other.strIt); }
        bool operator!=(const StringIterator<T> &other) { return !operator==(other); }
 
        bool operator<(const StringIterator<T> &other) { return (strIt < other.strIt); }
        bool operator<=(const StringIterator<T> &other) { return (strIt <= other.strIt); }
        bool operator>(const StringIterator<T> &other) { return (strIt > other.strIt); }
        bool operator>=(const StringIterator<T> &other) { return (strIt >= other.strIt); }
 
        T base() const {return strIt;}
 
    private:
        StringIterator(T strIt) : strIt(strIt) {};
        T strIt;
    };
 
    using iterator = StringIterator<std::string::iterator>;
    using const_iterator = StringIterator<std::string::const_iterator>;
    using reverse_iterator = std::reverse_iterator<iterator>;
    using const_reverse_iterator = std::reverse_iterator<const_iterator>;
 
    String();
 
    String(const char *characters);
 
    String(const std::u32string &string);
 
    String& operator=(const char *characters);
 
    String& operator=(const std::u32string &string);
 
    bool empty() const { return m_string.size() == 0; }
 
    size_type size() const;
 
    size_type length() const { return size(); };
 
    void clear() { m_string.clear(); }
 
    void reserve(gd::String::size_type size) { m_string.reserve(size); }
 
    String::iterator begin();
 
    String::const_iterator begin() const;
 
    String::iterator end();
 
    String::const_iterator end() const;
 
    template<typename T>
    static String From(T value)
    {
        static_assert(!std::is_same<T, std::string>::value, "Can't use gd::String::From with std::string.");
 
        std::ostringstream oss;
        oss.precision(17);
        oss << value;
        return gd::String(oss.str().c_str());
    }
 
    template<typename T>
    T To() const
    {
        static_assert(!std::is_same<T, std::string>::value, "Can't use gd::String::To with std::string.");
 
        T value;
        std::istringstream oss(m_string);
        oss >> value;
        return value;
    }
 
    static String FromLocale( const std::string &localizedString );
 
    static String FromUTF32( const std::u32string &string );
 
    static String FromUTF8( const std::string &utf8Str );
 
    static String FromWide( const std::wstring &wstr );
 
    std::string ToLocale() const;
 
    std::u32string ToUTF32() const;
 
    std::string ToUTF8() const;
 
    std::wstring ToWide() const;
 
    bool IsValid() const;
 
    String& ReplaceInvalid( value_type replacement = 0xfffd );
 
    value_type operator[]( const size_type position ) const;
 
    std::string& Raw() { return m_string; }
 
    const std::string& Raw() const { return m_string; }
 
    const char* c_str() const { return m_string.c_str(); }
 
    String& operator+=( const String &other );
 
    String& operator+=( const char *other );
 
    String& operator+=( value_type character );
 
    void push_back( value_type character );
 
    void pop_back();
 
    String& insert( size_type pos, const String &str );
 
    String& replace( iterator i1, iterator i2, const String &str );
 
    String& replace( iterator i1, iterator i2, size_type n, const char c );
 
    String& replace( size_type pos, size_type len, const String &str );
 
    String& replace( size_type pos, size_type len, const char c );
 
    String& replace_if( iterator i1, iterator i2, std::function<bool(char32_t)> p, const String &str );
 
    String& RemoveConsecutiveOccurrences(iterator i1, iterator i2, const char c);
 
    iterator erase( iterator first, iterator last );
 
    iterator erase( iterator p );
 
    void erase( size_type pos = 0, size_type len = npos );
 
    std::vector<String> Split( value_type delimiter ) const;
 
    String CaseFold() const;
 
    String UpperCase() const;
 
    String LowerCase() const;
 
    String CapitalizeFirstLetter() const;
 
    String FindAndReplace(String search, String replacement, bool all = true) const;
 
    String LeftTrim(const gd::String& chars = " \t\n\v\f\r")
    {
        String trimmedString(*this);
        trimmedString.erase(0, trimmedString.find_first_not_of(chars));
        return trimmedString;
    }
 
    String RightTrim(const gd::String& chars = " \t\n\v\f\r")
    {
        String trimmedString(*this);
        trimmedString.erase(trimmedString.find_last_not_of(chars) + 1);
        return trimmedString;
    }
 
    String Trim(const gd::String& chars = " \t\n\v\f\r")
    {
        return LeftTrim(chars).RightTrim(chars);
    }
 
    enum NormForm
    {
        NFD, 
        NFC, 
        NFKD, 
        NFKC, 
    };
 
    String& Normalize(NormForm form = NFC);
 
    String substr( size_type start = 0, size_type length = npos ) const;
 
    size_type find( const String &search, size_type pos = 0 ) const;
 
    size_type find( const char *search, size_type pos = 0 ) const;
 
    size_type find( const value_type search, size_type pos = 0 ) const;
 
    size_type rfind( const String &search, size_type pos = npos ) const;
 
    size_type rfind( const char *search, size_type pos = npos ) const;
 
    size_type rfind( const value_type &search, size_type pos = npos ) const;
 
    size_type find_first_of( const String &match, size_type startPos = 0 ) const;
 
    size_type find_first_not_of( const String &not_match, size_type startPos = 0 ) const;
 
    size_type find_last_of( const String &match, size_type endPos = npos ) const;
 
    size_type find_last_not_of( const String &not_match, size_type endPos = npos ) const;
 
    int compare( const String &other ) const;
 
    size_type FindCaseInsensitive( const String &search, size_type pos = 0 ) const;
 
private:
    std::string m_string; 
 
};
 
String GD_CORE_API operator+(String lhs, const String &rhs);
 
String GD_CORE_API operator+(String lhs, const char *rhs);
 
String GD_CORE_API operator+(const char *lhs, const String &rhs);
 
const String& GD_CORE_API operator||(const String &lhs, const String &rhs);
 
String GD_CORE_API operator||(String lhs, const char *rhs);
 
bool GD_CORE_API operator==( const String &lhs, const String &rhs );
bool GD_CORE_API operator==( const String &lhs, const char *rhs );
bool GD_CORE_API operator==( const char *lhs, const String &rhs );
 
bool GD_CORE_API operator!=( const String &lhs, const String &rhs );
bool GD_CORE_API operator!=( const String &lhs, const char *rhs );
bool GD_CORE_API operator!=( const char *lhs, const String &rhs );
 
bool GD_CORE_API operator<( const String &lhs, const String &rhs );
bool GD_CORE_API operator<( const String &lhs, const char *rhs );
bool GD_CORE_API operator<( const char *lhs, const String &rhs );
 
bool GD_CORE_API operator<=( const String &lhs, const String &rhs );
bool GD_CORE_API operator<=( const String &lhs, const char *rhs );
bool GD_CORE_API operator<=( const char *lhs, const String &rhs );
 
bool GD_CORE_API operator>( const String &lhs, const String &rhs );
bool GD_CORE_API operator>( const String &lhs, const char *rhs );
bool GD_CORE_API operator>( const char *lhs, const String &rhs );
 
bool GD_CORE_API operator>=( const String &lhs, const String &rhs );
bool GD_CORE_API operator>=( const String &lhs, const char *rhs );
bool GD_CORE_API operator>=( const char *lhs, const String &rhs );
 
std::ostream& GD_CORE_API operator<<(std::ostream &os, const String &str);
 
std::istream& GD_CORE_API operator>>(std::istream &is, String &str);
 
bool GD_CORE_API CaseSensitiveEquiv( String lhs, String rhs, bool compat = true );
 
bool GD_CORE_API CaseInsensitiveEquiv( const String &lhs, const String &rhs, bool compat = true );
 
}
 
namespace std
{
    template <> struct GD_CORE_API hash<gd::String>
    {
        size_t operator()(const gd::String & x) const
        {
            return hash<std::string>()(x.Raw());
        }
    };
}
 
#endif
 
 
// NOLINTEND