File.h

Go to the documentation of this file.

//
// Copyright Contributors to the MaterialX Project
// SPDX-License-Identifier: Apache-2.0
//
 
#ifndef MATERIALX_FILE_H
#define MATERIALX_FILE_H
 
 
#include <MaterialXFormat/Export.h>
 
#include <MaterialXCore/Util.h>
 
MATERIALX_NAMESPACE_BEGIN
 
class FilePath;
using FilePathVec = vector<FilePath>;
 
extern MX_FORMAT_API const string PATH_LIST_SEPARATOR;
extern MX_FORMAT_API const string MATERIALX_SEARCH_PATH_ENV_VAR;
 
class MX_FORMAT_API FilePath
{
  public:
    enum Type
    {
        TypeRelative = 0,
        TypeAbsolute = 1,
        TypeNetwork = 2
    };
 
    enum Format
    {
        FormatWindows = 0,
        FormatPosix = 1,
#if defined(_WIN32)
        FormatNative = FormatWindows
#else
        FormatNative = FormatPosix
#endif
    };
 
  public:
    FilePath() :
        _type(TypeRelative)
    {
    }
    ~FilePath() { }
 
    bool operator==(const FilePath& rhs) const
    {
        return _vec == rhs._vec &&
               _type == rhs._type;
    }
    bool operator!=(const FilePath& rhs) const
    {
        return !(*this == rhs);
    }
 
 
    FilePath(const string& str)
    {
        assign(str);
    }
 
    FilePath(const char* str)
    {
        assign(str ? string(str) : EMPTY_STRING);
    }
 
    operator string() const
    {
        return asString();
    }
 
    void assign(const string& str);
 
    string asString(Format format = FormatNative) const;
 
    bool isEmpty() const
    {
        return _vec.empty();
    }
 
    bool isAbsolute() const
    {
        return _type != TypeRelative;
    }
 
    const string& getBaseName() const
    {
        if (isEmpty())
        {
            return EMPTY_STRING;
        }
        return _vec[_vec.size() - 1];
    }
 
    FilePath getParentPath() const
    {
        FilePath parent(*this);
        if (!parent.isEmpty())
        {
            parent._vec.pop_back();
        }
        return parent;
    }
 
    string getExtension() const
    {
        const string& baseName = getBaseName();
        size_t i = baseName.rfind('.');
        return i != string::npos ? baseName.substr(i + 1) : EMPTY_STRING;
    }
 
    void addExtension(const string& ext)
    {
        assign(asString() + "." + ext);
    }
 
    void removeExtension()
    {
        if (!isEmpty())
        {
            string& baseName = _vec[_vec.size() - 1];
            size_t i = baseName.rfind('.');
            if (i != string::npos)
            {
                baseName = baseName.substr(0, i);
            }
        }
    }
 
    FilePath operator/(const FilePath& rhs) const;
 
    size_t size() const
    {
        return _vec.size();
    }
 
    string operator[](size_t index)
    {
        return _vec[index];
    }
 
    const string& operator[](size_t index) const
    {
        return _vec[index];
    }
 
    FilePath getNormalized() const;
 
 
    bool exists() const;
 
    bool isDirectory() const;
 
    FilePathVec getFilesInDirectory(const string& extension) const;
 
    FilePathVec getSubDirectories() const;
 
    void createDirectory() const;
 
    bool setCurrentPath();
 
 
    static FilePath getCurrentPath();
 
    static FilePath getModulePath();
 
  private:
    StringVec _vec;
    Type _type;
};
 
class MX_FORMAT_API FileSearchPath
{
  public:
    using Iterator = FilePathVec::iterator;
    using ConstIterator = FilePathVec::const_iterator;
 
  public:
    FileSearchPath() = default;
 
    FileSearchPath(const string& searchPath, const string& sep = PATH_LIST_SEPARATOR)
    {
        for (const string& path : splitString(searchPath, sep))
        {
            if (!path.empty())
            {
                append(FilePath(path));
            }
        }
    }
 
    string asString(const string& sep = PATH_LIST_SEPARATOR) const
    {
        string str;
        for (size_t i = 0; i < _paths.size(); i++)
        {
            str += _paths[i];
            if (i + 1 < _paths.size())
            {
                str += sep;
            }
        }
        return str;
    }
 
    void append(const FilePath& path)
    {
        _paths.push_back(path);
    }
 
    void append(const FileSearchPath& searchPath)
    {
        for (const FilePath& path : searchPath)
        {
            _paths.push_back(path);
        }
    }
 
    void prepend(const FilePath& path)
    {
        _paths.insert(_paths.begin(), path);
    }
 
    void clear()
    {
        _paths.clear();
    }
 
    size_t size() const
    {
        return _paths.size();
    }
 
    bool isEmpty() const
    {
        return _paths.empty();
    }
 
    FilePath& operator[](size_t index)
    {
        return _paths[index];
    }
 
    const FilePath& operator[](size_t index) const
    {
        return _paths[index];
    }
 
    FilePath find(const FilePath& filename) const
    {
        if (_paths.empty() || filename.isEmpty())
        {
            return filename;
        }
        if (!filename.isAbsolute())
        {
            for (const FilePath& path : _paths)
            {
                FilePath combined = path / filename;
                if (combined.exists())
                {
                    return combined;
                }
            }
        }
        return filename;
    }
 
 
    Iterator begin() { return _paths.begin(); }
    ConstIterator begin() const { return _paths.begin(); }
 
    Iterator end() { return _paths.end(); }
    ConstIterator end() const { return _paths.end(); }
 
 
  private:
    FilePathVec _paths;
};
 
MX_FORMAT_API FileSearchPath getEnvironmentPath(const string& sep = PATH_LIST_SEPARATOR);
 
MATERIALX_NAMESPACE_END
 
#endif