TnbFileFinder.h

[詳解]

#pragma once
#include "TnbStr.h"
#include "TnbException.h"
 
 
 
//TNB Library
namespace TNB
{
 
 
 
class CAbstractFileFinder : CCopyImpossible
{
public:
    enum EFindType
    {
        ALL,            
        FILE_ONLY,      
        DIR_ONLY,       
    };
 
    #ifndef _TnbDOXYGEN //Document作成用シンボル
    class iterator
    {
        CAbstractFileFinder*    m_pff;
    public:
        iterator(CAbstractFileFinder* pff) : m_pff(pff)
        {
            if ( m_pff != NULL && ! m_pff->IsFinding() )
            {
                m_pff = NULL;
            }
        }
        const WIN32_FIND_DATA* operator->(void)
        {
            if ( m_pff == NULL ) { return NULL; }
            return &(m_pff->Get());
        }
        const WIN32_FIND_DATA& operator*(void)
        {
            if ( m_pff == NULL ) { throw CEmptyException(); }
            return m_pff->Get();
        }
        iterator& operator++(void)
        {
            if ( m_pff != NULL && ! m_pff->Next() ) { m_pff = NULL; }
            return *this;
        }
        iterator& operator++(int)
        {
            return operator++();
        }
        bool operator==(const iterator& i) const
        {
            return m_pff == i.m_pff;
        }
        bool operator!=(const iterator& i) const
        {
            return ! operator==(i);
        }
    };
    #endif //_TnbDOXYGEN
 
    iterator begin(void)
    {
        return iterator(this);
    }
 
    iterator end(void)
    {
        return iterator(NULL);
    }
 
 
    //-------------------------
 
 
    CAbstractFileFinder(void) : m_isFinding(false)
    {
    }
 
    virtual ~CAbstractFileFinder(void) {}
 
    void Finish(void)
    {
        m_isFinding = false;
        m_strPath.Empty();
        m_strMask.Empty();
        OnFinish();
    }
    
    bool Start(LPCTSTR lpszPath, LPCTSTR lpszMask = _T("*.*"), EFindType type = ALL)
    {
        Finish();
        CStr s = lpszPath;
        if ( lpszMask != NULL )
        {
            if ( lpszMask[0] != '\\' && lpszMask[0] != '/' )
            {
                s += _T("\\");
            }
            s += lpszMask;
            s.Replace(_T("\\\\"), _T("\\"));
        }
        if ( OnStart(m_data, s) )
        {
            m_isFinding = true;
            m_strPath = lpszPath;
            m_strMask = lpszMask;
            m_type = type;
            if ( m_IsTarget(m_data, m_type) )
            {
                return true;
            }
            return Next();
        }
        Finish();
        return false;
    }
 
    bool Next(void)
    {
        bool r = false;
        if ( IsFinding() )
        {
            while ( true )
            {
                r = OnNext(m_data);
                if ( ! r )
                {
                    Finish();
                    break;
                }
                else if ( m_IsTarget(m_data, m_type) )
                {
                    break;
                }
            }
        }
        return r;
    }
 
    bool IsFinding(void) const
    {
        return m_isFinding;
    }
 
    const WIN32_FIND_DATA& Get(void) const
    {
        if ( ! IsFinding() ) { throw CEmptyException(); }
        return m_data;
    }
 
    const WIN32_FIND_DATA* operator->(void) const
    {
        return &Get();
    }
 
    CStr GetFoundName(void) const
    {
        if ( ! IsFinding() ) { return CStr(); }
        CStr s = m_strPath;
        s += _T("\\");
        s += Get().cFileName;
        s.Replace(_T("\\\\"), _T("\\"));
        s.TrimLeft('\\');
        return s;
    }
 
    bool IsDirectory(void) const
    {
        if ( IsFinding() && (Get().dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0 )
        {
            return true;
        }
        return false;
    }
#if 0
    virtual HFINDPUSH Push(void) { return NULL; };
 
    virtual void Pop(HFINDPUSH h) {};
#endif
 
protected:
 
    virtual bool OnStart(WIN32_FIND_DATA& _data, LPCTSTR lpszName) = 0;
 
    virtual bool OnNext(WIN32_FIND_DATA& _data) = 0;
 
    virtual void OnFinish(void) = 0;
 
private:
 
    bool                m_isFinding;
    CStr                m_strPath;  
    CStr                m_strMask;  
    EFindType           m_type;     
    WIN32_FIND_DATA     m_data;     
 
    bool m_IsTarget(const WIN32_FIND_DATA& data, EFindType type) const
    {
        if ( STRLIB::Compare(data.cFileName, _T("..")) == 0 )
        {
            return false;
        }
        if ( STRLIB::Compare(data.cFileName, _T(".")) == 0 )
        {
            return false;
        }
        switch ( type )
        {
        case FILE_ONLY:
            if ( (data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0 )
            {
                return false;
            }
            break;
        case DIR_ONLY:
            if ( (data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) == 0 )
            {
                return false;
            }
            break;
        default:
            break;
        }
        return true;
    }
};
 
 
 
class CFileFinder : public CAbstractFileFinder
{
    DEFSUPER(CAbstractFileFinder);
public:
 
    CFileFinder(void) : _super(), m_hFind(INVALID_HANDLE_VALUE)
    {
    }
 
    virtual ~CFileFinder(void)
    {
        Finish();
    }
 
protected:
 
    virtual bool OnStart(WIN32_FIND_DATA& _data, LPCTSTR lpszName)
    {
        Finish();
        m_hFind = ::FindFirstFile(lpszName, &_data);
        return (m_hFind != INVALID_HANDLE_VALUE);
    }
 
    virtual bool OnNext(WIN32_FIND_DATA& _data)
    {
        if ( m_hFind != INVALID_HANDLE_VALUE )
        {
            return !! ::FindNextFile(m_hFind, &_data);
        }
        return false;
    }
 
    virtual void OnFinish(void)
    {
        if ( m_hFind != INVALID_HANDLE_VALUE )
        {
            ::FindClose(m_hFind);
            m_hFind = INVALID_HANDLE_VALUE;
        }
    }
#if 0
    virtual HFINDPUSH Push(void)
    {
        if ( IsDirectory() )
        {
            TPushParam* P = new TPushParam;
            P->hFind = m_hFind;
            P->strPath = m_strPath;
            P->data = m_data;
            //
            m_strPath += _T("\\");
            m_strPath += m_data.cFileName;
            m_hFind = ::FindFirstFile(m_strPath, &m_data);
            if ( m_hFind != INVALID_HANDLE_VALUE )
            {
                if ( ! IsTarget(m_data, m_type) )
                {
                    if ( Next() )
                    {
                        return P;
                    }
                }
            }
            m_hFind = P->hFind;
            m_strPath = P->strPath;
            m_data = P->data;
            delete P;
        }
        return NULL;
    }
 
    virtual void Pop(HFINDPUSH h) 
    {
        if ( h != NULL )
        {
            TPushParam* P = reinterpret_cast<TPushParam*>(h);
            m_hFind = P->hFind;
            m_strPath = P->strPath;
            m_data = P->data;
            delete P;
        }
    };
#endif
 
private:
    HANDLE              m_hFind;    
    friend class CFileFinderTest;
};
 
 
 
}; //TNB
 
#if 0
struct WIN32_FIND_DATA
{
    DWORD dwFileAttributes;
    FILETIME ftCreationTime;
    FILETIME ftLastAccessTime;
    FILETIME ftLastWriteTime;
    DWORD nFileSizeHigh;
    DWORD nFileSizeLow;
    DWORD dwReserved0;
    DWORD dwReserved1;
    TCHAR cFileName[ MAX_PATH ];
    TCHAR cAlternateFileName[ 14 ];
} WIN32_FIND_DATA;
 
enum
{
    FILE_ATTRIBUTE_ARCHIVE              = 0x00000020, 
    FILE_ATTRIBUTE_COMPRESSED           = 0x00000800, 
    FILE_ATTRIBUTE_DEVICE               = 0x00000040, 
    FILE_ATTRIBUTE_DIRECTORY            = 0x00000010, 
    FILE_ATTRIBUTE_ENCRYPTED            = 0x00004000, 
    FILE_ATTRIBUTE_HIDDEN               = 0x00000002, 
    FILE_ATTRIBUTE_NORMAL               = 0x00000080, 
    FILE_ATTRIBUTE_NOT_CONTENT_INDEXED  = 0x00002000, 
    FILE_ATTRIBUTE_OFFLINE              = 0x00001000, 
    FILE_ATTRIBUTE_READONLY             = 0x00000001, 
    FILE_ATTRIBUTE_REPARSE_POINT        = 0x00000400, 
    FILE_ATTRIBUTE_SPARSE_FILE          = 0x00000200, 
    FILE_ATTRIBUTE_SYSTEM               = 0x00000004, 
    FILE_ATTRIBUTE_TEMPORARY            = 0x00000100, 
};
#endif