requestProvider.cpp

Go to the documentation of this file.

#include "requestProvider.h"
#include "ewmscp.h"
#include "errMsgQueue.h"
#include <libgen.h>
#include <string.h>
 
defineStatic(requestProvider::pathMap, '\0', "pathMap",
             "map of source to destination directories");
defineStatic(requestProvider::badMapEntry, "no map", "found");
 
decltype(requestProvider::getFactoryMap()) requestProvider::getFactoryMap() {
    static std::remove_reference<decltype(getFactoryMap())>::type map;
    return map;
}
 
requestProvider* requestProvider::newProvider(const std::string& choice,
        decltype(requests) aRequests,
        decltype(delayedRequests) aDelayedRequests,
        decltype(parents) aParents,
        decltype(InputHandler) aInputHandler,
        decltype(OutputHandler) aOutputHandler) {
    return getFactoryMap()[choice]->create(aRequests, aDelayedRequests, aParents, aInputHandler, aOutputHandler);
}
void requestProvider::addAllowedNamesToOption(options::single<std::string>& option) {
    for (const auto& item : getFactoryMap()) {
        option.fAddToRange(item.first);
    }
}
 
const singleMap& requestProvider::getDstPath(const std::string& source,
        std::string& destination,
        bool baseNameOnly) {
    for (const auto& item : pathMap) {
        if (item.first.empty() // we have the catchall item
                || source.find(item.first) == 0) { // srcPath starts with this mapped dir
            destination = item.second;
            if (destination.back() != '/') {
                destination += "/";
            }
            auto shortPath = source.substr(item.first.size());
            while (!shortPath.empty() && shortPath.front() == '/') {
                shortPath.erase(0, 1);
            }
            if (parents && !baseNameOnly) {
                if (shortPath.find("./") == 0) {
                    destination += shortPath.substr(2);
                } else {
                    destination += shortPath;
                }
            } else {
                auto disposable_buffer = strdup(shortPath.c_str());
                destination += basename(disposable_buffer);
                free(disposable_buffer);
            }
            return item;
        }
    }
    errMsg::emit(errMsg::level::crit, errMsg::location(),
                 source, "map paths", "no dir mapping found");
    for (const auto& item : pathMap) {
        errMsg::emit(errMsg::level::crit, errMsg::location(),
                     source, "map paths",
                     "candidate: ", item.first, " -> ", item.second);
    }
    throw std::runtime_error("no dir mapping found for " + source);
    return badMapEntry;
}
 
 
void requestProvider::prepareMappings(std::vector<std::string>& sources,
                                      std::string& destination) {
    if (!destination.empty()) { // last arg (destination) is also a source
        sources.push_back(destination);
        destination.clear();
    }
    if (pathMap.empty()) {
        throw std::runtime_error("no mapping given");
    }
}
 
void requestProvider::printMappings(std::ostream& stream) {
    stream << "Path mapping:\n";
    stream << "There are " << pathMap.size() << " directory mappings:\n";
    for (const auto& item : pathMap) {
        stream << "'" << item.first << "' -> '" << item.second << "'\n";
    }
}