renameEventHandler.h

Go to the documentation of this file.

#ifndef __renameEventHandler_h_
#define __renameEventHandler_h_
 
#include "requestProvider.h"
 
class renameHalfEvent {
  public:
    typedef long cookieType;
    typedef std::chrono::system_clock timeType;
    typedef std::string pathType;
    typedef std::map<cookieType, renameHalfEvent> mapType;
    static bool cmp(const renameHalfEvent* lhs, const renameHalfEvent* rhs) {
        return lhs->timestamp < rhs->timestamp;
    };
    typedef std::multiset<renameHalfEvent*, decltype(cmp)*> setType;
    enum class moveTypeEnum {
        moveFrom,
        moveTo
    };
  public:
    cookieType cookie;
    pathType srcPath;
    pathType dstPath;
    moveTypeEnum moveType;
    const singleMap& mapEntry;
    timeType::time_point timestamp;
    setType::iterator setIterator;
    renameHalfEvent(cookieType aCookie,
                    const pathType& aSrcPath,
                    const pathType& aDstPath,
                    moveTypeEnum aMoveType,
                    const singleMap& aMapEntry,
                    timeType::time_point aTimestamp):
        cookie(aCookie), srcPath(aSrcPath), dstPath(aDstPath),
        moveType(aMoveType), mapEntry(aMapEntry), timestamp(aTimestamp) {};
};
 
class renameEventHandler {
    renameHalfEvent::mapType renameEventMap;
    renameHalfEvent::setType renameEventSet;
  public:
    renameEventHandler() = default;
    const renameHalfEvent* getRenamePartner(renameHalfEvent::cookieType cookie,
                                            const renameHalfEvent::pathType& aSrcPath,
                                            const renameHalfEvent::pathType& aDstPath,
                                            renameHalfEvent::moveTypeEnum aIsMoveFrom,
                                            const singleMap& aMapEntry,
                                            renameHalfEvent::timeType::time_point aTimestamp) {
        auto result = renameEventMap.emplace(std::piecewise_construct,
                                             std::forward_as_tuple(cookie),
                                             std::forward_as_tuple(cookie,
                                                     aSrcPath,
                                                     aDstPath,
                                                     aIsMoveFrom,
                                                     aMapEntry,
                                                     aTimestamp));
        auto& event = result.first->second;
        if (result.second) { // no partner found, event is new
            event.setIterator = renameEventSet.emplace(&event);
            return nullptr;
        } else { // partner found, event is old
            renameEventSet.erase(event.setIterator);
            return &event;
        }
    }
    void forgetRenameEvent(const renameHalfEvent* what) {
        renameEventMap.erase(what->cookie);
    }
    const renameHalfEvent *getNextStaleSingle(renameHalfEvent::timeType::duration timeout) {
        auto it = renameEventSet.begin();
        renameHalfEvent::timeType::time_point age_limit = renameHalfEvent::timeType::now() -
                timeout;
        if (it != renameEventSet.end() &&
                (*it)->timestamp < age_limit) {
            auto retval = *it;
            renameEventSet.erase(it);
            return retval;
        }
        return nullptr;
    }
};
#endif