acedia/acedia_string.hpp

/*                                                                            *\
**                          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/>.             **
\*                                                                            */

#ifndef ACEDIA_STRING_H
#define ACEDIA_STRING_H

#include <list>
#include <string>
#include <boost/cstdint.hpp>
#include <boost/archive/text_oarchive.hpp>
#include <boost/archive/text_iarchive.hpp>

namespace acedia
{

    // forward declaration
    namespace details { class shared_string; }

    class String
    {

        details::shared_string *str;

        // detach str if needed
        void detach();

    public:

        typedef std::string::const_iterator const_iterator;

        String();

        String(const String &other);

        String(const std::string &str);

        String(const char *cstr);

        String(const char *cstr, ::size_t n);

        ~String();

        ::size_t length() const;

        inline ::size_t size() const { return length(); }

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

        inline const char &at(::size_t pos) const { return (*this)[pos]; }

        const char *c_str() const;

        bool empty() const;

        const std::string &const_str() const;

//      operator const std::string & () const { return const_str(); }

        inline bool operator<(const String &other) const
        {
            return const_str() < other.const_str();
        }

        inline bool operator<=(const String &other) const
        {
            return const_str() <= other.const_str();
        }

        inline bool operator>(const String &other) const
        {
            return const_str() > other.const_str();
        }

        inline bool operator>=(const String &other) const
        {
            return const_str() >= other.const_str();
        }

        const_iterator begin() const;

        const_iterator end() const;

        String &operator=(const String &other);

        inline bool operator==(const String &other) const
        {
            return str == other.str || const_str() == other.const_str();
        }

        inline bool operator!=(const String &other) const
        {
            return !(*this == other);
        }

        String &append(const String &str);

        String &append(const String &str, ::size_t pos, ::size_t n);

        String &append(char c);

        String &append(const char *cstr);

        String &append(const char *cstr, ::size_t n);

        String &append(const std::string &str);

        inline String &operator+=(const String &str) { return append(str); }

        inline String &operator+=(const char *cstr) { return append(cstr); }

        inline String &operator+=(char c) { return append(c); }

        void serialize(boost::archive::text_oarchive &ar,
                       const unsigned int unused) const;

        void serialize(boost::archive::text_iarchive &ar,
                       const unsigned int unused);

        void reserve(::size_t n);

        bool startsWith(const char *cString) const;

        bool startsWith(const String &str) const;

    };

/*
    // forward declarations
    namespace details
    {
        class shared_string_list;
        class StringListIteratorPrivate;
    }

    class StringList
    {

        friend class details::StringListIteratorPrivate;

        details::shared_string_list *d;

        void detach();

    public:

        StringList();

        explicit StringList(const String& firstElement);

        StringList(const StringList& other);

        ~StringList();

        ::size_t size() const;

        StringList &append(const String &str);

        bool operator==(const StringList& other) const;

        void serialize(boost::archive::text_oarchive &ar,
                       const unsigned int unused) const;
        void serialize(boost::archive::text_iarchive &ar,
                       const unsigned int unused);

    };

    class StringListIterator
    {

        details::StringListIteratorPrivate* d;

     public:

        StringListIterator(const StringList& stringList);
        ~StringListIterator();
        bool hasNext () const;
        const String& next();
        void toFront();

    };
    */

}

#endif // ACEDIA_STRING_H

---