fileInWork.cpp

Go to the documentation of this file.

#include "fileInWork.h"
#include "copyRequest.h"
 
namespace copyRequest {
    defineStaticNoArg(copyRequest::fileInWork::filesInWork);
    defineStaticNoArg(copyRequest::fileInWork::filesInWorkMutex);
    defineStaticNoArg(copyRequest::fileInWork::cv);
 
 
    std::ostream& operator<< (std::ostream& stream,
                              fileInWork::slotTypes t) {
        switch (t) {
            case fileInWork::slotTypes::none:
                stream << "none";
                break;
            case fileInWork::slotTypes::copy:
                stream << "copy";
                break;
            case fileInWork::slotTypes::move:
                stream << "move";
                break;
            case fileInWork::slotTypes::unlink:
                stream << "unlink";
                break;
            default:
                stream << "oops";
                break;
        }
        return stream;
    }
 
    void copyRequest::fileInWork::waitForAllInstancesGone() {
        std::unique_lock<decltype(filesInWorkMutex)> lock(filesInWorkMutex);
 
        timerInst(wait);
        while (! filesInWork.empty()) {
            cv.wait(lock);
        }
    }
 
    fileInWork::slotTypes fileInWork::getLatestRequestType() const {
        if (this->empty()) {
            return queuedRequestType;
        } else {
            return this->back()->getSlotType();
        }
    }
 
 
    void fileInWork::inserter::enRegister(std::unique_ptr<copyRequest::base>& request) {
        request->registerIterator(iter);
        iter->second.remove_if([&request](std::unique_ptr<copyRequest::base>& item) {
            return item->getSlotType() == request->getSlotType();
        });
        iter->second.emplace_back(std::move(request));
    }
    void fileInWork::inserter::markForQueueing(std::unique_ptr<copyRequest::base>& request) {
        request->registerIterator(iter);
        getFileInWork().queuedRequestType = request->getSlotType();
    }
 
 
    fileInWork::eraser::eraser(const copyRequest::base& request):
        lockuser(request.getFilesInWorkIteraror()) {
    }
    std::unique_ptr<copyRequest::base> fileInWork::eraser::getNext() {
        if (iter == filesInWork.end()) { // happens for nonFollow request providers
            return nullptr;
        }
        if (iter->second.empty()) {
            timerInst(erase);
            filesInWork.erase(iter);
            return nullptr;
        } else {
            auto request = std::move(iter->second.front());
            iter->second.pop_front();
            iter->second.queuedRequestType = request->getSlotType();
            return request;
        }
    }
    fileInWork::typeChanger::typeChanger(copyRequest::base& request, stateBitType newType) :
        lockuser(request.getFilesInWorkIteraror()) {
        request.state.clear(stateBitType::action);
        request.state.set(newType);
    }
}; // end namespace copyRequest