MainSynchroSpace.cpp

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

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

#include <Cntm/Synchro/MainSynchroSpace.h>
#include <Cntm/Synchro/LoopInNoMainThreadException.h>
#include <Cntm/Synchro/NoReentrantModeException.h>

// Implement //////////////////////////////////////////////////////////////////////////////////////////////////////////////////

Cntm::MainSynchroSpace::Implement::Implement(): 
        instance(NULL), stopping(false), runned(false)
{
        if (!SynchroSpace::SetMainSynchroSpaceFactory(this))
                throw IllegalStateException("Cntm::MainSynchroSpace::Begin", "Попытка повторного создания главного синхропространства");
        holdInstance = SynchroSpace::Main(); // Получаем свою собственную ссылку на главное синхропространство.
}

Cntm::SynchroSpace::Ptr Cntm::MainSynchroSpace::Implement::QueryMainInstance()
{
        // Сначала пытаемся воспользоваться указателем, который храним на время работы.
        SynchroSpace::Ptr res = holdInstance;
        if (res) return res;

        // Инициализируем ссылочный указатель из обычного. Если объект не существует
        // или он находится в состоянии удаления, то создаем новый объект.
        boost::recursive_mutex::scoped_lock lock(instanceMutex);
        res.SetPointer(instance);
        if (!res)
        {
                res = new MainSynchroSpace();
                instance = res.Pointer();
        }
        return res;
}

void Cntm::MainSynchroSpace::Implement::Start()
{
        DoEnter(); // Вход в синхропространство для инициализации.
}

void Cntm::MainSynchroSpace::Implement::Run()
{
        // Проверки.
        if (!MainSynchroSpace::IsMainThread())
                throw LoopInNoMainThreadException("Cntm::MainSynchroSpace::Run", "Метод Cntm::MainSynchroSpace::Run должен вызываться из главного потока");

        if (runned)
                throw NoReentrantModeException("Cntm::MainSynchroSpace::Run", "Cntm::MainSynchroSpace не допускает реентерабельный вход");

        DoLeave(); // Перед запуском цикла выходим из синхропространства (вошли в Begin'е).
        
        runned = true; // Блокировка реентерабельного входа.
        
        // Цикл приложения.
        do
        {
                ProcessQueue();
        }
        while (!stopping);
        
        stopping = false; // Сбрасываем флаг останова для последующих запусков.
        runned = false; // Разблокировка входа.

        DoEnter(); // Вход в синхропространство для деинициализации.
}

void Cntm::MainSynchroSpace::Implement::Finish()
{
        // Проверки.
        if (!MainSynchroSpace::IsMainThread())
                throw LoopInNoMainThreadException("Cntm::MainSynchroSpace::End", "Метод Cntm::MainSynchroSpace::End должен вызываться из главного потока");

        DoLeave(); // Перед запуском цикла выходим из синхропространства (вошли в Run'е).

        holdInstance.SetNull(); // Освобождаем свою ссылку на главное синхропространство.
        
        // Запускаем цикл обработки событий пока остается главное синхропространство.
        while (instance)
                ProcessQueue();
}

void Cntm::MainSynchroSpace::Implement::Stop()
{
        stopping = true;
        signalFlag.Set();
}

void Cntm::MainSynchroSpace::Implement::MainInstanceDeleted(MainSynchroSpace* Inst) 
{
        // Если синхропространство не было пересоздано когда текущее пространство находилось в удаляемом состоянии,
        // сбрасываем указатель и посылаем сообщение о выходе из цикла обработки сообщений. Если пространство было
        // пересоздано, то указатель трогать не надо, а о выходе сообщит новое пространство при своем удалении.
        boost::recursive_mutex::scoped_lock lock(instanceMutex);
        if (instance == Inst)
        {
                instance = NULL;
                signalFlag.Set();
        }
}

void Cntm::MainSynchroSpace::Implement::ProcessQueue()
{
        signalFlag.Wait(true, 0);
        DoEnter();
        taskQueue.Exec();
        DoLeave();
}


// QTMainSynchroSpace /////////////////////////////////////////////////////////////////////////////////////////////////////////

Cntm::MainSynchroSpace::Implement* Cntm::MainSynchroSpace::implement;

void Cntm::MainSynchroSpace::Begin()
{
        implement = new Implement;
        implement->Start();
}

---