BasicRefHandle.h

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

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

#ifndef CNTM_BASICREFHANDLE_H
#define CNTM_BASICREFHANDLE_H
#include <cstddef>
#include <utility>
#include <map>
#include <Cntm/SystemUtils/SysCriticalSection.h>
#include <Cntm/Exceptions/IllegalStateException.h>
#include <Cntm/RefCount/RefPtr.h>

namespace Cntm
{
        namespace SpecUtils
        {

                /**
                 * Базовый класс для хэндлов.
                 * @author Овсеевич Р. 
                 */
                template < typename T, typename RefImplementationT >    
                class BasicRefHandle
                {
                public:
                
                        typedef T Type;
                        
                        /**
                         * Оператор доступа к членам.
                         */
                        Type* operator -> () const
                        {
                                Type* tmp = Object().Pointer();
#ifndef CNTM_NO_DEREFERENCE_CHECK
                                if (!tmp) throw IllegalStateException("Доступ к членам объекта Cntm::SpecUtils::BasicRefHadle::operator->()", "Хэндл не связан с объектом, доступ к членам объекта невозможен");
#endif //CNTM_NO_DEREFERENCE_CHECK
                                return tmp;
                        }
                                
                        /**
                         * Оператор преобразования к ссылочному указателю. Возвращает Object().
                         */
                        operator RefPtr < Type > () const { return Object(); }
                                        
                        /**
                         * Приведение к типу bool. Возвращает Assigned().
                         */
                        operator bool () const { return Assigned(); }
                        
                        /**
                         * Оператор not. Возвращает !Assigned().
                         */
                        bool operator ! () const { return !Assigned(); }
                        
                        /**
                         * Оператор сравнения на равенство. Использует ссылочный указатель.
                         */
                        template < typename T2 >
                        bool operator == (const RefPtr < T2 > & Ptr) const { return Object() == Ptr; }
        
                        /**
                         * Оператор сравнения на равенство. Использует хэндл.
                         */
                        bool operator == (const BasicRefHandle < T, RefImplementationT > & Handle) const
                        {
                                return Object() == Handle.Object();
                        }
                        
                        /**
                         * Оператор сравнения на неравенство. Использует ссылочный указатель.
                         */
                        template < typename T2 >
                        bool operator != (const RefPtr < T2 > & Ptr) const { return Object() != Ptr; }
                        
                        /**
                         * Оператор сравнения на неравенство. Использует хэндл.
                         */
                        bool operator != (const BasicRefHandle < T, RefImplementationT > & Handle) const
                        {
                                return Object() != Handle.Object();
                        }
                        
                        /**
                         * Получить ссылочный указатель на объект, с которым связан хэндл. Если хэндл не связан, то возвращается NULL. 
                         */
                        RefPtr<T> Object() const 
                        {
                                typename Controller::Ptr tmp = controller;
                                return tmp? tmp->HandledObject() : RefPtr<T>::Null();
                        }
        
                        /**
                         * Возвращает true, если хэндл связан с объектом и false в противном случае. 
                         */
                        bool Assigned() const { return controller; }
                        
                protected:
                
                        /**
                         * Конструктор. Инициализирует контроллер. 
                         */
                        BasicRefHandle(const RefPtr<T>& HandledObject, void (*FinalizeProc)(RefPtr<T>)):
                                controller(Controller::Query(HandledObject, FinalizeProc)) {}
                        
                        /**
                         * Изменить значение. заменяет контроллер для нового объекта. 
                         */
                        void Assign(const RefPtr<T>& HandledObject, void (*FinalizeProc)(RefPtr<T>))
                        {
                                controller = Controller::Query(HandledObject, FinalizeProc);
                        }
                        
                private:
        
                        /**
                         * Класс контроллера. Обеспечивает при своем уничтожении вызов метода объекта.
                         * 
                         * Хэндл содержит указатель на контроллер. Когда хэндлов не осталось, контроллер уничтожается.
                         * 
                         * Контроллеры ведут список объектов и контроллеров в виде map. При инициализации хэндла просматривается список, если для этого объекта уже есть контроллер, то используется он, иначе создается новый. Особый случай, когда контроллер в удаляемом состоянии. В этом случае ему посылается сигнал, что бы он не выполнял вызов метода и не удалял себя из map, а в map для этого объекта помещается новый контроллер. 
                         * @author Овсеевич Р.
                         */
                        class Controller: public RefImplementationT
                        {
                        private:
        
                                typedef std::map<T*, Controller*> Map;
        
                                typedef typename std::map<T*, Controller*>::iterator Iterator;
        
                        public:
                                
                                typedef RefPtr<Controller> Ptr;
                                
                                /**
                                 * Возвращает связанный с контроллером объект, для которого будет вызван метод.
                                 */
                                RefPtr<T> HandledObject() const { return handledObject; }
                                
                                /**
                                 * Возвращает контроллер по указанному объекту. Либо создает его, либо использует существующий.
                                 */
                                static Ptr Query(const RefPtr<T>& HandledObject, void (*FinalizeProc)(RefPtr<T>))
                                {
                                        if (!HandledObject) return Ptr::Null();
                                        
                                        SysCriticalSection::Lock lck(critSection);
        
                                        // Производим попытку вставки нового значения. В любом случае нам вернется 
                                        // итератор нового или уже существующего значения в res.first, а в res.second -
                                        // true - не было, вставили, false - было.
                                        std::pair<Iterator, bool> insres = controllers.insert(std::make_pair(HandledObject.Pointer(), (Controller*)NULL));
                                        Iterator it = insres.first;
                                        
                                        // Если в списке не было контроллера для указанного объекта, то создаем и выходим.
                                        if (insres.second) return Ptr(it->second = new Controller(HandledObject, FinalizeProc, it));
                                        
                                        // Контроллер уже существует и если он не в удаляемом состоянии, то используем его.
                                        Ptr res = it->second;
                                        if (res) return res;
                                        
                                        // Контроллер в удаляемом состоянии, поэтому сообщаем старому контроллеру о том, чтобы он
                                        // не изымал из перечня свой эл-т, т.к. он будет занят новым контроллером.
                                        it->second->recreated = true;
                                        return Ptr(it->second = new Controller(HandledObject, FinalizeProc, it));
                                }
                                
                        private:
                                
                                /**
                                 * Критическая секция, которой блокируются операции со списком объектов.
                                 */
                                static SysCriticalSection critSection;
                                
                                /**
                                 * Ассоциативный список объектов и их контроллеров.
                                 */
                                static Map controllers;
                                
                                /**
                                 * Объект, которым управляет контроллер.
                                 */
                                RefPtr<T> handledObject;
                                
                                /**
                                 * Функция, которую следует вызвать при завершении.
                                 */
                                void (*finalizeProc)(RefPtr<T>);                        
        
                                /**
                                 * Итератор в ассоциативном списке объектов и их контроллеров, соответствующий данному контроллеру.
                                 */
                                Iterator iterator;
                                
                                /**
                                 * Признак того, что когда контроллер находился в удаляемом состоянии был создан новый хэндл и операции по уничтожению выполнять не надо.
                                 */
                                bool recreated;
                                
                                /**
                                 * Конструктор.
                                 */
                                Controller(const RefPtr<T>& HandledObject, void (*FinalizeProc)(RefPtr<T>), Iterator Iter):
                                        RefImplementationT(HandledObject), handledObject(HandledObject), finalizeProc(FinalizeProc), iterator(Iter), recreated(false) {}
        
                                /**
                                 * Деструктор. Изымает контроллер из списка и вызывает указанный метод. Для синхрохэндлов этот деструктор вызывается синхронизированно отложенно.
                                 */
                                ~Controller()
                                {
                                        try
                                        {
                                                SysCriticalSection::Lock lck(critSection);
        
                                                // Если был создан новый контроллер, когда этот находился в удаляемом состоянии, то 
                                                // эл-т списка контроллеров будет занят новым, и финализацию произведет тоже новый.
                                                if (recreated) return;
                                        
                                                controllers.erase(iterator);
                                                lck.Unlock();
        
                                                finalizeProc(handledObject);
                                        }
                                        catch (...) {}
                                }
                        };
        
                        /**
                         * Контроллер вызова метода. 
                         */
                        typename Controller::Ptr controller;
                };

        }
}

template < typename T, typename RefImplementationT >    
Cntm::SpecUtils::SysCriticalSection 
        Cntm::SpecUtils::BasicRefHandle < T, RefImplementationT > ::Controller::critSection;

template < typename T, typename RefImplementationT >    
typename Cntm::SpecUtils::BasicRefHandle < T, RefImplementationT > ::Controller::Map 
        Cntm::SpecUtils::BasicRefHandle < T, RefImplementationT > ::Controller::controllers;

#endif //CNTM_BASICREFHANDLE_H

---