inputHandler.h

Go to the documentation of this file.

#ifndef __inputHandler_h__
#define __inputHandler_h__
#include "ioHandle.h"
#include "pathHandler.h"
#include <unwindCheck.h>
#include <map>
#include <vector>
#include <memory>
#include <stdexcept>
 
class block;
namespace copyRequest {
    class stateType;
};
 
class delayAdvisingError: public std::runtime_error {
  public:
    delayAdvisingError(const std::string& aWhat) : std::runtime_error(aWhat) {};
    delayAdvisingError(const char* aWhat) : std::runtime_error(aWhat) {};
    ~delayAdvisingError() override = default;
};
 
namespace inputHandler {
    class base: virtual public pathHandler {
        // now follows some reflection magic
      public:
        class factoryClass;
      protected:
        static std::map<std::string, factoryClass*>& getFactoryMap() {
            static std::remove_reference<decltype(getFactoryMap())>::type map;
            return map;
        }
      public:
        class factoryClass {
          protected:
            const std::string name;
            factoryClass(const std::string& aName):
                name(aName) {
                getFactoryMap()[name] = this;
            }
          public:
            virtual base* create() const = 0;
        };
        template <class T> class factoryTemplate: public factoryClass {
          public:
            factoryTemplate(const std::string& aName): factoryClass(aName) {};
            base* create() const override {
                return new T();
            }
        };
        // end of reflection magic
      protected:
        base() = default;
      public:
        virtual ~base() override = default;
 
        class reader: protected unwindCheck, virtual public ioHandle {
          protected:
            const genericStat& readInitialStat; 
            std::remove_const<decltype(readInitialStat.size)>::type totalBytesRead = 0; 
            reader(const genericStat& inititalStat): readInitialStat(inititalStat) {};
          public:
            virtual ~reader() noexcept(false) = default;
 
            virtual bool setupSparseRegions(const std::string& /*sparseHandling*/) {
                return false;
            };
 
            virtual bool readBlock(block &b) = 0;
 
 
            virtual void readBlockP(block& /*b*/, size_t /*bytesToRead*/, off_t /*offset*/) {
                throw unimplementedActionError("parallel reading not implemented");
            }
 
            virtual void checkUnchangedness() = 0;
 
            virtual void seek(size_t /*pos*/ 
                             ) {
                throw unimplementedActionError("seek not implemented");
            };
        };
 
        virtual std::unique_ptr<reader> newReader(const std::string& path, 
                copyRequest::stateType &state, 
                const genericStat& inititalStat 
                                                 ) = 0;
 
 
        static base* newHandler(const std::string& name) {
            auto it = getFactoryMap().find(name);
            if (it != getFactoryMap().end()) {
                return it->second->create();
            }
            throw std::runtime_error("no inputHandler factory called " + name);
        }
        template <class T> static void addAllowedNamesToOption(T& option) {
            for (const auto& item : getFactoryMap()) {
                option.fAddToRange(item.first);
            }
        };
 
        virtual bool readLinkTarget(const std::string& /*path*/,
                                    std::vector<char>& /*target*/) {
            throw unimplementedActionError("link reading not implemented");
        }
 
 
        virtual std::unique_ptr<acl::list> getAclData(const std::string& /*path*/) {
            return nullptr;
        }
 
        class Directory: protected unwindCheck {
          protected:
            const std::string path;
          public:
            class Entry {
                const std::string name;
                std::unique_ptr<const genericStat> stat;
              public:
                Entry(const std::string& aName,
                      std::unique_ptr<const genericStat>& aStat): name(aName),
                    stat(std::move(aStat)) {
                };
                Entry(const std::string& aName,
                      std::unique_ptr<genericStat>& aStat): name(aName),
                    stat(std::move(aStat)) {
                };
                ~Entry() = default;
                const std::string& getName() const {
                    return name;
                };
                std::unique_ptr<const genericStat> getStat()    {
                    return std::move(stat);
                }
            };
            Directory(const std::string& aPath): path(aPath) {};
            virtual ~Directory() noexcept(false) {};
            virtual std::unique_ptr<Entry> getNextEntry(bool ignoreMissing) = 0;
        };
        virtual std::unique_ptr<Directory> getDirectory(const std::string& path) = 0;
 
    };
} // end namespace inputHandler
#endif