Directory.h

/*
 * Copyright (c) 2008-2014, Pedigree Developers
 *
 * Please see the CONTRIB file in the root of the source tree for a full
 * list of contributors.
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#ifndef DIRECTORY_H
#define DIRECTORY_H

#include "File.h"
#include "pedigree/kernel/Log.h"
#include "pedigree/kernel/compiler.h"
#include "pedigree/kernel/processor/types.h"
#include "pedigree/kernel/time/Time.h"
#include "pedigree/kernel/utilities/HashTable.h"
#include "pedigree/kernel/utilities/LazyEvaluate.h"
#include "pedigree/kernel/utilities/Pointers.h"
#include "pedigree/kernel/utilities/String.h"
#include "pedigree/kernel/utilities/utility.h"

class StringView;
class HashedStringView;

class EXPORTED_PUBLIC Directory : public File
{
    friend class Filesystem;

  public:
    static Directory *fromFile(File *pF)
    {
        if (!pF->isDirectory())
            FATAL("Casting non-directory File to Directory!");
        return reinterpret_cast<Directory *>(pF);
    }

    Directory();

  private:
    Directory(const Directory &file);
    Directory &operator=(const Directory &);

  public:
    Directory(
        const String &name, Time::Timestamp accessedTime,
        Time::Timestamp modifiedTime, Time::Timestamp creationTime,
        uintptr_t inode, class Filesystem *pFs, size_t size, File *pParent);
    virtual ~Directory();

    virtual bool isDirectory()
    {
        return true;
    }

    File *getChild(size_t n);

    size_t getNumChildren();

    virtual void cacheDirectoryContents();

    virtual bool isCachePopulated() const
    {
        return m_bCachePopulated;
    }

    File *lookup(const HashedStringView &s) const;

    void remove(const HashedStringView &s);

    Directory *getReparsePoint() const;

    void setReparsePoint(Directory *pTarget);

    bool addEphemeralFile(File *pFile);

    bool empty();

  protected:
    struct DirectoryEntryMetadata
    {
        DirectoryEntryMetadata();
        DirectoryEntryMetadata(DirectoryEntryMetadata &&other);

        ~DirectoryEntryMetadata();

        // No copy construction (UniqueArray)
        NOT_COPYABLE_OR_ASSIGNABLE(DirectoryEntryMetadata);

        // These two should always be known at metadata creation time.
        Directory *pDirectory;
        String filename;

        // Space for anything else to be stored by the filesystem.
        UniqueArray<char> opaque;
    };

  private:
    static File *evaluateEntry(const DirectoryEntryMetadata &meta);
    static void destroyEntry(File *file);

    virtual bool isBytewise() const
    {
        // This will cause read()/write() to fail as readBytewise/writeBytewise
        // are not overridden and remain as their default implementation, which
        // errors out.
        return true;
    }

  protected:
    typedef LazyEvaluate<
        File, DirectoryEntryMetadata, evaluateEntry, destroyEntry>
        DirectoryEntry;

  private:
    typedef HashTable<String, DirectoryEntry *, HashedStringView> DirectoryEntryCache;

    DirectoryEntryCache m_Cache;

    bool m_bCachePopulated;

    Directory *m_ReparseTarget = nullptr;

  protected:
    virtual const DirectoryEntryCache &getCache()
    {
        return m_Cache;
    }

    void markCachePopulated()
    {
        m_bCachePopulated = true;
    }

    void addDirectoryEntry(const String &name, File *pTarget);

    void addDirectoryEntry(const String &name, DirectoryEntryMetadata &&meta);

    void preallocateDirectoryEntries(size_t count);

    virtual File *convertToFile(const DirectoryEntryMetadata &meta);
};

extern template class HashTable<String, Directory::DirectoryEntry *, HashedStringView>;

#endif