Added CMake support

1 files changed, 243 insertions, 0 deletions

diff --git a/utils/gen_adldata/ini/ini_processing_variant.h b/utils/gen_adldata/ini/ini_processing_variant.h
new file mode 100644
index 0000000..34f999a
--- /dev/null
+++ b/utils/gen_adldata/ini/ini_processing_variant.h
@@ -0,0 +1,243 @@
+/*
+INI Processor - a small library which allows you parsing INI-files
+
+Copyright (c) 2017 Vitaliy Novichkov <admin@wohlnet.ru>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the "Software"),
+to deal in the Software without restriction, including without limitation the
+rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+*/
+
+/*
+A QVariant-like thing created just like a proxy between
+INI Processor and target value (to be compatible with QSettings)
+*/
+
+#ifndef INI_PROCESSING_VARIANT_H
+#define INI_PROCESSING_VARIANT_H
+
+#include <string>
+#include <cstring>
+#include <cstdlib>
+#ifdef INI_PROCESSING_ALLOW_QT_TYPES
+#include <QString>
+#endif
+
+class IniProcessingVariant
+{
+    std::string  m_data;
+    std::string *m_dataP;
+    inline std::string &data()
+    {
+        if(m_dataP)
+            return *m_dataP;
+        else
+            return m_data;
+    }
+public:
+    IniProcessingVariant():
+        m_data(""),
+        m_dataP(nullptr) {}
+
+    IniProcessingVariant(const std::string &data):
+        m_data(data),
+        m_dataP(nullptr) {}
+    IniProcessingVariant(const char *data):
+        m_data(data),
+        m_dataP(nullptr) {}
+    #ifdef INI_PROCESSING_ALLOW_QT_TYPES
+    IniProcessingVariant(const QString &data):
+        m_data(data.toStdString()),
+        m_dataP(nullptr) {}
+    #endif
+    IniProcessingVariant(std::string *dataPointer):
+        m_data(""),
+        m_dataP(dataPointer) {}
+
+    IniProcessingVariant(const IniProcessingVariant &v):
+        m_data(v.m_data),
+        m_dataP(v.m_dataP) {}
+
+    IniProcessingVariant(char data):
+        m_data(std::to_string(data)),
+        m_dataP(nullptr) {}
+
+    IniProcessingVariant(unsigned char data):
+        m_data(std::to_string(data)),
+        m_dataP(nullptr) {}
+
+    IniProcessingVariant(bool data):
+        m_data(std::to_string(data)),
+        m_dataP(nullptr) {}
+
+    IniProcessingVariant(short data):
+        m_data(std::to_string(data)),
+        m_dataP(nullptr) {}
+
+    IniProcessingVariant(unsigned short data):
+        m_data(std::to_string(data)),
+        m_dataP(nullptr) {}
+
+    IniProcessingVariant(int data):
+        m_data(std::to_string(data)),
+        m_dataP(nullptr) {}
+    IniProcessingVariant(unsigned int data):
+        m_data(std::to_string(data)),
+        m_dataP(nullptr) {}
+
+    IniProcessingVariant(long data):
+        m_data(std::to_string(data)),
+        m_dataP(nullptr) {}
+    IniProcessingVariant(unsigned long data):
+        m_data(std::to_string(data)),
+        m_dataP(nullptr) {}
+
+    IniProcessingVariant(long long data):
+        m_data(std::to_string(data)),
+        m_dataP(nullptr) {}
+    IniProcessingVariant(unsigned long long data):
+        m_data(std::to_string(data)),
+        m_dataP(nullptr) {}
+
+    IniProcessingVariant(float data):
+        m_data(std::to_string(data)),
+        m_dataP(nullptr) {}
+
+    IniProcessingVariant(double data):
+        m_data(std::to_string(data)),
+        m_dataP(nullptr) {}
+
+    IniProcessingVariant(long double data):
+        m_data(std::to_string(data)),
+        m_dataP(nullptr) {}
+
+    bool isNull()
+    {
+        return (m_data.empty() && !m_dataP);
+    }
+
+    bool isValid()
+    {
+        return ((!m_data.empty()) || (static_cast<std::string *>(m_dataP)));
+    }
+
+    std::string toString()
+    {
+        std::string out = data();
+
+        if((out.size() > 2) && (out[0] == '"'))
+            out.erase(0, 1);
+
+        if((out.size() > 1) && (out[out.size() - 1] == '"'))
+            out.erase((out.size() - 1), 1);
+
+        return out;
+    }
+
+    #ifdef INI_PROCESSING_ALLOW_QT_TYPES
+    QString toQString()
+    {
+        return QString::fromStdString(toString());
+    }
+    #endif
+
+    bool toBool()
+    {
+        size_t i = 0;
+        size_t ss = std::min(static_cast<size_t>(4ul), data().size());
+        char buff[4] = {0, 0, 0, 0};
+        const char *pbufi = data().c_str();
+        char *pbuff = buff;
+
+        for(; i < ss; i++)
+            (*pbuff++) = static_cast<char>(std::tolower(*pbufi++));
+
+        if(ss < 4)
+        {
+            if(ss == 0)
+                return false;
+
+            if(ss == 1)
+                return (buff[0] == '1');
+
+            try
+            {
+                long num = std::strtol(buff, 0, 0);
+                return num != 0l;
+            }
+            catch(...)
+            {
+                bool res = (std::memcmp(buff, "yes", 3) == 0) ||
+                           (std::memcmp(buff, "on", 2) == 0);
+                return res;
+            }
+        }
+
+        if(std::memcmp(buff, "true", 4) == 0)
+            return true;
+
+        try
+        {
+            long num = std::strtol(buff, 0, 0);
+            return num != 0l;
+        }
+        catch(...)
+        {
+            return false;
+        }
+    }
+
+    int toInt()
+    {
+        return std::atoi(data().c_str());
+    }
+    unsigned int toUInt()
+    {
+        return static_cast<unsigned int>(std::strtoul(data().c_str(), nullptr, 0));
+    }
+
+    long toLong()
+    {
+        return std::atol(data().c_str());
+    }
+    unsigned long toULong()
+    {
+        return std::strtoul(data().c_str(), nullptr, 0);
+    }
+
+    long long toLongLong()
+    {
+        return std::atoll(data().c_str());
+    }
+    unsigned long long toULongLong()
+    {
+        return std::strtoull(data().c_str(), nullptr, 0);
+    }
+
+    float toFloat()
+    {
+        return float(std::atof(data().c_str()));
+    }
+
+    double toDouble()
+    {
+        return std::atof(data().c_str());
+    }
+};
+
+
+#endif // INI_PROCESSING_VARIANT_H