FileSystemIterator.h

// Copyright (c) Stefano Cristiano
// SPDX-License-Identifier: MIT
#pragma once
#include "../Foundation/Compiler.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 "../Foundation/Result.h"
#include "../Foundation/StringPath.h"
 
namespace SC
{
 
 
 
struct FileSystemIterator
{
    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; }
 
    Result checkErrors()
    {
        errorsChecked = true;
        return errorResult;
    }
 
    Result init(StringSpan directory, Span<FolderState> recursiveEntries);
 
 
    Result enumerateNext();
 
    Result recurseSubdirectory();
 
  private:
    static constexpr auto MaxPath = StringPath::MaxPath;
    struct Internal;
    struct RecurseStack
    {
        Span<FolderState> recursiveEntries;
 
        int currentEntry = -1;
 
        FolderState& back();
 
        void   pop_back();
        Result push_back(const FolderState& other);
        size_t size() const { return size_t(currentEntry + 1); }
        bool   isEmpty() const { return currentEntry == -1; }
    };
    RecurseStack recurseStack;
 
    Entry  currentEntry;
    Result errorResult   = Result(true);
    bool   errorsChecked = false;
 
#if SC_PLATFORM_WINDOWS
    bool       expectDotDirectories = true;
    StringPath currentPath;
    uint64_t   dirEnumeratorBuffer[592 / sizeof(uint64_t)];
#else
    StringPath currentPath;
#endif
 
    Result enumerateNextInternal(Entry& entry);
    Result recurseSubdirectoryInternal(Entry& entry);
};
 
} // namespace SC