checksumBase.h

Go to the documentation of this file.

#ifndef __checksumClass_h__
#define __checksumClass_h__
#include <string>
#include <stdexcept>
#include <map>
 
namespace checksum {
    class base {
        // 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;
            explicit factoryClass(const std::string& aName):
                name(aName) {
                getFactoryMap()[name] = this;
            }
          public:
            virtual base* create() const = 0;
        };
        template <class T> class factoryTemplate: public factoryClass {
          public:
            explicit factoryTemplate(const std::string& aName): factoryClass(aName) {};
            base* create() const override {
                return new T(name);
            }
        };
        // end of reflection magic
      protected:
        const std::string& name;
        std::string result;
        std::string expected;
        explicit base(const std::string& aName): name(aName) {}
      public:
        virtual ~base() = default;
        virtual bool parallelizable() const {
            return false;
        }
        const std::string& getName() const {
            return name;
        };
        const std::string& getResult() const {
            return result;
        };
        void setExpectedResult(const std::string& expectedResult) {
            expected = expectedResult;
        }
        const std::string& getExpectedResult() const {
            return expected;
        }
        bool checkExpectation() const {
            if (expected.empty()) { // always agree on unset expectation
                return true;
            }
            return result == expected;
        }
        virtual void update(void *data, size_t size) = 0;
        virtual void update(size_t size) = 0;
        virtual void finish() = 0;
 
        static factoryClass* newFactory(const std::string& aName) {
            auto it = getFactoryMap().find(aName);
            if (it != getFactoryMap().end()) {
                return it->second;
            }
            throw std::runtime_error("no checksum factory called " + aName);
        }
        template <class T> static void addAllowedNamesToOption(T& option) {
            for (const auto& item : getFactoryMap()) {
                option.fAddToRange(item.first);
            }
        };
    };
 
    class parallel {
      public:
        virtual void update(void *data, size_t size, size_t offset) = 0;
        virtual void update(size_t size, size_t offset) = 0;
        virtual void parallelFinish() = 0;
    };
 
}; // end namespace checksum
#endif