RefPtr.h

См. документацию.

/*
 * CntmLib - Подсчет ссылок, потоки, синхронизация, асинхронные процедуры, события
 * Copyright (c) 2005, Овсеевич Роман, CntmLib@mail.ru
 * _______________________________________________________________________________
 * Разрешено свободное использование, копирование, распространение, изменение
 * (изменение сведений об авторских правах запрещено). Запрещена продажа и
 * включение всей библиотеки или ее частей в другие библиотеки. В сведениях об
 * авторских правах на программу (или сведениях о программе, об авторах,
 * использованных средствах разработки и т.д.) должна быть указана информация
 * о библиотеке CntmLib, ее авторе и, возможно, сайте или email'е.
 * Библиотека поставляется "как есть", без каких-либо гарантий со стороны автора.
 */

#ifndef CNTM_REFPTR_H
#define CNTM_REFPTR_H
#include <cstddef>
#include <typeinfo>
#include <Cntm/Exceptions/IllegalStateException.h>

namespace Cntm
{

        namespace SpecUtils {}

        /**
         * Специальный ссылочный указатель для автоматизации подсчета ссылок на объекты. 
         * 
         * На данный момент указатель может работать с двумя типами объектов:
         * - объектов с полной поддержкой подсчета ссылок, классы которых реализуют интерфейс Cntm::IRefObject;
         * - всех прочих типов объектов - для них подсчет ссылок не производится (такая возможность реализована, чтобы была возможность использовать остальные средства библиотеки с объектами без подсчета ссылок).
         * 
         * Для ссылочных классов, наследующих Cntm::IRefObject, Cntm::RefBase, Cntm::RefBaseEx принцип работы ссылочного указателя следующий: при присвоении указателю ссылки он увеличивает кол-во ссылок на присваиваемый объект и уменьшает на тот объект, на который он ссылался до присвоения.
         *
         * Пример:
         * \code
         * // Использование RefPtr(Type* Src). В конструкторе кол-во ссылок устанавливается в 0,
         * // при присвоении ссылочному указателю p1 кол-во ссылок увеличивается до 1.
         * Class1::Ptr p1 = new Class1(Arg1);
         * Class1::Ptr p2 = p1; // Копирование указателя увеличивает кол-во ссылок до 2.
         * 
         * // Присваивание обычному указатель - кол-во ссылок на новый объект = 0. 
         * Class1* c1 = new Class1(Arg3);
         * Class1::Ptr p3 = c1; // Кол-во ссылок на второй объект увеличивается до 1.
         * // Замена значения указателя увеличивает кол-во ссылок на первый объект до 3, 
         * // а на второй - до 0, что приводит к его автоматическому уничтожению.
         * p3 = p2; 
         * \endcode
         * Более полная информация приведена в описании классов Cntm::IRefObject, Cntm::RefBase, Cntm::RefBaseEx.
         *
         * Данный класс обеспечивает многопоточность.
         * @author Овсеевич Р.
         * \ingroup RefCount
         */
        template < typename T >
        class RefPtr
        {
        public:

                template < typename T2 > friend class RefPtr;

                typedef T Type;

                /**
                 * Конструктор без параметров. Инициализирует указатель в NULL.
                 */
                RefPtr(): pointer(NULL) {CheckCompleteType();}

                /**
                 * Конструктор. Использует указатель на объект. Увеличивает кол-во ссылок на объект, если он не NULL.
                 * 
                 * Данный конструктор следует использовать при создании объекта с помощью new или при преобразовании "this" в RefPtr. Во всех прочих случаях конструктор должен использоваться с осторожностью.
                 */
                RefPtr(const Type* Src): pointer(NULL)
                {
                        using namespace SpecUtils;
                        CheckCompleteType();
                        RefPtrInitFromRefPtr(pointer,
                                GetRefPtrProxy(Src, const_cast<Type*>(Src)),
                                GetRefPtrPtrProxy(pointer, &pointer));
                }

                /**
                 * Конструктор копирования. Использует ссылочный указатель на объект. Увеличивает кол-во ссылок на объект, если он не NULL.
                 */
                RefPtr(const RefPtr < Type > & Src): pointer(NULL)
                {
                        using namespace SpecUtils;
                        CheckCompleteType();
                        RefPtrInitFromRefPtr(pointer,
                                GetRefPtrPtrProxy(Src.pointer, const_cast<Type**>(&Src.pointer)),
                                GetRefPtrPtrProxy(pointer, &pointer));
                }

                /**
                 * Конструктор копирования. Использует ссылочный указатель на объект совместимого типа. Увеличивает кол-во ссылок на объект, если он не NULL.
                 */
                template < typename T2 >
                RefPtr(const RefPtr < T2 > & Src): pointer(NULL)
                {
                        using namespace SpecUtils;
                        CheckCompleteType();
                        CheckCast(Src.Pointer());
                        RefPtrInitFromRefPtr(pointer,
                                GetRefPtrPtrProxy(Src.pointer, const_cast<T2**>(&Src.pointer)),
                                GetRefPtrPtrProxy(pointer, &pointer));
                }

                /**
                 * Деструктор. Уменьшает кол-во ссылок на объект, если он не NULL.
                 */
                ~RefPtr()
                {
                        using namespace SpecUtils;
                        CheckCompleteType();
                        RefPtrDeinitPtr(pointer, GetRefPtrPtrProxy(pointer, &pointer));
                }

                /**
                 * Оператор присвоения. Использует указатель на объект. Увеличивает кол-во ссылок на новый объект и уменьшает на старый, если они не NULL.
                 * 
                 * Данный оператор следует использовать при создании объекта с помощью new или при преобразовании "this" в RefPtr. Во всех прочих случаях оператор должен использоваться с осторожностью.
                 */
                RefPtr < Type > & operator = (const Type* Src)
                {
                        using namespace SpecUtils;
                        CheckCompleteType();
                        RefPtrChangeFromRefPtr(pointer,
                                GetRefPtrProxy(Src, const_cast<Type*>(Src)),
                                GetRefPtrPtrProxy(pointer, &pointer));
                        return *this;
                }

                /**
                 * Оператор присвоения. Использует ссылочный указатель на объект совместимого типа. Увеличивает кол-во ссылок на новый объект и уменьшает на старый, если они не NULL.
                 */
                template < typename T2 >
                RefPtr < Type > & operator = (const RefPtr < T2 > & Src)
                {
                        using namespace SpecUtils;
                        CheckCompleteType();
                        CheckCast(Src.Pointer());
                        RefPtrChangeFromRefPtr(pointer,
                                GetRefPtrPtrProxy(Src.pointer, const_cast<T2**>(&Src.pointer)),
                                GetRefPtrPtrProxy(pointer, &pointer));
                        return *this;
                }

                /**
                 * Оператор присвоения. Использует ссылочный указатель на объект. Увеличивает кол-во ссылок на новый объект и уменьшает на старый, если они не NULL.
                 */
                RefPtr < Type > & operator = (const RefPtr < Type > & Src)
                {
                        using namespace SpecUtils;
                        CheckCompleteType();
                        RefPtrChangeFromRefPtr(pointer,
                                GetRefPtrPtrProxy(Src.pointer, const_cast<Type**>(&Src.pointer)),
                                GetRefPtrPtrProxy(pointer, &pointer));
                        return *this;
                }

                /**
                 * Оператор разыменования, возвращает ссылку на объект.
                 */
                Type& operator* () const
                {
                        CheckCompleteType();
                        Type* tmp = pointer;
#ifndef CNTM_NO_DEREFERENCE_CHECK
                        if (!tmp) throw IllegalStateException(std::string("Разыменование указателя на объект Cntm::RefPtr{") + typeid(Type).name() + "}::operator*()", "Ссылочный указатель не указывает на объект, использование ссылок на NULL запрещено");
#endif //CNTM_NO_DEREFERENCE_CHECK
                        return *tmp;
                }

                /**
                 * Оператор доступа к членам.
                 */
                Type* operator-> () const
                {
                        CheckCompleteType();
                        Type* tmp = pointer;
#ifndef CNTM_NO_DEREFERENCE_CHECK
                        if (!tmp) throw IllegalStateException(std::string("Доступ к членам объекта Cntm::RefPtr{") + typeid(Type).name() + "}::operator->()", "Ссылочный указатель не указывает на объект, доступ к членам объекта невозможен");
#endif //CNTM_NO_DEREFERENCE_CHECK
                        return tmp;
                }

                /**
                 * Оператор преобразования к указателю.
                 */
                operator Type* () const
                {
                        CheckCompleteType();
                        return pointer;
                }

                /**
                 * Приведение к типу bool.
                 */
                operator bool () const
                {
                        CheckCompleteType(); 
                        return pointer != NULL;
                }

                /**
                 * Оператор not.
                 */
                bool operator ! () const
                {
                        CheckCompleteType(); 
                        return pointer == NULL;
                }

                /**
                 * Оператор сравнения на равенство. Использует указатель на объект.
                 */
                bool operator == (Type* Ptr) const
                {
                        CheckCompleteType(); 
                        return pointer == Ptr;
                }

                /**
                 * Оператор сравнения на равенство. Использует ссылочный указатель.
                 */
                bool operator == (const RefPtr & Ptr) const
                {
                        CheckCompleteType();
                        return pointer == Ptr.Pointer();
                }

                /**
                 * Оператор сравнения на равенство. Использует ссылочный указатель.
                 */
                template < typename T2 >
                bool operator == (const RefPtr < T2 > & Ptr) const
                {
                        CheckCompleteType();
                        return pointer == Ptr.Pointer();
                }

                /**
                 * Оператор сравнения на неравенство. Использует указатель на объект.
                 */
                bool operator != (Type* Ptr) const { CheckCompleteType(); return pointer != Ptr; }

                /**
                 * Оператор сравнения на неравенство. Использует ссылочный указатель.
                 */
                bool operator != (const RefPtr & Ptr) const
                {
                        CheckCompleteType();
                        return pointer != Ptr.Pointer();
                }

                /**
                 * Оператор сравнения на неравенство. Использует ссылочный указатель.
                 */
                template < typename T2 >
                bool operator != (const RefPtr < T2 > & Ptr) const
                {
                        CheckCompleteType();
                        return pointer != Ptr.Pointer();
                }

                /**
                 * Оператор <. Использует ссылочный указатель.
                 */
                bool operator < (const RefPtr & Ptr) const
                {
                        CheckCompleteType();
                        return pointer < Ptr.Pointer();
                }

                /**
                 * Оператор <=. Использует ссылочный указатель.
                 */
                bool operator <= (const RefPtr & Ptr) const
                {
                        CheckCompleteType();
                        return pointer <= Ptr.Pointer();
                }

                /**
                 * Оператор >. Использует ссылочный указатель.
                 */
                bool operator > (const RefPtr & Ptr) const
                {
                        CheckCompleteType();
                        return pointer > Ptr.Pointer();
                }

                /**
                 * Оператор >=. Использует ссылочный указатель.
                 */
                bool operator >= (const RefPtr & Ptr) const
                {
                        CheckCompleteType();
                        return pointer >= Ptr.Pointer();
                }

                /**
                 * Возвращает пустой ссылочный указатель.
                 */
                static RefPtr < Type > Null()
                {
                        CheckCompleteType();
                        return RefPtr();
                }

                /**
                 * Операция статического приведения типов ссылочных указателей. Соответствует static_cast для обычных указателей.
                 *
                 * Пример: Class1::Ptr p1(new Class1); Class2::Ptr p2 = Class2::Ptr::StaticCast(p1);
                 */
                template < typename SrcT >
                static RefPtr < Type > StaticCast(const RefPtr < SrcT > & Src)
                {
                        CheckCompleteType();
                        RefPtr<SrcT> tmp = Src;
                        return RefPtr(static_cast<Type*>(tmp.Pointer()));
                }

                /**
                 * Операция динамического приведения типов ссылочных указателей. Соответствует dynamic_cast для обычных указателей.
                 *
                 * Пример: Class1::Ptr p1(new Class1); Class2::Ptr p2 = Class2::Ptr::DynamicCast(p1);
                 */
                template < typename SrcT >
                static RefPtr < Type > DynamicCast(const RefPtr < SrcT > & Src)
                {
                        CheckCompleteType();
                        RefPtr<SrcT> tmp = Src;
                        return RefPtr(dynamic_cast<Type*>(tmp.Pointer()));
                }

                /**
                 * Получить указатель на объект.
                 */
                Type* Pointer() const { return pointer; }

                /**
                 * Проверка на NULL.
                 */
                bool IsNull() const { CheckCompleteType(); return pointer == NULL; }

                /**
                 * Возвращает true, если тип Type унаследован от IRefObject, т.е. объект подсчитывает ссылки на себя, false - в противном случае.
                 */
                bool IsRefObject()
                {
                        using namespace SpecUtils;
                        CheckCompleteType();
                        return RefPtrIsRefObject(pointer);
                }

                /**
                 * Операция присвоения NULL. Уменьшает кол-во ссылок на старый объект, если он не NULL.
                 */
                void SetNull()
                {
                        CheckCompleteType();
                        SetPointer(NULL);
                }

                /**
                 * Операция присвоения указателя на объект. Увеличивает кол-во ссылок на новый объект и уменьшает на старый, если они не NULL.
                 * 
                 * Данный метод следует использовать при создании объекта с помощью new или при преобразовании "this" в RefPtr. Во всех прочих случаях метод должен использоваться с осторожностью.
                 */
                void SetPointer(Type* Src)
                {
                        using namespace SpecUtils;
                        CheckCompleteType();
                        RefPtrChangeFromRefPtr(pointer,
                                GetRefPtrProxy(Src, Src),
                                GetRefPtrPtrProxy(pointer, &pointer));
                }

                /**
                 * Операция присвоения указателя на объект. Не уменьшает кол-во ссылок на старый объект и не увеличивает кол-во ссылок на новый.
                 * 
                 * Данный метод может использоваться для перевода объекта на ручное управление ссылками.
                 * 
                 * Использовать данный метод следует только в случае крайней необходимости, т.к. он нарушает идеологию подсчета сылок.
                 */
                void SetPointerWithoutRefCounting(Type* Src)
                {
                        using namespace SpecUtils;
                        CheckCompleteType();
                        RefPtrChangeFromPtrWithoutRefCounting(pointer,
                                GetRefPtrProxy(Src, Src),
                                GetRefPtrPtrProxy(pointer, &pointer));
                }

        private:

                /**
                 * Обычный указатель на объект.
                 */
                Type* pointer;

                /**
                 * Метод предназначен для проверки приводимости других типов к типу Type во время компиляции.
                 */
                static void CheckCast(Type* Ptr) {}

                /**
                 * Метод предназначен для проверки того, что тип Type полностью определен на момент инстанциации шаблона. Проверка делается для того, чтобы избежать ошибок, когда тип еще не определен, но уже объявлен, т.к. RefPtr работает с типом как с произвольным, потому что на момент инстанциации неизвестно, что тип наследует RefBase.
                 */
                static int CheckCompleteType() { return sizeof(Type); }
        };

}

#endif //CNTM_REFPTR_H

---