SynchroRefHandleFn.h

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

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

#ifndef CNTM_SYNCHROREFHANDLEFN_H
#define CNTM_SYNCHROREFHANDLEFN_H
#include <Cntm/RefUtils/Internal/SynchroRefHandleRefImplementation.h>
#include <Cntm/RefUtils/Internal/BasicRefHandle.h>
#include <Cntm/Synchro/SynchroObject.h>

namespace Cntm
{       

        /**
         * Механизм хэндлов предназначен для автоматизации вызова определенного метода объекта при уничтожении последнего хэндла, связанного с объектом.
         * 
         * Отличием данного класса от SynchroRefHandle является то, что задается не метод, а функция, принимающая ссылочный указатель на класс в качестве параметра.
         * 
         * Данный класс является шаблоном, первым параметром которого является тип объекта, а вторым - указатель на функцию, которую следует вызвать. Функция должна иметь сигнатуру void(RefPtr<T>). При вызове данной функции гарантируется, что переданный указатель никогда не будет содержать NULL значения.
         * 
         * Указанный в шаблоне метод может вызываться многократно. Это происходит, если после уничтожения всех хэндлов, связанных с объектом и вызова указанного метода, вновь будут созданы хэндлы, связанные с объектом.
         * 
         * Отличием данного класса от RefHandleFn является то, что гарантируется синхронизированный отложенный вызов указанного в шаблоне метода. Это приводит к тому, что объект, с которым связан хэндл, может быть только синхрообъектом.
         * 
         * Особенность вызова указанной в шаблоне функции. Если после того, как будет уничтожен последний хэндл, связанный с объектом, но до выполнения функции (она вызывается отложенно) создать новый хэндл, связанный с объектом, внутри синхропространства, к которому принадлежит объект, то гарантируется, что вызов функции будет отменен.
         * 
         * Пример:
         * \code
         * class Class1: public SynchroRefBase
         * {
         * private:
         *      static void AutoClose(RefPtr<Class1> p) {...}
         * public:
         *      typedef RefPtr<Class1> Ptr;
         *      typedef SynchroRefHandleFn<Class1, &Class1::AutoClose> Handle;
         * };
         * 
         * int main(int argc, char **argv)
         * {
         *      Cntm::QTMainSynchroSpace::Application a(argc, argv);
         * 
         *      mw = new Form1();
         *      mw->setCaption( "Form1" );
         *      mw->show();
         *      a.connect( &a, SIGNAL(lastWindowClosed()), &a, SLOT(quit()) );
         *      
         *      Class1::Ptr p(new Class1);
         * 
         *      if (Какое-то условие)
         *      {
         *              Class1::Handle h1 = p;
         *              Какието-действия с объектом p.
         *      } // Гарантируется вызов метода Close() для объекта p после уничтожения хэндла, связанного с ним.
         *      a.exec();
         * }
         * \endcode
         * 
         * Класс обеспечивает многопоточность.
         * @author Овсеевич Р.
         * \ingroup RefUtils
         */
        template < typename T, void (*FinalizeP)(RefPtr < T > )>
        class SynchroRefHandleFn: public SpecUtils::BasicRefHandle < T, SpecUtils::SynchroRefHandleRefImplementation >
        {
        public:
        
                /**
                 * Конструктор по умолчанию. Создает хэндл, не связанный ни с каким объектом. 
                 */
                SynchroRefHandleFn(): 
                        SpecUtils::BasicRefHandle<T, SpecUtils::SynchroRefHandleRefImplementation>(RefPtr<T>::Null(), FinalizeP)
                {
                        CheckTypeCast<SynchroObject*>((T*)NULL);
                }
                
                /**
                 * Конструктор. Создает хэндл, связанный с указанным объектом. 
                 */
                SynchroRefHandleFn(RefPtr<T> Object): 
                        SpecUtils::BasicRefHandle<T, SpecUtils::SynchroRefHandleRefImplementation>(Object, FinalizeP)
                {
                        CheckTypeCast<SynchroObject*>((T*)NULL);
                }
                
                /**
                 * Связывает хэндл с новым объектом. 
                 */
                SynchroRefHandleFn < T, FinalizeP > & operator = (RefPtr<T> Object)
                {
                        Assign(Object);
                        return *this;
                }
                
                /**
                 * Связывает хэндл с новым объектом. 
                 */
                void Assign(RefPtr<T> Object)
                {
                        SpecUtils::BasicRefHandle<T, SpecUtils::SynchroRefHandleRefImplementation>::Assign(Object, FinalizeP);
                }
        
                /**
                 * Делает хэндл не связанным. 
                 */
                void Unassign()
                {
                        Assign(RefPtr<T>::Null());
                }
                
        private:
        
                /**
                 * Вызывает указанный метод объекта. 
                 */
                static void Finalize(RefPtr<T> HandledObject) { (HandledObject.Pointer()->*FinalizeP)(); }
        };

}

#endif //CNTM_SYNCHROREFHANDLEFN_H

---