fileInWork.h

Go to the documentation of this file.

#ifndef __fileInWork_h__
#define __fileInWork_h__
#include "copyRequestTypes.h"
#include <list>
#include <memory>
#include <iostream>
#include "timer.h"
 
namespace copyRequest {
    class base;
 
 
 
    class fileInWork : public std::list<std::unique_ptr<base>> {
      public:
        enum class slotTypes { none, copy, move, unlink, nTypes };
 
      private:
        clock_type::time_point earliestProcessTime;  
        clock_type::duration waitTime;  
        slotTypes queuedRequestType;
      public:
        static std::map<std::string, fileInWork> filesInWork; 
        static std::mutex filesInWorkMutex; 
        static std::condition_variable cv; 
 
 
        slotTypes getLatestRequestType() const;
      protected:
 
        class lockuser {
          protected:
            std::unique_lock<decltype(filesInWorkMutex)> lock;
            decltype(filesInWork)::iterator iter;
            lockuser(decltype(iter) Iter) :  lock(filesInWorkMutex), iter(Iter) {
            }
            lockuser() :  lock(filesInWorkMutex) {
            }
            ~lockuser() = default;
 
          public:
            bool empty() const {
                return iter->second.empty();
            }
        };
      public:
        fileInWork(clock_type::time_point earliest):
            earliestProcessTime(earliest),
            waitTime(clock_type::duration::zero()),
            queuedRequestType(slotTypes::none) {
        }
        ~fileInWork() {
            cv.notify_all();
        }
        void setWaitTime(clock_type::duration aWaitTime) {
            waitTime = aWaitTime;
        }
        void updateExecTime(clock_type::time_point start) {
            earliestProcessTime = start + waitTime;
        }
        clock_type::time_point getEarliestprocessTime() const {
            return earliestProcessTime;
        }
 
        static void waitForAllInstancesGone();
 
        class inserter: public lockuser {
          public:
            inserter(const std::string& fileName) {
                timerInst(create);
                iter = filesInWork.find(fileName);
                if (iter == filesInWork.end()) {
                    timerInst(emplace);
                    auto result = filesInWork.emplace(fileName, clock_type::now());
                    iter = result.first;
                }
            }
            void enRegister(std::unique_ptr<copyRequest::base>& request);
 
            fileInWork& getFileInWork() {
                return iter->second;
            }
            void markForQueueing(std::unique_ptr<copyRequest::base>& request);
        };
 
        class eraser: protected lockuser {
          public:
            eraser(const copyRequest::base& request);
            std::unique_ptr<copyRequest::base> getNext();
        };
 
        class typeChanger: protected lockuser {
          public:
            typeChanger(copyRequest::base& request, stateBitType newType);
        };
    };
}; // end namespace copyRequest
 
#endif