CRNString.h

Go to the documentation of this file.

/* Copyright 2008-2016 INSA Lyon, CoReNum, Université Paris Descartes, ENS-Lyon
 * 
 * This file is part of libcrn.
 * 
 * libcrn is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 * 
 * libcrn is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License for more details.
 * 
 * You should have received a copy of the GNU Lesser General Public License
 * along with libcrn.  If not, see <http://www.gnu.org/licenses/>.
 * 
 * file: CRNString.h
 * \author Yann LEYDIER
 */

#ifndef CRNSTRING_Header
#define CRNSTRING_Header

#include <CRNObject.h>
#include <string>
#include <vector>
#include <sstream>
#include <complex>
#include <iomanip>
#include <stdlib.h>

#include <string.h> // MT : because new error with strlen - gcc 6.2.0 - Ubuntu 16.10

namespace crn
{
    class StringUTF8;
    class Prop3;

    inline wint_t ToWUpper(wint_t c) { return towupper(c); }
    inline wint_t ToWLower(wint_t c) { return towlower(c); }
    /****************************************************************************/
    class String: public Object
    {
        public:
            /**********************************************************************/
            /* Constructors                                                       */
            /**********************************************************************/
            String() = default;
            virtual ~String() override = default;
            String(const std::u32string &s):data(s) {}
            String(std::u32string &&s) noexcept:data(std::move(s)) {}
            String(char32_t *s) {if (s) data = s; else data = U""; }
            String(const char32_t *s) {if (s) data = s; else data = U""; }
            String(const String &s):data(s.data) {}
            String(char32_t c, size_t n = 1);
            String(const StringUTF8 &s);
            String(const Prop3 &p);
            String(char *s);
            String(const char *s);
            String(const std::string &s);
            String(char c, size_t n = 1);
            String(int i) { convertFrom(i); }
            String(unsigned int i) { convertFrom(i); }
            String(long i) { convertFrom(i); }
            String(unsigned long i) { convertFrom(i); }
            String(float f) { convertFrom(f); }
            String(double d) { convertFrom(double(d)); }
            String(long double d) { convertFrom(d); }
            String(long long i) { convertFrom(i); }
            String(unsigned long long i) { convertFrom(i); }
            template<typename T> String(const std::complex<T> &c) { *this = String(U"(") + c.real() + String(U", ") + c.imag() + String(U")"); }

            String(String&&) = default;
            String& operator=(String&&) = default;

            /**********************************************************************/
            /* Typecast methods                                                   */
            /**********************************************************************/
            std::u32string& Std() & noexcept { return data; }
            const std::u32string& Std() const & noexcept { return data; }
            std::u32string Std() && { return std::move(data); }
            const char32_t* CWStr() const noexcept { return data.c_str(); }
            const char* CStr() const;
            Prop3 ToProp3() const;
            int ToInt() const { return convertTo<int>(); }
            unsigned int ToUInt() const { return convertTo<unsigned int>(); }
            long ToLong() const { return convertTo<long>(); }
            unsigned long ToULong() const { return convertTo<unsigned long>(); }
            float ToFloat() const { return convertTo<float>(); }
            double ToDouble() const { return convertTo<double>(); }
            long double ToLongDouble() const { return convertTo<long double>(); }
long long ToLongLong() const { return convertTo<long long>(); }
            unsigned long long ToULongLong() const { return convertTo<unsigned long long>(); }
            int64_t ToInt64() const { return convertTo<int64_t>(); }
            uint64_t ToUInt64() const { return convertTo<uint64_t>(); }

            /**********************************************************************/
            /* String manipulation                                                */
            /**********************************************************************/
            size_t Size() const noexcept { return data.length(); }
            size_t Length() const noexcept { return data.length(); }
            bool operator!() const noexcept { return data.empty(); }
            bool IsEmpty() const noexcept { return data.empty(); }
            bool IsNotEmpty() const noexcept { return !data.empty(); }

            char32_t& operator[](size_t index);
            const char32_t& operator[](size_t index) const;

            String& operator=(const String &s) { data = s.data; return *this; }

            String& operator+=(const String &s) { data += s.data; return *this; }

            String& Insert(size_t pos, const String &s);

            String& Crop(size_t pos, size_t n = 0);
            String& Erase(size_t pos, size_t n = 0);

            String& Replace(const String &s, size_t pos, size_t n = 0);

            String& ReplaceSuffix(const String &old_suffix, const String &new_suffix);
            String& ReplaceSuffix(const size_t n, const String &new_suffix);
            String& DeleteSuffix(const String &suffix);         
            std::vector<String> WhichSuffixes(const std::vector<String> &suffixes) const;
            std::vector<String> WhichPrefixes(const std::vector<String> &prefixes) const;
            std::vector<String> WhichSubstrings(const std::vector<String> &substrings) const;

            String& Replace(char32_t from, char32_t to);

            String& ToUpper();
            String& FirstCharacterToUpper();

            String& ToLower();

            String SubString(size_t pos, size_t n = 0) const;

            size_t Find(const String &s, size_t from_pos = 0) const;
            size_t FindAnyOf(const String &s, size_t from_pos = 0) const;
            size_t FindNotOf(const String &s, size_t from_pos = 0) const;

            size_t BackwardFind(const String &s, size_t last_pos = NPos()) const;
            size_t BackwardFindAnyOf(const String &s, size_t from_pos = NPos()) const;
            size_t BackwardFindNotOf(const String &s, size_t from_pos = NPos()) const;

            bool StartsWith(const String &s) const;
            
            bool EndsWith(const String &s) const;
            bool EndsWith(const std::vector<String> &suffixes) const;

            std::vector<String> Split(const String &sep) const;

            int EditDistance(const String &s) const;

            static int& Precision() noexcept;

            void ShrinkToFit();

            void Swap(String &str) noexcept { data.swap(str.data); }

            static size_t NPos() noexcept;

            static String CreateUniqueId(size_t len = 8);

            void Deserialize(xml::Element &el);
            xml::Element Serialize(xml::Element &parent) const;

        private:
            template<typename T> T convertTo() const { std::stringstream ss(CStr()); T val; ss >> val; return val; }
            template<typename T> void convertFrom(T val) { std::stringstream ss; ss << std::setprecision(Precision()) << val; *this = ss.str(); }

            std::u32string data; 
            mutable std::string cdata; 
        CRN_DECLARE_CLASS_CONSTRUCTOR(String)
        CRN_SERIALIZATION_CONSTRUCTOR(String)
    };
    template<> struct IsClonable<String> : public std::true_type {};
    template<> struct IsSerializable<String> : public std::true_type {};
    template<> struct IsMetric<String> : public std::true_type {};

    /* \addtogroup string */
    inline bool operator==(const String &s1, const String &s2) { return s1.Std() == s2.Std(); }
    inline bool operator!=(const String &s1, const String &s2) { return s1.Std() != s2.Std(); }
    inline bool operator<(const String &s1, const String &s2) { return s1.Std() < s2.Std(); }
    inline bool operator>(const String &s1, const String &s2) { return s1.Std() > s2.Std(); }
    inline bool operator<=(const String &s1, const String &s2) { return s1.Std() <= s2.Std(); }
    inline bool operator>=(const String &s1, const String &s2) { return s1.Std() >= s2.Std(); }
    inline String operator+(const String &s1, const String &s2) { return String(s1.Std() + s2.Std()); }
    
    inline double Distance(const String &s1, const String &s2) { return s1.EditDistance(s2); }

    inline void Swap(String &s1, String &s2) noexcept { s1.Swap(s2); }

    inline size_t Size(const String &s) noexcept { return s.Size(); }

    namespace literals
    {
        inline String operator"" _s(const char32_t *str, size_t len)
        {
            return String{std::u32string{str, len}};
        }
    }
}

#include <CRNStringPtr.h>

namespace std
{
    inline void swap(crn::String &s1, crn::String &s2) noexcept { s1.Swap(s2); }

    template<> struct hash<crn::String>
    {
        inline size_t operator()(const crn::String&s) const { return hash<u32string>{}(s.Std()); }
    };
}

#include <ostream>
template<typename traits> inline std::basic_ostream<char, traits>& operator<<(std::basic_ostream<char, traits> &strm, const crn::String &s)
{
    strm << s.CStr();
    return strm;
}

#endif