util.h

Go to the documentation of this file.

#ifndef NEO_UTIL_H
#define NEO_UTIL_H

namespace neo
{
    enum WIN_TYPE
    {
        WIN_UNKNOWN_OLDER  = 0, 
        WIN_2000           = 1, 
        WIN_XP             = 2, 
        WIN_SERVER_2003    = 3, 
        WIN_VISTA          = 4, 
        WIN_SERVER_2008    = 4, 
        WIN_SERVER_2008_R2 = 5, 
        WIN_7              = 5, 
        WIN_SERVER_2012    = 6, 
        WIN_8              = 6, 
        WIN_SERVER_2012_R2 = 7, 
        WIN_8_1            = 7, 
        WIN_UNKNOWN_NEWER  = 8, 
    };

    class OSVersion
    {
    public:
        static const OSVersion& Get();

        WIN_TYPE windowsType;
        OSVERSIONINFOEX info;
    };

    class DynamicLib
    {
    public:
        DynamicLib(const tstring& filename)
        {
            _lib = LoadLibrary(filename.c_str());
        }

        ~DynamicLib()
        {
            if(_lib)
                FreeLibrary(_lib);
        }

        bool IsLoaded() { return _lib != 0; }
        operator HMODULE() { return _lib; }
    protected:
        DynamicLib()
            : _lib(0)
        {}

        HMODULE _lib;
    private:
        DynamicLib(const DynamicLib& other) {}
        DynamicLib& operator=(const DynamicLib& other) { return *this; }
    };

    class LoadedLib : public DynamicLib
    {
    public:
        LoadedLib(const tstring& filename)
        {
            _lib = GetModuleHandle(filename.c_str());
        }

        // override destructor, we don't want to free the handle under any circumstances
        ~LoadedLib()
        {}
    };

#ifdef _DEBUG
    inline HRESULT UseHR(HRESULT hr, LPCSTR file, long line)
    {
        if(FAILED(hr))
        {
            // convert HRESULT error to readable string
            // this should work for standard Windows stuff
            // for special APIs like DirectX 9, FormatMessage will not always have a translation
            static const int bufferSize = 2000;
            std::string buffer;
            buffer.resize(bufferSize);
            DWORD bytesWritten = FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM, 0, hr, 0, &buffer[0], bufferSize, 0);
            if(bytesWritten == 0)
            {
                DWORD error = GetLastError();
                buffer = "FormatMessage failed: code " + std::to_string(error);
            }
            // prepend file and line in such a way that you can click this line in Visual C++
            // and it jumps right to the code
            // E:\example.cpp(123): Error
            buffer = file + std::string("(") + std::to_string(line) + "): " + buffer;

            OutputDebugStringA(buffer.c_str());
        }
        return hr;
    }
#endif

    // USEHR : passes the HRESULT along and outputs error
    // CHECKHR : convert HRESULT to bool and outputs error

#ifdef _DEBUG
    #define USEHR(hr) UseHR((hr), __FILE__, __LINE__)
    #define CHECKHR(hr) SUCCEEDED(UseHR((hr), __FILE__, __LINE__))
#else
    #define USEHR(hr) hr
    #define CHECKHR(hr) SUCCEEDED((hr))
#endif

    //-------------------------------------------------------------------------

    enum SEEK_FROM
    {
        FROM_START,   
        FROM_CURRENT, 
        FROM_END,     
    };

    class File
    {
    public:
        File();
        File(const tstring& filename, const tstring& openMode);
        ~File();

        bool Open(const tstring& filename, const tstring& openMode);

        bool Close();

        bool IsOpen() const { return _fp != 0; }

        operator bool() const { return IsOpen(); }

        void Seek(int64_t offset, SEEK_FROM mode = FROM_START);

        int64_t Tell();

        int64_t Size();

        bool Eof();

        size_t Write(const void* buffer, size_t byteSize);

        bool Write(const std::string& buffer);

        size_t Read(void* buffer, size_t byteSize);

        bool ReadLine(std::string* line, const std::string& delim = "\n");
        
        bool ReadAll(std::string* all);

        FILE* GetInternalPtr() const { return _fp; }
    private:
        FILE* _fp;
    };

    //----------------------------------------------------------------------------

    struct FileSearchItem : public WIN32_FIND_DATA
    {
        bool IsDirectory() const { return (dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0; }
    
        bool IsReadonly() const { return (dwFileAttributes & FILE_ATTRIBUTE_READONLY) != 0; }
    
        bool IsHidden() const { return (dwFileAttributes & FILE_ATTRIBUTE_HIDDEN) != 0; }
    
        bool IsSystemFile() const { return (dwFileAttributes & FILE_ATTRIBUTE_SYSTEM) != 0; }
    
        bool IsTemporary() const { return (dwFileAttributes & FILE_ATTRIBUTE_TEMPORARY) != 0; }

        int64_t GetFilesize() const { return int64_t(nFileSizeHigh) * 0x100000000 + int64_t(nFileSizeLow); }

        tstring GetFilename() const { return cFileName; }
    };

    //----------------------------------------------------------------------------

    class FileSearch
    {
    public:
        FileSearch(const tstring& searchPattern);
        ~FileSearch();

        bool Ok() const;
    
        bool Done() const;
    
        bool Next();

        const FileSearchItem& Data() const;

        class iterator
        {
        public:
            friend FileSearch;

            iterator()
                : _search(0)
                , _end(false)
            {}
            

            const FileSearchItem& operator*() const { return _search->Data(); }
            const FileSearchItem* operator->() const { return &_search->Data(); }
            iterator& operator++()
            {
                // pre increment
                assert(!_search->Done());
                _search->Next();
                return *this;
            }
            iterator operator++(int) const
            {
                // post increment
                assert(!_search->Done());
                _search->Next();
                return *this;
            }
            bool operator==(const iterator& rhs) const
            {
                // abuse of != operator to check if the iteration has ended
                if(_search && rhs._end)
                    return _search->Done();
                return false;
            }
            bool operator!=(const iterator& rhs) const { return !(*this == rhs); }
        private:
            iterator(FileSearch* search, bool end)
                : _search(search)
                , _end(end)
            {}

            FileSearch* _search;
            bool _end;
        };

        iterator begin() { return iterator(this, false); }

        iterator end() { return iterator(0, true); }
    private:
        HANDLE _file;
        bool _done;
        FileSearchItem _wfd;
    };

    //----------------------------------------------------------------------------

    class Path
    {

    public:
        static bool Exists(const tstring& path);

        static bool IsFile(const tstring& path);

        static bool IsDirectory(const tstring& path);

        static bool IsAbsolute(const tstring& path);

        static bool HasExt(const tstring& path);

        static tstring Join(const tstring& p1, const tstring& p2);

        static tstring Join(const tstring& p1, const tstring& p2, const tstring& p3);

        static tstring Join(const tstring& p1, const tstring& p2, const tstring& p3, const tstring& p4);

        static tstring GetDrive(const tstring& path);

        static tstring GetParent(const tstring& path);

        static tstring GetFilename(const tstring& path);

        static tstring GetFilenameWithoutExt(const tstring& path);

        static tstring GetExt(const tstring& path);

        static std::pair<tstring,tstring> SplitDrive(const tstring& path);
        static std::pair<tstring,tstring> SplitParent(const tstring& path);
        static std::pair<tstring,tstring> SplitExt(const tstring& path);

        static tstring ChangeFilename(const tstring& path, const tstring& name);

        static tstring ChangeExt(const tstring& path, const tstring& ext);

        static tstring GetCurrentDir();
    private:
        enum Drive_t
        {
            DRIVE_NONE,
            DRIVE_LOCAL,
            DRIVE_NETWORK,
        };
        static tstring::size_type _GetDriveEnd(const tstring& path, Drive_t* type);

        static tstring _GetSeparators()
        {
            return _T("/\\");
        }
        static bool _IsSeparator(TCHAR c)
        {
            return c == _T('/') || c == _T('\\');
        }
    };

} // namespace neo

#endif