moveRequestProvider.cpp

Go to the documentation of this file.

#include "moveRequestProvider.h"
#include "throwcall.h"
#include "escapism.h"
#include <errMsgQueue.h>
 
defineStatic(moveRequestProvider::factory, "move");
 
void moveRequestProvider::processSource(const std::string& source) {
    auto sourceStat = InputHandler->getStat(source, dereferenceCmdLine);
    if (!sourceStat) {
        if (ignoreMissing) {
            if (! quiet) {
                errMsg::emit(errMsg::level::warning, errMsg::location(),
                             source, "stat", "not found");
            }
            return;
        }
        throw std::runtime_error("can't stat " + source);
    }
    if (sourceStat->isDir()) {
        if (recursive) {
            std::string dstPath;
            auto mapEntry = getDstPath(source, dstPath, true);
            addDirContent(source, dstPath, mapEntry, *sourceStat);
        } else {
            throw std::runtime_error(source + " is a directory");
        }
    } else {
        std::string dst;
        auto mapEntry = getDstPath(source, dst, true);
        requestList.push_front(new copyRequest::base(InputHandler, source, dst,
                               source, source, mapEntry,
                               copyRequest::clock_type::now()));
    }
}
 
void moveRequestProvider::processSources(const std::vector<std::string>& sources) {
 
    for (auto& source : sources) {
        static auto escaper = escapism::newEscaper(sourceDecodeMethod);
        if (escaper) {
            std::string srcbuf;
            escaper->deEscape(source, srcbuf);
            processSource(srcbuf);
        } else {
            processSource(source);
        }
    }
    for (auto request : requestList) {
        std::unique_ptr<copyRequest::base> item(request);
        requests.enqueue(item);
    }
    requestList.clear();
}
 
void moveRequestProvider::addDirContent(const std::string& srcpath,
                                        const std::string& dstpath,
                                        const singleMap &mapEntry,
                                        const genericStat& dirStat) {
    // with the subdir list we have only one open dir at a time
    class subdirType {
      public:
        std::string srcPath;
        std::string dstPath;
        std::unique_ptr<const genericStat> dirStat;
        subdirType(const std::string& aSrcPath,
                   const std::string& aDstPath,
                   std::unique_ptr<const genericStat>& aDirStat) :
            srcPath(aSrcPath),
            dstPath(aDstPath),
            dirStat(std::move(aDirStat)) {};
    };
    std::list<subdirType> subdirs;
    {
        auto dir = InputHandler->getDirectory(srcpath);
        while (auto entry = dir->getNextEntry(ignoreMissing)) {
            std::string subpath(srcpath);
            subpath += "/";
            subpath += entry->getName();
            std::string destpath(dstpath);
            destpath += "/";
            destpath += entry->getName();
            auto entryStat = entry->getStat();
 
            if (entryStat->isDir() &&
                    entryStat->device == dirStat.device) {
                subdirs.emplace_back(subpath, destpath, entryStat);
            } else if (entryStat->isRegularFile() || entryStat->isLink()) {
                requestList.push_front(new copyRequest::base(InputHandler, subpath, destpath,
                                       subpath, subpath, mapEntry,
                                       copyRequest::clock_type::now()));
            }
        }
    }
 
    for (auto& subdir : subdirs) {
        addDirContent(subdir.srcPath, subdir.dstPath, mapEntry, *(subdir.dirStat));
    }
}