builds/digitalwerk/solutions/adtf_content/adtf_base/adtf_core/src/libraries/a_utils/include/a_utils/sys/system.h

Go to the documentation of this file.

 
#ifndef _SYSTEM_CLASS_HEADER_
#define _SYSTEM_CLASS_HEADER_
 
namespace A_UTILS_NS
{
 
#define MAX_ETHERNET_PHYSICAL_ADDRESS_LENGTH 6
 
class DOEXPORT cSystem
{
    public:
                
        class IAdapterInfoCallback
        {
            public:
                virtual tResult HandleAdapterInfo(const tChar* strName,
                                                  const tChar* strDescription,
                                                  tUInt8* pui8PhysicalAddress) = 0;
        };
 
        class cAdapterInfo: public IAdapterInfoCallback
        {
            public:
                struct tAdapterInfo
                {
                    cString strAdapterName;
                    cString strDescription;
                    tUInt8 aui8PhysicalAddress[MAX_ETHERNET_PHYSICAL_ADDRESS_LENGTH];
                };
 
            private: 
                std::vector<tAdapterInfo> m_vecAdapters;    
 
            public:
                tResult HandleAdapterInfo(const tChar* strName,
                                          const tChar* strDescription,
                                          tUInt8* pui8PhysicalAddress)
                {
                    m_vecAdapters.resize(m_vecAdapters.size() + 1);
                    m_vecAdapters.back().strAdapterName = strName;
                    m_vecAdapters.back().strDescription = strDescription;
                    cMemoryBlock::MemCopy(m_vecAdapters.back().aui8PhysicalAddress,
                                          pui8PhysicalAddress,
                                          MAX_ETHERNET_PHYSICAL_ADDRESS_LENGTH);
                    RETURN_NOERROR;
                }
 
                tBool Empty() const
                {
                    return m_vecAdapters.empty();
                }
 
                tSize Size() const
                {
                    return m_vecAdapters.size();
                }
 
                const tAdapterInfo& At(tUInt nPos)
                {
                    return m_vecAdapters.at(nPos);
                }
        };
 
 
        static tUInt32 GetLastSystemError();
 
        static cString GetLastErrorString(const tUInt32 ui32Error);
 
        static cString GetEnvVariable(const cString& strName, const cString& strDefaultValue="");
 
        static tResult SetEnvVariable(const cString& strName, const cString& strValue);
 
        static cString GetUserName();
 
        static cString GetComputerName();
 
        static tInt32 Execute(const cFilename& strExeFile,
                              const cString& strArgs = "",
                              const cFilename& strWorkingPath ="",
                              const tBool bModal = tFalse,
                              cString* pOutput = nullptr,
                              const cFilename oStdErrForward = "");
 
        static tResult ChildExecute(tUInt64* pChildProcessId,
                                    const cFilename& strExeFile,
                                    const cString& strArgs = "");
 
        static tResult ChildWait(tUInt64 nChildProcessId, tTimeStamp tmTimeOut = -1);
 
        static tResult ChildTerminate(tUInt64 nChildProcessId);
 
        static tUInt32 OpenDocument(tHandle hWndParent,
                                    const cFilename& strFilename,
                                    const cString& strWorkingPath = "",
                                    tBool bModal = tFalse,
                                    tBool bMessage = tFalse);
 
        static tUInt32 OpenFolder(tHandle hWndParent,
                                  const cFilename& strFilename,
                                  tHandle &hProcessHandle,
                                  tBool bModal = tFalse);
 
        static tTimeStamp GetTime();
        
        static tVoid Sleep(tTimeStamp tmMicroseconds);
 
        static tResult GetMACAddress(cString& strMACAddress);
        
        static tInt GetProcessorCount();
 
        static tInt32 GetCurrentThreadId();
 
        static tUInt64 GetCurrentProcessId();
 
        static tUInt64 GetVirtualUserMemoryTotal();
 
        static tUInt64 GetVirtualUserMemoryUsed();
 
        static tUInt64 GetVirtualMemoryTotal();
 
        static tUInt64 GetVirtualMemoryUsed();
 
        static tUInt64 GetVirtualMemoryUsedByMe();
 
        static tUInt64 GetPhysicalMemoryTotal();
 
        static tUInt64 GetPhysicalMemoryUsed(tBool bIncludeCaches = tFalse);
 
        static tUInt64 GetPhysicalMemoryUsedByMe();
 
        static tResult GetMallocInfo(tUInt64& nMallocTotal, tUInt64& nMallocFree, tUInt64& nMallocUsed);
 
        static tResult HasIfaceWithMAC(const cString& strMACAddress);
 
        static tBool QueryDriveSpace(const cString &strDriveLetter,
                                           tUInt64 &uint64FreeSize);
 
        static tResult SwapEndian(tUInt8* pui8Value);
 
        static tResult SwapEndian(tInt8*  pi8Value);
 
        static tResult SwapEndian(tUInt16* pui16Value);
 
        static tResult SwapEndian(tInt16*  pi16Value);
 
        static tResult SwapEndian(tUInt32* pui32Value);
 
        static tResult SwapEndian(tInt32* pi32Value);
 
        static tResult SwapEndian(tUInt64* pui64Value);
 
        static tResult SwapEndian(tInt64* pi64Value);
 
        static tResult HostToNetwork(tUInt16* pui16Value);
 
        static tResult HostToNetwork(tUInt32* pui32Value);
 
        static tResult HostToNetwork(tUInt64* pui64Value);
 
        static tResult NetworkToHost(tUInt16* pui16Value);
 
        static tResult NetworkToHost(tUInt32* pui32Value);
 
        static tResult NetworkToHost(tUInt64* pui64Value);
 
 
        static tResult SendMail(
            const cString &strOriginator,
            const cString &strOriginatorName,
            const cString &strRecipient,
            const cString &strRecipientName,
            const cString &strSubject,
            const cString &strText,
            const cString &strFilePath);
 
        static tResult GetEthernetAdapterInfo(IAdapterInfoCallback *pAdapterInfo);
};
 
} // namespace A_UTILS_NS
 
#endif // _SYSTEM_CLASS_HEADER_