FilePool.cc

Go to the documentation of this file.

#include "FilePool.hh"
#include "File.hh"
#include "FileContext.hh"
#include "FileOperations.hh"
#include "TclObject.hh"
#include "CommandException.hh"
#include "Display.hh"
#include "EventDistributor.hh"
#include "CliComm.hh"
#include "Reactor.hh"
#include "outer.hh"
#include "xrange.hh"
#include <memory>
 
namespace openmsx {
 
[[nodiscard]] static TclObject initialFilePoolSettingValue()
{
        TclObject result;
 
        for (const auto& p : systemFileContext().getPaths()) {
                result.addListElement(
                        makeTclDict("-path", tmpStrCat(p, "/systemroms"),
                                    "-types", "system_rom"),
                        makeTclDict("-path", tmpStrCat(p, "/software"),
                                    "-types", "rom disk tape"));
        }
        return result;
}
 
FilePool::FilePool(CommandController& controller, Reactor& reactor_)
        : core(FileOperations::getUserDataDir() + "/.filecache",
               [&] { return getDirectories(); },
               [&](std::string_view message) { reportProgress(message); })
        , filePoolSetting(
                controller, "__filepool",
                "This is an internal setting. Don't change this directly, "
                "instead use the 'filepool' command.",
                initialFilePoolSettingValue().getString())
        , reactor(reactor_)
        , sha1SumCommand(controller)
{
        filePoolSetting.attach(*this);
        reactor.getEventDistributor().registerEventListener(EventType::QUIT, *this);
}
 
FilePool::~FilePool()
{
        reactor.getEventDistributor().unregisterEventListener(EventType::QUIT, *this);
        filePoolSetting.detach(*this);
}
 
File FilePool::getFile(FileType fileType, const Sha1Sum& sha1sum)
{
        return core.getFile(fileType, sha1sum);
}
 
Sha1Sum FilePool::getSha1Sum(File& file)
{
        return core.getSha1Sum(file);
}
 
[[nodiscard]] static FileType parseTypes(Interpreter& interp, const TclObject& list)
{
        auto result = FileType::NONE;
        for (auto i : xrange(list.getListLength(interp))) {
                std::string_view elem = list.getListIndex(interp, i).getString();
                if (elem == "system_rom") {
                        result |= FileType::SYSTEM_ROM;
                } else if (elem == "rom") {
                        result |= FileType::ROM;
                } else if (elem == "disk") {
                        result |= FileType::DISK;
                } else if (elem == "tape") {
                        result |= FileType::TAPE;
                } else {
                        throw CommandException("Unknown type: ", elem);
                }
        }
        return result;
}
 
FilePoolCore::Directories FilePool::getDirectories() const
{
        FilePoolCore::Directories result;
        try {
                auto& interp = filePoolSetting.getInterpreter();
                const TclObject& all = filePoolSetting.getValue();
                for (auto i : xrange(all.getListLength(interp))) {
                        FilePoolCore::Dir dir;
                        bool hasPath = false;
                        dir.types = FileType::NONE;
                        TclObject line = all.getListIndex(interp, i);
                        unsigned numItems = line.getListLength(interp);
                        if (numItems & 1) {
                                throw CommandException(
                                        "Expected a list with an even number "
                                        "of elements, but got ", line.getString());
                        }
                        for (unsigned j = 0; j < numItems; j += 2) {
                                std::string_view name  = line.getListIndex(interp, j + 0).getString();
                                TclObject value = line.getListIndex(interp, j + 1);
                                if (name == "-path") {
                                        dir.path = value.getString();
                                        hasPath = true;
                                } else if (name == "-types") {
                                        dir.types = parseTypes(interp, value);
                                } else {
                                        throw CommandException("Unknown item: ", name);
                                }
                        }
                        if (!hasPath) {
                                throw CommandException(
                                        "Missing -path item: ", line.getString());
                        }
                        if (dir.types == FileType::NONE) {
                                throw CommandException(
                                        "Missing -types item: ", line.getString());
                        }
                        result.push_back(std::move(dir));
                }
        } catch (CommandException& e) {
                reactor.getCliComm().printWarning(
                        "Error while parsing '__filepool' setting", e.getMessage());
        }
        return result;
}
 
void FilePool::update(const Setting& setting) noexcept
{
        assert(&setting == &filePoolSetting); (void)setting;
        (void)getDirectories(); // check for syntax errors
}
 
void FilePool::reportProgress(std::string_view message)
{
        if (quit) core.abort();
        reactor.getCliComm().printProgress(message);
        reactor.getDisplay().repaint();
}
 
int FilePool::signalEvent(const Event& event)
{
        (void)event; // avoid warning for non-assert compiles
        assert(getType(event) == EventType::QUIT);
        quit = true;
        return 0;
}
 
 
// class Sha1SumCommand
 
FilePool::Sha1SumCommand::Sha1SumCommand(
                CommandController& commandController_)
        : Command(commandController_, "sha1sum")
{
}
 
void FilePool::Sha1SumCommand::execute(std::span<const TclObject> tokens, TclObject& result)
{
        checkNumArgs(tokens, 2, "filename");
        File file(FileOperations::expandTilde(std::string(tokens[1].getString())));
        auto& filePool = OUTER(FilePool, sha1SumCommand);
        result = filePool.getSha1Sum(file).toString();
}
 
std::string FilePool::Sha1SumCommand::help(std::span<const TclObject> /*tokens*/) const
{
        return "Calculate sha1 value for the given file. If the file is "
               "(g)zipped the sha1 is calculated on the unzipped version.";
}
 
void FilePool::Sha1SumCommand::tabCompletion(std::vector<std::string>& tokens) const
{
        completeFileName(tokens, userFileContext());
}
 
} // namespace openmsx