requestProvider.h

Go to the documentation of this file.

#ifndef __requestProvider_h__
#define __requestProvider_h__
#include "copyRequest.h"
 
 
//typedef std::pair<std::string, std::string> singleMap;
 
class requestProvider {
  public:
  private:
    struct pathMapCmp {
        bool operator()(const singleMap& lhs,
                        const singleMap& rhs) const {
            if (lhs.first.size() == rhs.first.size()) {
                return lhs.first < rhs.first;
            } else {
                return lhs.first.size() > rhs.first.size();
            }
 
        }
    };
    typedef std::set<singleMap, pathMapCmp> pathMapType;
  protected:
    static options::map<std::string, pathMapType> pathMap;
    static singleMap badMapEntry;
    copyRequest::simpleQueue& requests;
    copyRequest::timedQueue& delayedRequests;
    bool parents;
    inputHandler::base* InputHandler;
    outputHandler::base* OutputHandler;
 
 
 
    // now follows some reflection magic
    class factoryClass;
    static std::map<std::string, factoryClass*>& getFactoryMap();
    class factoryClass {
      protected:
        factoryClass(const std::string& name) {
            getFactoryMap()[name] = this;
        }
      public:
        virtual requestProvider* create(decltype(requests) aRequests,
                                        decltype(delayedRequests) aDelayedRequests,
                                        decltype(parents) aParents,
                                        decltype(InputHandler) aInputHandler,
                                        decltype(OutputHandler) aOutputHandler) = 0;
    };
    template <class T> class factoryTemplate: public factoryClass {
      public:
        factoryTemplate(const std::string& name): factoryClass(name) {};
        requestProvider* create(decltype(requests) aRequests,
                                decltype(delayedRequests) aDelayedRequests,
                                decltype(parents) aParents,
                                decltype(InputHandler) aInputHandler,
                                decltype(OutputHandler) aOutputHandler
                               ) override {
            return new T(aRequests, aDelayedRequests, aParents, aInputHandler, aOutputHandler);
        }
    };
    // end of reflection magic
 
    virtual const singleMap& getDstPath(const std::string& source, 
                                        std::string& destination, 
                                        bool baseNameOnly = false); 
  public:
    requestProvider(decltype(requests) aRequests,
                    decltype(delayedRequests) aDelayedRequests,
                    decltype(parents) aParents,
                    decltype(InputHandler) aInputHandler,
                    decltype(OutputHandler) aOutputHandler):
        requests(aRequests),
        delayedRequests(aDelayedRequests),
        parents(aParents),
        InputHandler(aInputHandler),
        OutputHandler(aOutputHandler) {
    };
    virtual ~requestProvider() = default;
    virtual bool isFollowMode() const = 0;
    virtual void prepareMappings(std::vector<std::string>& sources,
                                 std::string& destination);
    virtual void printMappings(std::ostream& stream);
    virtual void processSources(const std::vector<std::string>& sources) = 0;
 
    static requestProvider* newProvider(const std::string& choice,
                                        decltype(requests) aRequests,
                                        decltype(delayedRequests) aDelayedRequests,
                                        decltype(parents) aParents,
                                        decltype(InputHandler) aInputHandler,
                                        decltype(OutputHandler) aOutputHandler);
    static void addAllowedNamesToOption(options::single<std::string>& option);
 
};
 
 
#endif