Directory.h

#pragma once


#include <libutl/Collection.h>
#include <libutl/Factory.h>
#include <libutl/FSobject.h>


UTL_NS_BEGIN;



class Directory : public FSobject
{
    UTL_CLASS_DECL(Directory, FSobject);

public:
    Directory(const String& path, const Directory* dir = nullptr)
        : FSobject(path, dir)
    {
        init();
    }

    virtual int compare(const Object& rhs) const;

    virtual void copy(const Object& rhs);

    virtual void dump(Stream& os, uint_t level = uint_t_max) const;

    virtual void serialize(Stream& stream, uint_t io, uint_t mode = ser_default);

    virtual void unlink();

    void unlinkRecursive();

    bool
    isFlat() const
    {
        return getFlag(flg_flat);
    }

    const Collection*
    entries() const
    {
        return _entries;
    }

    Collection*
    entries()
    {
        return _entries;
    }

    void takeEntries(Directory& rhs);

    FSobject* find(const Pathname& path, bool relative = true) const;

    void make(uint_t mode = uint_t_max) const;

    size_t
    scan(uint_t flags = 0,
         Factory* factory = nullptr,
         const Predicate* pred = nullptr,
         bool predVal = true)
    {
        return scan(flags, factory, pred, predVal, nullptr);
    }

    void rescan(uint_t flags = 0,
                Factory* factory = nullptr,
                const Predicate* pred = nullptr,
                bool predVal = true);

    enum scan_t
    {
        scan_recursive = 1,      
        scan_recursive_flat = 2, 
        scan_followLinks = 4,    
        scan_excludeDotDirs = 8, 
        scan_ignoreEx = 16,      
        scan_append = 32,        
    };

private:
    void
    init()
    {
        _entries = nullptr;
    }
    void
    deInit()
    {
        delete _entries;
    }
    void
    setFlat(bool flat)
    {
        setFlag(flg_flat, flat);
    }
    size_t scan(uint_t flags,
                Factory* factory,
                const Predicate* pred,
                bool predVal,
                const Pathname* flatPrefix);

private:
    enum flg_t
    {
        flg_flat = 4
    };

private:
    Collection* _entries;
};


UTL_NS_END;