listingRequestProvider.cpp

Go to the documentation of this file.

#include "listingRequestProvider.h"
#include "throwcall.h"
#include "escapism.h"
#include "ewmscp.h"
#include "timer.h"
 
defineStatic(listingRequestProvider::factory, "listing");
 
 
 
namespace copyRequest {
    class listingRequest: public base {
      protected:
        static options::single<bool> reverse;
        static options::single<bool> sortByTime;
        static options::single<bool> sortBySize;
 
        void printModeBits(std::ostream& stream, mode_t bits) {
            stream << (bits & 4 ? "r" : "-") << (bits & 2 ? "w" : "-")  << (bits & 1 ? "x" : "-");
        }
        void printMode(std::ostream& stream, mode_t bits) {
            switch (bits & S_IFMT) {
                case S_IFSOCK:
                    stream << "s";
                    break;
                case S_IFLNK:
                    stream << "l";
                    break;
                case S_IFREG:
                    stream << "-";
                    break;
                case S_IFBLK:
                    stream << "b";
                    break;
                case S_IFDIR:
                    stream << "d";
                    break;
                case S_IFCHR:
                    stream << "c";
                    break;
                case S_IFIFO:
                    stream << "f";
                    break;
            }
            printModeBits(stream, bits >> 6);
            printModeBits(stream, bits >> 3);
            printModeBits(stream, bits >> 0);
            stream << " ";
        }
        static singleMap dummyMapEntry;
      public:
        listingRequest(const std::string& aSource,
                       std::unique_ptr<const genericStat>& aStat,
                       inputHandler::base* aInputHandler):
            base(aInputHandler, aSource, "", aStat, dummyMapEntry, false, copyRequest::clock_type::now()) {}
        void process(perThreadData& /*threadData*/) override {
        }
        bool compare(const base& rhs) const override {
            if (sortByTime) {
                return (readInitialStat->mTime > rhs.getInitialStat().mTime) ^ reverse;
            } else if (sortBySize) {
                return (readInitialStat->size > rhs.getInitialStat().size) ^ reverse;
            } else {
                return (source < rhs.getSource()) ^ reverse;
            }
        }
 
        void printResults(std::ostream& /*hashStream*/,
                          std::ostream& logStream) override {
            static auto escaper = escapism::newEscaper("C");
            timerInst(print);
            std::string name;
            escaper->escape(source, name);
            printMode(logStream, readInitialStat->mode);
            logStream << std::setw(6)  << readInitialStat->ownerUid << " ";
            logStream << std::setw(10) << readInitialStat->ownerGid << " ";
            logStream << std::setw(13) << readInitialStat->size << " ";
            std::string time;
            readInitialStat->getMtime(time);
            logStream << time << " ";
            logStream << name << "\n";
            timerInst(nix);
        }
        static void printFinalLine(std::ostream& /*stream*/) {
        }
        static void prepareStatPrint() {
            statPrinter = printFinalLine;
        }
    };
    defineStatic(listingRequest::reverse, 'r', "reverse", "sort listing in reverse order");
    defineStatic(listingRequest::sortByTime, 't', "sortByMtime", "sort listing by mTime");
    defineStatic(listingRequest::sortBySize, 'S', "sortBySize", "sort listing by size");
    defineStatic(listingRequest::dummyMapEntry, {"dummy", "entry"});
} // end namespace copyRequest
 
 
 
 
 
 
copyRequest::base* listingRequestProvider::newRequest(inputHandler::base* aInputHandler,
        const std::string& aSource,
        const std::string& /*aDestination*/,
        std::unique_ptr<const genericStat>& aStat,
        const singleMap& /*aMapEntry*/,
        bool /*remove*/,
        copyRequest::clock_type::time_point /*timestamp*/) {
    return new copyRequest::listingRequest(aSource, aStat, aInputHandler);
}
 
 
 
 
void listingRequestProvider::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();
    }
    singleDestination = "/dev/null";
}