Filename.hh

Go to the documentation of this file.

#ifndef FILENAME_HH
#define FILENAME_HH
 
#include "FileContext.hh"
#include "FileOperations.hh"
#include <string>
 
namespace openmsx {
 
class Filename
{
public:
        // dummy constructor, to be able to serialize vector<Filename>
        Filename() = default;
        Filename(Filename&&) = default;
        Filename& operator=(Filename&&) = default;
        Filename& operator=(const Filename&) = default;
 
        //workaround msvc bug(?)
        //Filename(const Filename&) = default;
        Filename(const Filename& f)
                : originalFilename(f.originalFilename)
                , resolvedFilename(f.resolvedFilename) {}
 
        // needed because the template below hides this version
        Filename(Filename& f) : Filename(const_cast<const Filename&>(f)) {}
 
        template<typename String>
        explicit Filename(String&& filename)
                : originalFilename(std::forward<String>(filename))
                , resolvedFilename(originalFilename) {}
 
        template<typename String>
        Filename(String&& filename, const FileContext& context)
                : originalFilename(std::forward<String>(filename))
                , resolvedFilename(FileOperations::getAbsolutePath(
                        context.resolve(originalFilename))) {}
 
        [[nodiscard]] const std::string& getOriginal() const { return originalFilename; }
        [[nodiscard]] const std::string& getResolved() const & { return           resolvedFilename; }
        [[nodiscard]]       std::string  getResolved() &&      { return std::move(resolvedFilename); }
 
        void updateAfterLoadState();
 
        [[nodiscard]] bool empty() const;
 
        void setResolved(std::string resolved) {
                resolvedFilename = std::move(resolved);
        }
 
        // Do both Filename objects point to the same file?
        [[nodiscard]] bool operator==(const Filename& other) const {
                return resolvedFilename == other.resolvedFilename;
        }
 
        template<typename Archive>
        void serialize(Archive& ar, unsigned version);
 
private:
        // non-const because we want this class to be assignable
        // (to be able to store them in std::vector)
        std::string originalFilename;
        std::string resolvedFilename;
};
 
} // namespace openmsx
 
#endif