text.hpp

Go to the documentation of this file.

/* libobby - Network text editing library
 * Copyright (C) 2005, 2006 0x539 dev group
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This program 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
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public
 * License along with this program; if not, write to the Free
 * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

#ifndef _OBBY_TEXT_HPP_
#define _OBBY_TEXT_HPP_

#include <string>
#include <list>
#include <net6/packet.hpp>
#include "ptr_iterator.hpp"
#include "user.hpp"

namespace obby
{

class text
{
public:
        typedef std::string string_type;

        typedef string_type::size_type size_type;

        static const size_type npos = string_type::npos;

protected:
        class chunk
        {
        public:
                chunk(const chunk& other);
                chunk(const string_type& string,
                      const user* author);

                chunk(const net6::packet& pack,
                      unsigned int& index,
                      const user_table& table);

                chunk(const serialise::object& obj,
                      const user_table& table);

                void serialise(serialise::object& obj) const;

                void append_packet(net6::packet& pack) const;

                void prepend(const string_type& text);

                void append(const string_type& text);

                void insert(size_type pos, const string_type& text);

                void erase(size_type pos, size_type len = npos);

                const string_type& get_text() const;

                size_type get_length() const;

                const user* get_author() const;
        protected:
                string_type m_text;
                const user* m_author;
        };

        typedef std::list<chunk*> list_type;

public:
        // TODO: Cache iterators to serveral points in the text (1/8, 1/4, ...)
        // to optimize insert, erase and other functions

        typedef ptr_iterator<
                const chunk,
                list_type,
                list_type::const_iterator
        > chunk_iterator;

        text(size_type initial_chunk_size = npos);
        text(const text& other);
        text(const string_type& string,
             const user* author,
             size_type initial_chunk_size = npos);

        text(const net6::packet& pack,
             unsigned int& index,
             const user_table& table);

        text(const serialise::object& obj,
             const user_table& table);
        ~text();

        text& operator=(const text& other);

        void serialise(serialise::object& obj) const;

        void append_packet(net6::packet& pack) const;

        void clear();

        text substr(size_type pos,
                    size_type len = npos) const;

        void insert(size_type pos,
                    const string_type& str,
                    const user* author);

        void insert(size_type pos,
                    const text& str);

        void erase(size_type pos,
                   size_type len = npos);

        void append(const string_type& str,
                    const user* author);

        void append(const text& str);

        void prepend(const string_type& str,
                     const user* author);

        void prepend(const text& str);

        size_type length() const;

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

        bool operator!=(const text& other) const;

        bool operator<(const text& other) const;

        bool operator>(const text& other) const;

        bool operator<=(const text& other) const;

        bool operator>=(const text& other) const;

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

        bool operator!=(const string_type& other) const;

        bool operator<(const string_type& other) const;

        bool operator>(const string_type& other) const;

        bool operator<=(const string_type& other) const;

        bool operator>=(const string_type& other) const;

        bool empty() const;

        chunk_iterator chunk_begin() const;

        chunk_iterator chunk_end() const;

        void set_max_chunk_size(size_type max_chunk);

        operator std::string() const;

protected:
        size_type m_max_chunk;
        list_type m_chunks;

private:
        list_type::iterator find_chunk(size_type& pos);

        list_type::const_iterator find_chunk(size_type& pos) const;

        list_type::iterator insert_chunk(list_type::iterator chunk_it,
                                         size_type& chunk_pos,
                                         const string_type& str,
                                         const user* author);

        list_type::iterator erase_chunk(list_type::iterator chunk_it,
                                        size_type pos,
                                        size_type len);

        enum compare_result {
                GREATER,

                EQUAL_OWNERMATCH,

                EQUAL,

                LESS
        };

        compare_result compare(const text& other) const;
        compare_result compare(const string_type& text) const;
};

}

#endif // _OBBY_TEXT_HPP_

---