escapism.cpp

Go to the documentation of this file.

#include "escapism.h"
 
 
class escapismFactoryClass;
 
static std::map<std::string, escapismFactoryClass*>& getEscapismFactoryMap() {
    static std::remove_reference<decltype(getEscapismFactoryMap())>::type factoryMap;
    return factoryMap;
}
class escapismFactoryClass {
  public:
    escapismFactoryClass(const std::string& name) {
        getEscapismFactoryMap()[name] = this;
    }
    virtual const escapism* create() = 0;
};
template <class T> class escapismFactoryClassTemplate: public escapismFactoryClass {
  public:
    escapismFactoryClassTemplate(const std::string& name): escapismFactoryClass(name) {};
    const escapism* create() override {
        return new T();
    }
};
 
const escapism* escapism::newEscaper(const std::string& name) {
    if (name == "None") {
        return nullptr;
    }
    return getEscapismFactoryMap()[name]->create();
}
void escapism::addAllowedNamesToOption(options::single<std::string>& option) {
    for (const auto& item : getEscapismFactoryMap()) {
        option.fAddToRange(item.first);
    }
}
options::single<std::string>* escapism::newEscaperOption(const std::string& name,
        const std::string& description,
        const std::string& defaultValue) {
    auto opt = new options::single<std::string>('\0', name, description, defaultValue);
    addAllowedNamesToOption(*opt);
    if (defaultValue == "None") {
        opt->fAddToRange(defaultValue);
    }
    return opt;
}
 
class escapismUrl: public escapism {
    static escapismFactoryClassTemplate<escapismUrl> factory;
    static charCodingBitPatternType initCodeList() {
        charCodingBitPatternType codingPattern = {{0ull, 0ull, 0ull, 0ull}};
        const char* ueChars = "0123456789.-~_ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
        for (const char *c = ueChars; *c; c++) {
            codingPattern.bits[charCodingBitPatternType::index(*c)] |= charCodingBitPatternType::mask(*c);
        }
        return codingPattern;
    }
    virtual bool unencoded(char c) const {
        static charCodingBitPatternType codingPattern = initCodeList();
        return (codingPattern.bits[charCodingBitPatternType::index(c)] & charCodingBitPatternType::mask(c)) != 0ull;
    }
    void escape(const std::string& unEscaped, std::string& escaped) const override {
        for (auto c : unEscaped) {
            if (unencoded(c)) {
                escaped.push_back(c);
            } else {
                static const char hexEncode[] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
                escaped.push_back('%');
                // array indices are safe due to & 0x0f,
                escaped.push_back(hexEncode[ (c >> 4) & 0x0F ]); // NOLINT(cppcoreguidelines-pro-bounds-constant-array-index)
                escaped.push_back(hexEncode[ c & 0x0F ]); // NOLINT(cppcoreguidelines-pro-bounds-constant-array-index)
            }
        }
    }
    void deEscape(const std::string& escaped, std::string& unEscaped) const override {
        unEscaped.reserve(escaped.size()); // de-Escaped is always smaller, so this always fits and saves time
        std::remove_reference<decltype(unEscaped)>::type::value_type code;
        enum {normal, firstNibble, secondNibble} state = normal;
        for (auto c : escaped) {
            if (state == normal) {
                if (c == '%') {
                    state = firstNibble;
                    continue;
                }
                unEscaped.push_back(c);
            } else {
                decltype(code) nibble;
                if (std::isdigit(c)) {
                    nibble = c - '0';
                } else {
                    c = std::toupper(c);
                    if ('A' <= c && c <= 'F') {
                        nibble = c - 'A' + 10;
                    } else {
                        throw std::invalid_argument("bad encoding");
                    }
                }
                if (state == firstNibble) {
                    code = nibble << 4;
                    state = secondNibble;
                    continue;
                } else {
                    code |= nibble;
                    unEscaped.push_back(code);
                    state = normal;
                    continue;
                }
            }
        }
 
        if (state != normal) {
            throw std::invalid_argument("bad encoding");
        }
    }
};
decltype(escapismUrl::factory) escapismUrl::factory("Url");
 
 
class escapismUrlsoft: public escapismUrl {
    static escapismFactoryClassTemplate<escapismUrlsoft> factory;
    static charCodingBitPatternType initCodeList() {
        charCodingBitPatternType codingPattern = {{0ull, 0ull, 0ull, 0ull}};
        const char* ueChars = "0123456789.-~_ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz/";
        for (const char *c = ueChars; *c; c++) {
            codingPattern.bits[charCodingBitPatternType::index(*c)] |= charCodingBitPatternType::mask(*c);
        }
        return codingPattern;
    }
    bool unencoded(char c) const override {
        static charCodingBitPatternType codingPattern = initCodeList();
        return (codingPattern.bits[charCodingBitPatternType::index(c)] & charCodingBitPatternType::mask(c)) != 0ull;
    }
};
decltype(escapismUrlsoft::factory) escapismUrlsoft::factory("Urlsoft");
 
 
 
class escapismC: public escapism {
    static escapismFactoryClassTemplate<escapismC> factory;
    static const std::map<char, char>& getEscapeMap() {
        static std::remove_reference<decltype(getEscapeMap())>::type escapeMap{
            {'\a', 'a'},
            {'\b', 'b'},
            {'\f', 'f'},
            {'\n', 'n'},
            {'\r', 'r'},
            {'\v', 'v'},
            {'\\', '\\'},
            {' ', ' '},
            {'\'', '\''},
            {'"', '"'},
        };
        return escapeMap;
    }
    static const std::map<char, char> invertEscapeMap() {
        std::map<char, char> map;
        for (const auto& item : getEscapeMap()) {
            map.emplace(item.second, item.first);
        }
        return map;
    }
    static const std::map<char, char>& getUnEscapeMap() {
        static std::remove_reference<decltype(getUnEscapeMap())>::type unEscapeMap(invertEscapeMap());
        return unEscapeMap;
    }
 
    static charCodingBitPatternType initCodeList() {
        charCodingBitPatternType codingPattern = {{0ull, 0ull, 0ull, 0ull}};
        for (char c = ' '; c < 127; c++) {
            if (getEscapeMap().find(c) == getEscapeMap().end()) {
                codingPattern.bits[charCodingBitPatternType::index(c)] |= charCodingBitPatternType::mask(c);
            }
        }
        return codingPattern;
    }
    static bool unencoded(char c) {
        static charCodingBitPatternType codingPattern = initCodeList();
        return (codingPattern.bits[charCodingBitPatternType::index(c)] & charCodingBitPatternType::mask(c)) != 0ull;
    }
    void escape(const std::string& unEscaped, std::string& escaped) const override {
        for (auto c : unEscaped) {
            if (unencoded(c)) {
                escaped.push_back(c);
            } else {
                escaped.push_back('\\');
                auto enc = getEscapeMap().find(c);
                if (enc != getEscapeMap().end()) {
                    escaped.push_back(enc->second);
                } else {
                    escaped.push_back('0' + ((c >> 6) & 0x07));
                    escaped.push_back('0' + ((c >> 3) & 0x07));
                    escaped.push_back('0' + ((c >> 0) & 0x07));
                }
            }
        }
    }
    void deEscape(const std::string& escaped, std::string& unEscaped) const override {
        unEscaped.reserve(escaped.size()); // de-Escaped is always smaller, so this always fits and saves time
        std::remove_reference<decltype(unEscaped)>::type::value_type code;
        enum {normal, escaping, second3bits, last3bits} state = normal;
        for (auto c : escaped) {
            if (state == normal) {
                if (c == '\\') {
                    state = escaping;
                    continue;
                }
                unEscaped.push_back(c);
            } else if (state == escaping) {
                auto enc = getUnEscapeMap().find(c);
                if (enc != getUnEscapeMap().end()) {
                    unEscaped.push_back(enc->second);
                    state = normal;
                    continue;
                }
                if ('0' <= c && c <= '7') {
                    decltype(code) threeBits;
                    threeBits = c - '0';
                    code = threeBits << 6;
                    state = second3bits;
                    continue;
                } else {
                    throw std::invalid_argument("bad encoding");
                }
            } else if (state == second3bits) {
                if ('0' <= c && c <= '7') {
                    decltype(code) threeBits;
                    threeBits = c - '0';
                    code |= threeBits << 3;
                    state = last3bits;
                    continue;
                } else {
                    throw std::invalid_argument("bad encoding");
                }
            } else if (state == last3bits) {
                if ('0' <= c && c <= '7') {
                    decltype(code) threeBits;
                    threeBits = c - '0';
                    code |= threeBits << 0;
                    unEscaped.push_back(code);
                    state = normal;
                    continue;
                } else {
                    throw std::invalid_argument("bad encoding");
                }
            }
        }
 
        if (state != normal) {
            throw std::invalid_argument("bad encoding");
        }
    }
};
decltype(escapismC::factory) escapismC::factory("C");