GxSysBase.h

Go to the documentation of this file.

//===========================================================================
//===========================================================================
#pragma once
 
GX_CORE_NAMESPACE_BEGIN()
 
//===========================================================================
//===========================================================================
class GxSysBase : public GxClassBase
{
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    // RTTI定義
    GX_RTTI_ABSTRACT_CLASS(GxSysBase, GxClassBase)
    // GxClassBase継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE(GxSysBase)
    // new, delete定義
    GX_OPERATOR_NEW_DELETE(GxAllocatorList::ALLOCATOR_TYPE::SYSTEM)
 
protected:
    enum class LOCK_TYPE
    {
        SEQUENTIAL_THREAD_SAFE, 
        THREAD_SAFE,            
    };
 
    class GxScopeLock;
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    GxSysBase(void) : _pModules(nullptr){}
    ~GxSysBase(void) override {}
 
    virtual b32 initialize(const GxClassBase* pInitialiInformation = nullptr);
    virtual void terminate(void);
protected:
    void terminateGxModules(void);
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    virtual void update(void);
protected:
    void lock(LOCK_TYPE type = LOCK_TYPE::THREAD_SAFE);
    void unlock(LOCK_TYPE type = LOCK_TYPE::THREAD_SAFE);
 
    template<typename T> T* addModule(void)
    {
        if (!_pModules)
        {
            _pModules = GX_NEW GxArrayClassBase;
        }
#if GX_DEVELOP
        for (auto* pModule : *_pModules)
        {
            if (static_cast<GxModSysBase*>(pModule)->getRtti().isDerived(T::GX_RTTI)
                || T::GX_RTTI.isDerived(static_cast<GxModSysBase*>(pModule)->getRtti()))
            {
                GX_ERROR(false, "Module(%s) is already craeted", T::GX_RTTI.getName());
                return nullptr;
            }
        }
#endif //GX_DEVELOP
        if (getRtti().isDerived(T::getOwnerDerivedRtti()))
        {
            auto pModule = static_cast<T*>(T::GX_RTTI.GX_CREATE_INSTANCE());
            GX_ASSERT(pModule, "Module(%s) create error", T::GX_RTTI.getName());
            pModule->setOwner(this);
            _pModules->addBottom(pModule);
            return pModule;
        }
        return nullptr;
    }
 
    template<typename T> void removeModule(void)
    {
        if (_pModules)
        {
            for (u32 i = 0; i < _pModules->getCount(); i++)
            {
                auto* pModule = static_cast<GxModSysBase*>((*_pModules)[i]);
                if (pModule->getRtti() == T::GX_RTTI)
                {
                    _pModules->remove(i);
                    GX_SAFE_DELETE(pModule);
                    break;
                }
            }
        }
    }
public:
    b32  isLocked(void);
    void sleep(f32 time);
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    template<typename T> T* getModule(void) const
    {
        if (_pModules)
        {
            for (auto* pModule : *_pModules)
            {
                if (static_cast<GxModSysBase*>(pModule)->getRtti() == T::GX_RTTI)
                {
                    return static_cast<T*>(pModule);
                }
            }
        }
        return nullptr;
    }
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
private:
    GxCriticalSection   _criticalSection;   
    GxArrayClassBase*   _pModules;          
 
};
 
//===========================================================================
//===========================================================================
class GxSysBase::GxScopeLock
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GxScopeLock(GxSysBase* pSystem, GxSysBase::LOCK_TYPE type = LOCK_TYPE::THREAD_SAFE) : _pSysBase(pSystem), _type(type) { _pSysBase->lock(type); }
    virtual ~GxScopeLock(void) { _pSysBase->unlock(_type); }
 
    GX_PROHIBIT_COPY(GxScopeLock)
 
    
    //-----------------------------------------------------------
    //-----------------------------------------------------------
private:
    GxSysBase*              _pSysBase;  
    GxSysBase::LOCK_TYPE    _type;      
 
};
 
GX_CORE_NAMESPACE_END()