Saf/Text/String.h

Go to the documentation of this file.

/*
    This file is part of Simple Application Framework (Saf) library.
    Copyright (C) 2010 - 2012 Ondrej Danek <ondrej.danek@gmail.com>

    This library 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 3 of the License, or
    (at your option) any later version.

    Saf 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 Simple Application Framework library. If not, 
    see <http://www.gnu.org/licenses/>.
*/

#ifndef SAF_TEXT_STRING_H
#define SAF_TEXT_STRING_H

#include "../Core.h"
#include "../Mem/Alloc.h"
#include "Char.h"
#include "../Algo/Swap.h"

namespace Saf
{
    namespace Text
    {
        class SAF_DLL_EXPORT String
        {
        private:
            Char *m_data;
            Size *m_refCounter;
            Size m_codePoints;

        protected:
            void Resize(Size sz);
            void Free();

        public:
            String()
                : m_data(nullptr), m_refCounter(nullptr), m_codePoints(0)
            {}

            String(Size count, const Char &c);

            String(const char *str);

            String(const String &str) 
                : m_data(nullptr), m_refCounter(nullptr), m_codePoints(0)
            {
                *this = str;
            }

            ~String()
            {
                Free();
            }

            String& operator=(const String &str);

            void Swap(String& s)
            {
                if (this != &s)
                {
                    Algo::Swap(m_data, s.m_data);
                    Algo::Swap(m_refCounter, s.m_refCounter);
                    Algo::Swap(m_codePoints, s.m_codePoints);
                }
            }

            Size Elements() const 
            { 
                return CodePoints();
            }

            Size CodePoints() const
            {
                return m_codePoints;
            }

            String Upper() const;

            String Lower() const;

            String Trim(bool left, bool right) const;

            String Pad(const Char &ch, Size left, Size right) const;

            String Mid(Size pos, Size sz) const;

            String Left(Size sz) const
            {
                return Mid(0, sz);
            }

            String Right(Size sz) const
            {
                return Mid(Elements() - sz, sz);
            }

            String Reverse() const;

            bool IsEmpty() const 
            { 
                return (Elements() == 0);
            }

            String operator+(const String &str) const;

            bool operator<(const String &str) const;

            bool operator==(const String &str) const;

            Char operator[](Size n) const 
            { 
                return m_data[n]; 
            }
        };
    }

    namespace Algo
    {
        // Swap specialization for strings.
        template <>
        struct SwapFunc<Text::String>
        {
            void operator()(Text::String& x, Text::String& y)
            {
                x.Swap(y);
            }
        };
    }
}

#endif