path.h

Go to the documentation of this file.

#pragma once
//------------------------------------------------------------------------------
#include "core/types.h"
#include "util/string.h"
#include "util/stringatom.h"
#include "util/dictionary.h"
#include "io/uri.h"
 
//------------------------------------------------------------------------------
namespace IO
{
 
class Path
{
public:
 
    // TODO: switch from using a string for the type, and use an enum
    enum FileTypes
    {
        Texture,
        Model,
        Material,
        Mesh
    };

    Path();
    ~Path();

    Path(const Path& path);

    static Path Parse(const Util::String& serialized);
    static Path Folder(const Util::String& folder);
    static Path FolderAndFile(const Util::String& type, const Util::String& folderAndFile);
    static Path FolderAndFile(const char* type, const Util::String& folderAndFile);
    static Path File(const Util::String& folder, const Util::String& file, const Util::String& type);
    static Path File(const Util::String& folder, const Util::String& file, const char* type);

    void Clear();
    bool IsEmpty() const;
    bool IsFolder() const;
    bool IsFile() const;

    const Util::String AsString() const;

    bool operator==(const Path& path) const;
    bool operator<(const Path& path) const;
    bool operator>(const Path& path) const;
    Path operator/(const char* folder) const;
    Path operator/(const Util::String& folder) const;
    Path operator/(const Path& folder) const;
    IO::URI WorkURI(const char* workFolder) const;
    IO::URI WorkURI(const Util::String& workFolder) const;
    IO::URI ExportURI() const;

    void SetFolder(const Util::String& folder);
    void ClearFolder();
    void SetFile(const Util::String& file, const Util::String& type);
    void ClearFile();

    const Util::String& GetFolderAndFile() const;
    const Util::String& GetFile() const;
    const Util::String& GetFolder() const;
    const Util::String& GetType() const;

    Util::String GetWorkFile() const;
    Util::String GetExportFile() const;

    static void AddExportMapping(const Util::StringAtom& ns, const Util::StringAtom& extension);
    static void AddWorkMapping(const Util::StringAtom& ns, const Util::StringAtom& extension);
    static void SetWorkRoot(const Util::StringAtom& root);
 
    static Util::Dictionary<Util::StringAtom, Util::StringAtom> ExportExtensions, WorkExtensions;
    static Util::StringAtom WorkRoot;
 
private:
    void Build();
 
    bool isFile;
    Util::String folder;
    Util::String file;
    Util::String type;
 
    Util::String folderAndFile;
};
 
 
//------------------------------------------------------------------------------
inline void
Path::AddExportMapping(const Util::StringAtom& ns, const Util::StringAtom& extension)
{
    n_assert(Path::ExportExtensions.FindIndex(ns) == InvalidIndex);
    Path::ExportExtensions.Add(ns, extension);
}
 
//------------------------------------------------------------------------------
inline void
Path::AddWorkMapping(const Util::StringAtom& ns, const Util::StringAtom& extension)
{
    n_assert(Path::WorkExtensions.FindIndex(ns) == InvalidIndex);
    Path::WorkExtensions.Add(ns, extension);
}
 
//------------------------------------------------------------------------------
inline void
Path::SetWorkRoot(const Util::StringAtom& root)
{
    Path::WorkRoot = root;
}
 
} // namespace IO
 
//------------------------------------------------------------------------------
IO::Path operator""_path(const char* c, std::size_t s);