Saf/Mem/SharedPtr.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_MEM_SHAREDPTR_H
#define SAF_MEM_SHAREDPTR_H

#include <typeinfo>
#include "../Type.h"
#include "../OverflowException.h"
#include "../InvalidOperationException.h"
#include "../InvalidCastException.h"
#include "../ArgumentNullException.h"
#include "../Type/Limits.h"

namespace Saf
{
    namespace Mem
    {
        template <class T> 
        class SharedPtr
        {
        private:
            Size *m_refCounter;
            T *m_ptr;

        public:
            SharedPtr() 
                : m_refCounter(nullptr), m_ptr(nullptr)
            {}

            explicit SharedPtr(T *ptr) 
                : m_refCounter(nullptr), m_ptr(nullptr)
            { 
                Bind(ptr);
            }

            SharedPtr(const SharedPtr<T> &p)
                : m_refCounter(nullptr), m_ptr(nullptr)
            {
                *this = p;
            }

            ~SharedPtr()
            {
                Free();
            }

            SharedPtr<T>& operator=(const SharedPtr<T>& p)
            {
                if (&p != this)
                {
                    Free();

                    if (p.m_refCounter != nullptr)
                    {                    
                        if (*p.m_refCounter == Type::Limits<Size>::Max())
                        {
                            throw OverflowException(SAF_SOURCE_LOCATION, 
                                "Reference counter overflow.");
                        }

                        m_ptr = p.m_ptr;
                        m_refCounter = p.m_refCounter;
                        (*m_refCounter)++;
                    }
                }

                return *this;
            }

            void Swap(SharedPtr<T>& p)
            {
                if (this != &p)
                {
                    Algo::Swap(m_ptr, p.m_ptr);
                    Algo::Swap(m_refCounter, p.m_refCounter);
                }
            }

            SharedPtr<T>& Bind(T *ptr)
            {            
                if (ptr == nullptr)
                {
                    throw ArgumentNullException(SAF_SOURCE_LOCATION, "Binding a null pointer.");
                }

                if (m_ptr == ptr)
                {
                    throw InvalidOperationException(SAF_SOURCE_LOCATION, 
                        "Binding a pointer that has been already binded.");
                }

                Free();

                m_refCounter = SAF_NEW Size(1);
                m_ptr = ptr;

                return *this;
            }

            SharedPtr<T>& BindWithCounter(T *ptr, Size *counter)
            {            
                if (ptr == nullptr)
                {
                    throw ArgumentNullException(SAF_SOURCE_LOCATION, "Binding a null pointer.");
                }

                if (m_ptr == ptr)
                {
                    throw InvalidOperationException(SAF_SOURCE_LOCATION, 
                        "Binding a pointer that has been already binded.");
                }

                if (counter == nullptr)
                {
                    throw ArgumentNullException(SAF_SOURCE_LOCATION, "Counter is a null pointer.");
                }

                if (*counter == Type::Limits<Size>::Max())
                {
                    throw OverflowException(SAF_SOURCE_LOCATION, "Reference counter overflow.");
                }

                Free();
            
                m_ptr = ptr;
                m_refCounter = counter;
                (*m_refCounter)++;

                return *this;
            }

            void Free() 
            { 
                if (m_refCounter != nullptr)
                {
                    if (*m_refCounter > 1)
                    {
                        (*m_refCounter)--;
                        m_refCounter = nullptr;
                        m_ptr = nullptr;
                    }
                    else
                    {
                        Mem::Delete(m_refCounter);
                        Mem::Delete(m_ptr);
                    }
                }
            }

            template <class C>
            SharedPtr<C> Cast()
            {
                Ptr<C> p;

                if (m_refCounter != nullptr)
                {
                    C *np = dynamic_cast<C *>(m_ptr);

                    if (np == nullptr)
                    {
                        throw InvalidCastException(SAF_SOURCE_LOCATION);
                    }

                    p.BindWithCounter(np, m_refCounter);
                }

                return p;
            }

            bool IsNull() const 
            { 
                return m_ptr == nullptr;
            }

            T* Get()
            { 
                return m_ptr;
            }

            const T* Get() const 
            { 
                return m_ptr;
            }

            T *operator->()
            { 
                return m_ptr; 
            }

            const T *operator->() const 
            { 
                return m_ptr; 
            }

            T& operator*()
            {
                return *m_ptr;
            }

            const T& operator*() const
            {
                return *m_ptr;
            }
        };
    }

    namespace Algo
    {
        // Swap specialization for pointer container.
        template <class T>
        struct SwapFunc< Ptr<T> >
        {
            void operator()(Ptr<T>& x, Ptr<T>& y)
            {
                x.Swap(y);
            }
        };
    }
}

#endif