cAppState.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cAppState_H
#define _INC_cAppState_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "cSingleton.h"
#include "cString.h"
#include "cObject.h"
#include "cArrayString.h"
#include "cFilePath.h"
#include "cThreadLocalSys.h"
#include "cThreadLock.h"
#include "cBits.h"
#include "cOSProcess.h"
#include "cUnitTestDecl.h"
 
namespace Gray
{
        UNITTEST2_PREDEF(cAppState);
 
        enum APPSTATE_TYPE_
        {
                APPSTATE_Init,          
                APPSTATE_RunInit,       
                APPSTATE_Run,           
                APPSTATE_RunExit,       
                APPSTATE_Exit,          
                APPSTATE_QTY,
        };
 
        typedef const FILECHAR_t* const* APP_ARGS_t;    
 
        class GRAYCORE_LINK cAppArgs
        {
 
        private:
                cStringF m_sArguments;                                  
        public:
                cArrayString<FILECHAR_t> m_asArgs;              
 
        private:
                void InitArgsInt(ITERATE_t argc, APP_ARGS_t ppszArgs);
 
        public:
                static inline bool IsArgSwitch(wchar_t ch) noexcept
                {
                        return ((ch) == '-' || (ch) == '/');
                }
 
                cStringF get_ArgsStr() const noexcept;
                ITERATE_t get_ArgsQty() const noexcept;
                cStringF GetArgsEnum(ITERATE_t i) const;        
 
                void InitArgsF(const FILECHAR_t* pszCommandArgs, const FILECHAR_t* pszSep = nullptr);
                void InitArgs2(int argc, APP_ARGS_t argv);
 
                ITERATE_t FindCommandArg(const FILECHAR_t* pszCommandArg, bool bRegex = true, bool bIgnoreCase = true) const;
                ITERATE_t _cdecl FindCommandArgs(bool bIgnoreCase, const FILECHAR_t* pszCommandArgFind, ...) const;
 
                bool HasCommandArg(const FILECHAR_t* pszCommandArg, bool bRegex = true, bool bIgnoreCase = true) const
                {
                        ITERATE_t iRet = FindCommandArg(pszCommandArg, bRegex, bIgnoreCase);
                        return (iRet >= 0);
                }
        };
 
        class GRAYCORE_LINK cAppState : public cSingleton<cAppState>
        {
 
                friend class cSingleton < cAppState >;
                friend class cAppImpl;
                friend class cAppStateMain;
                friend class cUnitTestAppState;
 
        public:
                const cObjectSignature<> m_Sig;         
                cThreadLocalSysT<bool> m_ThreadModuleLoading;   
                cAppArgs m_Args;                
                cBitmask<> m_ArgsValid;                 
                static HMODULE sm_hInstance;    
 
        protected:
                THREADID_t m_nMainThreadId;             
                APPSTATE_TYPE_ m_eAppState;             
 
                cString m_sUserName;                    
                cStringF m_sTempDir;                    
                bool m_bTempDirWritable;                
 
        protected:
                cAppState();
                virtual ~cAppState();
 
        public:
                static cStringF GRAYCALL get_AppFilePath();                     
                static cStringF GRAYCALL get_AppFileTitle();            
                static cStringF GRAYCALL get_AppFileDir();
 
                static HRESULT inline CheckValidSignature(UINT32 nGrayCoreVer, size_t nSizeofThis)
                {
 
                        const cAppState* const pApp = get_SingleU();
                        if (!cMem::IsValidApp(pApp))
                        {
                                // Something is wrong. No idea.
                                return HRESULT_WIN32_C(ERROR_INTERNAL_ERROR);
                        }
                        if (nGrayCoreVer != _INC_GrayCore_H || !pApp->m_Sig.IsValidSignature(nGrayCoreVer, nSizeofThis))
                        {
                                // My *Core DLL is not the correct version or packing is incorrect!
                                return HRESULT_WIN32_C(ERROR_PRODUCT_VERSION);
                        }
                        return S_OK;    // Things seem good.
                }
 
                APPSTATE_TYPE_ get_AppState() const noexcept
                {
                        return m_eAppState;
                }
                static APPSTATE_TYPE_ GRAYCALL GetAppState();
                void put_AppState(APPSTATE_TYPE_ eAppState) noexcept
                {
                        m_eAppState = eAppState;
                }
                void InitAppState() noexcept;
 
                THREADID_t get_MainThreadId() const noexcept
                {
                        return m_nMainThreadId;
                }
 
                static bool GRAYCALL isInCInit();
                static bool GRAYCALL isAppRunning();
                static bool GRAYCALL isAppStateRun();
                static bool GRAYCALL isInCExit();
 
                static bool GRAYCALL isDebuggerPresent();
                static bool GRAYCALL isRemoteSession();
                static void GRAYCALL SetExecutionState(bool bActiveCPU, bool bActiveGUI);
 
                static bool GRAYCALL isCurrentUserAdmin();
                static cString GRAYCALL GetCurrentUserName(bool bForce = false);
                static cStringF GRAYCALL GetCurrentUserDir(const FILECHAR_t* pszSubFolder = nullptr, bool bCreate = true);              
 
                static PROCESSID_t GRAYCALL get_CurrentProcessId()
                {
#ifdef _WIN32
                        return ::GetCurrentProcessId();
#elif defined(__linux__)
                        return ::getpid();
#else
#error NOOS
                        return PROCESSID_BAD;
#endif
                }
 
                static HMODULE GRAYCALL get_HModule();
 
                static UINT GRAYCALL get_LibVersion();                  
 
                static StrLen_t GRAYCALL GetEnvironStr(const FILECHAR_t* pszVarName, FILECHAR_t* pszValue, StrLen_t iLenMax) noexcept;
                static cStringF GRAYCALL GetEnvironStr(const FILECHAR_t* pszVarName) noexcept;  
                static ITERATE_t GRAYCALL GetEnvironArray(cArrayString<FILECHAR_t>& a);
                static bool GRAYCALL SetEnvironStr(const FILECHAR_t* pszVarName, const FILECHAR_t* pszVal);
 
                static StrLen_t GRAYCALL GetCurrentDir(FILECHAR_t* pszDir, StrLen_t iSizeMax);
                static cStringF GRAYCALL get_CurrentDir();      
                static bool GRAYCALL SetCurrentDir(const FILECHAR_t* pszDir);
 
                // cStringF GetUserHomeDir();
                // cStringF GetUserHomeAppDir();
 
                cStringF get_TempDir();
                cStringF GetTempFile(const FILECHAR_t* pszFileTitle);
                cStringF GetTempDir(const FILECHAR_t* pszFileDir, bool bCreate = true);
 
                void SetArgValid(ITERATE_t i);
                cStringF get_InvalidArgs() const;
 
                void InitArgsF(const FILECHAR_t* pszCommandArgs);
                void InitArgs2(int argc, APP_ARGS_t argv);
 
                static void GRAYCALL AbortApp(APP_EXITCODE_t uExitCode = APP_EXITCODE_ABORT);
 
                CHEAPOBJECT_IMPL;
                UNITTEST_FRIEND(cAppState);
        };
 
        class GRAYCORE_LINK cAppStateMain
        {
        public:
                cAppState& m_AppState;
 
        public:
#if defined(_WIN32)
                cAppStateMain(HINSTANCE hInstance, const FILECHAR_t* pszCommandArgs);
#endif
                cAppStateMain(int argc, APP_ARGS_t argv);
                ~cAppStateMain() noexcept
                {
                        m_AppState.put_AppState(APPSTATE_Exit); // destructors should be called next.
                }
        };
 
        class cAppStateModuleLoad
        {
        public:
                cAppStateModuleLoad()
                {
                        cAppState& I = cAppState::I();
                        ASSERT(!I.m_ThreadModuleLoading.GetData());
                        I.m_ThreadModuleLoading.PutData(true);
                }
                ~cAppStateModuleLoad()
                {
                        cAppState& I = cAppState::I();
                        ASSERT(I.m_ThreadModuleLoading.GetData());
                        I.m_ThreadModuleLoading.PutData(false);
                }
        };
 
        class GRAYCORE_LINK cAppExitCatcher : public cSingletonStatic < cAppExitCatcher >
        {
        private:
                static void __cdecl ExitCatchProc();
        protected:
                virtual void ExitCatch();
        public:
                cAppExitCatcher();
                ~cAppExitCatcher();
        };
}
#endif // _INC_cAppState_H