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() = default;
 
    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.resize(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 = EMPTY_STRING) const;

    FilePathVec getSubDirectories() const;

    void createDirectory(bool recursive = false) 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