CRNString.cpp

Go to the documentation of this file.

/* Copyright 2008-2016 INSA Lyon, CoReNum, 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.cpp
 * \author Yann LEYDIER
 */

#include <CRNi18n.h>
#include <CRNString.h>
#include <CRNStringUTF8.h>
#include <CRNException.h>
#include <3rdParty/unicode/UtfConverter.h>
#include <CRNStringUTF8.h>
#include <CRNMath/CRNProp3.h>
#include <CRNData/CRNDataFactory.h>
#include <CRNProtocols.h>
#include <algorithm> // for min & max

using namespace crn;

int& String::Precision() noexcept
{
    static int precision = 16;
    return precision;
}

size_t String::NPos() noexcept
{
    return std::u32string::npos;
}

String::String(char32_t c, size_t n)
{
    data = std::u32string(n, c);
}

String::String(const StringUTF8 &s)
{
    data = UtfConverter::FromUtf8(s.Std());
}

String::String(const Prop3 &p)
{
    if (p.IsTrue())
        data = U"true";
    else if (p.IsFalse())
        data = U"false";
    else
        data = U"unknown";
}

String::String(char *s)
{
    data = UtfConverter::FromUtf8(s);
}

String::String(const char *s)
{
    data = UtfConverter::FromUtf8(s);
}

String::String(const std::string &s)
{
    data = UtfConverter::FromUtf8(s);
}

String::String(char c, size_t n)
{
    data = UtfConverter::FromUtf8(std::string(n, c));
}

char32_t& String::operator[](size_t index)
{
    if (index >= Size())
        throw ExceptionDomain(StringUTF8("char& String::operator[](size_t index): ") +
                _("index out of bounds."));
    return data[index];
}

const char32_t& String::operator[](size_t index) const
{
    if (index >= Size())
        throw ExceptionDomain(StringUTF8("const char& String::operator[](size_t index) const: ") +
                _("index out of bounds."));
    return data[index];
}

const char* String::CStr() const
{
    cdata = UtfConverter::ToUtf8(data);
    return cdata.c_str();
}

Prop3 String::ToProp3() const
{
    if (data == U"true")
        return Prop3::True();
    else if (data == U"false")
        return Prop3::False();
    else
        return Prop3::Unknown();
}

String& String::Insert(size_t pos, const String &s)
{
    if (pos == NPos())
    {
        *this += s;
        return *this;
    }
    if (pos >= Size())
    {
        throw ExceptionDomain(StringUTF8("String& String::Insert(int pos, const String &s): ") +
                _("index out of bounds."));
    }
    data.insert(pos, s.data);
    return *this;
}

String String::SubString(size_t pos, size_t n) const
{
    if ((pos >= Size()) || (pos + n > Size()))
    {
        throw ExceptionDomain(StringUTF8("String String::SubString(int pos, int n): ") +
                StringUTF8(_("index out of bounds.")) + StringUTF8(pos) +
                StringUTF8(" + ") + StringUTF8(n) + StringUTF8(" > ") + StringUTF8(Size()));
    }
    String s;
    if (n == 0)
    {
        s = data.substr(pos);
    }
    else
    {
        s = data.substr(pos, n);
    }
    return s;
}

String& String::Crop(size_t pos, size_t n)
{
    *this = SubString(pos, n);
    return *this;
}

String& String::Erase(size_t pos, size_t n)
{
    if ((pos >= Size()) || (pos + n > Size()))
    {
        throw ExceptionDomain(StringUTF8("String& String::Erase(int pos, int n): ") +
                _("index out of bounds."));
    }
    if (n <= 0)
        data.erase(pos);
    else
        data.erase(pos, n);
    return *this;
}

String& String::Replace(const String &s, size_t pos, size_t n)
{
    if ((pos >= Size()) || (pos + n > Size()))
    {
        throw ExceptionDomain(StringUTF8("String& String::Replace(const String &s, int pos, int n): ") +
                _("index out of bounds."));
    }
    data.replace(pos, n, s.data);
    return *this;
}

String& String::ReplaceSuffix(const String &old_suffix, const String &new_suffix)
{
    size_t old_suffix_length = old_suffix.Length();
    if (!old_suffix_length)
        throw ExceptionInvalidArgument(_("Null suffix to search."));
    size_t word_length = Length();

    if (old_suffix_length <= word_length)
    {
        size_t pivot = word_length - old_suffix_length;

        if (EndsWith(old_suffix))
        {
            data.erase(pivot);
            data.append(new_suffix.Std());
        }
    }

    return *this;
}

String& String::ReplaceSuffix(const size_t n, const String &new_suffix)
{
    size_t word_length = Length();

    if (n <= word_length)
    {
        size_t pivot = word_length - n;

        data.erase(pivot);
        data.append(new_suffix.Std());
    }

    return *this;
}

String& String::DeleteSuffix(const String &suffix)
{
    size_t suffix_length = suffix.Length();
    if (!suffix_length)
        throw ExceptionInvalidArgument(_("Null suffix to delete."));
    size_t word_length = Length();

    if (suffix_length <= word_length)
    {
        size_t pivot = word_length - suffix_length;

        if (EndsWith(suffix))
        {
            data.erase(pivot);
        }
    }

    return *this;
}

std::vector<String> String::WhichSuffixes(const std::vector<String> &suffixes) const
{
    std::vector<String> found;

    size_t n = suffixes.size();

    for (size_t k = 0; k < n; k++)
    {
        String sf = suffixes[k];

        if (EndsWith(sf))
        {
            found.push_back(sf);
        }
    }

    return found;
}

std::vector<String> String::WhichPrefixes(const std::vector<String> &prefixes) const
{
    std::vector<String> found;

    size_t n = prefixes.size();

    for (size_t k = 0; k < n; k++)
    {
        String pf = prefixes[k];

        if (StartsWith(pf))
        {
            found.push_back(pf);
        }
    }

    return found;
}

std::vector<String> String::WhichSubstrings(const std::vector<String> &substrings) const
{
    std::vector<String> found;

    for (auto str : substrings)
    {
        

        if (Find(str) != String::NPos())
        {
            found.push_back(str);
        }
    }

    return found;
}



String& String::Replace(char32_t from, char32_t to)
{
    for (auto & elem : data)
        if (elem == from)
            elem = to;
    return *this;
}

String& String::ToUpper()
{
    for (auto & elem : data)
        elem = char32_t(ToWUpper(wint_t(elem)));
    return *this;
}

String& String::FirstCharacterToUpper()
{
    data[0] = char32_t(ToWUpper(wint_t(data[0])));

    return *this;
}

String& String::ToLower()
{
    for (auto & elem : data)
        elem = char32_t(ToWLower(wint_t(elem)));
    return *this;
}

size_t String::Find(const String &s, size_t from_pos) const
{
    if (IsEmpty())
        return NPos();
    if (s.Size() > Size())
    {
        return NPos();
    }
    if (from_pos >= Size())
    {
        throw ExceptionDomain(StringUTF8("int String::Find(const String &s, int from_pos = 0) const: ") +
                _("index out of bounds."));
    }
    return data.find(s.data, from_pos);
}


bool String::StartsWith(const String &s) const
{
    size_t idx = Find(s, 0);

    if (idx == NPos())
    {
        return false;
    }
    else
    {
        if (idx == 0)
        {
            return true;
        }
        else
        {
            return false;
        }
    }
}

bool String::EndsWith(const String &s) const
{
    size_t length_main = Length();
    size_t length_suffix = s.Length();

    if (length_main < length_suffix)
    {
        return false;
    }
    else
    {
        size_t pos = length_main - length_suffix;
        size_t idx = Find(s, pos);

        return (idx == pos);
    }
}

bool String::EndsWith(const std::vector<String> &suffixes) const
{
    size_t nb_suffixes = suffixes.size();
    size_t k = 0;
    bool found = false;

    while (!found && (k < nb_suffixes))
    {
        found = EndsWith(suffixes[k]);
        k++;
    }

    return found;
}

size_t String::FindAnyOf(const String &s, size_t from_pos) const
{
    if (from_pos >= Size())
    {
        throw ExceptionDomain(StringUTF8("int String::FindAnyOf(const String &s, int from_pos = 0) const: ") +
                _("index out of bounds."));
    }

    return data.find_first_of(s.data, from_pos);
}

size_t String::FindNotOf(const String &s, size_t from_pos) const
{
    if (from_pos >= Size())
    {
        throw ExceptionDomain(StringUTF8("int String::NotOf::FindNotOf(const String &s, int from_pos = 0) const: ") +
                _("index out of bounds."));
    }

    return data.find_first_not_of(s.data, from_pos);
}

size_t String::BackwardFind(const String &s, size_t last_pos) const
{
    if (s.Size() > Size())
        return NPos();
    if (last_pos == NPos())
        return data.rfind(s.data);
    if (last_pos >= Size())
    {
        throw ExceptionDomain(StringUTF8("int String::BackwardFind(const String &s, int last_pos = -1) const: ") +
                _("index out of bounds."));
    }
    return data.rfind(s.data, last_pos);
}

size_t String::BackwardFindAnyOf(const String &s, size_t last_pos) const
{
    if (last_pos == NPos())
        return data.find_last_of(s.data);
    if (last_pos >= Size())
    {
        throw ExceptionDomain(StringUTF8("int String::BackwardFindAnyOf(const String &s, int last_pos = -1) const: ") +
                _("index out of bounds."));
    }
    return data.find_last_of(s.data, last_pos);
}

size_t String::BackwardFindNotOf(const String &s, size_t last_pos) const
{
    if (last_pos == NPos())
        return data.find_last_not_of(s.data);
    if (last_pos >= Size())
    {
        throw ExceptionDomain(StringUTF8("int String::BackwardFindNotOf(const String &s, int last_pos = -1) const: ") +
                _("index out of bounds."));
    }
    return data.find_last_not_of(s.data, last_pos);
}

int String::EditDistance(const String &s) const
{
    unsigned int s1 = (unsigned int)Size();
    unsigned int s2 = (unsigned int)s.Size();
    std::vector<std::vector<unsigned int> > d(s1 + 1, std::vector<unsigned int>(s2 + 1));

    for (unsigned int i = 1; i <= s1; ++i) d[i][0] = i;
    for (unsigned int i = 1; i <= s2; ++i) d[0][i] = i;

    for (unsigned int i = 1; i <= s1; ++i)
        for (unsigned int j = 1; j <= s2; ++j)
            d[i][j] = std::min(std::min(d[i - 1][j] + 1, d[i][j - 1] + 1),
                    d[i - 1][j - 1] + (data[i - 1] == s[j - 1] ? 0 : 1));
    return d[s1][s2];
}

void String::Deserialize(xml::Element &el)
{
    if (el.GetName() != "String")
    {
        throw ExceptionInvalidArgument(StringUTF8("void String::Deserialize(xml::Element &el): ") +
                _("Wrong XML element."));
    }
    xml::Node c(el.GetFirstChild());
    if (!c)
        return; // no content
    xml::Text t(c.AsText()); // may throw
    *this = t.GetValue();
    ShrinkToFit();
}

xml::Element String::Serialize(xml::Element &parent) const
{
    xml::Element el(parent.PushBackElement("String"));
    el.PushBackText(CStr());
    return el;
}

std::vector<String> String::Split(const String &sep) const
{
    size_t n = data.length();
    auto start = data.find_first_not_of(sep.data);
    std::vector<String> words;
    while (start < n)
    {
        auto stop = data.find_first_of(sep.data, start);
        if (stop > n) stop = n;
            words.push_back(data.substr(start, stop - start));
        start = data.find_first_not_of(sep.data, stop + 1);
    }
    return words;
}

void String::ShrinkToFit()
{
    data.shrink_to_fit();
}

crn::String String::CreateUniqueId(size_t len)
{
    return StringUTF8::CreateUniqueId(len);
}

CRN_BEGIN_CLASS_CONSTRUCTOR(String)
    CRN_DATA_FACTORY_REGISTER(U"String", String)
    Cloner::Register<String>();
    Ruler::Register<String>();
CRN_END_CLASS_CONSTRUCTOR(String)