---

DirWalker.cpp

Go to the documentation of this file.

#include <stdio.h>
#include <string.h>
#include "DirWalker.h"
#include "Debug.h"

#ifndef WIN32
#include <sys/stat.h>
#define FILE_SEP '/'
#else
#define FILE_SEP '\\'
#endif

// IMPORTANT: The code for WIN32 hasn't been tested and it's very likely
// that it still requires some modifications.

DirWalker::DirWalker()
{ 
        hFile = INVALID_HANDLE_VALUE; 
        *szDirPath = '\0';
        nDirPathLen = 0;
}

bool DirWalker::OpenDir(const char* szDirName)  
{ 
        CloseDir();

#ifdef WIN32
        hFile = FindFirstFile(szDirName, &findData); // perhaps szDirName + "*.*"
#else
        hFile = opendir(szDirName); 
#endif

        if (hFile != INVALID_HANDLE_VALUE)
        {
                nDirPathLen = strlen(szDirName);
                memcpy(szDirPath, szDirName, nDirPathLen + 1);

                if (szDirPath[nDirPathLen - 1] != FILE_SEP)
                {
                        szDirPath[nDirPathLen] = FILE_SEP;
                        szDirPath[nDirPathLen + 1] = '\0';
                        nDirPathLen++;
                }

                return true;
        }
        
        return false;
}

void DirWalker::CloseDir()
{ 
        if (hFile != INVALID_HANDLE_VALUE)
        { 
#ifdef WIN32
                FindClose(hFile);
#else
                closedir(hFile); 
#endif
                hFile = INVALID_HANDLE_VALUE;
                *szDirPath = '\0';
                nDirPathLen = 0;
        } 
}

bool DirWalker::GetNextFileOrDir(char* szFileName, size_t buffSize)
{
        const char* sz;
        size_t len;

        // Clear out szFileName before hand in case something goes wrong.
        *szFileName = '\0';

        // Read next file
#ifdef WIN32
        if (FindNextFile(hFile, &findData) == 0) 
                return false;

        sz = findData.cFileName;
#else
        struct dirent* dp;

        if ((dp = readdir(hFile)) == 0) 
                return false;

        sz = dp->d_name;
#endif

        len = strlen(sz);

        if (nDirPathLen + len > buffSize - 1)
                return false;

        if (sz[0] == '.' && (len == 1 || (len == 2 && sz[1] == '.')))
        {
                memcpy(szFileName, sz, len + 1);
        }
        else
        {
                memcpy(szFileName, szDirPath, nDirPathLen);
                memcpy(szFileName + nDirPathLen, sz, len + 1);
        }

        return true;
}

bool DirWalker::GetNextFile(char* szFileName, size_t buffSize, char* szFileExt /*=NULL*/)
{
        bool bSuccess;

        do {
                bSuccess = GetNextFileOrDir(szFileName, buffSize);

        } while(bSuccess && IsDirectory(szFileName));

        if (szFileExt && bSuccess)
        {
                *szFileExt = '\0'; // Init the string
                size_t len = strlen(szFileName + nDirPathLen);
                char* pEnd = szFileName + nDirPathLen + len - 1;

                for (int i = 0; i < 4; i++, pEnd--)
                {
                        if (*pEnd == '.')
                        {
                                strcpy(szFileExt, pEnd + 1);
                                break;
                        }
                }
        }

        return bSuccess;
}

bool DirWalker::GetNextDir(char* szFileName, size_t buffSize)
{
        bool bSuccess, bDotDirectory;

        do {
                bSuccess = GetNextFileOrDir(szFileName, buffSize);

                // Ignore dot and dot-dot directory
                if (!strcmp(szFileName, ".") || !strcmp(szFileName, ".."))
                        bDotDirectory = true;
                else
                        bDotDirectory = false;

        } while(bSuccess && (bDotDirectory || !IsDirectory(szFileName)));

        return bSuccess;
}

/*static*/ 
bool DirWalker::IsDirectory(const char* szFileName)
{
#ifdef WIN32
        DWORD info = GetFileAttributes(szFileName);
        return (info & FILE_ATTRIBUTE_DIRECTORY) != 0;
#else
        struct stat info;

        if (stat(szFileName, &info) != 0)
                return false;
        else
                return (info.st_mode & S_IFDIR) != 0;
#endif
}

/*static*/ 
const char* DirWalker::FindFileExtention(const char* szFileName)
{
        size_t len = strlen(szFileName);
        const char* pEnd = szFileName + len - 1;

        for (; pEnd > szFileName && *pEnd != FILE_SEP; pEnd--)
                if (*pEnd == '.')
                        return pEnd + 1;

        return szFileName + len;
}

/*static*/ 
bool DirWalker::CompFileExt(const char* szFileName, const char* szFileExt)
{
        return strcmp(szFileExt, FindFileExtention(szFileName)) == 0;
}

/*static*/ 
void DirWalker::ChangeFileExt(const char* szFileName, const char* szExt, char* szNewName)
{
        const char* szOldExt = FindFileExtention(szFileName);
        int nBytes = szOldExt - szFileName;

        memcpy(szNewName, szFileName, nBytes);

        if (szExt)
        {
                if (szNewName[nBytes - 1] != '.')
                        szNewName[nBytes++] = '.';

                strcpy(szNewName + nBytes, szExt);
        }
        /* szExt == NULL*/
        else if (szNewName[nBytes - 1] == '.')
                szNewName[nBytes - 1] = '\0';
        else
                szNewName[nBytes] = '\0';
}

/*static*/
int DirWalker::CompareLastModifDate(const char* szFileName1, const char* szFileName2)
{
#ifndef WIN32
        struct stat info1, info2;

        info1.st_mtime = info2.st_mtime = 0;

        stat(szFileName1, &info1);
        stat(szFileName2, &info2);

        return info1.st_mtime - info2.st_mtime;
#else
        return 0;
#endif

}

/*static*/ 
int DirWalker::CreateFileName(const char* szDirName, const char* szPrefix, 
                                                          const char* szFileExt, char szFileName[])
{
        DirWalker dw;

        *szFileName = '\0';     // just for safety

        if (!DirWalker::IsDirectory(szDirName) || !dw.OpenDir(szDirName))
                return -1;

        int nPrefixLen = strlen(szPrefix), nPathLen = dw.GetDirPathLen();
        char szExt[10];
        int n, nMax = -1;

        while (dw.GetNextFile(szFileName, MAX_PATH, szExt))
        {
                if (!strncmp(szPrefix, szFileName + nPathLen, nPrefixLen) && 
                        !strcmp(szFileExt, szExt))
                {
                        n = atoi(szFileName + nPathLen + nPrefixLen);

                        if (n > nMax)
                                nMax = n;
                }
        }

        sprintf(szFileName, "%s%s%d.%s", dw.GetDirPath(), szPrefix, ++nMax, szFileExt);

        return nMax;
}

/*int ReadDir(char* name)
{
        DIR* dirp = opendir(".");
        struct dirent* dp;
        int errno;

        while (dirp) 
        {
                errno = 0;

                if ((dp = readdir(dirp)) != NULL) 
                {
                        DBG_MSG(dp->d_name)
                        if (strcmp(dp->d_name, name) == 0) 
                        {
                                closedir(dirp);
                                return FOUND;
                        }
                } 
                else 
                {
                        if (errno == 0) 
                        {
                                closedir(dirp);
                                return NOT_FOUND;
                        }

                        closedir(dirp);

                        return READ_ERROR;
                }
        }

        return OPEN_ERROR;
}*/

---