src/acedia_string.cpp

/*                                                                            *\
**                          Copyright (C) 2009-2010                           **
**       Dominik Charousset < Dominik.Charousset (at) haw-hamburg.de >        **
**                                                                            **
**            MMM       MMMMMM   MMMMMMMMM MMMMMMM   MMM       MMM            **
**           MMMMM     MMMMMMMM  MMMMMMMMM MMMMMMMM  MMM      MMMMM           **
**          MMM MMM   MMM        MMMM      MMM   MMM MMM     MMM MMM          **
**         MMM   MMM  MMM        MMMMMMMMM MMM   MMM MMM    MMM   MMM         **
**        MMMMMMMMMMM MMMM   MMM MMMM      MMM   MMM MMM   MMMMMMMMMMM        **
**       MMM       MMM MMMMMMMM  MMMMMMMMM MMMMMMMM  MMM  MMM       MMM       **
**      MMM         MMM MMMMMM   MMMMMMMMM MMMMMMM   MMM MMM         MMM      **
**                                                                            **
**                                                                            **
** This file is part of the acedia library.                                   **
**                                                                            **
** This library 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.                                        **
**                                                                            **
** This library 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 acedia. If not, see <http://www.gnu.org/licenses/>.             **
\*                                                                            */

#define ACEDIA_REDUCED_ANNOUNCE

#include "acedia_string.hpp"
#include "acedia_atomic.hpp"

#include <cstring>

namespace acedia
{
    namespace details
    {
        // this class does explicitly not use ReferenceCounted to
        // avoid virtual members and its initial reference count is always 1
        class shared_string : public std::string
        {

            volatile boost::int32_t m_rc; // reference count

        public:

            typedef std::string super;

            inline shared_string() : super(), m_rc(1) { }

            inline shared_string(const std::string &str) :
                    super(str), m_rc(1) { }

            inline shared_string(const char *str) :
                    super(str), m_rc(1) { }

            inline shared_string(const char *str, ::size_t n) :
                    super(str, n), m_rc(1) { }

            inline void ref() { (void) atomic::addAndFetch(&m_rc, 1); }

            inline bool deref() { return 0 != atomic::addAndFetch(&m_rc, -1); }

            inline bool unique() const { return 1 == m_rc; }

            inline shared_string *deep_copy() const
            {
                return new shared_string(*this);
            }

            inline bool operator==(const shared_string &other)
            {
                return 0 == super::compare(other);
            }

        };

        /*
        class shared_string_list : public std::list<String>
        {

            volatile boost::int32_t m_rc; // reference count

        public:

            typedef std::list<String> super;

            inline shared_string_list() : super(), m_rc(1) { }

            inline void ref() { (void) atomic::addAndFetch(&m_rc, 1); }

            inline bool deref() { return 0 != atomic::addAndFetch(&m_rc, -1); }

            inline bool unique() const { return 1 == m_rc; }

            inline shared_string_list *deep_copy() const
            {
                shared_string_list *copy = new shared_string_list();
                copy->insert(copy->begin(), begin(), end());
                return copy;
            }

            inline bool operator==(const shared_string &other)
            {
                return ((super&) *this) == ((const super&) other);
            }

        };
        */

    } // namespace details

}

namespace acedia
{

    /**************************************************************************
     *                                 String                                 *
     **************************************************************************/

    String::String() : str(new details::shared_string("")) { }

    String::String(const String &other) : str(other.str) { str->ref(); }

    String::String(const std::string &stdstr) :
            str(new details::shared_string(stdstr)) { }

    String::String(const char *cstr) : str(new details::shared_string(cstr)) { }

    String::String(const char *cstr, ::size_t n) :
            str(new details::shared_string(cstr, n)) { }

    String::~String()
    {
        if (!str->deref()) delete str;
    }

    ::size_t String::length() const
    {
        return str->size();
    }

    const char &String::operator[](::size_t pos) const { return (*str)[pos]; }

    const char *String::c_str() const { return str->c_str(); }

    bool String::empty() const { return str->empty(); }

    std::string::const_iterator String::begin() const
    {
        return str->begin();
    }

    std::string::const_iterator String::end() const
    {
        return str->end();
    }

    String &String::operator=(const String &other)
    {
        if (str != other.str)
        {
            if (!str->deref()) delete str;
            str = other.str;
            str->ref();
        }
        return *this;
    }

    void String::detach()
    {
        if (!str->unique())
        {
            details::shared_string *new_str = str->deep_copy();
            if (!str->deref()) delete str;
            str = new_str;
        }
    }

    String &String::append(const String &s)
    {
        detach();
        str->append(*(s.str));
        return *this;
    }

    String &String::append(const String &s, ::size_t pos, ::size_t n)
    {
        detach();
        str->append(*(s.str), pos, n);
        return *this;
    }

    String &String::append(char c)
    {
        detach();
        (*str) += c;
        return *this;
    }

    String &String::append(const char *cstr)
    {
        detach();
        str->append(cstr);
        return *this;
    }

    String &String::append(const char *cstr, ::size_t n)
    {
        detach();
        str->append(cstr, n);
        return *this;
    }

    String &String::append(const std::string &s)
    {
        detach();
        str->append(s);
        return *this;
    }

    void String::serialize(boost::archive::text_oarchive &ar,
                   const unsigned int) const
    {
        ar << ((std::string &) *str);
    }

    void String::serialize(boost::archive::text_iarchive &ar,
                   const unsigned int)
    {
        detach();
        ar >> ((std::string &) *str);
    }

    void String::reserve(::size_t n)
    {
        detach();
        str->reserve(n);
    }

    const std::string &String::const_str() const
    {
        return (*str);
    }

    bool starts_with_impl(const char *s1, const char *s2, int len)
    {
        for (int i = 0; i < len; ++i) if (s1[i] != s2[i]) return false;
        return true;
    }

    bool String::startsWith(const char *s) const
    {
        ::size_t slen = strlen(s);
        if (length() < slen) return false;
        return starts_with_impl(s, c_str(), slen);
    }

    bool String::startsWith(const String &s) const
    {
        ::size_t l = s.length();
        if (length() < l) return false;
        return starts_with_impl(c_str(), s.c_str(), l);
    }

    /**************************************************************************
     *                               StringList                               *
     **************************************************************************/
/*
    StringList::StringList() : d(new details::shared_string_list) { }

    StringList::StringList(const String &firstElement)
            : d(new details::shared_string_list)
    {
        append(firstElement);
    }

    StringList::StringList(const StringList &other) : d(other.d)
    {
        other.d->ref();
    }

    StringList::~StringList()
    {
        if (!d->deref()) delete d;
    }

    ::size_t StringList::size() const
    {
        return d->size();
    }

    StringList &StringList::append(const String &str)
    {
        detach();
        d->push_back(str);
        return *this;
    }

    void StringList::detach()
    {
        if (!d->unique())
        {
            details::shared_string_list *nd = d->deep_copy();
            if (!d->deref()) delete d;
            d = nd;
        }
    }

    bool StringList::operator==(const StringList& other) const
    {
        if (d == other.d) return true;
        else if (size() == other.size())
        {
            StringListIterator i1(*this);
            StringListIterator i2(other);
            while (i1.hasNext())
            {
                if (i1.next() != i2.next()) return false;
            }
            return true;
        }
        return false;
    }

    void StringList::serialize(boost::archive::text_oarchive &ar,
                   const unsigned int unused) const
    {
        boost::uint32_t s = (boost::uint32_t) size();
        ar << s;
        StringListIterator i(*this);
        while (i.hasNext())
        {
            ar << i.next();
        }
    }

    // deserialization
    void StringList::serialize(boost::archive::text_iarchive &ar,
                   const unsigned int unused)
    {
        detach();
        boost::uint32_t s;
        ar >> s;
        for (boost::uint32_t i = 0; i < s; ++i)
        {
            String str;
            ar >> str;
            append(str);
        }
    }

    namespace details
    {
        class StringListIteratorPrivate
        {
            typedef std::list<String>::const_iterator NativeIterator;

            const StringList& list;
            NativeIterator* i;

         public:

            StringListIteratorPrivate(const StringList& l) : list(l), i(NULL) {}

            ~StringListIteratorPrivate()
            {
                if (i) delete i;
            }

            bool hasNext() const
            {
                if (!i)
                {
                    NativeIterator ni = list.d->begin();
                    return ni != list.d->end();
                }
                else
                {
                    NativeIterator ni = *i;
                    ++ni;
                    return ni != list.d->end();
                }
            }

            const String& next()
            {
                if (!i)
                {
                    i = new NativeIterator(list.d->begin());
                    NativeIterator& iRef = *i;
                    return *iRef;
                }
                else
                {
                    NativeIterator& iRef = *i;
                    ++iRef;
                    return *iRef;
                }
            }

            void toFront()
            {
                if (i)
                {
                    delete i;
                }
                i = NULL;
            }

        };
    }

    StringListIterator::StringListIterator(const StringList &stringList)
        : d(new details::StringListIteratorPrivate(stringList))
    {
    }

    StringListIterator::~StringListIterator() { delete d; }

    bool StringListIterator::hasNext() const
    {
        return d->hasNext();
    }

    const String& StringListIterator::next()
    {
        return d->next();
    }

    void StringListIterator::toFront()
    {
        d->toFront();
    }
*/

} // namespace acedia

---