Directory.hpp

//
//  Copyright PHOENIX CONTACT Electronics GmbH
//
#pragma once
#include "Arp/System/Core/Arp.h"
#include "Arp/System/Core/IEnumerator.hxx"
#include <boost/regex.hpp>

namespace Arp { namespace System { namespace Commons { namespace Io
{

class Directory
{
public: // construction/destruction
    Directory(void) = delete;
    Directory(const Directory& arg) = delete;
    Directory& operator=(const Directory& arg) = delete;
    ~Directory(void) = delete;

public: // static operations
    static bool     Exists(const String& path);

    static void     Create(const String& path);

    static void     Create(const String& path, bool sync);

    static void     Delete(const String& path);

    static void     Delete(const String& path, bool sync);

    static void     Clear(const String& path);

    static void     Clear(const String& path, bool sync);

    static void     Copy(const String& sourcePath, const String& destinationPath, bool clear = false);

    static void     Copy(const String& sourcePath, const String& destinationPath, bool clear, bool sync);

    static void     Move(const String& sourcePath, const String& destinationPath, bool overwrite = false);

    static void     Move(const String& sourcePath, const String& destinationPath, bool overwrite, bool sync);

    // <summary>Rename a directory or File</summary>
    ARP_DEPRECATED("Please use Directory::Move() instead of Directory::Rename().")
    static void     Rename(const String& sourcePath, const String& destinationPath);

    static String   GetCurrent(void);

    static void SyncAll(void);

    static void Sync(const String& path);

    static IEnumerator<String>::Ptr    GetEnumerator(const String& path, bool recursive = false);

    static IEnumerator<String>::Ptr    GetEnumerator(const String& path, const char* searchPattern, bool recursive = false);

    static IEnumerator<String>::Ptr    GetFileEnumerator(const String& path, bool recursive = false);

    static IEnumerator<String>::Ptr    GetFileEnumerator(const String& path, const char* searchPattern, bool recursive = false);

    static IEnumerator<String>::Ptr    GetDirectoryEnumerator(const String& path, bool recursive = false);

    static IEnumerator<String>::Ptr    GetDirectoryEnumerator(const String& path, const char* searchPattern, bool recursive = false);

    static IEnumerator<String>::Ptr    TryGetEnumerator(const String& path, bool recursive = false);

    static IEnumerator<String>::Ptr    TryGetEnumerator(const String& path, const char* searchPattern, bool recursive = false);

    static IEnumerator<String>::Ptr    TryGetFileEnumerator(const String& path, bool recursive = false);

    static IEnumerator<String>::Ptr    TryGetFileEnumerator(const String& path, const char* searchPattern, bool recursive = false);

    static IEnumerator<String>::Ptr    TryGetDirectoryEnumerator(const String& path, bool recursive = false);

    static IEnumerator<String>::Ptr    TryGetDirectoryEnumerator(const String& path, const char* searchPattern, bool recursive = false);

private: // static methods
    static IEnumerator<String>::Ptr    GetEnumerator(const String& path, bool recursive, bool files, bool directories);
    static IEnumerator<String>::Ptr    GetSearchEnumerator(const String& path, const char* searchPattern, bool recursive, bool files, bool directories);
    static IEnumerator<String>::Ptr    TryGetEnumerator(const String& path, bool recursive, bool files, bool directories);
    static IEnumerator<String>::Ptr    TryGetSearchEnumerator(const String& path, const char* searchPattern, bool recursive, bool files, bool directories);

private: // nested class Enumerator
    template<class Iterator>
    class Enumerator : public IEnumerator<String>
    {
        friend class Directory;

    private: // construction
        Enumerator(const String& path, bool files, bool directories, bool& error);

    public: // Implementation of IEnumerator<String>
        bool    MoveNext(void)override;
        String  GetCurrent(void)override;

    private: // fields
        Iterator    boostIterator;
        bool        initialMoved;
        bool        files;
        bool        directories;
    };

private: // nested class SearchEnumerator
    template<class Iterator>
    class SearchEnumerator : public IEnumerator<String>
    {
        friend class Directory;

    private: // construction
        SearchEnumerator(const String& path, const String& searchPattern, bool files, bool directories, bool& error);

    public: // Implementation of IEnumerator<String>
        bool    MoveNext(void)override;
        String  GetCurrent(void)override;

    private: // static methods
        static String NormalizeSearchPattern(const String& searchPattern);

    private: // fields
        boost::regex    searchRegex;
        Iterator        boostIterator;
        bool            initialMoved;
        bool            files;
        bool            directories;
    };

private: // nested class Enumerator
    class EmptyEnumerator : public IEnumerator<String>
    {
        friend class Directory;

    private: // construction
        EmptyEnumerator() = default;

    public: // Implementation of IEnumerator<String>
        bool    MoveNext(void)override
        {
            return false;
        }
        String  GetCurrent(void)override
        {
            return String::Empty;
        }
    };
};

// inline methods of class Directory

inline IEnumerator<String>::Ptr Directory::GetEnumerator(const String& path, bool recursive)
{
    return Directory::GetEnumerator(path, recursive, true, true);
}

inline IEnumerator<String>::Ptr Directory::GetEnumerator(const String& path, const char* searchPattern, bool recursive)
{
    return Directory::GetSearchEnumerator(path, searchPattern, recursive, true, true);
}

inline IEnumerator<String>::Ptr Directory::GetFileEnumerator(const String& path, bool recursive)
{
    return Directory::GetEnumerator(path, recursive, true, false);
}

inline IEnumerator<String>::Ptr Directory::GetFileEnumerator(const String& path, const char* searchPattern, bool recursive)
{
    return Directory::GetSearchEnumerator(path, searchPattern, recursive, true, false);
}

inline IEnumerator<String>::Ptr Directory::GetDirectoryEnumerator(const String& path, bool recursive)
{
    return Directory::GetEnumerator(path, recursive, false, true);
}

inline IEnumerator<String>::Ptr Directory::GetDirectoryEnumerator(const String& path, const char* searchPattern, bool recursive)
{
    return Directory::GetSearchEnumerator(path, searchPattern, recursive, false, true);
}

inline IEnumerator<String>::Ptr Directory::TryGetEnumerator(const String& path, bool recursive)
{
    return Directory::TryGetEnumerator(path, recursive, true, true);
}

inline IEnumerator<String>::Ptr Directory::TryGetEnumerator(const String& path, const char* searchPattern, bool recursive)
{
    return Directory::TryGetSearchEnumerator(path, searchPattern, recursive, true, true);
}

inline IEnumerator<String>::Ptr Directory::TryGetFileEnumerator(const String& path, bool recursive)
{
    return Directory::TryGetEnumerator(path, recursive, true, false);
}

inline IEnumerator<String>::Ptr Directory::TryGetFileEnumerator(const String& path, const char* searchPattern, bool recursive)
{
    return Directory::TryGetSearchEnumerator(path, searchPattern, recursive, true, false);
}

inline IEnumerator<String>::Ptr Directory::TryGetDirectoryEnumerator(const String& path, bool recursive)
{
    return Directory::TryGetEnumerator(path, recursive, false, true);
}

inline IEnumerator<String>::Ptr Directory::TryGetDirectoryEnumerator(const String& path, const char* searchPattern, bool recursive)
{
    return Directory::TryGetSearchEnumerator(path, searchPattern, recursive, false, true);
}

}}}} // end of namespace Arp::System::Commons::Io