E:/Programming/MyProject/K_Game_hg/GameEngine/include/platform/PlatformManager.h

Go to the documentation of this file.

// Copyright 2006-2011 by Kat'Oun

#ifndef _PLATFORM_MANAGER_H_
#define _PLATFORM_MANAGER_H_

#include <EngineConfig.h>
#include <core/Types.h>
#include <core/Singleton.h>
#include <core/Utils.h>
#include <engine/Object.h>

#include <string>
#include <map>

namespace platform
{

class Thread;
class Timer;
class File;
class FileSystem;
class FileSystemFactory;
class PlatformDriver;
enum CpuTechnology;

typedef FileSystem* (ENGINE_CALLBACK *FILESYSTEM_FACTORY)(const std::string& filename, const std::string& type);
typedef void (ENGINE_CALLBACK *FILESYSTEM_RELEASE)(FileSystem* fs);

class ENGINE_PUBLIC_EXPORT PlatformManager: public engine::Object, public core::Singleton<PlatformManager>
{
public:
        
        PlatformManager();

        ~PlatformManager();

        void start();

        void stop();

        Timer* getTimer();

        const char* getCPUVendorId();

        f32 getCPUFrequency();

        bool checkCPUTechnology(CpuTechnology tech);

        u16 getLogicalProcessorsNum();

        u16 getPhysicalProcessorsNum();

        u32 getCPUCacheSize(u32 level);

        u32 getTotalMemory();
        
        u32 getFreeMemory();

        u32 getSharedMemory();

        u32 getBufferMemory();

        u32 getTotalSwap();

        u32 getFreeSwap();

        void copyToClipboard(const c8* text);

        c8* getTextFromClipboard();
        
        void sleep(u32 miliseconds);

        FileSystem* createFileSystem(const std::string& path, const std::string& type);

        void removeFileSystem(FileSystem* fs);

        void removeAllFileSystems();

        void registerFileSystemFactory(const std::string& type, FileSystemFactory* factory);
        void removeFileSystemFactory(const std::string& type);

        void setTimer(Timer *timer);
        void removeTimer();

        Thread* createThread();

        void removeThread(Thread* thread);
        void removeThread(const u32& id);

        void removeAllThreads();

        void setPlatformDriver(PlatformDriver *driver);
        void removePlatformDriver();

        static PlatformManager* getInstance();

protected:

        void initializeImpl();
        void uninitializeImpl();
        void updateImpl(f32 elapsedTime);

        Timer* mTimer;
        PlatformDriver* mPlatformDriver;

        std::map<std::string, FileSystemFactory*> mFileSystemFactories;

        struct FileSystemInfo
        {
                FileSystemInfo()
                {
                        mFileSystem = NULL;
                        mType = core::STRING_BLANK;
                }

                FileSystemInfo& operator=(const FileSystemInfo& other)
                {
                        mFileSystem = other.mFileSystem;
                        mType = other.mType;
                        return *this;
                }

                FileSystem* mFileSystem;
                std::string mType;
        };
        std::map<u32, FileSystemInfo> mFileSystems;

        std::map<u32, Thread*> mThreads;
};

} // end namespace platform

#endif