FileSystemIterator.h

// Copyright (c) Stefano Cristiano
// SPDX-License-Identifier: MIT
#pragma once
#include "../Common/CompilerMacrosExport.h"
#ifndef SC_EXPORT_LIBRARY_FILE_SYSTEM_ITERATOR
#define SC_EXPORT_LIBRARY_FILE_SYSTEM_ITERATOR 0
#endif
#define SC_FILE_SYSTEM_ITERATOR_EXPORT SC_COMPILER_LIBRARY_EXPORT(SC_EXPORT_LIBRARY_FILE_SYSTEM_ITERATOR)
 
#include "../Common/Assert.h"
#include "../Common/IGrowableBufferStringPath.h"
#include "FileSystemIteratorError.h"
 
namespace SC
{
SC_DECLARE_ASSERT_PROVIDER(FileSystemIteratorAssert, SC_FILE_SYSTEM_ITERATOR_EXPORT);
 
#define SC_FILE_SYSTEM_ITERATOR_ASSERT_RELEASE(e)        SC_ASSERT_PROVIDER_RELEASE(SC::FileSystemIteratorAssert, e)
#define SC_FILE_SYSTEM_ITERATOR_ASSERT_DEBUG(e)          SC_ASSERT_PROVIDER_DEBUG(SC::FileSystemIteratorAssert, e)
#define SC_FILE_SYSTEM_ITERATOR_TRUST_RESULT(expression) SC_FILE_SYSTEM_ITERATOR_ASSERT_RELEASE(expression)
 
 
 
struct FileSystemIterator
{
    static_assert(StringPath::MaxPath <= 65535, "ResultFileSystemIterator depth must fit in uint16_t");
 
    enum class Type
    {
        Directory,
        File
    };
 
    struct FolderState
    {
#if SC_PLATFORM_WINDOWS
        void* fileDescriptor = (void*)(long long)-1;
#else
        int   fileDescriptor = -1;
        void* dirEnumerator  = nullptr;
#endif
        size_t textLengthInBytes = 0;
        bool   gotDot1           = false;
        bool   gotDot2           = false;
    };
 
    struct Entry
    {
        StringSpan name;               
        StringSpan path;               
        uint32_t   level = 0;          
        Type       type  = Type::File; 
 
        bool isDirectory() const { return type == Type::Directory; }
 
#if SC_PLATFORM_WINDOWS
        void* parentFileDescriptor = nullptr;
#else
        int parentFileDescriptor = 0;
#endif
    };
 
    struct Options
    {
        bool recursive      = false; 
        bool forwardSlashes = false; 
    };
 
    Options options; 
 
    ~FileSystemIterator();
 
    const Entry& get() const { return currentEntry; }
 
    ResultFileSystemIterator checkErrors() const { return errorResult; }
 
    ResultFileSystemIterator init(StringSpan directory, Span<FolderState> recursiveEntries);
 
 
    [[nodiscard]] bool enumerateNext();
 
    ResultFileSystemIterator recurseSubdirectory();
 
  private:
    static constexpr auto MaxPath = StringPath::MaxPath;
    struct Internal;
    struct RecurseStack
    {
        Span<FolderState> recursiveEntries;
 
        int currentEntry = -1;
 
        FolderState& back();
 
        void                     pop_back();
        ResultFileSystemIterator push_back(const FolderState& other);
        size_t                   size() const { return size_t(currentEntry + 1); }
        bool                     isEmpty() const { return currentEntry == -1; }
    };
    RecurseStack recurseStack;
 
    Entry                    currentEntry;
    ResultFileSystemIterator errorResult    = ResultFileSystemIterator(true);
    bool                     initialized    = false;
    bool                     finished       = false;
    bool                     entryAvailable = false;
 
#if SC_PLATFORM_WINDOWS
    bool       expectDotDirectories = true;
    StringPath currentPath;
    StringPath outputPath;
    uint64_t   dirEnumeratorBuffer[592 / sizeof(uint64_t)];
#else
    StringPath currentPath;
#endif
 
    ResultFileSystemIterator initInternal(StringSpan directory, Span<FolderState> recursiveEntries);
    ResultFileSystemIterator enumerateNextInternal(Entry& entry, bool& hasEntry);
    ResultFileSystemIterator recurseSubdirectoryInternal(Entry& entry);
};
 
} // namespace SC