Tileson.hpp

 
 
#ifndef TILESON_TILESON_H
#define TILESON_TILESON_H
 
 
 
 
/* Copyright (c) 2013 Dropbox, Inc.
 *
 * 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.
 */
 
#pragma once
 
#include <initializer_list>
#include <map>
#include <memory>
#include <string>
#include <vector>
 
#define JSON11_IS_DEFINED
 
#ifdef _MSC_VER
    #if _MSC_VER <= 1800 // VS 2013
        #ifndef noexcept
            #define noexcept throw()
        #endif
 
        #ifndef snprintf
            #define snprintf _snprintf_s
        #endif
    #endif
#endif
 
namespace json11 {
 
    enum JsonParse {
        STANDARD,
        COMMENTS
    };
 
    class JsonValue;
 
    class Json final {
    public:
        // Types
        enum Type {
            NUL,
            NUMBER,
            BOOL,
            STRING,
            ARRAY,
            OBJECT
        };
 
        // Array and object typedefs
        typedef std::vector<Json> array;
        typedef std::map<std::string, Json> object;
 
        // Constructors for the various types of JSON value.
        inline Json() noexcept; // NUL
        inline Json(std::nullptr_t) noexcept; // NUL
        inline Json(double value); // NUMBER
        inline Json(int value); // NUMBER
        inline Json(bool value); // BOOL
        inline Json(const std::string &value); // STRING
        inline Json(std::string &&value); // STRING
        inline Json(const char *value); // STRING
        inline Json(const array &values); // ARRAY
        inline Json(array &&values); // ARRAY
        inline Json(const object &values); // OBJECT
        inline Json(object &&values); // OBJECT
 
        // Implicit constructor: anything with a to_json() function.
        template<class T, class = decltype(&T::to_json)>
        inline Json(const T &t) : Json(t.to_json())
        {}
 
        // Implicit constructor: map-like objects (std::map, std::unordered_map, etc)
        template<class M, typename std::enable_if<std::is_constructible<std::string, decltype(std::declval<M>().begin()->first)>::value &&
                                                      std::is_constructible<Json, decltype(std::declval<M>().begin()->second)>::value,
                                                  int>::type = 0>
        inline Json(const M &m) : Json(object(m.begin(), m.end()))
        {}
 
        // Implicit constructor: vector-like objects (std::list, std::vector, std::set, etc)
        template<class V, typename std::enable_if<std::is_constructible<Json, decltype(*std::declval<V>().begin())>::value, int>::type = 0>
        inline Json(const V &v) : Json(array(v.begin(), v.end()))
        {}
 
        // This prevents Json(some_pointer) from accidentally producing a bool. Use
        // Json(bool(some_pointer)) if that behavior is desired.
        Json(void *) = delete;
 
        // Accessors
        inline Type type() const;
 
        inline bool is_null() const { return type() == NUL; }
 
        inline bool is_number() const { return type() == NUMBER; }
 
        inline bool is_bool() const { return type() == BOOL; }
 
        inline bool is_string() const { return type() == STRING; }
 
        inline bool is_array() const { return type() == ARRAY; }
 
        inline bool is_object() const { return type() == OBJECT; }
 
        // Return the enclosed value if this is a number, 0 otherwise. Note that json11 does not
        // distinguish between integer and non-integer numbers - number_value() and int_value()
        // can both be applied to a NUMBER-typed object.
        inline double number_value() const;
        inline int int_value() const;
 
        // Return the enclosed value if this is a boolean, false otherwise.
        inline bool bool_value() const;
        // Return the enclosed string if this is a string, "" otherwise.
        inline const std::string &string_value() const;
        // Return the enclosed std::vector if this is an array, or an empty vector otherwise.
        inline const array &array_items() const;
        // Return the enclosed std::map if this is an object, or an empty map otherwise.
        inline const object &object_items() const;
 
        // Return a reference to arr[i] if this is an array, Json() otherwise.
        inline const Json &operator[](size_t i) const;
        // Return a reference to obj[key] if this is an object, Json() otherwise.
        inline const Json &operator[](const std::string &key) const;
 
        // Serialize.
        inline void dump(std::string &out) const;
 
        inline std::string dump() const
        {
            std::string out;
            dump(out);
            return out;
        }
 
        // Parse. If parse fails, return Json() and assign an error message to err.
        static inline Json parse(const std::string &in, std::string &err, JsonParse strategy = JsonParse::STANDARD);
 
        static inline Json parse(const char *in, std::string &err, JsonParse strategy = JsonParse::STANDARD)
        {
            if (in) {
                return parse(std::string(in), err, strategy);
            } else {
                err = "null input";
                return nullptr;
            }
        }
 
        // Parse multiple objects, concatenated or separated by whitespace
        static inline std::vector<Json> parse_multi(
            const std::string &in, std::string::size_type &parser_stop_pos, std::string &err, JsonParse strategy = JsonParse::STANDARD);
 
        static inline std::vector<Json> parse_multi(const std::string &in, std::string &err, JsonParse strategy = JsonParse::STANDARD)
        {
            std::string::size_type parser_stop_pos;
            return parse_multi(in, parser_stop_pos, err, strategy);
        }
 
        inline bool operator==(const Json &rhs) const;
        inline bool operator<(const Json &rhs) const;
 
        inline bool operator!=(const Json &rhs) const { return !(*this == rhs); }
 
        inline bool operator<=(const Json &rhs) const { return !(rhs < *this); }
 
        inline bool operator>(const Json &rhs) const { return (rhs < *this); }
 
        inline bool operator>=(const Json &rhs) const { return !(*this < rhs); }
 
        /* has_shape(types, err)
         *
         * Return true if this is a JSON object and, for each item in types, has a field of
         * the given type. If not, return false and set err to a descriptive message.
         */
        typedef std::initializer_list<std::pair<std::string, Type>> shape;
        inline bool has_shape(const shape &types, std::string &err) const;
 
    private:
        std::shared_ptr<JsonValue> m_ptr;
    };
 
    // Internal class hierarchy - JsonValue objects are not exposed to users of this API.
    class JsonValue {
    protected:
        friend class Json;
        friend class JsonInt;
        friend class JsonDouble;
        virtual Json::Type type() const = 0;
        virtual bool equals(const JsonValue *other) const = 0;
        virtual bool less(const JsonValue *other) const = 0;
        virtual void dump(std::string &out) const = 0;
        virtual double number_value() const;
        virtual int int_value() const;
        virtual bool bool_value() const;
        virtual const std::string &string_value() const;
        virtual const Json::array &array_items() const;
        virtual const Json &operator[](size_t i) const;
        virtual const Json::object &object_items() const;
        virtual const Json &operator[](const std::string &key) const;
 
        virtual ~JsonValue() {}
    };
 
} // namespace json11
 
 
#include <cassert>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <limits>
 
namespace json11 {
 
    static const int max_depth = 200;
 
    using std::initializer_list;
    using std::make_shared;
    using std::map;
    using std::move;
    using std::string;
    using std::vector;
 
    /* Helper for representing null - just a do-nothing struct, plus comparison
     * operators so the helpers in JsonValue work. We can't use nullptr_t because
     * it may not be orderable.
     */
    struct NullStruct {
        bool operator==(NullStruct) const { return true; }
 
        bool operator<(NullStruct) const { return false; }
    };
 
    /* * * * * * * * * * * * * * * * * * * *
     * Serialization
     */
 
    static void dump(NullStruct, string &out)
    {
        out += "null";
    }
 
    static void dump(double value, string &out)
    {
        if (std::isfinite(value)) {
            char buf[32];
            snprintf(buf, sizeof buf, "%.17g", value);
            out += buf;
        } else {
            out += "null";
        }
    }
 
    static void dump(int value, string &out)
    {
        char buf[32];
        snprintf(buf, sizeof buf, "%d", value);
        out += buf;
    }
 
    static void dump(bool value, string &out)
    {
        out += value ? "true" : "false";
    }
 
    static void dump(const string &value, string &out)
    {
        out += '"';
        for (size_t i = 0; i < value.length(); i++) {
            const char ch = value[i];
            if (ch == '\\') {
                out += "\\\\";
            } else if (ch == '"') {
                out += "\\\"";
            } else if (ch == '\b') {
                out += "\\b";
            } else if (ch == '\f') {
                out += "\\f";
            } else if (ch == '\n') {
                out += "\\n";
            } else if (ch == '\r') {
                out += "\\r";
            } else if (ch == '\t') {
                out += "\\t";
            } else if (static_cast<uint8_t>(ch) <= 0x1f) {
                char buf[8];
                snprintf(buf, sizeof buf, "\\u%04x", ch);
                out += buf;
            } else if (static_cast<uint8_t>(ch) == 0xe2 && static_cast<uint8_t>(value[i + 1]) == 0x80 && static_cast<uint8_t>(value[i + 2]) == 0xa8) {
                out += "\\u2028";
                i += 2;
            } else if (static_cast<uint8_t>(ch) == 0xe2 && static_cast<uint8_t>(value[i + 1]) == 0x80 && static_cast<uint8_t>(value[i + 2]) == 0xa9) {
                out += "\\u2029";
                i += 2;
            } else {
                out += ch;
            }
        }
        out += '"';
    }
 
    static void dump(const Json::array &values, string &out)
    {
        bool first = true;
        out += "[";
        for (const auto &value : values) {
            if (!first) out += ", ";
            value.dump(out);
            first = false;
        }
        out += "]";
    }
 
    static void dump(const Json::object &values, string &out)
    {
        bool first = true;
        out += "{";
        for (const auto &kv : values) {
            if (!first) out += ", ";
            dump(kv.first, out);
            out += ": ";
            kv.second.dump(out);
            first = false;
        }
        out += "}";
    }
 
    void Json::dump(string &out) const
    {
        m_ptr->dump(out);
    }
 
    /* * * * * * * * * * * * * * * * * * * *
     * Value wrappers
     */
 
    template<Json::Type tag, typename T>
    class Value : public JsonValue {
    protected:
        // Constructors
        explicit Value(const T &value) : m_value(value) {}
 
        explicit Value(T &&value) : m_value(move(value)) {}
 
        // Get type tag
        Json::Type type() const override { return tag; }
 
        // Comparisons
        bool equals(const JsonValue *other) const override { return m_value == static_cast<const Value<tag, T> *>(other)->m_value; }
 
        bool less(const JsonValue *other) const override { return m_value < static_cast<const Value<tag, T> *>(other)->m_value; }
 
        const T m_value;
 
        void dump(string &out) const override { json11::dump(m_value, out); }
    };
 
    class JsonDouble final : public Value<Json::NUMBER, double> {
        double number_value() const override { return m_value; }
 
        int int_value() const override { return static_cast<int>(m_value); }
 
        bool equals(const JsonValue *other) const override { return m_value == other->number_value(); }
 
        bool less(const JsonValue *other) const override { return m_value < other->number_value(); }
 
    public:
        explicit JsonDouble(double value) : Value(value) {}
    };
 
    class JsonInt final : public Value<Json::NUMBER, int> {
        double number_value() const override { return m_value; }
 
        int int_value() const override { return m_value; }
 
        bool equals(const JsonValue *other) const override { return m_value == other->number_value(); }
 
        bool less(const JsonValue *other) const override { return m_value < other->number_value(); }
 
    public:
        explicit JsonInt(int value) : Value(value) {}
    };
 
    class JsonBoolean final : public Value<Json::BOOL, bool> {
        bool bool_value() const override { return m_value; }
 
    public:
        explicit JsonBoolean(bool value) : Value(value) {}
    };
 
    class JsonString final : public Value<Json::STRING, string> {
        const string &string_value() const override { return m_value; }
 
    public:
        explicit JsonString(const string &value) : Value(value) {}
 
        explicit JsonString(string &&value) : Value(move(value)) {}
    };
 
    class JsonArray final : public Value<Json::ARRAY, Json::array> {
        const Json::array &array_items() const override { return m_value; }
 
        const Json &operator[](size_t i) const override;
 
    public:
        explicit JsonArray(const Json::array &value) : Value(value) {}
 
        explicit JsonArray(Json::array &&value) : Value(move(value)) {}
    };
 
    class JsonObject final : public Value<Json::OBJECT, Json::object> {
        const Json::object &object_items() const override { return m_value; }
 
        const Json &operator[](const string &key) const override;
 
    public:
        explicit JsonObject(const Json::object &value) : Value(value) {}
 
        explicit JsonObject(Json::object &&value) : Value(move(value)) {}
    };
 
    class JsonNull final : public Value<Json::NUL, NullStruct> {
    public:
        JsonNull() : Value({}) {}
    };
 
    /* * * * * * * * * * * * * * * * * * * *
     * Static globals - static-init-safe
     */
    struct Statics {
        const std::shared_ptr<JsonValue> null = make_shared<JsonNull>();
        const std::shared_ptr<JsonValue> t = make_shared<JsonBoolean>(true);
        const std::shared_ptr<JsonValue> f = make_shared<JsonBoolean>(false);
        const string empty_string;
        const vector<Json> empty_vector;
        const map<string, Json> empty_map;
 
        Statics() {}
    };
 
    static const Statics &statics()
    {
        static const Statics s {};
        return s;
    }
 
    static const Json &static_null()
    {
        // This has to be separate, not in Statics, because Json() accesses statics().null.
        static const Json json_null;
        return json_null;
    }
 
    /* * * * * * * * * * * * * * * * * * * *
     * Constructors
     */
 
    Json::Json() noexcept : m_ptr(statics().null) {}
 
    Json::Json(std::nullptr_t) noexcept : m_ptr(statics().null) {}
 
    Json::Json(double value) : m_ptr(make_shared<JsonDouble>(value)) {}
 
    Json::Json(int value) : m_ptr(make_shared<JsonInt>(value)) {}
 
    Json::Json(bool value) : m_ptr(value ? statics().t : statics().f) {}
 
    Json::Json(const string &value) : m_ptr(make_shared<JsonString>(value)) {}
 
    Json::Json(string &&value) : m_ptr(make_shared<JsonString>(move(value))) {}
 
    Json::Json(const char *value) : m_ptr(make_shared<JsonString>(value)) {}
 
    Json::Json(const Json::array &values) : m_ptr(make_shared<JsonArray>(values)) {}
 
    Json::Json(Json::array &&values) : m_ptr(make_shared<JsonArray>(move(values))) {}
 
    Json::Json(const Json::object &values) : m_ptr(make_shared<JsonObject>(values)) {}
 
    Json::Json(Json::object &&values) : m_ptr(make_shared<JsonObject>(move(values))) {}
 
    /* * * * * * * * * * * * * * * * * * * *
     * Accessors
     */
 
    inline Json::Type Json::type() const
    {
        return m_ptr->type();
    }
 
    inline double Json::number_value() const
    {
        return m_ptr->number_value();
    }
 
    inline int Json::int_value() const
    {
        return m_ptr->int_value();
    }
 
    inline bool Json::bool_value() const
    {
        return m_ptr->bool_value();
    }
 
    inline const string &Json::string_value() const
    {
        return m_ptr->string_value();
    }
 
    inline const vector<Json> &Json::array_items() const
    {
        return m_ptr->array_items();
    }
 
    inline const map<string, Json> &Json::object_items() const
    {
        return m_ptr->object_items();
    }
 
    inline const Json &Json::operator[](size_t i) const
    {
        return (*m_ptr)[i];
    }
 
    inline const Json &Json::operator[](const string &key) const
    {
        return (*m_ptr)[key];
    }
 
    inline double JsonValue::number_value() const
    {
        return 0;
    }
 
    inline int JsonValue::int_value() const
    {
        return 0;
    }
 
    inline bool JsonValue::bool_value() const
    {
        return false;
    }
 
    inline const string &JsonValue::string_value() const
    {
        return statics().empty_string;
    }
 
    inline const vector<Json> &JsonValue::array_items() const
    {
        return statics().empty_vector;
    }
 
    inline const map<string, Json> &JsonValue::object_items() const
    {
        return statics().empty_map;
    }
 
    inline const Json &JsonValue::operator[](size_t) const
    {
        return static_null();
    }
 
    inline const Json &JsonValue::operator[](const string &) const
    {
        return static_null();
    }
 
    inline const Json &JsonObject::operator[](const string &key) const
    {
        auto iter = m_value.find(key);
        return (iter == m_value.end()) ? static_null() : iter->second;
    }
 
    inline const Json &JsonArray::operator[](size_t i) const
    {
        if (i >= m_value.size())
            return static_null();
        else
            return m_value[i];
    }
 
    /* * * * * * * * * * * * * * * * * * * *
     * Comparison
     */
 
    bool Json::operator==(const Json &other) const
    {
        if (m_ptr == other.m_ptr) return true;
        if (m_ptr->type() != other.m_ptr->type()) return false;
 
        return m_ptr->equals(other.m_ptr.get());
    }
 
    bool Json::operator<(const Json &other) const
    {
        if (m_ptr == other.m_ptr) return false;
        if (m_ptr->type() != other.m_ptr->type()) return m_ptr->type() < other.m_ptr->type();
 
        return m_ptr->less(other.m_ptr.get());
    }
 
    /* * * * * * * * * * * * * * * * * * * *
     * Parsing
     */
 
    /* esc(c)
     *
     * Format char c suitable for printing in an error message.
     */
    static inline string esc(char c)
    {
        char buf[12];
        if (static_cast<uint8_t>(c) >= 0x20 && static_cast<uint8_t>(c) <= 0x7f) {
            snprintf(buf, sizeof buf, "'%c' (%d)", c, c);
        } else {
            snprintf(buf, sizeof buf, "(%d)", c);
        }
        return string(buf);
    }
 
    static inline bool in_range(long x, long lower, long upper)
    {
        return (x >= lower && x <= upper);
    }
 
    namespace {
        /* JsonParser
         *
         * Object that tracks all state of an in-progress parse.
         */
        struct JsonParser final {
            /* State
             */
            const string &str;
            size_t i;
            string &err;
            bool failed;
            const JsonParse strategy;
 
            /* fail(msg, err_ret = Json())
             *
             * Mark this parse as failed.
             */
            Json fail(string &&msg) { return fail(move(msg), Json()); }
 
            template<typename T>
            T fail(string &&msg, const T err_ret)
            {
                if (!failed) err = std::move(msg);
                failed = true;
                return err_ret;
            }
 
            /* consume_whitespace()
             *
             * Advance until the current character is non-whitespace.
             */
            void consume_whitespace()
            {
                while (str[i] == ' ' || str[i] == '\r' || str[i] == '\n' || str[i] == '\t')
                    i++;
            }
 
            /* consume_comment()
             *
             * Advance comments (c-style inline and multiline).
             */
            bool consume_comment()
            {
                bool comment_found = false;
                if (str[i] == '/') {
                    i++;
                    if (i == str.size()) return fail("unexpected end of input after start of comment", false);
                    if (str[i] == '/') { // inline comment
                        i++;
                        // advance until next line, or end of input
                        while (i < str.size() && str[i] != '\n') {
                            i++;
                        }
                        comment_found = true;
                    } else if (str[i] == '*') { // multiline comment
                        i++;
                        if (i > str.size() - 2) return fail("unexpected end of input inside multi-line comment", false);
                        // advance until closing tokens
                        while (!(str[i] == '*' && str[i + 1] == '/')) {
                            i++;
                            if (i > str.size() - 2) return fail("unexpected end of input inside multi-line comment", false);
                        }
                        i += 2;
                        comment_found = true;
                    } else
                        return fail("malformed comment", false);
                }
                return comment_found;
            }
 
            /* consume_garbage()
             *
             * Advance until the current character is non-whitespace and non-comment.
             */
            void consume_garbage()
            {
                consume_whitespace();
                if (strategy == JsonParse::COMMENTS) {
                    bool comment_found = false;
                    do {
                        comment_found = consume_comment();
                        if (failed) return;
                        consume_whitespace();
                    } while (comment_found);
                }
            }
 
            /* get_next_token()
             *
             * Return the next non-whitespace character. If the end of the input is reached,
             * flag an error and return 0.
             */
            char get_next_token()
            {
                consume_garbage();
                if (failed) return static_cast<char>(0);
                if (i == str.size()) return fail("unexpected end of input", static_cast<char>(0));
 
                return str[i++];
            }
 
            /* encode_utf8(pt, out)
             *
             * Encode pt as UTF-8 and add it to out.
             */
            void encode_utf8(long pt, string &out)
            {
                if (pt < 0) return;
 
                if (pt < 0x80) {
                    out += static_cast<char>(pt);
                } else if (pt < 0x800) {
                    out += static_cast<char>((pt >> 6) | 0xC0);
                    out += static_cast<char>((pt & 0x3F) | 0x80);
                } else if (pt < 0x10000) {
                    out += static_cast<char>((pt >> 12) | 0xE0);
                    out += static_cast<char>(((pt >> 6) & 0x3F) | 0x80);
                    out += static_cast<char>((pt & 0x3F) | 0x80);
                } else {
                    out += static_cast<char>((pt >> 18) | 0xF0);
                    out += static_cast<char>(((pt >> 12) & 0x3F) | 0x80);
                    out += static_cast<char>(((pt >> 6) & 0x3F) | 0x80);
                    out += static_cast<char>((pt & 0x3F) | 0x80);
                }
            }
 
            /* parse_string()
             *
             * Parse a string, starting at the current position.
             */
            string parse_string()
            {
                string out;
                long last_escaped_codepoint = -1;
                while (true) {
                    if (i == str.size()) return fail("unexpected end of input in string", "");
 
                    char ch = str[i++];
 
                    if (ch == '"') {
                        encode_utf8(last_escaped_codepoint, out);
                        return out;
                    }
 
                    if (in_range(ch, 0, 0x1f)) return fail("unescaped " + esc(ch) + " in string", "");
 
                    // The usual case: non-escaped characters
                    if (ch != '\\') {
                        encode_utf8(last_escaped_codepoint, out);
                        last_escaped_codepoint = -1;
                        out += ch;
                        continue;
                    }
 
                    // Handle escapes
                    if (i == str.size()) return fail("unexpected end of input in string", "");
 
                    ch = str[i++];
 
                    if (ch == 'u') {
                        // Extract 4-byte escape sequence
                        string esc = str.substr(i, 4);
                        // Explicitly check length of the substring. The following loop
                        // relies on std::string returning the terminating NUL when
                        // accessing str[length]. Checking here reduces brittleness.
                        if (esc.length() < 4) {
                            return fail("bad \\u escape: " + esc, "");
                        }
                        for (size_t j = 0; j < 4; j++) {
                            if (!in_range(esc[j], 'a', 'f') && !in_range(esc[j], 'A', 'F') && !in_range(esc[j], '0', '9'))
                                return fail("bad \\u escape: " + esc, "");
                        }
 
                        long codepoint = strtol(esc.data(), nullptr, 16);
 
                        // JSON specifies that characters outside the BMP shall be encoded as a pair
                        // of 4-hex-digit \u escapes encoding their surrogate pair components. Check
                        // whether we're in the middle of such a beast: the previous codepoint was an
                        // escaped lead (high) surrogate, and this is a trail (low) surrogate.
                        if (in_range(last_escaped_codepoint, 0xD800, 0xDBFF) && in_range(codepoint, 0xDC00, 0xDFFF)) {
                            // Reassemble the two surrogate pairs into one astral-plane character, per
                            // the UTF-16 algorithm.
                            encode_utf8((((last_escaped_codepoint - 0xD800) << 10) | (codepoint - 0xDC00)) + 0x10000, out);
                            last_escaped_codepoint = -1;
                        } else {
                            encode_utf8(last_escaped_codepoint, out);
                            last_escaped_codepoint = codepoint;
                        }
 
                        i += 4;
                        continue;
                    }
 
                    encode_utf8(last_escaped_codepoint, out);
                    last_escaped_codepoint = -1;
 
                    if (ch == 'b') {
                        out += '\b';
                    } else if (ch == 'f') {
                        out += '\f';
                    } else if (ch == 'n') {
                        out += '\n';
                    } else if (ch == 'r') {
                        out += '\r';
                    } else if (ch == 't') {
                        out += '\t';
                    } else if (ch == '"' || ch == '\\' || ch == '/') {
                        out += ch;
                    } else {
                        return fail("invalid escape character " + esc(ch), "");
                    }
                }
            }
 
            /* parse_number()
             *
             * Parse a double.
             */
            Json parse_number()
            {
                size_t start_pos = i;
 
                if (str[i] == '-') i++;
 
                // Integer part
                if (str[i] == '0') {
                    i++;
                    if (in_range(str[i], '0', '9')) return fail("leading 0s not permitted in numbers");
                } else if (in_range(str[i], '1', '9')) {
                    i++;
                    while (in_range(str[i], '0', '9'))
                        i++;
                } else {
                    return fail("invalid " + esc(str[i]) + " in number");
                }
 
                if (str[i] != '.' && str[i] != 'e' && str[i] != 'E' && (i - start_pos) <= static_cast<size_t>(std::numeric_limits<int>::digits10)) {
                    return std::atoi(str.c_str() + start_pos);
                }
 
                // Decimal part
                if (str[i] == '.') {
                    i++;
                    if (!in_range(str[i], '0', '9')) return fail("at least one digit required in fractional part");
 
                    while (in_range(str[i], '0', '9'))
                        i++;
                }
 
                // Exponent part
                if (str[i] == 'e' || str[i] == 'E') {
                    i++;
 
                    if (str[i] == '+' || str[i] == '-') i++;
 
                    if (!in_range(str[i], '0', '9')) return fail("at least one digit required in exponent");
 
                    while (in_range(str[i], '0', '9'))
                        i++;
                }
 
                return std::strtod(str.c_str() + start_pos, nullptr);
            }
 
            /* expect(str, res)
             *
             * Expect that 'str' starts at the character that was just read. If it does, advance
             * the input and return res. If not, flag an error.
             */
            Json expect(const string &expected, Json res)
            {
                assert(i != 0);
                i--;
                if (str.compare(i, expected.length(), expected) == 0) {
                    i += expected.length();
                    return res;
                } else {
                    return fail("parse error: expected " + expected + ", got " + str.substr(i, expected.length()));
                }
            }
 
            /* parse_json()
             *
             * Parse a JSON object.
             */
            Json parse_json(int depth)
            {
                if (depth > max_depth) {
                    return fail("exceeded maximum nesting depth");
                }
 
                char ch = get_next_token();
                if (failed) return Json();
 
                if (ch == '-' || (ch >= '0' && ch <= '9')) {
                    i--;
                    return parse_number();
                }
 
                if (ch == 't') return expect("true", true);
 
                if (ch == 'f') return expect("false", false);
 
                if (ch == 'n') return expect("null", Json());
 
                if (ch == '"') return parse_string();
 
                if (ch == '{') {
                    map<string, Json> data;
                    ch = get_next_token();
                    if (ch == '}') return data;
 
                    while (1) {
                        if (ch != '"') return fail("expected '\"' in object, got " + esc(ch));
 
                        string key = parse_string();
                        if (failed) return Json();
 
                        ch = get_next_token();
                        if (ch != ':') return fail("expected ':' in object, got " + esc(ch));
 
                        data[std::move(key)] = parse_json(depth + 1);
                        if (failed) return Json();
 
                        ch = get_next_token();
                        if (ch == '}') break;
                        if (ch != ',') return fail("expected ',' in object, got " + esc(ch));
 
                        ch = get_next_token();
                    }
                    return data;
                }
 
                if (ch == '[') {
                    vector<Json> data;
                    ch = get_next_token();
                    if (ch == ']') return data;
 
                    while (1) {
                        i--;
                        data.push_back(parse_json(depth + 1));
                        if (failed) return Json();
 
                        ch = get_next_token();
                        if (ch == ']') break;
                        if (ch != ',') return fail("expected ',' in list, got " + esc(ch));
 
                        ch = get_next_token();
                        (void) ch;
                    }
                    return data;
                }
 
                return fail("expected value, got " + esc(ch));
            }
        };
    } // namespace
 
    Json Json::parse(const string &in, string &err, JsonParse strategy)
    {
        JsonParser parser {in, 0, err, false, strategy};
        Json result = parser.parse_json(0);
 
        // Check for any trailing garbage
        parser.consume_garbage();
        if (parser.failed) return Json();
        if (parser.i != in.size() &&
            ((parser.i + 1) != in.size() &&
             in[parser.i] != 0)) // RBP: If there is only 1 character diff, it is probably just a terminating zero from a memory read.
        {
            return parser.fail("unexpected trailing " + esc(in[parser.i]));
        }
        return result;
    }
 
    // Documented in json11.hpp
    vector<Json> Json::parse_multi(const string &in, std::string::size_type &parser_stop_pos, string &err, JsonParse strategy)
    {
        JsonParser parser {in, 0, err, false, strategy};
        parser_stop_pos = 0;
        vector<Json> json_vec;
        while (parser.i != in.size() && !parser.failed) {
            json_vec.push_back(parser.parse_json(0));
            if (parser.failed) break;
 
            // Check for another object
            parser.consume_garbage();
            if (parser.failed) break;
            parser_stop_pos = parser.i;
        }
        return json_vec;
    }
 
    /* * * * * * * * * * * * * * * * * * * *
     * Shape-checking
     */
 
    bool Json::has_shape(const shape &types, string &err) const
    {
        if (!is_object()) {
            err = "expected JSON object, got " + dump();
            return false;
        }
 
        const auto &obj_items = object_items();
        for (auto &item : types) {
            const auto it = obj_items.find(item.first);
            if (it == obj_items.cend() || it->second.type() != item.second) {
                err = "bad type for " + item.first + " in " + dump();
                return false;
            }
        }
 
        return true;
    }
 
} // namespace json11
 
 
 
 
//
// Created by robin on 22.03.2020.
//
 
#ifndef TILESON_TILESON_PARSER_HPP
    #define TILESON_TILESON_PARSER_HPP
 
    // RBP: FS-namespace is defined in tileson_parser now!
    #if _MSC_VER && !__INTEL_COMPILER
        #include <filesystem>
namespace fs = std::filesystem;
    #elif __MINGW64__
        #if __MINGW64_VERSION_MAJOR > 6
            #include <filesystem>
namespace fs = std::filesystem;
        #else
            #include <experimental/filesystem>
namespace fs = std::experimental::filesystem;
        #endif
    #elif __clang__
        #if __clang_major__ < 8
            #include <experimental/filesystem>
namespace fs = std::experimental::filesystem;
        #else
            #include <filesystem>
namespace fs = std::filesystem;
        #endif
    #else // Linux
        #if __GNUC__ < 8 // GCC major version less than 8
            #include <experimental/filesystem>
namespace fs = std::experimental::filesystem;
        #else
            #include <filesystem>
namespace fs = std::filesystem;
        #endif
    #endif
 
    #include <fstream>
    #include <memory>
    #include <sstream>
 
 
    //
    // Created by robin on 31.07.2020.
    //
 
    #ifndef TILESON_TOOLS_HPP
        #define TILESON_TOOLS_HPP
 
        #include <cstdint>
        #include <string_view>
        #include <vector>
 
namespace tson {
    class Tools {
    public:
        Tools() = delete;
        ~Tools() = delete;
        inline static std::vector<uint8_t> Base64DecodedStringToBytes(std::string_view str);
        inline static std::vector<uint32_t> BytesToUnsignedInts(const std::vector<uint8_t> &bytes);
        inline static std::vector<std::string> SplitString(const std::string &s, char delim);
        inline static bool Equal(float a, float b, float precision = 8192.f);
 
    private:
        template<typename Out>
        static void split(const std::string &s, char delim, Out result)
        {
            std::stringstream ss;
            ss.str(s);
            std::string item;
 
            while (std::getline(ss, item, delim)) {
                *(result++) = item;
            }
        }
    };
 
    std::vector<uint8_t> Tools::Base64DecodedStringToBytes(std::string_view str)
    {
        std::vector<uint8_t> bytes;
        for (size_t i = 0; i < str.size(); ++i) {
            uint8_t u8 = static_cast<uint8_t>(str[i]);
            bytes.push_back(u8);
        }
        return bytes;
    }
 
    std::vector<uint32_t> Tools::BytesToUnsignedInts(const std::vector<uint8_t> &bytes)
    {
        std::vector<uint32_t> uints;
        std::vector<uint8_t> toConvert;
        // uint32_t size8 = (compressed[55] << 24) | (compressed[56] << 16) | (compressed[57] << 8) | compressed[58]; //Should be 66000
 
        for (size_t i = 0; i < bytes.size(); ++i) {
            toConvert.push_back(bytes[i]);
            if (toConvert.size() == 4) {
                uint32_t u32 = (toConvert[3] << 24) | (toConvert[2] << 16) | (toConvert[1] << 8) | toConvert[0];
                uints.push_back(u32);
                toConvert.clear();
            }
        }
 
        return uints;
    }
 
    std::vector<std::string> Tools::SplitString(const std::string &s, char delim)
    {
        std::vector<std::string> elems;
        split(s, delim, std::back_inserter(elems));
        return elems;
    }
 
    bool Tools::Equal(float a, float b, float precision)
    {
        float threshold = 1.f / precision;
        float diff = fabsf(a - b);
        return diff <= threshold;
    }
} // namespace tson
 
    #endif // TILESON_TOOLS_HPP
 
 
 
    //
    // Created by robin on 29.07.2020.
    // The Base64 decoding logic is heavily based on: https://github.com/ReneNyffenegger/cpp-base64
    //
 
    #ifndef TILESON_BASE64DECOMPRESSOR_HPP
        #define TILESON_BASE64DECOMPRESSOR_HPP
 
 
        //
        // Created by robin on 29.07.2020.
        //
 
        #ifndef TILESON_IDECOMPRESSOR_HPP
            #define TILESON_IDECOMPRESSOR_HPP
 
            #include <string_view>
 
namespace tson {
    template<class TIn, class TOut>
    class IDecompressor {
    public:
        [[nodiscard]]
        virtual const std::string &name() const = 0;
 
        virtual TOut decompress(const TIn &input) = 0;
 
        virtual TOut decompressFile(const fs::path &path) = 0;
 
        virtual TOut decompress(const void *data, size_t size) = 0;
 
        virtual ~IDecompressor() = default;
    };
} // namespace tson
 
        #endif // TILESON_IDECOMPRESSOR_HPP
 
 
        #include <string>
 
namespace tson {
    class Base64Decompressor : public IDecompressor<std::string_view, std::string> {
    public:
        [[nodiscard]]
        inline const std::string &name() const override;
 
        inline std::string decompress(const std::string_view &s) override;
 
        inline std::string decompressFile(const fs::path &path) override;
        inline std::string decompress(const void *data, size_t size) override;
 
    private:
        inline unsigned int pos_of_char(const unsigned char chr);
        inline static const std::string NAME = "base64";
    };
 
    const std::string &Base64Decompressor::name() const
    {
        return NAME;
    }
 
    std::string Base64Decompressor::decompress(const std::string_view &s)
    {
        size_t length_of_string = s.length();
        if (!length_of_string) return std::string("");
 
        size_t in_len = length_of_string;
        size_t pos = 0;
 
        //
        // The approximate length (bytes) of the decoded string might be one ore
        // two bytes smaller, depending on the amount of trailing equal signs
        // in the encoded string. This approximation is needed to reserve
        // enough space in the string to be returned.
        //
        size_t approx_length_of_decoded_string = length_of_string / 4 * 3;
        std::string ret;
        ret.reserve(approx_length_of_decoded_string);
 
        while (pos < in_len) {
            unsigned int pos_of_char_1 = pos_of_char(s[pos + 1]);
 
            ret.push_back(static_cast<std::string::value_type>(((pos_of_char(s[pos + 0])) << 2) + ((pos_of_char_1 & 0x30) >> 4)));
 
            if (s[pos + 2] != '=' && s[pos + 2] != '.') { // accept URL-safe base 64 strings, too, so check for '.' also.
 
                unsigned int pos_of_char_2 = pos_of_char(s[pos + 2]);
                ret.push_back(static_cast<std::string::value_type>(((pos_of_char_1 & 0x0f) << 4) + ((pos_of_char_2 & 0x3c) >> 2)));
 
                if (s[pos + 3] != '=' && s[pos + 3] != '.') {
                    ret.push_back(static_cast<std::string::value_type>(((pos_of_char_2 & 0x03) << 6) + pos_of_char(s[pos + 3])));
                }
            }
 
            pos += 4;
        }
 
        return ret;
    }
 
    unsigned int Base64Decompressor::pos_of_char(const unsigned char chr)
    {
        //
        // Return the position of chr within base64_encode()
        //
 
        if (chr >= 'A' && chr <= 'Z')
            return chr - 'A';
        else if (chr >= 'a' && chr <= 'z')
            return chr - 'a' + ('Z' - 'A') + 1;
        else if (chr >= '0' && chr <= '9')
            return chr - '0' + ('Z' - 'A') + ('z' - 'a') + 2;
        else if (chr == '+' || chr == '-')
            return 62; // Be liberal with input and accept both url ('-') and non-url ('+') base 64 characters (
        else if (chr == '/' || chr == '_')
            return 63; // Ditto for '/' and '_'
 
        throw "If input is correct, this line should never be reached.";
    }
 
    std::string Base64Decompressor::decompressFile(const fs::path &)
    {
        return std::string();
    }
 
    std::string Base64Decompressor::decompress(const void *, size_t)
    {
        return std::string();
    }
} // namespace tson
 
    #endif // TILESON_BASE64DECOMPRESSOR_HPP
 
 
 
    //
    // Created by robin on 16.01.2021.
    //
    // #include "../../extras/pocketlzma.hpp"
    #ifdef POCKETLZMA_POCKETLZMA_H
 
        #ifndef TILESON_LZMA_HPP
            #define TILESON_LZMA_HPP
 
namespace tson {
    class Lzma : public IDecompressor<std::vector<uint8_t>, std::vector<uint8_t>> {
    public:
        inline const std::string &name() const override { return NAME; }
 
        inline std::vector<uint8_t> decompress(const std::vector<uint8_t> &input) override
        {
            std::vector<uint8_t> out;
 
            plz::PocketLzma p;
            plz::StatusCode status = p.decompress(input, out);
 
            if (status != plz::StatusCode::Ok) return std::vector<uint8_t>();
 
            return out;
        }
 
        inline std::vector<uint8_t> decompressFile(const fs::path &path) override
        {
            std::vector<uint8_t> in;
            std::vector<uint8_t> out;
 
            plz::PocketLzma p;
            plz::FileStatus fileStatus = plz::File::FromFile(path.generic_string(), in);
            if (fileStatus.status() != plz::FileStatus::Code::Ok) return std::vector<uint8_t>();
 
            plz::StatusCode status = p.decompress(in, out);
 
            if (status != plz::StatusCode::Ok) return std::vector<uint8_t>();
 
            return out;
        }
 
        inline std::vector<uint8_t> decompress(const void *data, size_t size) override
        {
            std::vector<uint8_t> out;
 
            plz::PocketLzma p;
            plz::StatusCode status = p.decompress((uint8_t *) data, size, out);
 
            if (status != plz::StatusCode::Ok) return std::vector<uint8_t>();
 
            return out;
        }
 
    private:
        inline static const std::string NAME {"lzma"};
    };
} // namespace tson
 
        #endif // TILESON_LZMA_HPP
 
    #endif
 
 
    //
    // Created by robin on 30.07.2020.
    //
 
    #ifndef TILESON_DECOMPRESSORCONTAINER_HPP
        #define TILESON_DECOMPRESSORCONTAINER_HPP
 
        #include <functional>
        #include <memory>
        #include <string_view>
        #include <vector>
 
namespace tson {
    class DecompressorContainer {
    public:
        inline DecompressorContainer() = default;
        template<typename T, typename... Args>
        inline void add(Args &&...args);
        inline void remove(std::string_view name);
        inline bool contains(std::string_view name) const;
        inline bool empty() const;
        inline size_t size() const;
        inline void clear();
 
        inline IDecompressor<std::string_view, std::string> *get(std::string_view name);
 
    private:
        // Key: name,
        std::vector<std::unique_ptr<IDecompressor<std::string_view, std::string>>> m_decompressors;
    };
 
    template<typename T, typename... Args>
    void DecompressorContainer::add(Args &&...args)
    {
        m_decompressors.emplace_back(new T(args...));
    }
 
    bool DecompressorContainer::contains(std::string_view name) const
    {
        auto iter = std::find_if(m_decompressors.begin(), m_decompressors.end(), [&](const auto &item) { return item->name() == name; });
 
        return iter != m_decompressors.end();
    }
 
    void DecompressorContainer::remove(std::string_view name)
    {
        auto iter = std::remove_if(m_decompressors.begin(), m_decompressors.end(), [&](const auto &item) { return item->name() == name; });
        m_decompressors.erase(iter);
    }
 
    size_t DecompressorContainer::size() const
    {
        return m_decompressors.size();
    }
 
    IDecompressor<std::string_view, std::string> *DecompressorContainer::get(std::string_view name)
    {
        auto iter = std::find_if(m_decompressors.begin(), m_decompressors.end(), [&](const auto &item) { return item->name() == name; });
 
        return (iter != m_decompressors.end()) ? iter->get() : nullptr;
    }
 
    bool DecompressorContainer::empty() const
    {
        return m_decompressors.empty();
    }
 
    void DecompressorContainer::clear()
    {
        m_decompressors.clear();
    }
} // namespace tson
    #endif // TILESON_DECOMPRESSORCONTAINER_HPP
 
 
 
    //
    // Created by robin on 22.03.2020.
    //
 
    #ifndef TILESON_MEMORYSTREAM_HPP
        #define TILESON_MEMORYSTREAM_HPP
 
 
        //
        // Created by robin on 22.03.2020.
        //
 
        #ifndef TILESON_MEMORYBUFFER_HPP
            #define TILESON_MEMORYBUFFER_HPP
 
            #include <iostream>
 
namespace tson {
    class MemoryBuffer : public std::basic_streambuf<char> {
    public:
        MemoryBuffer(const uint8_t *p, size_t l) { setg((char *) p, (char *) p, (char *) p + l); }
    };
} // namespace tson
 
        #endif // TILESON_MEMORYBUFFER_HPP
 
 
namespace tson {
    class MemoryStream : public std::istream {
    public:
        MemoryStream(const uint8_t *p, size_t l) : std::istream(&m_buffer), m_buffer(p, l) { rdbuf(&m_buffer); }
 
    private:
        MemoryBuffer m_buffer;
    };
} // namespace tson
 
    #endif // TILESON_MEMORYSTREAM_HPP
 
 
 
    //
    // Created by robin on 22.03.2020.
    //
 
    #ifndef TILESON_MAP_HPP
        #define TILESON_MAP_HPP
 
 
        //
        // Created by robin on 09.08.2019.
        //
 
        #ifndef TILESON_COLOR_HPP
            #define TILESON_COLOR_HPP
 
            #include <cstdint>
            #include <string>
            #include <type_traits>
 
namespace tson {
 
    template<typename T>
    class Color {
    public:
        inline explicit Color(const std::string &color) { parseHexString(color); }
 
        inline Color(T red, T green, T blue, T alpha);
 
        inline Color()
        {
            r = g = b = 0;
            a = 255;
        }
 
        inline bool operator==(const Color &rhs) const;
        inline bool operator==(const std::string &rhs) const;
        inline bool operator!=(const Color &rhs) const;
 
        inline Color<float> asFloat();
        inline Color<uint8_t> asInt();
 
        T r;
        T g;
        T b;
        T a;
 
    private:
        void parseHexString(const std::string &color)
        {
            if constexpr (std::is_same<T, float>::value) {
                if (color.size() == 9) {
                    a = (float) std::stoi(color.substr(1, 2), nullptr, 16) / 255;
                    r = (float) std::stoi(color.substr(3, 2), nullptr, 16) / 255;
                    g = (float) std::stoi(color.substr(5, 2), nullptr, 16) / 255;
                    b = (float) std::stoi(color.substr(7, 2), nullptr, 16) / 255;
                } else if (color.size() == 7) {
                    r = (float) std::stoi(color.substr(1, 2), nullptr, 16) / 255;
                    g = (float) std::stoi(color.substr(3, 2), nullptr, 16) / 255;
                    b = (float) std::stoi(color.substr(5, 2), nullptr, 16) / 255;
                    a = 1.f;
                }
            } else if constexpr (std::is_same<T, uint8_t>::value) {
                if (color.size() == 9) {
                    a = static_cast<uint8_t>(std::stoi(color.substr(1, 2), nullptr, 16));
                    r = static_cast<uint8_t>(std::stoi(color.substr(3, 2), nullptr, 16));
                    g = static_cast<uint8_t>(std::stoi(color.substr(5, 2), nullptr, 16));
                    b = static_cast<uint8_t>(std::stoi(color.substr(7, 2), nullptr, 16));
                } else if (color.size() == 7) {
                    r = static_cast<uint8_t>(std::stoi(color.substr(1, 2), nullptr, 16));
                    g = static_cast<uint8_t>(std::stoi(color.substr(3, 2), nullptr, 16));
                    b = static_cast<uint8_t>(std::stoi(color.substr(5, 2), nullptr, 16));
                    a = 255;
                }
            }
        }
    };
 
    typedef Color<uint8_t> Colori;
    typedef Color<float> Colorf;
 
    template<typename T>
    tson::Colorf Color<T>::asFloat()
    {
        if constexpr (std::is_same<T, float>::value)
            *this;
        else
            return tson::Colorf((float) r / 255, (float) g / 255, (float) b / 255, (float) a / 255);
    }
 
    template<typename T>
    tson::Colori Color<T>::asInt()
    {
        if constexpr (std::is_same<T, float>::value)
            return tson::Colori(
                static_cast<std::uint8_t>((float) r * 255), static_cast<std::uint8_t>((float) g * 255), static_cast<std::uint8_t>((float) b * 255),
                static_cast<std::uint8_t>((float) a * 255));
        else
            *this;
    }
 
    template<typename T>
    Color<T>::Color(T red, T green, T blue, T alpha)
    {
        r = red;
        g = green;
        b = blue;
        a = alpha;
    }
 
    template<typename T>
    bool Color<T>::operator==(const std::string &rhs) const
    {
        Color other {rhs};
        return *this == other;
    }
 
    template<typename T>
    bool Color<T>::operator==(const Color &rhs) const
    {
        return r == rhs.r && g == rhs.g && b == rhs.b && a == rhs.a;
    }
 
    template<typename T>
    bool Color<T>::operator!=(const Color &rhs) const
    {
        return !(rhs == *this);
    }
 
} // namespace tson
 
        #endif // TILESON_COLOR_HPP
 
 
 
        //
        // Created by robin on 31.07.2019.
        //
 
        #ifndef TILESON_VECTOR2_HPP
            #define TILESON_VECTOR2_HPP
 
namespace tson {
    template<typename T>
    class Vector2 {
    public:
        inline Vector2(T xPos, T yPos);
 
        inline Vector2() { x = y = 0; }
 
        inline bool operator==(const Vector2 &rhs) const;
        inline bool operator!=(const Vector2 &rhs) const;
 
        T x;
        T y;
    };
 
    template<typename T>
    Vector2<T>::Vector2(T xPos, T yPos)
    {
        x = xPos;
        y = yPos;
    }
 
    template<typename T>
    bool Vector2<T>::operator==(const Vector2 &rhs) const
    {
        return x == rhs.x && y == rhs.y;
    }
 
    template<typename T>
    bool Vector2<T>::operator!=(const Vector2 &rhs) const
    {
        return !(rhs == *this);
    }
 
    typedef Vector2<int> Vector2i;
    typedef Vector2<float> Vector2f;
} // namespace tson
 
        #endif // TILESON_VECTOR2_HPP
 
 
        // #include "../external/json.hpp"
 
 
        //
        // Created by robin on 06.01.2021.
        //
 
        #ifndef TILESON_IJSON_HPP
            #define TILESON_IJSON_HPP
 
namespace tson {
    class IJson {
    public:
        virtual IJson &operator[](std::string_view key) = 0;
        virtual IJson &at(std::string_view key) = 0;
        virtual IJson &at(size_t pos) = 0;
        [[nodiscard]]
        virtual std::vector<std::unique_ptr<IJson>> array() = 0;
        [[nodiscard]]
        virtual std::vector<std::unique_ptr<IJson>> &array(std::string_view key) = 0;
        [[nodiscard]]
        virtual size_t size() const = 0;
        [[nodiscard]]
        virtual bool parse(const fs::path &path) = 0;
        [[nodiscard]]
        virtual bool parse(const void *data, size_t size) = 0;
 
        template<typename T>
        [[nodiscard]]
        T get(std::string_view key);
        template<typename T>
        [[nodiscard]]
        T get();
        [[nodiscard]]
        virtual size_t count(std::string_view key) const = 0;
        [[nodiscard]]
        virtual bool any(std::string_view key) const = 0;
        [[nodiscard]]
        virtual bool isArray() const = 0;
        [[nodiscard]]
        virtual bool isObject() const = 0;
        [[nodiscard]]
        virtual bool isNull() const = 0;
 
        [[nodiscard]]
        virtual fs::path directory() const = 0;
        virtual void directory(const fs::path &directory) = 0;
 
        virtual ~IJson() = default;
 
    protected:
        [[nodiscard]]
        virtual int32_t getInt32(std::string_view key) = 0;
        [[nodiscard]]
        virtual uint32_t getUInt32(std::string_view key) = 0;
        [[nodiscard]]
        virtual int64_t getInt64(std::string_view key) = 0;
        [[nodiscard]]
        virtual uint64_t getUInt64(std::string_view key) = 0;
        [[nodiscard]]
        virtual double getDouble(std::string_view key) = 0;
        [[nodiscard]]
        virtual float getFloat(std::string_view key) = 0;
        [[nodiscard]]
        virtual std::string getString(std::string_view key) = 0;
        [[nodiscard]]
        virtual bool getBool(std::string_view key) = 0;
 
        [[nodiscard]]
        virtual int32_t getInt32() = 0;
        [[nodiscard]]
        virtual uint32_t getUInt32() = 0;
        [[nodiscard]]
        virtual int64_t getInt64() = 0;
        [[nodiscard]]
        virtual uint64_t getUInt64() = 0;
        [[nodiscard]]
        virtual double getDouble() = 0;
        [[nodiscard]]
        virtual float getFloat() = 0;
        [[nodiscard]]
        virtual std::string getString() = 0;
        [[nodiscard]]
        virtual bool getBool() = 0;
    };
 
    template<typename T>
    T IJson::get(std::string_view key)
    {
        if constexpr (std::is_same<T, double>::value) return getDouble(key);
        if constexpr (std::is_same<T, float>::value)
            return getFloat(key);
        else if constexpr (std::is_same<T, int32_t>::value)
            return getInt32(key);
        else if constexpr (std::is_same<T, uint32_t>::value)
            return getUInt32(key);
        else if constexpr (std::is_same<T, int64_t>::value)
            return getInt64(key);
        else if constexpr (std::is_same<T, uint64_t>::value)
            return getUInt64(key);
        else if constexpr (std::is_same<T, std::string>::value)
            return getString(key);
        else if constexpr (std::is_same<T, bool>::value)
            return getBool(key);
        else
            return nullptr;
    }
 
    template<typename T>
    T IJson::get()
    {
        if constexpr (std::is_same<T, double>::value) return getDouble();
        if constexpr (std::is_same<T, float>::value)
            return getFloat();
        else if constexpr (std::is_same<T, int32_t>::value)
            return getInt32();
        else if constexpr (std::is_same<T, uint32_t>::value)
            return getUInt32();
        else if constexpr (std::is_same<T, int64_t>::value)
            return getInt64();
        else if constexpr (std::is_same<T, uint64_t>::value)
            return getUInt64();
        else if constexpr (std::is_same<T, std::string>::value)
            return getString();
        else if constexpr (std::is_same<T, bool>::value)
            return getBool();
        else
            return nullptr;
    }
 
} // namespace tson
 
        #endif // TILESON_IJSON_HPP
 
 
 
        //
        // Created by robin on 08.01.2021.
        //
 
        #ifdef INCLUDE_NLOHMANN_JSON_HPP_
 
            #ifndef TILESON_NLOHMANNJSON_HPP
                #define TILESON_NLOHMANNJSON_HPP
 
namespace tson {
    class NlohmannJson : public tson::IJson {
    public:
        inline NlohmannJson() = default;
 
        IJson &operator[](std::string_view key) override
        {
            if (m_arrayCache.count(key.data()) == 0) m_arrayCache[key.data()] = std::make_unique<NlohmannJson>(&m_json->operator[](key.data())); //.front());
 
            return *m_arrayCache[key.data()].get();
        }
 
        inline explicit NlohmannJson(nlohmann::json *json) : m_json {json} {}
 
        inline IJson &at(std::string_view key) override
        {
            if (m_arrayCache.count(key.data()) == 0) m_arrayCache[key.data()] = std::make_unique<NlohmannJson>(&m_json->operator[](key.data())); //.front());
 
            return *m_arrayCache[key.data()].get();
        }
 
        inline IJson &at(size_t pos) override
        {
            if (m_arrayPosCache.count(pos) == 0) m_arrayPosCache[pos] = std::make_unique<NlohmannJson>(&m_json->at(pos));
 
            return *m_arrayPosCache[pos];
        }
 
        std::vector<std::unique_ptr<IJson>> array() override
        {
            std::vector<std::unique_ptr<IJson>> vec;
            for (auto &item : *m_json) {
                nlohmann::json *ptr = &item;
                vec.emplace_back(std::make_unique<NlohmannJson>(ptr));
            }
 
            return vec;
        }
 
        inline std::vector<std::unique_ptr<IJson>> &array(std::string_view key) override
        {
            if (m_arrayListDataCache.count(key.data()) == 0) {
                if (m_json->count(key.data()) > 0 && m_json->operator[](key.data()).is_array()) {
                    std::for_each(m_json->operator[](key.data()).begin(), m_json->operator[](key.data()).end(), [&](nlohmann::json &item) {
                        nlohmann::json *ptr = &item;
                        m_arrayListDataCache[key.data()].emplace_back(std::make_unique<NlohmannJson>(ptr));
                    });
                }
            }
 
            return m_arrayListDataCache[key.data()];
        }
 
        [[nodiscard]]
        inline size_t size() const override
        {
            return m_json->size();
        }
 
        inline bool parse(const fs::path &path) override
        {
            clearCache();
            m_data = nullptr;
            m_json = nullptr;
            if (fs::exists(path) && fs::is_regular_file(path)) {
                m_path = path.parent_path();
                m_data = std::make_unique<nlohmann::json>();
                std::ifstream i(path.generic_string());
                try {
                    i >> *m_data;
                    m_json = m_data.get();
                } catch (const nlohmann::json::parse_error &error) {
                    std::string message = "Parse error: ";
                    message += std::string(error.what());
                    message += std::string("\n");
                    std::cerr << message;
                    return false;
                }
                return true;
            }
            return false;
        }
 
        inline bool parse(const void *data, size_t size) override
        {
            clearCache();
            m_json = nullptr;
            m_data = std::make_unique<nlohmann::json>();
            tson::MemoryStream mem {(uint8_t *) data, size};
            try {
                mem >> *m_data;
                m_json = m_data.get();
            } catch (const nlohmann::json::parse_error &error) {
                std::string message = "Parse error: ";
                message += std::string(error.what());
                message += std::string("\n");
                std::cerr << message;
                return false;
            }
            return true;
        }
 
        [[nodiscard]]
        inline size_t count(std::string_view key) const override
        {
            return m_json->count(key);
        }
 
        [[nodiscard]]
        inline bool any(std::string_view key) const override
        {
            return count(key) > 0;
        }
 
        [[nodiscard]]
        inline bool isArray() const override
        {
            return m_json->is_array();
        }
 
        [[nodiscard]]
        inline bool isObject() const override
        {
            return m_json->is_object();
        }
 
        [[nodiscard]]
        inline bool isNull() const override
        {
            return m_json->is_null();
        }
 
        fs::path directory() const override { return m_path; }
 
        void directory(const fs::path &directory) override { m_path = directory; }
 
    protected:
        [[nodiscard]]
        inline int32_t getInt32(std::string_view key) override
        {
            return m_json->operator[](key.data()).get<int32_t>();
        }
 
        [[nodiscard]]
        inline uint32_t getUInt32(std::string_view key) override
        {
            return m_json->operator[](key.data()).get<uint32_t>();
        }
 
        [[nodiscard]]
        inline int64_t getInt64(std::string_view key) override
        {
            return m_json->operator[](key.data()).get<int64_t>();
        }
 
        [[nodiscard]]
        inline uint64_t getUInt64(std::string_view key) override
        {
            return m_json->operator[](key.data()).get<uint64_t>();
        }
 
        [[nodiscard]]
        inline double getDouble(std::string_view key) override
        {
            return m_json->operator[](key.data()).get<double>();
        }
 
        [[nodiscard]]
        inline std::string getString(std::string_view key) override
        {
            return m_json->operator[](key.data()).get<std::string>();
        }
 
        [[nodiscard]]
        inline bool getBool(std::string_view key) override
        {
            return m_json->operator[](key.data()).get<bool>();
        }
 
        [[nodiscard]]
        float getFloat(std::string_view key) override
        {
            return m_json->operator[](key.data()).get<float>();
        }
 
        [[nodiscard]]
        inline int32_t getInt32() override
        {
            return m_json->get<int32_t>();
        }
 
        [[nodiscard]]
        inline uint32_t getUInt32() override
        {
            return m_json->get<uint32_t>();
        }
 
        [[nodiscard]]
        inline int64_t getInt64() override
        {
            return m_json->get<int64_t>();
        }
 
        [[nodiscard]]
        inline uint64_t getUInt64() override
        {
            return m_json->get<uint64_t>();
        }
 
        [[nodiscard]]
        inline double getDouble() override
        {
            return m_json->get<double>();
        }
 
        [[nodiscard]]
        inline std::string getString() override
        {
            return m_json->get<std::string>();
        }
 
        [[nodiscard]]
        inline bool getBool() override
        {
            return m_json->get<bool>();
        }
 
        [[nodiscard]]
        float getFloat() override
        {
            return m_json->get<float>();
        }
 
    private:
        inline void clearCache()
        {
            m_arrayCache.clear();
            m_arrayPosCache.clear();
            m_arrayListDataCache.clear();
        }
 
        nlohmann::json *m_json = nullptr;
        std::unique_ptr<nlohmann::json> m_data = nullptr; // Only used if this is the owner json!
        fs::path m_path;
 
        // Cache!
        std::map<std::string, std::unique_ptr<IJson>> m_arrayCache;
        std::map<size_t, std::unique_ptr<IJson>> m_arrayPosCache;
        std::map<std::string, std::vector<std::unique_ptr<IJson>>> m_arrayListDataCache;
    };
} // namespace tson
            #endif // TILESON_NLOHMANNJSON_HPP
 
        #endif // INCLUDE_NLOHMANN_JSON_HPP_
 
 
        //
        // Created by robin on 11.01.2021.
        //
 
        #ifdef picojson_h
            #ifndef TILESON_PICOJSON_HPP
                #define TILESON_PICOJSON_HPP
 
namespace tson {
    class PicoJson : public tson::IJson {
    public:
        inline PicoJson() = default;
 
        IJson &operator[](std::string_view key) override
        {
            if (m_arrayCache.count(key.data()) == 0) {
                if (m_json->is<picojson::object>()) {
                    picojson::object &o = m_json->get<picojson::object>();
                    m_arrayCache[key.data()] = std::make_unique<PicoJson>(&o[key.data()]);
                }
            }
 
            return *m_arrayCache[key.data()].get();
        }
 
        inline explicit PicoJson(picojson::value *json) : m_json {json} {}
 
        inline IJson &at(std::string_view key) override
        {
            if (m_arrayCache.count(key.data()) == 0) {
                if (m_json->is<picojson::object>()) {
                    picojson::object &o = m_json->get<picojson::object>();
                    m_arrayCache[key.data()] = std::make_unique<PicoJson>(&o[key.data()]);
                }
            }
            return *m_arrayCache[key.data()].get();
        }
 
        inline IJson &at(size_t pos) override
        {
            if (m_arrayPosCache.count(pos) == 0) {
                picojson::array &a = m_json->get<picojson::array>();
                m_arrayPosCache[pos] = std::make_unique<PicoJson>(&a.at(pos));
            }
 
            return *m_arrayPosCache[pos];
        }
 
        std::vector<std::unique_ptr<IJson>> array() override
        {
            std::vector<std::unique_ptr<IJson>> vec;
            if (m_json->is<picojson::array>()) {
                picojson::array &a = m_json->get<picojson::array>();
                for (auto &item : a) {
                    picojson::value *ptr = &item;
                    vec.emplace_back(std::make_unique<PicoJson>(ptr));
                }
            }
 
            return vec;
        }
 
        inline std::vector<std::unique_ptr<IJson>> &array(std::string_view key) override
        {
            if (m_arrayListDataCache.count(key.data()) == 0) {
                if (count(key.data()) > 0) {
                    if (isObject()) {
                        picojson::object &obj = m_json->get<picojson::object>();
                        picojson::value &v = obj.at(key.data());
                        bool isArray = v.is<picojson::array>();
                        if (isArray) {
                            picojson::array &a = v.get<picojson::array>();
 
                            std::for_each(a.begin(), a.end(), [&](picojson::value &item) {
                                picojson::value *ptr = &item;
                                m_arrayListDataCache[key.data()].emplace_back(std::make_unique<PicoJson>(ptr));
                            });
                        }
                    }
                }
            }
 
            return m_arrayListDataCache[key.data()];
        }
 
        [[nodiscard]]
        inline size_t size() const override
        {
            if (m_json->is<picojson::object>()) {
                picojson::object obj = m_json->get<picojson::object>();
                return obj.size();
            }
            return 0;
        }
 
        inline bool parse(const fs::path &path) override
        {
            clearCache();
            m_data = nullptr;
            m_json = nullptr;
            if (fs::exists(path) && fs::is_regular_file(path)) {
                m_path = path.parent_path();
                m_data = std::make_unique<picojson::value>();
                std::ifstream i(path.generic_string());
                try {
                    std::string error = picojson::parse(*m_data, i);
                    if (!error.empty()) {
                        std::cerr << "PicoJson parse error: " << error << "\n";
                        return false;
                    }
                    // i >> *m_data;
                    m_json = m_data.get();
                } catch (const std::exception &error) {
                    std::string message = "Parse error: ";
                    message += std::string(error.what());
                    message += std::string("\n");
                    std::cerr << message;
                    return false;
                }
                return true;
            }
            return false;
        }
 
        inline bool parse(const void *data, size_t size) override
        {
            clearCache();
            m_json = nullptr;
            m_data = std::make_unique<picojson::value>();
            tson::MemoryStream mem {(uint8_t *) data, size};
            try {
                std::string error = picojson::parse(*m_data, mem);
                if (!error.empty()) {
                    std::cerr << "PicoJson parse error: " << error << "\n";
                    return false;
                }
                // mem >> *m_data;
                m_json = m_data.get();
            } catch (const std::exception &error) {
                std::string message = "Parse error: ";
                message += std::string(error.what());
                message += std::string("\n");
                std::cerr << message;
                return false;
            }
            return true;
        }
 
        [[nodiscard]]
        inline size_t count(std::string_view key) const override
        {
            if (isObject()) {
                picojson::object obj = m_json->get<picojson::object>();
                return obj.count(key.data());
            }
 
            return m_json->contains(key.data()) ? 1 : 0;
        }
 
        [[nodiscard]]
        inline bool any(std::string_view key) const override
        {
            return count(key) > 0;
        }
 
        [[nodiscard]]
        inline bool isArray() const override
        {
            return m_json->is<picojson::array>();
        }
 
        [[nodiscard]]
        inline bool isObject() const override
        {
            return m_json->is<picojson::object>();
        }
 
        [[nodiscard]]
        inline bool isNull() const override
        {
            return m_json->is<picojson::null>();
        }
 
        fs::path directory() const override { return m_path; }
 
        void directory(const fs::path &directory) override { m_path = directory; }
 
    protected:
        [[nodiscard]]
        inline int32_t getInt32(std::string_view key) override
        {
            picojson::object obj = m_json->get<picojson::object>();
            return static_cast<int32_t>(getDouble(key));
        }
 
        [[nodiscard]]
        inline uint32_t getUInt32(std::string_view key) override
        {
            picojson::object obj = m_json->get<picojson::object>();
            return static_cast<uint32_t>(getDouble(key));
        }
 
        [[nodiscard]]
        inline int64_t getInt64(std::string_view key) override
        {
            picojson::object obj = m_json->get<picojson::object>();
            return static_cast<int64_t>(getDouble(key));
        }
 
        [[nodiscard]]
        inline uint64_t getUInt64(std::string_view key) override
        {
            picojson::object obj = m_json->get<picojson::object>();
            return static_cast<uint64_t>(getDouble(key));
        }
 
        [[nodiscard]]
        inline double getDouble(std::string_view key) override
        {
            picojson::object obj = m_json->get<picojson::object>();
            return obj[key.data()].get<double>();
        }
 
        [[nodiscard]]
        inline std::string getString(std::string_view key) override
        {
            picojson::object obj = m_json->get<picojson::object>();
            return obj[key.data()].get<std::string>();
        }
 
        [[nodiscard]]
        inline bool getBool(std::string_view key) override
        {
            picojson::object obj = m_json->get<picojson::object>();
            return obj[key.data()].get<bool>();
        }
 
        [[nodiscard]]
        float getFloat(std::string_view key) override
        {
            picojson::object obj = m_json->get<picojson::object>();
            return static_cast<float>(getDouble(key));
        }
 
        [[nodiscard]]
        inline int32_t getInt32() override
        {
            return static_cast<int32_t>(getDouble());
        }
 
        [[nodiscard]]
        inline uint32_t getUInt32() override
        {
            return static_cast<uint32_t>(getDouble());
        }
 
        [[nodiscard]]
        inline int64_t getInt64() override
        {
            return static_cast<int64_t>(getDouble());
        }
 
        [[nodiscard]]
        inline uint64_t getUInt64() override
        {
            return static_cast<uint64_t>(getDouble());
        }
 
        [[nodiscard]]
        inline double getDouble() override
        {
            return m_json->get<double>();
        }
 
        [[nodiscard]]
        inline std::string getString() override
        {
            return m_json->get<std::string>();
        }
 
        [[nodiscard]]
        inline bool getBool() override
        {
            return m_json->get<bool>();
        }
 
        [[nodiscard]]
        float getFloat() override
        {
            return static_cast<float>(getDouble());
        }
 
    private:
        inline void clearCache()
        {
            m_arrayCache.clear();
            m_arrayPosCache.clear();
            m_arrayListDataCache.clear();
        }
 
        picojson::value *m_json = nullptr;
        std::unique_ptr<picojson::value> m_data = nullptr; // Only used if this is the owner json!
        fs::path m_path;
 
        // Cache!
        std::map<std::string, std::unique_ptr<IJson>> m_arrayCache;
        std::map<size_t, std::unique_ptr<IJson>> m_arrayPosCache;
        std::map<std::string, std::vector<std::unique_ptr<IJson>>> m_arrayListDataCache;
    };
} // namespace tson
            #endif // TILESON_PICOJSON_HPP
        #endif
 
 
        // #include "../json/Gason.hpp" //Unsupported
 
 
        //
        // Created by robin on 16.01.2021.
        //
 
        #ifndef TILESON_JSON11_HPP
            #define TILESON_JSON11_HPP
 
namespace tson {
    class Json11 : public tson::IJson {
    public:
        inline Json11() = default;
 
        IJson &operator[](std::string_view key) override
        {
            if (m_arrayCache.count(key.data()) == 0) {
                if (m_json->is_object()) {
                    m_arrayCache[key.data()] = std::make_unique<Json11>(m_json->operator[](key.data()));
                }
            }
 
            return *m_arrayCache[key.data()].get();
        }
 
        inline explicit Json11(const json11::Json &json) : m_json {&json} {}
 
        inline IJson &at(std::string_view key) override
        {
            if (m_arrayCache.count(key.data()) == 0) {
                if (m_json->is_object()) {
                    m_arrayCache[key.data()] = std::make_unique<Json11>(m_json->operator[](key.data()));
                }
            }
            return *m_arrayCache[key.data()].get();
        }
 
        inline IJson &at(size_t pos) override
        {
            if (m_arrayPosCache.count(pos) == 0) {
                const std::vector<json11::Json> &a = m_json->array_items();
                m_arrayPosCache[pos] = std::make_unique<Json11>(a.at(pos));
            }
 
            return *m_arrayPosCache[pos];
        }
 
        std::vector<std::unique_ptr<IJson>> array() override
        {
            std::vector<std::unique_ptr<IJson>> vec;
            if (m_json->is_array()) {
                for (const json11::Json &item : m_json->array_items()) {
                    vec.emplace_back(std::make_unique<Json11>(item));
                }
            }
 
            return vec;
        }
 
        inline std::vector<std::unique_ptr<IJson>> &array(std::string_view key) override
        {
            if (m_arrayListDataCache.count(key.data()) == 0) {
                if (count(key.data()) > 0) {
                    if (isObject()) {
                        const json11::Json &v = m_json->operator[](key.data());
                        if (v.is_array()) {
                            for (const json11::Json &item : v.array_items()) {
                                m_arrayListDataCache[key.data()].emplace_back(std::make_unique<Json11>(item));
                            }
                        }
                    }
                }
            }
 
            return m_arrayListDataCache[key.data()];
        }
 
        [[nodiscard]]
        inline size_t size() const override
        {
            if (m_json->is_object())
                return m_json->object_items().size();
            else if (m_json->is_array())
                return m_json->array_items().size();
 
            return 0;
        }
 
        inline bool parse(const fs::path &path) override
        {
            clearCache();
            m_data = nullptr;
            m_json = nullptr;
            if (fs::exists(path) && fs::is_regular_file(path)) {
                std::ifstream file(path.generic_string());
                std::string str;
                m_path = path.parent_path();
 
                file.seekg(0, std::ios::end);
                str.reserve(static_cast<size_t>(file.tellg()));
                file.seekg(0, std::ios::beg);
 
                str.assign((std::istreambuf_iterator<char>(file)), std::istreambuf_iterator<char>());
 
                m_data = std::make_unique<json11::Json>();
 
                try {
                    std::string strError;
                    *m_data = json11::Json::parse(str, strError);
                    if (!strError.empty()) {
                        std::cerr << strError << "\n";
                        return false;
                    }
                    m_json = m_data.get();
                } catch (const std::exception &error) {
                    std::string message = "Json11 parse error: ";
                    message += std::string(error.what());
                    message += std::string("\n");
                    std::cerr << message;
                    return false;
                }
                return true;
            }
            return false;
        }
 
        inline bool parse(const void *data, size_t size) override
        {
            clearCache();
            m_json = nullptr;
            std::string str;
 
            str.reserve(size);
 
            tson::MemoryStream mem {(uint8_t *) data, size};
 
            str.assign((std::istreambuf_iterator<char>(mem)), std::istreambuf_iterator<char>());
 
            m_data = std::make_unique<json11::Json>();
 
            try {
                std::string strError;
 
                *m_data = json11::Json::parse(str, strError);
                if (!strError.empty()) {
                    std::cout << strError << "\n";
                    return false;
                }
                m_json = m_data.get();
            } catch (const std::exception &error) {
                std::string message = "Json11 parse error: ";
                message += std::string(error.what());
                message += std::string("\n");
                std::cerr << message;
                return false;
            }
            return true;
        }
 
        [[nodiscard]]
        inline size_t count(std::string_view key) const override
        {
            if (isObject()) {
                // const json11::Json &j = m_json->operator[](key.data());
                // size_t s1 = j.object_items().size();
                return m_json->object_items().count(key.data());
            }
 
            return 0;
        }
 
        [[nodiscard]]
        inline bool any(std::string_view key) const override
        {
            return count(key) > 0;
        }
 
        [[nodiscard]]
        inline bool isArray() const override
        {
            return m_json->is_array();
        }
 
        [[nodiscard]]
        inline bool isObject() const override
        {
            return m_json->is_object();
        }
 
        [[nodiscard]]
        inline bool isNull() const override
        {
            return m_json->is_null();
        }
 
        fs::path directory() const override { return m_path; }
 
        void directory(const fs::path &directory) override { m_path = directory; }
 
    protected:
        [[nodiscard]]
        inline int32_t getInt32(std::string_view key) override
        {
            return static_cast<int32_t>(getDouble(key));
        }
 
        [[nodiscard]]
        inline uint32_t getUInt32(std::string_view key) override
        {
            return static_cast<uint32_t>(getDouble(key));
        }
 
        [[nodiscard]]
        inline int64_t getInt64(std::string_view key) override
        {
            return static_cast<int64_t>(getDouble(key));
        }
 
        [[nodiscard]]
        inline uint64_t getUInt64(std::string_view key) override
        {
            return static_cast<uint64_t>(getDouble(key));
        }
 
        [[nodiscard]]
        inline double getDouble(std::string_view key) override
        {
            return m_json->operator[](key.data()).number_value();
        }
 
        [[nodiscard]]
        inline std::string getString(std::string_view key) override
        {
            return m_json->operator[](key.data()).string_value(); // .get<std::string>();
        }
 
        [[nodiscard]]
        inline bool getBool(std::string_view key) override
        {
            return m_json->operator[](key.data()).bool_value();
        }
 
        [[nodiscard]]
        float getFloat(std::string_view key) override
        {
            return static_cast<float>(getDouble(key));
        }
 
        [[nodiscard]]
        inline int32_t getInt32() override
        {
            return static_cast<int32_t>(getDouble());
        }
 
        [[nodiscard]]
        inline uint32_t getUInt32() override
        {
            return static_cast<uint32_t>(getDouble());
        }
 
        [[nodiscard]]
        inline int64_t getInt64() override
        {
            return static_cast<int64_t>(getDouble());
        }
 
        [[nodiscard]]
        inline uint64_t getUInt64() override
        {
            return static_cast<uint64_t>(getDouble());
        }
 
        [[nodiscard]]
        inline double getDouble() override
        {
            return m_json->number_value();
        }
 
        [[nodiscard]]
        inline std::string getString() override
        {
            return m_json->string_value();
        }
 
        [[nodiscard]]
        inline bool getBool() override
        {
            return m_json->bool_value();
        }
 
        [[nodiscard]]
        float getFloat() override
        {
            return static_cast<float>(getDouble());
        }
 
    private:
        inline void clearCache()
        {
            m_arrayCache.clear();
            m_arrayPosCache.clear();
            m_arrayListDataCache.clear();
        }
 
        // Owner values
        std::unique_ptr<json11::Json> m_data = nullptr; // Only used if this is the owner json!
 
        const json11::Json *m_json = nullptr;
        fs::path m_path;
 
        // Cache!
        std::map<std::string, std::unique_ptr<IJson>> m_arrayCache;
        std::map<size_t, std::unique_ptr<IJson>> m_arrayPosCache;
        std::map<std::string, std::vector<std::unique_ptr<IJson>>> m_arrayListDataCache;
    };
} // namespace tson
 
        #endif // TILESON_JSON11_HPP
 
 
 
        //
        // Created by robin on 22.03.2020.
        //
 
        #ifndef TILESON_LAYER_HPP
            #define TILESON_LAYER_HPP
 
            #include <set>
  // #include "../external/json.hpp"
 
 
            //
            // Created by robin on 22.03.2020.
            //
 
            #ifndef TILESON_CHUNK_HPP
                #define TILESON_CHUNK_HPP
 
// #include "../external/json.hpp"
 
namespace tson {
    class Chunk {
    public:
        inline Chunk() = default;
        inline explicit Chunk(IJson &json);
        inline bool parse(IJson &json);
 
        [[nodiscard]]
        inline const std::vector<int> &getData() const;
        [[nodiscard]]
        inline const std::string &getBase64Data() const;
        [[nodiscard]]
        inline const Vector2i &getSize() const;
        [[nodiscard]]
        inline const Vector2i &getPosition() const;
 
    private:
        std::vector<int> m_data; 
        std::string m_base64Data; 
        tson::Vector2i m_size; 
        tson::Vector2i m_position; 
    };
} // namespace tson
 
            #endif // TILESON_CHUNK_HPP
 
tson::Chunk::Chunk(IJson &json)
{
    parse(json);
}
 
bool tson::Chunk::parse(IJson &json)
{
    bool allFound = true;
 
    if (json.count("width") > 0 && json.count("height") > 0)
        m_size = {json["width"].get<int>(), json["height"].get<int>()};
    else
        allFound = false;
    if (json.count("x") > 0 && json.count("y") > 0)
        m_position = {json["x"].get<int>(), json["y"].get<int>()};
    else
        allFound = false;
 
    // Handle DATA (Optional)
    if (json.count("data") > 0) {
        if (json["data"].isArray()) {
            auto &data = json.array("data");
            std::for_each(data.begin(), data.end(), [&](std::unique_ptr<IJson> &item) { m_data.push_back(item->get<int>()); });
        } else
            m_base64Data = json["data"].get<std::string>();
    }
 
    return allFound;
}
 
const std::vector<int> &tson::Chunk::getData() const
{
    return m_data;
}
 
const std::string &tson::Chunk::getBase64Data() const
{
    return m_base64Data;
}
 
const tson::Vector2i &tson::Chunk::getSize() const
{
    return m_size;
}
 
const tson::Vector2i &tson::Chunk::getPosition() const
{
    return m_position;
}
 
 
 
            //
            // Created by robin on 22.03.2020.
            //
 
            #ifndef TILESON_OBJECT_HPP
                #define TILESON_OBJECT_HPP
 
                // #include "../external/json.hpp"
 
 
                //
                // Created by robin on 22.03.2020.
                //
 
                #ifndef TILESON_PROPERTYCOLLECTION_HPP
                    #define TILESON_PROPERTYCOLLECTION_HPP
 
 
                    //
                    // Created by robin on 22.03.2020.
                    //
 
                    #ifndef TILESON_PROPERTY_HPP
                        #define TILESON_PROPERTY_HPP
 
                        // #include "../../TilesonConfig.h"
 
                        // #if USE_CPP17_FILESYSTEM
 
                        #include <any>
                        #include <string>
 
 
                        //
                        // Created by robin on 22.03.2020.
                        //
 
                        #ifndef TILESON_ENUMS_HPP
                            #define TILESON_ENUMS_HPP
                            #include <cstdint>
 
 
                            //
                            // Created by robin on 08.11.2020.
                            //
 
                            #ifndef TILESON_ENUMBITFLAGS_HPP
                                #define TILESON_ENUMBITFLAGS_HPP
 
                                #include <iostream>
                                #include <type_traits>
 
                                #define TILESON_ENABLE_BITMASK_OPERATORS(x) \
                                    namespace tson {                        \
                                        ENABLE_BITMASK_OPERATORS(x)         \
                                    }
 
namespace tson {
                                #define ENABLE_BITMASK_OPERATORS(x)      \
                                    template<>                           \
                                    struct EnableBitMaskOperators<x> {   \
                                        static const bool enable = true; \
                                    };
 
    template<typename Enum>
    struct EnableBitMaskOperators {
        static const bool enable = false;
    };
 
    template<typename Enum>
    typename std::enable_if<EnableBitMaskOperators<Enum>::enable, Enum>::type operator|(Enum lhs, Enum rhs)
    {
        static_assert(std::is_enum<Enum>::value, "template parameter is not an enum type");
 
        using underlying = typename std::underlying_type<Enum>::type;
 
        return static_cast<Enum>(static_cast<underlying>(lhs) | static_cast<underlying>(rhs));
    }
 
    // Permissions operator &(Permissions lhs, Permissions rhs)
    template<typename Enum>
    typename std::enable_if<EnableBitMaskOperators<Enum>::enable, Enum>::type operator&(Enum lhs, Enum rhs)
    {
        static_assert(std::is_enum<Enum>::value, "template parameter is not an enum type");
 
        using underlying = typename std::underlying_type<Enum>::type;
 
        return static_cast<Enum>(static_cast<underlying>(lhs) & static_cast<underlying>(rhs));
    }
 
    // Permissions operator ^(Permissions lhs, Permissions rhs)
    template<typename Enum>
    typename std::enable_if<EnableBitMaskOperators<Enum>::enable, Enum>::type operator^(Enum lhs, Enum rhs)
    {
        static_assert(std::is_enum<Enum>::value, "template parameter is not an enum type");
 
        using underlying = typename std::underlying_type<Enum>::type;
 
        return static_cast<Enum>(static_cast<underlying>(lhs) ^ static_cast<underlying>(rhs));
    }
 
    // Permissions operator ~(Permissions rhs)
    template<typename Enum>
    typename std::enable_if<EnableBitMaskOperators<Enum>::enable, Enum>::type operator~(Enum rhs)
    {
        static_assert(std::is_enum<Enum>::value, "template parameter is not an enum type");
 
        using underlying = typename std::underlying_type<Enum>::type;
 
        return static_cast<Enum>(~static_cast<underlying>(rhs));
    }
 
    // Permissions& operator |=(Permissions &lhs, Permissions rhs)
    template<typename Enum>
    typename std::enable_if<EnableBitMaskOperators<Enum>::enable, Enum>::type &operator|=(Enum &lhs, Enum rhs)
    {
        static_assert(std::is_enum<Enum>::value, "template parameter is not an enum type");
 
        using underlying = typename std::underlying_type<Enum>::type;
 
        lhs = static_cast<Enum>(static_cast<underlying>(lhs) | static_cast<underlying>(rhs));
 
        return lhs;
    }
 
    // Permissions& operator &=(Permissions &lhs, Permissions rhs)
    template<typename Enum>
    typename std::enable_if<EnableBitMaskOperators<Enum>::enable, Enum>::type &operator&=(Enum &lhs, Enum rhs)
    {
        static_assert(std::is_enum<Enum>::value, "template parameter is not an enum type");
 
        using underlying = typename std::underlying_type<Enum>::type;
 
        lhs = static_cast<Enum>(static_cast<underlying>(lhs) & static_cast<underlying>(rhs));
 
        return lhs;
    }
 
    // Permissions& operator ^=(Permissions &lhs, Permissions rhs)
    template<typename Enum>
    typename std::enable_if<EnableBitMaskOperators<Enum>::enable, Enum>::type &operator^=(Enum &lhs, Enum rhs)
    {
        static_assert(std::is_enum<Enum>::value, "template parameter is not an enum type");
 
        using underlying = typename std::underlying_type<Enum>::type;
 
        lhs = static_cast<Enum>(static_cast<underlying>(lhs) ^ static_cast<underlying>(rhs));
 
        return lhs;
    }
} // namespace tson
 
                            #endif // TILESON_ENUMBITFLAGS_HPP
 
 
namespace tson {
    enum class Type : uint8_t {
        Undefined = 0,
        Color = 1, 
        File = 2, 
        Int = 3, 
        Boolean = 4, 
        Float = 5, 
        String = 6, 
        Class = 7, 
        Enum = 8, 
        Object = 9 
    };
 
    enum class LayerType : uint8_t {
        Undefined = 0,
        TileLayer = 1,
        ObjectGroup = 2,
        ImageLayer = 3,
        Group = 4
    };
 
    enum class ParseStatus : uint8_t {
        OK = 0, // OK unless otherwise stated
        FileNotFound = 1,
        ParseError = 2,
        MissingData = 3,
        DecompressionError = 4
    };
 
    enum class ObjectType : uint8_t {
        Undefined = 0,
        Object = 1,
        Ellipse = 2,
        Rectangle = 3,
        Point = 4,
        Polygon = 5,
        Polyline = 6,
        Text = 7,
        Template = 8
    };
 
    static constexpr uint32_t FLIPPED_HORIZONTALLY_FLAG = 0x80000000;
    static constexpr uint32_t FLIPPED_VERTICALLY_FLAG = 0x40000000;
    static constexpr uint32_t FLIPPED_DIAGONALLY_FLAG = 0x20000000;
    enum class TileFlipFlags : uint32_t {
        None = 0,
        Diagonally = FLIPPED_DIAGONALLY_FLAG,
        Vertically = FLIPPED_VERTICALLY_FLAG,
        Horizontally = FLIPPED_HORIZONTALLY_FLAG
    };
 
    enum class ObjectAlignment : uint8_t {
        Unspecified = 0, // unspecified
        TopLeft = 1, // topleft
        Top = 2, // top
        TopRight = 3, // topright
        Left = 4, // left
        Center = 5, // center
        Right = 6, // right
        BottomLeft = 7, // bottomleft
        Bottom = 8, // bottom
        BottomRight = 9 // bottomright
    };
 
    enum class TextAlignment : uint8_t {
        Unresolved = 0,
        Left = 1, // left
        Center = 2, // center
        Right = 3, // right
        Justify = 4, // justify
        Top = 5, // top
        Bottom = 6 // bottom
    };
 
    enum class TileRenderSize : uint8_t {
        Undefined = 0,
        Tile = 1, // tile (default)
        Grid = 2 // grid
    };
 
    enum class FillMode : uint8_t {
        Undefined = 0,
        Stretch = 1, // stretch (default)
        PreserveAspectFit = 2 // preserve-aspect-fit
    };
 
    enum class EnumStorageType : uint8_t {
        Unspecified = 0,
        Int = 1,
        String = 2
    };
 
    ENABLE_BITMASK_OPERATORS(TileFlipFlags)
} // namespace tson
 
                        #endif // TILESON_ENUMS_HPP
 
 
// #include "../external/json.hpp"
 
namespace tson {
    class Project;
 
    class Property {
    public:
        // enum class Type : uint8_t
        //{
        //         Undefined = 0,
        //         Color = 1, /*! color */
        //         File = 2, /*! file */
        //         Int = 3, /*! int */
        //         Boolean = 4, /*! bool */
        //         Float = 5, /*! float */
        //         String = 6 /*! string */
        // };
 
        inline Property();
        inline explicit Property(IJson &json, tson::Project *project = nullptr);
        inline Property(std::string name, std::any value, Type type);
 
        inline void setValue(const std::any &value);
        inline void setStrValue(const std::string &value);
        inline void setName(const std::string &name);
 
        [[nodiscard]]
        inline const std::type_info &getValueType() const;
        inline std::string getValueTypeInfo();
        [[nodiscard]]
        inline const std::any &getValue() const;
        template<typename T>
        inline T getValue() const;
        [[nodiscard]]
        inline const std::string &getName() const;
        [[nodiscard]]
        inline Type getType() const;
        [[nodiscard]]
        inline const std::string &getPropertyType() const;
 
        // Became public in v1.4.0
        inline void setValueByType(IJson &json); // Definition in tileson_forward.hpp
 
    protected:
        inline void setTypeByString(const std::string &str);
 
        tson::Project *m_project = nullptr; // Used for resolving 'enum' and 'class' objects
        Type m_type = Type::Undefined;
        std::string m_name {};
        std::string m_propertyType {};
        std::any m_value; // Using std::any to assign any type
    };
 
    template<typename T>
    T Property::getValue() const
    {
        bool isCorrectType = (m_value.type() == typeid(T));
 
        if (isCorrectType) {
            T value = std::any_cast<T>(m_value);
            return value;
        } else {
            static T defaultValue;
            return defaultValue;
        }
    }
} // namespace tson
 
tson::Property::Property() : m_name {"unnamed"} {}
 
tson::Property::Property(IJson &json, tson::Project *project) : m_project {project}
{
    m_name = json["name"].get<std::string>();
    if (json.count("propertytype") > 0)
        m_propertyType = json["propertytype"].get<std::string>();
    else if (json.count("propertyType") > 0) // Somehow Tiled's class objects uses propertyType with 'T'.
        m_propertyType = json["propertyType"].get<std::string>();
 
    setTypeByString(json["type"].get<std::string>());
    setValueByType(json["value"]);
}
 
tson::Property::Property(std::string name, std::any value, Type type) : m_type {type}, m_name {move(name)}, m_value {move(value)} {}
 
void tson::Property::setValue(const std::any &value)
{
    m_value = value;
}
 
void tson::Property::setStrValue(const std::string &value)
{
    m_value = value;
}
 
const std::any &tson::Property::getValue() const
{
    return m_value;
}
 
void tson::Property::setName(const std::string &name)
{
    m_name = name;
}
 
const std::string &tson::Property::getName() const
{
    return m_name;
}
 
const std::type_info &tson::Property::getValueType() const
{
    return m_value.type();
}
 
std::string tson::Property::getValueTypeInfo()
{
    return m_value.type().name();
}
 
tson::Type tson::Property::getType() const
{
    return m_type;
}
 
void tson::Property::setTypeByString(const std::string &str)
{
    if (str == "color")
        m_type = tson::Type::Color;
    else if (str == "file")
        m_type = tson::Type::File;
    else if (str == "int")
        m_type = tson::Type::Int;
    else if (str == "bool")
        m_type = tson::Type::Boolean;
    else if (str == "float")
        m_type = tson::Type::Float;
    else if (str == "string")
        m_type = tson::Type::String;
    else if (str == "class")
        m_type = tson::Type::Class;
    else if (str == "object")
        m_type = tson::Type::Object;
    else
        m_type = tson::Type::Undefined;
}
 
const std::string &tson::Property::getPropertyType() const
{
    return m_propertyType;
}
 
                    #endif // TILESON_PROPERTY_HPP
 
 
                    // #include "../external/json.hpp"
                    #include <map>
 
namespace tson {
    class PropertyCollection {
    public:
        inline PropertyCollection() = default;
 
        inline explicit PropertyCollection(std::string id);
 
        inline tson::Property *add(const tson::Property &property);
        inline tson::Property *add(IJson &json, tson::Project *project = nullptr);
        inline tson::Property *add(const std::string &name, const std::any &value, tson::Type type);
 
        inline void remove(const std::string &name);
 
        inline void setValue(const std::string &name, const std::any &value);
        inline void setProperty(const std::string &name, const tson::Property &value);
        inline void setId(const std::string &id);
 
        inline bool hasProperty(const std::string &name);
        inline tson::Property *getProperty(const std::string &name);
        inline std::map<std::string, Property> &getProperties();
        inline std::vector<Property *> get();
        template<typename T>
        inline T getValue(const std::string &name);
        [[nodiscard]]
        inline const std::string &getId() const;
        [[nodiscard]]
        inline size_t getSize() const;
 
    protected:
        std::string m_id;
        std::map<std::string, tson::Property> m_properties;
    };
} // namespace tson
 
template<typename T>
T tson::PropertyCollection::getValue(const std::string &name)
{
    static T defaultT;
    return (m_properties.count(name) > 0) ? m_properties[name].getValue<T>() : defaultT;
}
 
tson::PropertyCollection::PropertyCollection(std::string id) : m_id {std::move(id)} {}
 
tson::Property *tson::PropertyCollection::add(const tson::Property &property)
{
    m_properties[property.getName()] = property;
    return &m_properties[property.getName()];
}
 
tson::Property *tson::PropertyCollection::add(IJson &json, tson::Project *project)
{
    tson::Property property = tson::Property(json, project);
    std::string name = property.getName();
    m_properties[name] = std::move(property);
    return &m_properties[name];
}
 
tson::Property *tson::PropertyCollection::add(const std::string &name, const std::any &value, tson::Type type)
{
    m_properties[name] = {name, value, type};
    return &m_properties[name];
}
 
void tson::PropertyCollection::remove(const std::string &name)
{
    m_properties.erase(name);
}
 
void tson::PropertyCollection::setValue(const std::string &name, const std::any &value)
{
    if (m_properties.count(name) > 0) m_properties[name].setValue(value);
}
 
void tson::PropertyCollection::setProperty(const std::string &name, const tson::Property &value)
{
    m_properties[name] = value;
}
 
void tson::PropertyCollection::setId(const std::string &id)
{
    m_id = id;
}
 
bool tson::PropertyCollection::hasProperty(const std::string &name)
{
    return m_properties.count(name) > 0;
}
 
tson::Property *tson::PropertyCollection::getProperty(const std::string &name)
{
    return (m_properties.count(name) > 0) ? &m_properties[name] : nullptr;
}
 
std::map<std::string, tson::Property> &tson::PropertyCollection::getProperties()
{
    return m_properties;
}
 
std::vector<tson::Property *> tson::PropertyCollection::get()
{
    std::vector<tson::Property *> props;
    for (auto &i : m_properties)
        props.emplace_back(&i.second);
 
    return props;
}
 
const std::string &tson::PropertyCollection::getId() const
{
    return m_id;
}
 
size_t tson::PropertyCollection::getSize() const
{
    return m_properties.size();
}
 
                #endif // TILESON_PROPERTYCOLLECTION_HPP
 
 
 
                //
                // Created by robin on 05.08.2019.
                //
 
                #ifndef TILESON_TEXT_HPP
                    #define TILESON_TEXT_HPP
 
                    #include <string>
 
namespace tson {
    class Text {
    public:
        inline Text() = default;
 
        // inline Text(std::string _text, bool _wrap, tson::Colori _color) : text {std::move(_text)}, wrap {_wrap}, color {_color} {};
        inline explicit Text(IJson &json)
        {
            bool hasColor = json.count("color") > 0;
            tson::Color c = (hasColor) ? tson::Colori(json["color"].get<std::string>()) : tson::Colori();
            color = c;
            text = (json.count("text") > 0) ? json["text"].get<std::string>() : "";
            wrap = (json.count("wrap") > 0) ? json["wrap"].get<bool>() : false;
 
            // Previously missing properties
            bold = (json.count("bold") > 0) ? json["bold"].get<bool>() : false;
            fontFamily = (json.count("fontfamily") > 0) ? json["fontfamily"].get<std::string>() : "sans-serif";
            horizontalAlignment = (json.count("halign") > 0) ? resolveTextAlignmentByString(json["halign"].get<std::string>()) : TextAlignment::Left;
            italic = (json.count("italic") > 0) ? json["italic"].get<bool>() : false;
            kerning = (json.count("kerning") > 0) ? json["kerning"].get<bool>() : true;
            pixelSize = (json.count("pixelsize") > 0) ? json["pixelsize"].get<int32_t>() : 16;
            strikeout = (json.count("strikeout") > 0) ? json["strikeout"].get<bool>() : false;
            underline = (json.count("underline") > 0) ? json["underline"].get<bool>() : false;
            verticalAlignment = (json.count("valign") > 0) ? resolveTextAlignmentByString(json["valign"].get<std::string>()) : TextAlignment::Top;
        };
 
        // Just make it simple
        std::string text {};
        tson::Colori color {};
        bool wrap {};
 
        // Previously missing properties
        bool bold {false};
        std::string fontFamily {"sans-serif"};
        TextAlignment horizontalAlignment {TextAlignment::Left};
        bool italic {false};
        bool kerning {true};
        int pixelSize {16};
        bool strikeout {false};
        bool underline {false};
        TextAlignment verticalAlignment {TextAlignment::Top};
 
    private:
        [[nodiscard]]
        TextAlignment resolveTextAlignmentByString(const std::string &str) const
        {
            if (str == "left") return TextAlignment::Left;
            if (str == "center") return TextAlignment::Center;
            if (str == "right") return TextAlignment::Right;
            if (str == "justify") return TextAlignment::Justify;
            if (str == "top") return TextAlignment::Top;
            if (str == "bottom") return TextAlignment::Bottom;
 
            return TextAlignment::Unresolved;
        }
    };
} // namespace tson
 
                #endif // TILESON_TEXT_HPP
 
 
                #include <optional>
 
namespace tson {
    class TiledClass;
    class Map;
 
    class Object {
    public:
        // enum class Type : uint8_t
        //{
        //         Undefined = 0,
        //         Object = 1,
        //         Ellipse = 2,
        //         Rectangle = 3,
        //         Point = 4,
        //         Polygon = 5,
        //         Polyline = 6,
        //         Text = 7,
        //         Template = 8
        // };
 
        inline Object() = default;
        inline explicit Object(IJson &json, tson::Map *map);
        inline bool parse(IJson &json, tson::Map *map);
 
        [[nodiscard]]
        inline ObjectType getObjectType() const;
        [[nodiscard]]
        inline bool isEllipse() const;
        [[nodiscard]]
        inline uint32_t getGid() const;
        [[nodiscard]]
        inline const Vector2i &getSize() const;
        [[nodiscard]]
        inline int getId() const;
        [[nodiscard]]
        inline const std::string &getName() const;
        [[nodiscard]]
        inline bool isPoint() const;
        [[nodiscard]]
        inline float getRotation() const;
        [[nodiscard]]
        inline const std::string &getTemplate() const;
        [[nodiscard]]
        inline const std::string &getType() const;
        [[nodiscard]]
        inline const std::string &getClassType() const;
        [[nodiscard]]
        inline tson::TiledClass *getClass(); 
        [[nodiscard]]
        inline bool isVisible() const;
        [[nodiscard]]
        inline const Vector2i &getPosition() const;
 
        [[nodiscard]]
        inline const std::vector<tson::Vector2i> &getPolygons() const;
        [[nodiscard]]
        inline const std::vector<tson::Vector2i> &getPolylines() const;
        [[nodiscard]]
        inline PropertyCollection &getProperties();
        [[nodiscard]]
        inline const Text &getText() const;
 
        template<typename T>
        inline T get(const std::string &name);
        inline tson::Property *getProp(const std::string &name);
 
        // v1.2.0-stuff
        [[nodiscard]]
        inline TileFlipFlags getFlipFlags() const;
        inline bool hasFlipFlags(TileFlipFlags flags);
 
    private:
        inline void setObjectTypeByJson(IJson &json);
 
        ObjectType m_objectType = ObjectType::Undefined; 
        bool m_ellipse {}; 
        uint32_t m_gid {}; 
        tson::Vector2i m_size; 
        int m_id {}; 
        std::string m_name; 
        bool m_point {}; 
        std::vector<tson::Vector2i> m_polygon; 
        std::vector<tson::Vector2i> m_polyline; 
        tson::PropertyCollection m_properties; 
        float m_rotation {}; 
        std::string m_template; 
        tson::Text m_text; 
        std::string m_type; 
        bool m_visible {}; 
        tson::Vector2i m_position; 
        // v1.2.0-stuff
        tson::TileFlipFlags m_flipFlags = TileFlipFlags::None; 
        tson::Map *m_map {nullptr};
        std::shared_ptr<tson::TiledClass> m_class {};
    };
 
    template<typename T>
    T tson::Object::get(const std::string &name)
    {
        return m_properties.getValue<T>(name);
    }
} // namespace tson
 
tson::Object::Object(IJson &json, tson::Map *map)
{
    parse(json, map);
}
 
bool tson::Object::parse(IJson &json, tson::Map *map)
{
    m_map = map;
    bool allFound = true;
 
    if (json.count("ellipse") > 0) m_ellipse = json["ellipse"].get<bool>(); // Optional
    if (json.count("gid") > 0) {
        uint32_t gid = json["gid"].get<uint32_t>(); // Optional
        if (gid & FLIPPED_HORIZONTALLY_FLAG) m_flipFlags |= TileFlipFlags::Horizontally;
        if (gid & FLIPPED_VERTICALLY_FLAG) m_flipFlags |= TileFlipFlags::Vertically;
        if (gid & FLIPPED_DIAGONALLY_FLAG) m_flipFlags |= TileFlipFlags::Diagonally;
 
        // Clear flags
        gid &= ~(FLIPPED_HORIZONTALLY_FLAG | FLIPPED_VERTICALLY_FLAG | FLIPPED_DIAGONALLY_FLAG);
 
        m_gid = gid;
    }
    if (json.count("id") > 0)
        m_id = json["id"].get<int>();
    else
        allFound = false;
    if (json.count("name") > 0)
        m_name = json["name"].get<std::string>();
    else
        allFound = false;
    if (json.count("point") > 0) m_point = json["point"].get<bool>(); // Optional
    if (json.count("rotation") > 0)
        m_rotation = json["rotation"].get<float>();
    else
        allFound = false;
    if (json.count("template") > 0) m_template = json["template"].get<std::string>(); // Optional
 
    if (json.count("type") > 0)
        m_type = json["type"].get<std::string>();
    else if (json.count("class") > 0)
        m_type = json["class"].get<std::string>(); // Tiled v1.9 renamed 'type' to 'class'
    else
        allFound = false;
 
    if (json.count("visible") > 0)
        m_visible = json["visible"].get<bool>();
    else
        allFound = false;
 
    if (json.count("width") > 0 && json.count("height") > 0)
        m_size = {json["width"].get<int>(), json["height"].get<int>()};
    else
        allFound = false;
    if (json.count("x") > 0 && json.count("y") > 0)
        m_position = {json["x"].get<int>(), json["y"].get<int>()};
    else
        allFound = false;
 
    if (json.count("text") > 0) {
        // Old logic
        // bool hasColor = json["text"].count("color") > 0;
        // tson::Color c = (hasColor) ? tson::Colori(json["text"]["color"].get<std::string>()) : tson::Colori();
        // m_text = {json["text"]["text"].get<std::string>(), json["text"]["wrap"].get<bool>(), c}; //Optional
        m_text = tson::Text(json["text"]);
        //
    }
 
    setObjectTypeByJson(json);
 
    if (m_objectType == ObjectType::Template) allFound = true; // Just accept anything with this type
 
    // More advanced data
    if (json.count("polygon") > 0 && json["polygon"].isArray()) {
        auto &polygon = json.array("polygon");
        std::for_each(polygon.begin(), polygon.end(), [&](std::unique_ptr<IJson> &item) {
            IJson &j = *item;
            m_polygon.emplace_back(j["x"].get<int>(), j["y"].get<int>());
        });
    }
 
    if (json.count("polyline") > 0 && json["polyline"].isArray()) {
        auto &polyline = json.array("polyline");
        std::for_each(polyline.begin(), polyline.end(), [&](std::unique_ptr<IJson> &item) {
            IJson &j = *item;
            m_polyline.emplace_back(j["x"].get<int>(), j["y"].get<int>());
        });
    }
 
    if (json.count("properties") > 0 && json["properties"].isArray()) {
        auto &properties = json.array("properties");
        std::for_each(properties.begin(), properties.end(), [&](std::unique_ptr<IJson> &item) { m_properties.add(*item); });
    }
 
    return allFound;
}
 
void tson::Object::setObjectTypeByJson(IJson &json)
{
    m_objectType = ObjectType::Undefined;
    if (m_ellipse)
        m_objectType = ObjectType::Ellipse;
    else if (m_point)
        m_objectType = ObjectType::Point;
    else if (json.count("polygon") > 0)
        m_objectType = ObjectType::Polygon;
    else if (json.count("polyline") > 0)
        m_objectType = ObjectType::Polyline;
    else if (json.count("text") > 0)
        m_objectType = ObjectType::Text;
    else if (json.count("gid") > 0)
        m_objectType = ObjectType::Object;
    else if (json.count("template") > 0)
        m_objectType = ObjectType::Template;
    else
        m_objectType = ObjectType::Rectangle;
}
 
tson::ObjectType tson::Object::getObjectType() const
{
    return m_objectType;
}
 
bool tson::Object::isEllipse() const
{
    return m_ellipse;
}
 
uint32_t tson::Object::getGid() const
{
    return m_gid;
}
 
const tson::Vector2i &tson::Object::getSize() const
{
    return m_size;
}
 
int tson::Object::getId() const
{
    return m_id;
}
 
const std::string &tson::Object::getName() const
{
    return m_name;
}
 
bool tson::Object::isPoint() const
{
    return m_point;
}
 
float tson::Object::getRotation() const
{
    return m_rotation;
}
 
const std::string &tson::Object::getTemplate() const
{
    return m_template;
}
 
const std::string &tson::Object::getType() const
{
    return m_type;
}
 
const std::string &tson::Object::getClassType() const
{
    return m_type;
}
 
bool tson::Object::isVisible() const
{
    return m_visible;
}
 
const tson::Vector2i &tson::Object::getPosition() const
{
    return m_position;
}
 
const std::vector<tson::Vector2i> &tson::Object::getPolygons() const
{
    return m_polygon;
}
 
const std::vector<tson::Vector2i> &tson::Object::getPolylines() const
{
    return m_polyline;
}
 
tson::PropertyCollection &tson::Object::getProperties()
{
    return m_properties;
}
 
const tson::Text &tson::Object::getText() const
{
    return m_text;
}
 
tson::Property *tson::Object::getProp(const std::string &name)
{
    if (m_properties.hasProperty(name)) return m_properties.getProperty(name);
    return nullptr;
}
 
tson::TileFlipFlags tson::Object::getFlipFlags() const
{
    return m_flipFlags;
}
 
bool tson::Object::hasFlipFlags(TileFlipFlags flags)
{
    return ((m_flipFlags & flags) == flags) ? true : false;
}
 
            #endif // TILESON_OBJECT_HPP
 
 
 
            //
            // Created by robin on 26.07.2020.
            //
 
            #ifndef TILESON_TILEOBJECT_HPP
                #define TILESON_TILEOBJECT_HPP
 
 
                //
                // Created by robin on 24.07.2020.
                //
 
                #ifndef TILESON_RECT_HPP
                    #define TILESON_RECT_HPP
 
namespace tson {
    class Rect {
    public:
        inline Rect() = default;
        inline Rect(int x_, int y_, int width_, int height_);
 
        inline bool operator==(const Rect &rhs) const;
        inline bool operator!=(const Rect &rhs) const;
 
        int x {};
        int y {};
        int width {};
        int height {};
    };
 
    Rect::Rect(int x_, int y_, int width_, int height_)
    {
        x = x_;
        y = y_;
        width = width_;
        height = height_;
    }
 
    bool Rect::operator==(const Rect &rhs) const
    {
        return x == rhs.x && y == rhs.y && width == rhs.width && height == rhs.height;
    }
 
    bool Rect::operator!=(const Rect &rhs) const
    {
        return !(rhs == *this);
    }
} // namespace tson
 
                #endif // TILESON_RECT_HPP
 
 
namespace tson {
    class Tile;
 
    class TileObject {
    public:
        inline TileObject() = default;
        inline TileObject(const std::tuple<int, int> &posInTileUnits, tson::Tile *tile);
 
        inline void initialize(const std::tuple<int, int> &posInTileUnits, tson::Tile *tile); // Defined in tileson_forward.hpp
 
        inline Tile *getTile();
        inline const Vector2i &getPositionInTileUnits() const;
        inline const Vector2f &getPosition() const;
        inline const tson::Rect &getDrawingRect() const; // Defined in tileson_forward.hpp
 
    private:
        tson::Tile *m_tile;
        tson::Vector2i m_posInTileUnits;
        tson::Vector2f m_position;
    };
 
    TileObject::TileObject(const std::tuple<int, int> &posInTileUnits, tson::Tile *tile)
    {
        initialize(posInTileUnits, tile);
    }
 
    Tile *TileObject::getTile()
    {
        return m_tile;
    }
 
    const Vector2i &TileObject::getPositionInTileUnits() const
    {
        return m_posInTileUnits;
    }
 
    const Vector2f &TileObject::getPosition() const
    {
        return m_position;
    }
} // namespace tson
 
            #endif // TILESON_TILEOBJECT_HPP
 
 
 
            //
            // Created by robin on 13.11.2020.
            //
 
            #ifndef TILESON_FLAGGEDTILE_HPP
                #define TILESON_FLAGGEDTILE_HPP
 
namespace tson {
    class FlaggedTile {
    public:
        FlaggedTile(size_t x_, size_t y_, uint32_t id_, uint32_t tileId_) : x {x_}, y {y_}, id {id_}, tileId {tileId_} {}
 
        size_t x;
        size_t y;
        uint32_t id;
        uint32_t tileId;
    };
} // namespace tson
            #endif // TILESON_FLAGGEDTILE_HPP
 
 
namespace tson {
    class Tile;
    class Map;
 
    class Layer {
    public:
        inline Layer() = default;
        inline Layer(IJson &json, tson::Map *map);
        inline bool parse(IJson &json, tson::Map *map); // Defined in tileson_forward
 
        [[nodiscard]]
        inline const std::string &getCompression() const;
        [[nodiscard]]
        inline const std::vector<uint32_t> &getData() const;
        [[nodiscard]]
        inline const std::string &getBase64Data() const;
        [[nodiscard]]
        inline const std::string &getDrawOrder() const;
        [[nodiscard]]
        inline const std::string &getEncoding() const;
        [[nodiscard]]
        inline int getId() const;
        [[nodiscard]]
        inline const std::string &getImage() const;
        [[nodiscard]]
        inline const std::string &getName() const;
        [[nodiscard]]
        inline const Vector2f &getOffset() const;
        [[nodiscard]]
        inline float getOpacity() const;
        [[nodiscard]]
        inline const Vector2i &getSize() const;
        [[nodiscard]]
        inline const Colori &getTransparentColor() const;
        [[nodiscard]]
        inline const Vector2f &getParallax() const;
        [[nodiscard]]
        inline bool hasRepeatX() const;
        [[nodiscard]]
        inline bool hasRepeatY() const;
 
        [[nodiscard]]
        inline LayerType getType() const;
        [[nodiscard]]
        inline const std::string &getClassType() const;
        [[nodiscard]]
        inline tson::TiledClass *getClass(); 
        [[nodiscard]]
        inline const std::string &getTypeStr() const;
        [[nodiscard]]
        inline bool isVisible() const;
        [[nodiscard]]
        inline int getX() const;
        [[nodiscard]]
        inline int getY() const;
 
        [[nodiscard]]
        inline std::vector<tson::Chunk> &getChunks();
        [[nodiscard]]
        inline std::vector<tson::Layer> &getLayers();
        [[nodiscard]]
        inline std::vector<tson::Object> &getObjects();
        [[nodiscard]]
        inline PropertyCollection &getProperties();
 
        inline tson::Object *getObj(int id);
        inline tson::Object *firstObj(const std::string &name);
        inline std::vector<tson::Object> getObjectsByName(const std::string &name);
        inline std::vector<tson::Object> getObjectsByType(tson::ObjectType type);
 
        template<typename T>
        inline T get(const std::string &name);
        inline tson::Property *getProp(const std::string &name);
 
        inline void assignTileMap(std::map<uint32_t, tson::Tile *> *tileMap);
        inline void createTileData(const Vector2i &mapSize, bool isInfiniteMap);
 
        [[nodiscard]]
        inline const std::map<std::tuple<int, int>, tson::Tile *> &getTileData() const;
        inline tson::Tile *getTileData(int x, int y);
 
        // v1.2.0-stuff
        [[nodiscard]]
        inline const Colori &getTintColor() const;
        [[nodiscard]]
        inline tson::Map *getMap() const;
 
        [[nodiscard]]
        inline std::map<std::tuple<int, int>, tson::TileObject> &getTileObjects();
        inline tson::TileObject *getTileObject(int x, int y);
        [[nodiscard]]
        inline const std::set<uint32_t> &getUniqueFlaggedTiles() const;
        inline void resolveFlaggedTiles();
 
    private:
        inline void setTypeByString();
 
        std::vector<tson::Chunk> m_chunks; 
        std::string m_compression; 
        std::vector<uint32_t> m_data; 
        std::string m_base64Data; 
        std::string m_drawOrder; 
        std::string m_encoding; 
        int m_id {}; 
        std::string m_image; 
        std::vector<tson::Layer> m_layers; 
        std::string m_name; 
        std::vector<tson::Object> m_objects; 
        tson::Vector2f m_offset; 
        float m_opacity {}; 
        tson::PropertyCollection m_properties; 
        tson::Vector2i m_size; 
        tson::Colori m_transparentColor; 
        std::string m_typeStr; 
        LayerType m_type {LayerType::Undefined}; 
        bool m_visible {}; 
        int m_x {}; 
        int m_y {}; 
        tson::Vector2f m_parallax {1.f, 1.f}; 
        bool m_repeatX {}; 
        bool m_repeatY {}; 
        std::map<uint32_t, tson::Tile *> *m_tileMap;
        std::map<std::tuple<int, int>, tson::Tile *> m_tileData; 
        // v1.2.0-stuff
        tson::Colori m_tintColor; 
        inline void decompressData(); 
        inline void queueFlaggedTile(size_t x, size_t y, uint32_t id); 
        tson::Map *m_map; 
        std::map<std::tuple<int, int>, tson::TileObject> m_tileObjects;
        std::set<uint32_t> m_uniqueFlaggedTiles;
        std::vector<tson::FlaggedTile> m_flaggedTiles;
 
        std::string m_classType {}; 
        std::shared_ptr<tson::TiledClass> m_class {};
    };
 
    template<typename T>
    T Layer::get(const std::string &name)
    {
        return m_properties.getValue<T>(name);
    }
} // namespace tson
 
tson::Layer::Layer(IJson &json, tson::Map *map)
{
    parse(json, map);
}
 
void tson::Layer::queueFlaggedTile(size_t x, size_t y, uint32_t id)
{
    uint32_t tileId = id;
    tileId &= ~(FLIPPED_HORIZONTALLY_FLAG | FLIPPED_VERTICALLY_FLAG | FLIPPED_DIAGONALLY_FLAG);
    m_uniqueFlaggedTiles.insert(id);
    m_flaggedTiles.emplace_back(x, y, id, tileId);
}
 
std::vector<tson::Object> tson::Layer::getObjectsByName(const std::string &name)
{
    std::vector<tson::Object> found;
 
    std::copy_if(m_objects.begin(), m_objects.end(), std::back_inserter(found), [&](const tson::Object &item) { return item.getName() == name; });
 
    return found;
}
 
std::vector<tson::Object> tson::Layer::getObjectsByType(tson::ObjectType type)
{
    std::vector<tson::Object> found;
 
    std::copy_if(m_objects.begin(), m_objects.end(), std::back_inserter(found), [&](const tson::Object &item) { return item.getObjectType() == type; });
 
    return found;
}
 
tson::Object *tson::Layer::firstObj(const std::string &name)
{
    auto result = std::find_if(m_objects.begin(), m_objects.end(), [&](const tson::Object &obj) { return obj.getName() == name; });
    if (result == m_objects.end()) return nullptr;
 
    return &result.operator*();
}
 
tson::Object *tson::Layer::getObj(int id)
{
    auto result = std::find_if(m_objects.begin(), m_objects.end(), [&](const tson::Object &obj) { return obj.getId() == id; });
    if (result == m_objects.end()) return nullptr;
 
    return &result.operator*();
}
 
void tson::Layer::setTypeByString()
{
    if (m_typeStr == "tilelayer")
        m_type = LayerType::TileLayer;
    else if (m_typeStr == "objectgroup")
        m_type = LayerType::ObjectGroup;
    else if (m_typeStr == "imagelayer")
        m_type = LayerType::ImageLayer;
    else if (m_typeStr == "group")
        m_type = LayerType::Group;
    else
        m_type = LayerType::Undefined;
}
 
const std::string &tson::Layer::getCompression() const
{
    return m_compression;
}
 
const std::vector<uint32_t> &tson::Layer::getData() const
{
    return m_data;
}
 
const std::string &tson::Layer::getBase64Data() const
{
    return m_base64Data;
}
 
const std::string &tson::Layer::getDrawOrder() const
{
    return m_drawOrder;
}
 
const std::string &tson::Layer::getEncoding() const
{
    return m_encoding;
}
 
int tson::Layer::getId() const
{
    return m_id;
}
 
const std::string &tson::Layer::getImage() const
{
    return m_image;
}
 
const std::string &tson::Layer::getName() const
{
    return m_name;
}
 
const tson::Vector2f &tson::Layer::getOffset() const
{
    return m_offset;
}
 
float tson::Layer::getOpacity() const
{
    return m_opacity;
}
 
const tson::Vector2i &tson::Layer::getSize() const
{
    return m_size;
}
 
const tson::Colori &tson::Layer::getTransparentColor() const
{
    return m_transparentColor;
}
 
const std::string &tson::Layer::getTypeStr() const
{
    return m_typeStr;
}
 
bool tson::Layer::isVisible() const
{
    return m_visible;
}
 
int tson::Layer::getX() const
{
    return m_x;
}
 
int tson::Layer::getY() const
{
    return m_y;
}
 
std::vector<tson::Chunk> &tson::Layer::getChunks()
{
    return m_chunks;
}
 
std::vector<tson::Layer> &tson::Layer::getLayers()
{
    return m_layers;
}
 
std::vector<tson::Object> &tson::Layer::getObjects()
{
    return m_objects;
}
 
tson::PropertyCollection &tson::Layer::getProperties()
{
    return m_properties;
}
 
tson::Property *tson::Layer::getProp(const std::string &name)
{
    if (m_properties.hasProperty(name)) return m_properties.getProperty(name);
    return nullptr;
}
 
tson::LayerType tson::Layer::getType() const
{
    return m_type;
}
 
void tson::Layer::assignTileMap(std::map<uint32_t, tson::Tile *> *tileMap)
{
    m_tileMap = tileMap;
}
 
const std::map<std::tuple<int, int>, tson::Tile *> &tson::Layer::getTileData() const
{
    return m_tileData;
}
 
tson::Tile *tson::Layer::getTileData(int x, int y)
{
    return (m_tileData.count({x, y}) > 0) ? m_tileData[{x, y}] : nullptr;
}
 
tson::Map *tson::Layer::getMap() const
{
    return m_map;
}
 
void tson::Layer::createTileData(const Vector2i &mapSize, bool isInfiniteMap)
{
    size_t x = 0;
    size_t y = 0;
    if (!isInfiniteMap) {
        std::for_each(m_data.begin(), m_data.end(), [&](uint32_t tileId) {
            if (static_cast<int>(x) == mapSize.x) {
                ++y;
                x = 0;
            }
 
            if (tileId > 0 && m_tileMap->count(tileId) > 0) {
                m_tileData[{static_cast<int>(x), static_cast<int>(y)}] = m_tileMap->at(tileId);
                m_tileObjects[{static_cast<int>(x), static_cast<int>(y)}] = {
                    {static_cast<int>(x), static_cast<int>(y)}, m_tileData[{static_cast<int>(x), static_cast<int>(y)}]};
            } else if (tileId > 0 && m_tileMap->count(tileId) == 0) // Tile with flip flags!
            {
                queueFlaggedTile(x, y, tileId);
            }
            x++;
        });
    }
}
 
std::map<std::tuple<int, int>, tson::TileObject> &tson::Layer::getTileObjects()
{
    return m_tileObjects;
}
 
tson::TileObject *tson::Layer::getTileObject(int x, int y)
{
    return (m_tileObjects.count({x, y}) > 0) ? &m_tileObjects[{x, y}] : nullptr;
}
 
const std::set<uint32_t> &tson::Layer::getUniqueFlaggedTiles() const
{
    return m_uniqueFlaggedTiles;
}
 
void tson::Layer::resolveFlaggedTiles()
{
    std::for_each(m_flaggedTiles.begin(), m_flaggedTiles.end(), [&](const tson::FlaggedTile &tile) {
        if (tile.id > 0 && m_tileMap->count(tile.id) > 0) {
            m_tileData[{static_cast<int>(tile.x), static_cast<int>(tile.y)}] = m_tileMap->at(tile.id);
            m_tileObjects[{static_cast<int>(tile.x), static_cast<int>(tile.y)}] = {
                {static_cast<int>(tile.x), static_cast<int>(tile.y)}, m_tileData[{static_cast<int>(tile.x), static_cast<int>(tile.y)}]};
        }
    });
}
 
const tson::Colori &tson::Layer::getTintColor() const
{
    return m_tintColor;
}
 
const tson::Vector2f &tson::Layer::getParallax() const
{
    return m_parallax;
}
 
bool tson::Layer::hasRepeatX() const
{
    return m_repeatX;
}
 
bool tson::Layer::hasRepeatY() const
{
    return m_repeatY;
}
 
const std::string &tson::Layer::getClassType() const
{
    return m_classType;
}
 
        #endif // TILESON_LAYER_HPP
 
 
 
        //
        // Created by robin on 22.03.2020.
        //
 
        #ifndef TILESON_TILESET_HPP
            #define TILESON_TILESET_HPP
 
            // #include "../external/json.hpp"
 
 
            //
            // Created by robin on 04.04.2021.
            //
 
            #ifndef TILESON_TRANSFORMATIONS_HPP
                #define TILESON_TRANSFORMATIONS_HPP
 
namespace tson {
    class Transformations {
    public:
        inline Transformations() = default;
        inline explicit Transformations(IJson &json);
        inline bool parse(IJson &json);
 
        inline bool allowHflip() const;
        inline bool allowPreferuntransformed() const;
        inline bool allowRotation() const;
        inline bool allowVflip() const;
 
    private:
        bool m_hflip {}; 
        bool m_preferuntransformed {}; 
        bool m_rotate {}; 
        bool m_vflip {}; 
    };
 
    Transformations::Transformations(IJson &json)
    {
        parse(json);
    }
 
    bool Transformations::parse(IJson &json)
    {
        if (json.count("hflip") > 0) m_hflip = json["hflip"].get<bool>(); // Optional
        if (json.count("preferuntransformed") > 0) m_preferuntransformed = json["preferuntransformed"].get<bool>(); // Optional
        if (json.count("rotate") > 0) m_rotate = json["rotate"].get<bool>(); // Optional
        if (json.count("vflip") > 0) m_vflip = json["vflip"].get<bool>(); // Optional
 
        return true;
    }
 
    bool Transformations::allowHflip() const
    {
        return m_hflip;
    }
 
    bool Transformations::allowPreferuntransformed() const
    {
        return m_preferuntransformed;
    }
 
    bool Transformations::allowRotation() const
    {
        return m_rotate;
    }
 
    bool Transformations::allowVflip() const
    {
        return m_vflip;
    }
} // namespace tson
 
            #endif // TILESON_TRANSFORMATIONS_HPP
 
 
 
            //
            // Created by robin on 22.03.2020.
            //
 
            #ifndef TILESON_WANGSET_HPP
                #define TILESON_WANGSET_HPP
 
                // #include "../external/json.hpp"
 
 
                //
                // Created by robin on 22.03.2020.
                //
 
                #ifndef TILESON_WANGCOLOR_HPP
                    #define TILESON_WANGCOLOR_HPP
 
// #include "../external/json.hpp"
 
namespace tson {
    class WangColor {
    public:
        inline WangColor() = default;
        inline explicit WangColor(IJson &json, tson::Map *map);
        inline bool parse(IJson &json, tson::Map *map);
 
        [[nodiscard]]
        inline const Colori &getColor() const;
        [[nodiscard]]
        inline const std::string &getName() const;
        [[nodiscard]]
        inline float getProbability() const;
        [[nodiscard]]
        inline int getTile() const;
 
        inline PropertyCollection &getProperties();
        template<typename T>
        inline T get(const std::string &name);
        inline tson::Property *getProp(const std::string &name);
 
        [[nodiscard]]
        inline const std::string &getClassType() const;
        [[nodiscard]]
        inline tson::TiledClass *getClass(); 
    private:
        tson::Colori m_color; 
        std::string m_name; 
        float m_probability {}; 
        int m_tile {}; 
        // New in Tiled v1.5
        tson::PropertyCollection m_properties; 
        tson::Map *m_map;
        std::string m_classType {}; 
        std::shared_ptr<tson::TiledClass> m_class {};
    };
} // namespace tson
 
tson::WangColor::WangColor(IJson &json, tson::Map *map)
{
    parse(json, map);
}
 
bool tson::WangColor::parse(IJson &json, tson::Map *map)
{
    m_map = map;
    bool allFound = true;
 
    if (json.count("color") > 0)
        m_color = tson::Colori(json["color"].get<std::string>());
    else
        allFound = false;
    if (json.count("name") > 0)
        m_name = json["name"].get<std::string>();
    else
        allFound = false;
    if (json.count("probability") > 0)
        m_probability = json["probability"].get<float>();
    else
        allFound = false;
    if (json.count("tile") > 0)
        m_tile = json["tile"].get<int>();
    else
        allFound = false;
    if (json.count("class") > 0) m_classType = json["class"].get<std::string>(); // Optional
 
    if (json.count("properties") > 0 && json["properties"].isArray()) {
        auto &properties = json.array("properties");
        std::for_each(properties.begin(), properties.end(), [&](std::unique_ptr<IJson> &item) { m_properties.add(*item); });
    }
 
    return allFound;
}
 
const tson::Colori &tson::WangColor::getColor() const
{
    return m_color;
}
 
const std::string &tson::WangColor::getName() const
{
    return m_name;
}
 
float tson::WangColor::getProbability() const
{
    return m_probability;
}
 
int tson::WangColor::getTile() const
{
    return m_tile;
}
 
tson::PropertyCollection &tson::WangColor::getProperties()
{
    return m_properties;
}
 
template<typename T>
T tson::WangColor::get(const std::string &name)
{
    return m_properties.getValue<T>(name);
}
 
tson::Property *tson::WangColor::getProp(const std::string &name)
{
    if (m_properties.hasProperty(name)) return m_properties.getProperty(name);
 
    return nullptr;
}
 
const std::string &tson::WangColor::getClassType() const
{
    return m_classType;
}
 
                #endif // TILESON_WANGCOLOR_HPP
 
 
 
                //
                // Created by robin on 22.03.2020.
                //
 
                #ifndef TILESON_WANGTILE_HPP
                    #define TILESON_WANGTILE_HPP
 
// #include "../external/json.hpp"
 
namespace tson {
    class WangTile {
    public:
        inline WangTile() = default;
        inline explicit WangTile(IJson &json);
        inline bool parse(IJson &json);
 
        [[nodiscard]]
        inline bool hasDFlip() const;
        [[nodiscard]]
        inline bool hasHFlip() const;
        [[nodiscard]]
        inline uint32_t getTileid() const;
        [[nodiscard]]
        inline bool hasVFlip() const;
 
        [[nodiscard]]
        inline const std::vector<uint32_t> &getWangIds() const;
 
    private:
        bool m_dflip {}; 
        bool m_hflip {}; 
        uint32_t m_tileid {}; 
        bool m_vflip {}; 
        std::vector<uint32_t> m_wangId; 
    };
} // namespace tson
 
tson::WangTile::WangTile(IJson &json)
{
    parse(json);
}
 
bool tson::WangTile::parse(IJson &json)
{
    bool allFound = true;
 
    if (json.count("dflip") > 0) m_dflip = json["dflip"].get<bool>(); // Removed in Tiled v1.5 and is now optional
    if (json.count("hflip") > 0) m_hflip = json["hflip"].get<bool>(); // Removed in Tiled v1.5 and is now optional
    if (json.count("vflip") > 0) m_vflip = json["vflip"].get<bool>(); // Removed in Tiled v1.5 and is now optional
 
    if (json.count("tileid") > 0)
        m_tileid = json["tileid"].get<uint32_t>();
    else
        allFound = false;
    if (json.count("wangid") > 0 && json["wangid"].isArray()) {
        auto &wangid = json.array("wangid");
        std::for_each(wangid.begin(), wangid.end(), [&](std::unique_ptr<IJson> &item) { m_wangId.emplace_back(item->get<uint32_t>()); });
    }
 
    return allFound;
}
 
bool tson::WangTile::hasDFlip() const
{
    return m_dflip;
}
 
bool tson::WangTile::hasHFlip() const
{
    return m_hflip;
}
 
uint32_t tson::WangTile::getTileid() const
{
    return m_tileid;
}
 
bool tson::WangTile::hasVFlip() const
{
    return m_vflip;
}
 
const std::vector<uint32_t> &tson::WangTile::getWangIds() const
{
    return m_wangId;
}
 
                #endif // TILESON_WANGTILE_HPP
 
 
namespace tson {
    class WangSet {
    public:
        inline WangSet() = default;
        inline explicit WangSet(IJson &json, tson::Map *map);
        inline bool parse(IJson &json, tson::Map *map);
 
        [[nodiscard]]
        inline const std::string &getName() const;
        [[nodiscard]]
        inline int getTile() const;
 
        [[nodiscard]]
        inline const std::vector<tson::WangTile> &getWangTiles() const;
        [[nodiscard]]
        inline const std::vector<tson::WangColor> &getCornerColors() const;
        [[nodiscard]]
        inline const std::vector<tson::WangColor> &getEdgeColors() const;
 
        inline tson::WangColor *getColor(const std::string &name);
        inline const std::vector<tson::WangColor> &getColors() const;
        inline PropertyCollection &getProperties();
 
        template<typename T>
        inline T get(const std::string &name);
        inline tson::Property *getProp(const std::string &name);
 
        [[nodiscard]]
        inline const std::string &getClassType() const;
        [[nodiscard]]
        inline tson::TiledClass *getClass(); 
    private:
        inline bool parseTiled15Props(IJson &json);
 
        std::string m_name; 
        int m_tile {}; 
        std::vector<tson::WangTile> m_wangTiles; 
        std::vector<tson::WangColor> m_cornerColors; 
        std::vector<tson::WangColor> m_edgeColors; 
        tson::PropertyCollection m_properties; 
        // Tiled v1.5
        std::vector<tson::WangColor> m_colors; 
        tson::Map *m_map;
        std::string m_classType {}; 
        std::shared_ptr<tson::TiledClass> m_class {};
    };
 
    template<typename T>
    T tson::WangSet::get(const std::string &name)
    {
        return m_properties.getValue<T>(name);
    }
} // namespace tson
 
tson::WangSet::WangSet(IJson &json, tson::Map *map)
{
    parse(json, map);
}
 
bool tson::WangSet::parse(IJson &json, tson::Map *map)
{
    m_map = map;
    bool allFound = true;
 
    if (json.count("tile") > 0)
        m_tile = json["tile"].get<int>();
    else
        allFound = false;
    if (json.count("name") > 0)
        m_name = json["name"].get<std::string>();
    else
        allFound = false;
 
    // More advanced data
    if (json.count("wangtiles") > 0 && json["wangtiles"].isArray()) {
        auto &wangtiles = json.array("wangtiles");
        std::for_each(wangtiles.begin(), wangtiles.end(), [&](std::unique_ptr<IJson> &item) { m_wangTiles.emplace_back(*item); });
    }
    if (json.count("cornercolors") > 0 && json["cornercolors"].isArray()) {
        auto &cornercolors = json.array("cornercolors");
        std::for_each(cornercolors.begin(), cornercolors.end(), [&](std::unique_ptr<IJson> &item) { m_cornerColors.emplace_back(*item, m_map); });
    }
    if (json.count("edgecolors") > 0 && json["edgecolors"].isArray()) {
        auto &edgecolors = json.array("edgecolors");
        std::for_each(edgecolors.begin(), edgecolors.end(), [&](std::unique_ptr<IJson> &item) { m_edgeColors.emplace_back(*item, m_map); });
    }
    if (json.count("properties") > 0 && json["properties"].isArray()) {
        auto &properties = json.array("properties");
        std::for_each(properties.begin(), properties.end(), [&](std::unique_ptr<IJson> &item) { m_properties.add(*item); });
    }
 
    if (json.count("class") > 0) m_classType = json["class"].get<std::string>(); // Optional
 
    if (!parseTiled15Props(json)) allFound = false;
 
    return allFound;
}
 
bool tson::WangSet::parseTiled15Props(tson::IJson &json)
{
    if (json.count("colors") > 0 && json["colors"].isArray()) {
        auto &colors = json.array("colors");
        std::for_each(colors.begin(), colors.end(), [&](std::unique_ptr<IJson> &item) { m_colors.emplace_back(*item, m_map); });
    }
    return true;
}
 
const std::string &tson::WangSet::getName() const
{
    return m_name;
}
 
int tson::WangSet::getTile() const
{
    return m_tile;
}
 
const std::vector<tson::WangTile> &tson::WangSet::getWangTiles() const
{
    return m_wangTiles;
}
 
const std::vector<tson::WangColor> &tson::WangSet::getCornerColors() const
{
    return m_cornerColors;
}
 
const std::vector<tson::WangColor> &tson::WangSet::getEdgeColors() const
{
    return m_edgeColors;
}
 
tson::PropertyCollection &tson::WangSet::getProperties()
{
    return m_properties;
}
 
tson::Property *tson::WangSet::getProp(const std::string &name)
{
    if (m_properties.hasProperty(name)) return m_properties.getProperty(name);
 
    return nullptr;
}
 
const std::vector<tson::WangColor> &tson::WangSet::getColors() const
{
    return m_colors;
}
 
tson::WangColor *tson::WangSet::getColor(const std::string &name)
{
    auto color = std::find_if(m_colors.begin(), m_colors.end(), [&](const auto &c) { return c.getName() == name; });
 
    if (color != m_colors.end()) return &color.operator*();
 
    return nullptr;
}
 
const std::string &tson::WangSet::getClassType() const
{
    return m_classType;
}
 
            #endif // TILESON_WANGSET_HPP
 
 
 
            //
            // Created by robin on 22.03.2020.
            //
 
            #ifndef TILESON_TILE_HPP
                #define TILESON_TILE_HPP
 
                // #include "../external/json.hpp"
 
 
                //
                // Created by robin on 22.03.2020.
                //
 
                #ifndef TILESON_FRAME_HPP
                    #define TILESON_FRAME_HPP
 
// #include "../external/json.hpp"
 
namespace tson {
    class Frame {
    public:
        inline Frame() = default;
        inline Frame(int duration, uint32_t tileId);
        inline explicit Frame(IJson &json);
 
        inline bool parse(IJson &json);
 
        [[nodiscard]]
        inline int getDuration() const;
        [[nodiscard]]
        inline uint32_t getTileId() const;
 
    private:
        int m_duration {}; 
        uint32_t m_tileId {}; 
    };
} // namespace tson
 
tson::Frame::Frame(int duration, uint32_t tileId) : m_duration {duration}, m_tileId {tileId} {}
 
tson::Frame::Frame(IJson &json)
{
    parse(json);
}
 
bool tson::Frame::parse(IJson &json)
{
    bool allFound = true;
 
    if (json.count("duration") > 0)
        m_duration = json["duration"].get<int>();
    else
        allFound = false;
    if (json.count("tileid") > 0)
        m_tileId = json["tileid"].get<uint32_t>() + 1;
    else
        allFound = false;
 
    return allFound;
}
 
int tson::Frame::getDuration() const
{
    return m_duration;
}
 
uint32_t tson::Frame::getTileId() const
{
    return m_tileId;
}
 
                #endif // TILESON_FRAME_HPP
 
 
 
                //
                // Created by robin on 21.05.2021.
                //
 
                #ifndef TILESON_ANIMATION_HPP
                    #define TILESON_ANIMATION_HPP
 
namespace tson {
    class Animation {
    public:
        inline Animation() = default;
        inline Animation(const std::vector<tson::Frame> &frames) : m_frames {frames} {};
 
        inline void update(float timeDeltaMs);
        inline void reset();
 
        inline void setFrames(const std::vector<tson::Frame> &frames);
        inline void setCurrentFrame(uint32_t currentFrame);
        inline void setTimeDelta(float timeDelta);
 
        inline const std::vector<tson::Frame> &getFrames() const;
        inline const tson::Frame *getCurrentFrame() const;
        inline uint32_t getCurrentFrameNumber() const;
        inline uint32_t getCurrentTileId() const;
        inline float getTimeDelta() const;
 
        inline bool any() const;
        inline size_t size() const;
 
    private:
        inline int nextFrame();
        std::vector<tson::Frame> m_frames;
        uint32_t m_currentFrame {0};
        float m_timeDelta {0};
    };
 
    const std::vector<tson::Frame> &Animation::getFrames() const
    {
        return m_frames;
    }
 
    void Animation::reset()
    {
        m_currentFrame = 0;
        m_timeDelta = 0.f;
    }
 
    const tson::Frame *Animation::getCurrentFrame() const
    {
        return (m_frames.size() == 0 || m_currentFrame >= m_frames.size()) ? nullptr : &m_frames.at(m_currentFrame);
    }
 
    size_t Animation::size() const
    {
        return m_frames.size();
    }
 
    void Animation::update(float timeDeltaMs)
    {
        const tson::Frame *frame = getCurrentFrame();
        if (frame != nullptr) {
            m_timeDelta += timeDeltaMs;
            if (m_timeDelta >= frame->getDuration()) {
                m_timeDelta = static_cast<float>((int32_t) m_timeDelta % frame->getDuration());
                m_currentFrame = nextFrame();
            }
        }
    }
 
    int Animation::nextFrame()
    {
        return (m_currentFrame + 1 >= m_frames.size()) ? 0 : m_currentFrame + 1;
    }
 
    float Animation::getTimeDelta() const
    {
        return m_timeDelta;
    }
 
    uint32_t Animation::getCurrentFrameNumber() const
    {
        return m_currentFrame;
    }
 
    uint32_t Animation::getCurrentTileId() const
    {
        return (getCurrentFrame() != nullptr) ? getCurrentFrame()->getTileId() : 0;
    }
 
    void Animation::setFrames(const std::vector<tson::Frame> &frames)
    {
        m_frames = frames;
    }
 
    void Animation::setCurrentFrame(uint32_t currentFrame)
    {
        m_currentFrame = currentFrame;
    }
 
    void Animation::setTimeDelta(float timeDelta)
    {
        m_timeDelta = timeDelta;
    }
 
    bool Animation::any() const
    {
        return m_frames.size() > 0;
    }
} // namespace tson
 
                #endif // TILESON_ANIMATION_HPP
 
 
namespace tson {
    class Tileset;
    class TiledClass;
 
    class Tile {
    public:
        inline Tile() = default;
        inline Tile(IJson &json, tson::Tileset *tileset, tson::Map *map);
        inline Tile(uint32_t id, tson::Tileset *tileset, tson::Map *map);
        inline Tile(uint32_t id, tson::Map *map); // v1.2.0
        inline bool parse(IJson &json, tson::Tileset *tileset, tson::Map *map);
        inline bool parseId(IJson &json);
 
        [[nodiscard]]
        inline uint32_t getId() const;
        [[nodiscard]]
        inline const fs::path &getImage() const;
        [[nodiscard]]
        inline const Vector2i &getImageSize() const;
        [[nodiscard]]
        inline const std::string &getType() const;
        [[nodiscard]]
        inline const std::string &getClassType() const;
        [[nodiscard]]
        inline tson::TiledClass *getClass(); 
        //[[nodiscard]] inline const std::vector<tson::Frame> &getAnimation() const;
        [[nodiscard]]
        inline tson::Animation &getAnimation();
        [[nodiscard]]
        inline Layer &getObjectgroup();
        [[nodiscard]]
        inline PropertyCollection &getProperties();
        [[nodiscard]]
        inline const std::vector<int> &getTerrain() const;
 
        template<typename T>
        inline T get(const std::string &name);
        inline tson::Property *getProp(const std::string &name);
 
        // v1.2.0-stuff
        inline void setProperties(const tson::PropertyCollection &properties);
 
        [[nodiscard]]
        inline tson::Tileset *getTileset() const;
        [[nodiscard]]
        inline tson::Map *getMap() const;
        [[nodiscard]]
        inline const tson::Rect &getDrawingRect() const;
        [[nodiscard]]
        inline const Rect &getSubRectangle() const;
 
        inline const tson::Vector2f getPosition(const std::tuple<int, int> &tileDataPos);
        inline const tson::Vector2i getPositionInTileUnits(const std::tuple<int, int> &tileDataPos);
        [[nodiscard]]
        inline const tson::Vector2i getTileSize() const; 
        [[nodiscard]]
        inline TileFlipFlags getFlipFlags() const;
        inline bool hasFlipFlags(TileFlipFlags flags);
        [[nodiscard]]
        inline uint32_t getGid() const;
 
        inline void addTilesetAndPerformCalculations(tson::Tileset *tileset); // v1.2.0
 
    private:
        tson::Animation m_animation {}; 
        uint32_t m_id {}; 
        fs::path m_image; 
        tson::Vector2i m_imageSize; 
        tson::Layer m_objectgroup; 
        tson::PropertyCollection m_properties; 
        std::vector<int> m_terrain; 
        std::string m_type; 
        // v1.2.0-stuff
        uint32_t m_gid {}; 
        tson::Tileset *m_tileset; 
        tson::Map *m_map; 
        tson::Rect m_drawingRect; 
        tson::Rect m_subRect; 
        tson::TileFlipFlags m_flipFlags = TileFlipFlags::None; 
        inline void performDataCalculations(); 
        inline void manageFlipFlagsByIdThenRemoveFlags(uint32_t &id);
        friend class Layer;
        std::shared_ptr<tson::TiledClass> m_class {};
    };
 
    template<typename T>
    T tson::Tile::get(const std::string &name)
    {
        return m_properties.getValue<T>(name);
    }
} // namespace tson
 
tson::Tile::Tile(IJson &json, tson::Tileset *tileset, tson::Map *map)
{
    parse(json, tileset, map);
}
 
tson::Tile::Tile(uint32_t id, tson::Tileset *tileset, tson::Map *map) : m_id {id}, m_gid {id}
{
    m_tileset = tileset;
    m_map = map;
    manageFlipFlagsByIdThenRemoveFlags(m_gid);
    performDataCalculations();
}
 
tson::Tile::Tile(uint32_t id, tson::Map *map) : m_id {id}, m_gid {id}
{
    m_map = map;
    manageFlipFlagsByIdThenRemoveFlags(m_gid);
}
 
void tson::Tile::addTilesetAndPerformCalculations(tson::Tileset *tileset)
{
    m_tileset = tileset;
    performDataCalculations();
}
 
bool tson::Tile::parse(IJson &json, tson::Tileset *tileset, tson::Map *map)
{
    m_tileset = tileset;
    m_map = map;
 
    if (json.count("image") > 0) m_image = fs::path(json["image"].get<std::string>()); // Optional
 
    bool allFound = parseId(json);
 
    if (json.count("type") > 0)
        m_type = json["type"].get<std::string>(); // Optional
    else if (json.count("class") > 0)
        m_type = json["class"].get<std::string>(); // Tiled v1.9 renamed 'type' to 'class'
 
    if (json.count("objectgroup") > 0) m_objectgroup = tson::Layer(json["objectgroup"], m_map); // Optional
 
    if (json.count("imagewidth") > 0 && json.count("imageheight") > 0)
        m_imageSize = {json["imagewidth"].get<int>(), json["imageheight"].get<int>()}; // Optional
 
    m_subRect = {0, 0, m_imageSize.x, m_imageSize.y};
    if (json.count("x") > 0) m_subRect.x = json["x"].get<int>(); // Optional
    if (json.count("y") > 0) m_subRect.y = json["y"].get<int>(); // Optional
    if (json.count("width") > 0) m_subRect.width = json["width"].get<int>(); // Optional
    if (json.count("height") > 0) m_subRect.height = json["height"].get<int>(); // Optional
 
    // More advanced data
    if (json.count("animation") > 0 && json["animation"].isArray()) {
        auto &animation = json.array("animation");
        std::vector<tson::Frame> frames;
        std::for_each(animation.begin(), animation.end(), [&](std::unique_ptr<IJson> &item) { frames.emplace_back(*item); });
        if (frames.size() > 0) {
            m_animation.setFrames(frames);
        }
    }
    if (json.count("terrain") > 0 && json["terrain"].isArray()) {
        auto &terrain = json.array("terrain");
        std::for_each(terrain.begin(), terrain.end(), [&](std::unique_ptr<IJson> &item) { m_terrain.emplace_back(item->get<int>()); });
    }
 
    if (json.count("properties") > 0 && json["properties"].isArray()) {
        auto &properties = json.array("properties");
        std::for_each(properties.begin(), properties.end(), [&](std::unique_ptr<IJson> &item) { m_properties.add(*item); });
    }
 
    performDataCalculations();
 
    return allFound;
}
 
uint32_t tson::Tile::getId() const
{
    return m_id;
}
 
const fs::path &tson::Tile::getImage() const
{
    return m_image;
}
 
const tson::Vector2i &tson::Tile::getImageSize() const
{
    return m_imageSize;
}
 
const std::string &tson::Tile::getType() const
{
    return m_type;
}
 
const std::string &tson::Tile::getClassType() const
{
    return m_type;
}
 
tson::Animation &tson::Tile::getAnimation()
{
    return m_animation;
}
 
tson::Layer &tson::Tile::getObjectgroup()
{
    return m_objectgroup;
}
 
tson::PropertyCollection &tson::Tile::getProperties()
{
    return m_properties;
}
 
const std::vector<int> &tson::Tile::getTerrain() const
{
    return m_terrain;
}
 
tson::Property *tson::Tile::getProp(const std::string &name)
{
    if (m_properties.hasProperty(name)) return m_properties.getProperty(name);
 
    return nullptr;
}
 
tson::Tileset *tson::Tile::getTileset() const
{
    return m_tileset;
}
 
tson::Map *tson::Tile::getMap() const
{
    return m_map;
}
 
const tson::Rect &tson::Tile::getDrawingRect() const
{
    return m_drawingRect;
}
 
const tson::Vector2i tson::Tile::getPositionInTileUnits(const std::tuple<int, int> &tileDataPos)
{
    return {std::get<0>(tileDataPos), std::get<1>(tileDataPos)};
}
 
void tson::Tile::manageFlipFlagsByIdThenRemoveFlags(uint32_t &id)
{
    if (id & FLIPPED_HORIZONTALLY_FLAG) m_flipFlags |= TileFlipFlags::Horizontally;
    if (id & FLIPPED_VERTICALLY_FLAG) m_flipFlags |= TileFlipFlags::Vertically;
    if (id & FLIPPED_DIAGONALLY_FLAG) m_flipFlags |= TileFlipFlags::Diagonally;
 
    id &= ~(FLIPPED_HORIZONTALLY_FLAG | FLIPPED_VERTICALLY_FLAG | FLIPPED_DIAGONALLY_FLAG);
}
 
tson::TileFlipFlags tson::Tile::getFlipFlags() const
{
    return m_flipFlags;
}
 
bool tson::Tile::hasFlipFlags(tson::TileFlipFlags flags)
{
    return ((m_flipFlags & flags) == flags) ? true : false;
}
 
uint32_t tson::Tile::getGid() const
{
    return m_gid;
}
 
void tson::Tile::setProperties(const tson::PropertyCollection &properties)
{
    m_properties = properties;
}
 
const tson::Rect &tson::Tile::getSubRectangle() const
{
    return m_subRect;
}
 
            #endif // TILESON_TILE_HPP
 
 
 
            //
            // Created by robin on 22.03.2020.
            //
 
            #ifndef TILESON_TERRAIN_HPP
                #define TILESON_TERRAIN_HPP
 
// #include "../external/json.hpp"
 
namespace tson {
    class Terrain {
    public:
        inline Terrain() = default;
        inline Terrain(std::string name, int tile);
        inline explicit Terrain(IJson &json);
 
        inline bool parse(IJson &json);
 
        [[nodiscard]]
        inline const std::string &getName() const;
        [[nodiscard]]
        inline int getTile() const;
        [[nodiscard]]
        inline PropertyCollection &getProperties();
 
        template<typename T>
        inline T get(const std::string &name);
        inline tson::Property *getProp(const std::string &name);
 
    private:
        std::string m_name; 
        int m_tile {}; 
        tson::PropertyCollection m_properties; 
    };
 
    template<typename T>
    T tson::Terrain::get(const std::string &name)
    {
        return m_properties.getValue<T>(name);
    }
} // namespace tson
 
tson::Terrain::Terrain(std::string name, int tile) : m_name {std::move(name)}, m_tile {tile} {}
 
tson::Terrain::Terrain(IJson &json)
{
    parse(json);
}
 
bool tson::Terrain::parse(IJson &json)
{
    bool allFound = true;
 
    if (json.count("name") > 0)
        m_name = json["name"].get<std::string>();
    else
        allFound = false;
    if (json.count("tile") > 0)
        m_tile = json["tile"].get<int>();
    else
        allFound = false;
 
    if (json.count("properties") > 0 && json["properties"].isArray()) {
        auto &properties = json.array("properties");
        std::for_each(properties.begin(), properties.end(), [&](std::unique_ptr<IJson> &item) { m_properties.add(*item); });
    }
 
    return allFound;
}
 
const std::string &tson::Terrain::getName() const
{
    return m_name;
}
 
int tson::Terrain::getTile() const
{
    return m_tile;
}
 
tson::PropertyCollection &tson::Terrain::getProperties()
{
    return m_properties;
}
 
tson::Property *tson::Terrain::getProp(const std::string &name)
{
    if (m_properties.hasProperty(name)) return m_properties.getProperty(name);
    return nullptr;
}
 
            #endif // TILESON_TERRAIN_HPP
 
 
 
            //
            // Created by robin on 22.03.2020.
            //
 
            #ifndef TILESON_GRID_HPP
                #define TILESON_GRID_HPP
 
                #include <string>
 
// #include "../external/json.hpp"
 
namespace tson {
    class Grid {
    public:
        inline Grid() = default;
        inline explicit Grid(IJson &json);
 
        inline bool parse(IJson &json);
 
        [[nodiscard]]
        inline const std::string &getOrientation() const;
        [[nodiscard]]
        inline const Vector2i &getSize() const;
 
    private:
        std::string m_orientation; 
        tson::Vector2i m_size; 
    };
} // namespace tson
 
tson::Grid::Grid(IJson &json)
{
    parse(json);
}
 
bool tson::Grid::parse(IJson &json)
{
    bool allFound = true;
 
    if (json.count("orientation") > 0) m_orientation = json["orientation"].get<std::string>(); // Optional
 
    if (json.count("width") > 0 && json.count("height") > 0)
        m_size = {json["width"].get<int>(), json["height"].get<int>()};
    else
        allFound = false;
 
    return allFound;
}
 
const std::string &tson::Grid::getOrientation() const
{
    return m_orientation;
}
 
const tson::Vector2i &tson::Grid::getSize() const
{
    return m_size;
}
 
            #endif // TILESON_GRID_HPP
 
 
            #include <functional>
 
namespace tson {
    class Map;
 
    class Tileset {
    public:
        inline Tileset() = default;
        inline explicit Tileset(IJson &json, tson::Map *map);
        inline bool parse(IJson &json, tson::Map *map);
 
        [[nodiscard]]
        inline int getColumns() const;
        [[nodiscard]]
        inline int getFirstgid() const;
 
        [[nodiscard]]
        inline const fs::path &getImagePath() const;
        [[nodiscard]]
        inline const fs::path &getImage() const;
        [[nodiscard]]
        inline const Vector2i &getImageSize() const;
        [[nodiscard]]
        inline int getMargin() const;
        [[nodiscard]]
        inline const std::string &getName() const;
        [[nodiscard]]
        inline int getSpacing() const;
        [[nodiscard]]
        inline int getTileCount() const;
        [[nodiscard]]
        inline const Vector2i &getTileSize() const;
        [[nodiscard]]
        inline const Colori &getTransparentColor() const;
        [[nodiscard]]
        inline const std::string &getType() const;
        [[nodiscard]]
        inline const std::string &getClassType() const;
        [[nodiscard]]
        inline tson::TiledClass *getClass(); 
        [[nodiscard]]
        inline std::vector<tson::Tile> &getTiles();
        [[nodiscard]]
        inline const std::vector<tson::WangSet> &getWangsets() const;
        [[nodiscard]]
        inline PropertyCollection &getProperties();
        [[nodiscard]]
        inline const std::vector<tson::Terrain> &getTerrains() const;
        [[nodiscard]]
        inline const Vector2i &getTileOffset() const;
        [[nodiscard]]
        inline const Grid &getGrid() const;
        [[nodiscard]]
        inline TileRenderSize getTileRenderSize() const;
        [[nodiscard]]
        inline FillMode getFillMode() const;
 
        inline tson::Tile *getTile(uint32_t id);
        inline tson::Terrain *getTerrain(const std::string &name);
 
        template<typename T>
        inline T get(const std::string &name);
        inline tson::Property *getProp(const std::string &name);
 
        // v1.2.0-stuff
        [[nodiscard]]
        inline tson::Map *getMap() const;
        [[nodiscard]]
        inline ObjectAlignment getObjectAlignment() const;
 
        inline static tson::ObjectAlignment StringToAlignment(std::string_view str);
 
        // v1.3.0
        inline tson::Vector2i getMarginSpacingOffset(const tson::Vector2i &posInTileUnits);
        inline tson::WangSet *getWangset(const std::string &name);
        inline const Transformations &getTransformations() const;
 
            #ifndef TSON_TEST_ENABLED
    private:
            #endif
        inline void generateMissingTiles();
 
        int m_columns {}; 
        int m_firstgid {}; 
        fs::path m_image; 
        tson::Vector2i m_imageSize; 
        int m_margin {}; 
        std::string m_name; 
        int m_spacing {}; 
        int m_tileCount {}; 
        tson::Vector2i m_tileSize; 
        tson::Colori m_transparentColor; 
        std::string m_type; 
        std::vector<tson::Tile> m_tiles; 
        std::vector<tson::WangSet> m_wangsets; 
        tson::PropertyCollection m_properties; 
        std::vector<tson::Terrain> m_terrains; 
        tson::Vector2i m_tileOffset; 
        tson::Grid m_grid; 
        // v1.2.0-stuff
        tson::ObjectAlignment m_objectAlignment {tson::ObjectAlignment::Unspecified}; 
        tson::Map *m_map; 
        // v1.3.0-stuff
        fs::path m_source {}; 
        fs::path m_path {}; 
        Transformations m_transformations {}; 
        // v1.4.0-stuff
        TileRenderSize
            m_tileRenderSize {}; 
        FillMode m_fillMode {}; 
        std::string m_classType {}; 
        std::shared_ptr<tson::TiledClass> m_class {};
    };
 
    template<typename T>
    T tson::Tileset::get(const std::string &name)
    {
        return m_properties.getValue<T>(name);
    }
} // namespace tson
 
tson::Tileset::Tileset(IJson &json, tson::Map *map)
{
    parse(json, map);
}
 
bool tson::Tileset::parse(IJson &json, tson::Map *map)
{
    m_map = map;
    bool allFound = true;
 
    if (json.count("firstgid") > 0)
        m_firstgid = json["firstgid"].get<int>();
    else
        allFound = false;
 
    // Tileset is stored in external file if 'source' exists
    if (json.count("source") > 0) {
        if (!allFound) return allFound;
 
        std::string sourceStr = json["source"].get<std::string>();
        m_source = fs::path(sourceStr);
        m_path = json.directory() / m_source;
 
        if (!json.parse(m_path)) return false;
    }
 
    if (json.count("columns") > 0)
        m_columns = json["columns"].get<int>();
    else
        allFound = false;
 
    if (json.count("image") > 0)
        m_image = fs::path(json["image"].get<std::string>());
    else
        allFound = false;
 
    if (json.count("margin") > 0)
        m_margin = json["margin"].get<int>();
    else
        allFound = false;
    if (json.count("name") > 0)
        m_name = json["name"].get<std::string>();
    else
        allFound = false;
    if (json.count("spacing") > 0)
        m_spacing = json["spacing"].get<int>();
    else
        allFound = false;
    if (json.count("tilecount") > 0)
        m_tileCount = json["tilecount"].get<int>();
    else
        allFound = false;
    if (json.count("transparentcolor") > 0) m_transparentColor = tson::Colori(json["transparentcolor"].get<std::string>()); // Optional
    if (json.count("type") > 0) m_type = json["type"].get<std::string>();
    if (json.count("grid") > 0) m_grid = tson::Grid(json["grid"]);
    if (json.count("class") > 0) m_classType = json["class"].get<std::string>(); // Optional
 
    if (json.count("imagewidth") > 0 && json.count("imageheight") > 0)
        m_imageSize = {json["imagewidth"].get<int>(), json["imageheight"].get<int>()};
    else
        allFound = false;
    if (json.count("tilewidth") > 0 && json.count("tileheight") > 0)
        m_tileSize = {json["tilewidth"].get<int>(), json["tileheight"].get<int>()};
    else
        allFound = false;
    if (json.count("tileoffset") > 0) m_tileOffset = {json["tileoffset"]["x"].get<int>(), json["tileoffset"]["y"].get<int>()};
 
    if (json.count("tilerendersize") > 0) {
        std::string tileRenderStr = json["tilerendersize"].get<std::string>();
        if (tileRenderStr == "tile")
            m_tileRenderSize = TileRenderSize::Tile;
        else if (tileRenderStr == "grid")
            m_tileRenderSize = TileRenderSize::Grid;
    }
 
    if (json.count("fillmode") > 0) {
        std::string fillmode = json["fillmode"].get<std::string>();
        if (fillmode == "stretch")
            m_fillMode = FillMode::Stretch;
        else if (fillmode == "preserve-aspect-fit")
            m_fillMode = FillMode::PreserveAspectFit;
    }
 
    // More advanced data
    if (json.count("wangsets") > 0 && json["wangsets"].isArray()) {
        auto &wangsets = json.array("wangsets");
        std::for_each(wangsets.begin(), wangsets.end(), [&](std::unique_ptr<IJson> &item) { m_wangsets.emplace_back(*item, m_map); });
    }
    if (json.count("tiles") > 0 && json["tiles"].isArray()) {
        auto &tiles = json.array("tiles");
        std::for_each(tiles.begin(), tiles.end(), [&](std::unique_ptr<IJson> &item) { m_tiles.emplace_back(*item, this, m_map); });
    }
    if (json.count("terrains") > 0 && json["terrains"].isArray()) {
        auto &terrains = json.array("terrains");
        std::for_each(terrains.begin(), terrains.end(), [&](std::unique_ptr<IJson> &item) { m_terrains.emplace_back(*item); });
    }
 
    if (json.count("properties") > 0 && json["properties"].isArray()) {
        auto &properties = json.array("properties");
        std::for_each(properties.begin(), properties.end(), [&](std::unique_ptr<IJson> &item) { m_properties.add(*item); });
    }
 
    if (json.count("objectalignment") > 0) {
        std::string alignment = json["objectalignment"].get<std::string>();
        m_objectAlignment = StringToAlignment(alignment);
    }
 
    if (json.count("transformations") > 0) {
        m_transformations.parse(json["transformations"]);
    }
 
    generateMissingTiles();
 
    return allFound;
}
 
int tson::Tileset::getColumns() const
{
    return m_columns;
}
 
int tson::Tileset::getFirstgid() const
{
    return m_firstgid;
}
 
const fs::path &tson::Tileset::getImagePath() const
{
    return m_image;
}
 
const tson::Vector2i &tson::Tileset::getImageSize() const
{
    return m_imageSize;
}
 
int tson::Tileset::getMargin() const
{
    return m_margin;
}
 
const std::string &tson::Tileset::getName() const
{
    return m_name;
}
 
int tson::Tileset::getSpacing() const
{
    return m_spacing;
}
 
int tson::Tileset::getTileCount() const
{
    return m_tileCount;
}
 
const tson::Vector2i &tson::Tileset::getTileSize() const
{
    return m_tileSize;
}
 
const tson::Colori &tson::Tileset::getTransparentColor() const
{
    return m_transparentColor;
}
 
const std::string &tson::Tileset::getType() const
{
    return m_type;
}
 
const fs::path &tson::Tileset::getImage() const
{
    return m_image;
}
 
std::vector<tson::Tile> &tson::Tileset::getTiles()
{
    return m_tiles;
}
 
const std::vector<tson::WangSet> &tson::Tileset::getWangsets() const
{
    return m_wangsets;
}
 
tson::PropertyCollection &tson::Tileset::getProperties()
{
    return m_properties;
}
 
const std::vector<tson::Terrain> &tson::Tileset::getTerrains() const
{
    return m_terrains;
}
 
const tson::Vector2i &tson::Tileset::getTileOffset() const
{
    return m_tileOffset;
}
 
const tson::Grid &tson::Tileset::getGrid() const
{
    return m_grid;
}
 
tson::Tile *tson::Tileset::getTile(uint32_t id)
{
    auto result = std::find_if(m_tiles.begin(), m_tiles.end(), [&](const tson::Tile &item) { return item.getId() == id; });
    if (result == m_tiles.end()) return nullptr;
 
    return &result.operator*();
}
 
tson::Terrain *tson::Tileset::getTerrain(const std::string &name)
{
    auto result = std::find_if(m_terrains.begin(), m_terrains.end(), [&](const tson::Terrain &item) { return item.getName() == name; });
    if (result == m_terrains.end()) return nullptr;
 
    return &result.operator*();
}
 
tson::Property *tson::Tileset::getProp(const std::string &name)
{
    if (m_properties.hasProperty(name)) return m_properties.getProperty(name);
 
    return nullptr;
}
 
void tson::Tileset::generateMissingTiles()
{
    std::vector<uint32_t> tileIds;
    for (auto &tile : m_tiles)
        tileIds.push_back(tile.getId());
 
    for (uint32_t i = m_firstgid; i < m_firstgid + (uint32_t) m_tileCount; ++i) {
        if (std::count(tileIds.begin(), tileIds.end(), i) == 0) {
            m_tiles.emplace_back(Tile(i, this, m_map));
        }
    }
}
 
tson::Map *tson::Tileset::getMap() const
{
    return m_map;
}
 
tson::ObjectAlignment tson::Tileset::StringToAlignment(std::string_view str)
{
    if (str == "unspecified")
        return tson::ObjectAlignment::Unspecified;
    else if (str == "topleft")
        return tson::ObjectAlignment::TopLeft;
    else if (str == "top")
        return tson::ObjectAlignment::Top;
    else if (str == "topright")
        return tson::ObjectAlignment::TopRight;
    else if (str == "left")
        return tson::ObjectAlignment::Left;
    else if (str == "center")
        return tson::ObjectAlignment::Center;
    else if (str == "right")
        return tson::ObjectAlignment::Right;
    else if (str == "bottomleft")
        return tson::ObjectAlignment::BottomLeft;
    else if (str == "bottom")
        return tson::ObjectAlignment::Bottom;
    else if (str == "bottomright")
        return tson::ObjectAlignment::BottomRight;
    else
        return tson::ObjectAlignment::Unspecified;
}
 
tson::ObjectAlignment tson::Tileset::getObjectAlignment() const
{
    return m_objectAlignment;
}
 
tson::Vector2i tson::Tileset::getMarginSpacingOffset(const tson::Vector2i &posInTileUnits)
{
    if (m_margin == 0 && m_spacing == 0) return {0, 0};
 
    tson::Vector2i offset {(posInTileUnits.x * m_spacing) + m_margin, (posInTileUnits.y * m_spacing) + m_margin};
    return offset;
}
 
tson::WangSet *tson::Tileset::getWangset(const std::string &name)
{
    auto wangset = std::find_if(m_wangsets.begin(), m_wangsets.end(), [&](const auto &w) { return w.getName() == name; });
 
    if (wangset != m_wangsets.end()) return &wangset.operator*();
 
    return nullptr;
}
 
const tson::Transformations &tson::Tileset::getTransformations() const
{
    return m_transformations;
}
 
tson::TileRenderSize tson::Tileset::getTileRenderSize() const
{
    return m_tileRenderSize;
}
 
tson::FillMode tson::Tileset::getFillMode() const
{
    return m_fillMode;
}
 
const std::string &tson::Tileset::getClassType() const
{
    return m_classType;
}
 
        #endif // TILESON_TILESET_HPP
 
namespace tson {
    class Map {
    public:
        inline Map() = default;
        inline Map(ParseStatus status, std::string description);
        inline explicit Map(IJson &json, tson::DecompressorContainer *decompressors, tson::Project *project);
        inline bool parse(IJson &json, tson::DecompressorContainer *decompressors, tson::Project *project);
 
        [[nodiscard]]
        inline const Colori &getBackgroundColor() const;
        [[nodiscard]]
        inline const Vector2i &getSize() const;
        [[nodiscard]]
        inline int getHexsideLength() const;
        [[nodiscard]]
        inline bool isInfinite() const;
        [[nodiscard]]
        inline int getNextLayerId() const;
        [[nodiscard]]
        inline int getNextObjectId() const;
        [[nodiscard]]
        inline const std::string &getOrientation() const;
        [[nodiscard]]
        inline const std::string &getRenderOrder() const;
        [[nodiscard]]
        inline const std::string &getStaggerAxis() const;
        [[nodiscard]]
        inline const std::string &getStaggerIndex() const;
        [[nodiscard]]
        inline const std::string &getTiledVersion() const;
        [[nodiscard]]
        inline const Vector2i &getTileSize() const;
        [[nodiscard]]
        inline const std::string &getType() const;
        [[nodiscard]]
        inline const std::string &getClassType() const;
        [[nodiscard]]
        inline tson::TiledClass *getClass(); 
        [[nodiscard]]
        inline const Vector2f &getParallaxOrigin() const;
        //[[nodiscard]] inline int getVersion() const; //Removed - Tileson v1.3.0
 
        [[nodiscard]]
        inline std::vector<tson::Layer> &getLayers();
        [[nodiscard]]
        inline PropertyCollection &getProperties();
        [[nodiscard]]
        inline std::vector<tson::Tileset> &getTilesets();
 
        [[nodiscard]]
        inline ParseStatus getStatus() const;
        [[nodiscard]]
        inline const std::string &getStatusMessage() const;
        [[nodiscard]]
        inline const std::map<uint32_t, tson::Tile *> &getTileMap() const;
 
        inline Layer *getLayer(const std::string &name);
        inline Tileset *getTileset(const std::string &name);
 
        template<typename T>
        inline T get(const std::string &name);
        inline tson::Property *getProp(const std::string &name);
 
        // v1.2.0
        [[nodiscard]]
        inline int getCompressionLevel() const;
        inline DecompressorContainer *getDecompressors();
        inline Project *getProject();
        inline Tileset *getTilesetByGid(uint32_t gid);
 
    private:
        inline bool createTilesetData(IJson &json);
        inline void processData();
 
        Colori m_backgroundColor; 
        ;
        Vector2i m_size; 
        int m_hexsideLength {}; 
        bool m_isInfinite {}; 
        std::vector<tson::Layer> m_layers; 
        int m_nextLayerId {}; 
        int m_nextObjectId {}; 
        std::string m_orientation; 
        tson::PropertyCollection m_properties; 
        std::string m_renderOrder; 
        std::string m_staggerAxis; 
        std::string m_staggerIndex; 
        std::string m_tiledVersion; 
        Vector2i m_tileSize; 
        std::vector<tson::Tileset> m_tilesets; 
        std::string m_type; 
        tson::Vector2f m_parallaxOrigin; 
        // int                                    m_version{};       /*! 'version': The JSON format version - Removed in Tileson v1.3.0*/
 
        ParseStatus m_status {ParseStatus::OK};
        std::string m_statusMessage {"OK"};
 
        std::map<uint32_t, tson::Tile *> m_tileMap {}; 
        // v1.2.0
        int m_compressionLevel {-1}; 
        tson::DecompressorContainer *m_decompressors {nullptr};
        tson::Project *m_project {nullptr};
        std::map<uint32_t, tson::Tile> m_flaggedTileMap {}; 
        std::string m_classType {}; 
        std::shared_ptr<tson::TiledClass> m_class {};
    };
 
    template<typename T>
    T tson::Map::get(const std::string &name)
    {
        return m_properties.getValue<T>(name);
    }
} // namespace tson
 
tson::Map::Map(tson::ParseStatus status, std::string description) : m_status {status}, m_statusMessage {std::move(description)} {}
 
tson::Map::Map(IJson &json, tson::DecompressorContainer *decompressors, tson::Project *project)
{
    parse(json, decompressors, project);
}
 
bool tson::Map::parse(IJson &json, tson::DecompressorContainer *decompressors, tson::Project *project)
{
    m_decompressors = decompressors;
    m_project = project;
 
    bool allFound = true;
    if (json.count("compressionlevel") > 0) m_compressionLevel = json["compressionlevel"].get<int>(); // Tiled 1.3 - Optional
 
    if (json.count("backgroundcolor") > 0) m_backgroundColor = Colori(json["backgroundcolor"].get<std::string>()); // Optional
    if (json.count("width") > 0 && json.count("height") > 0)
        m_size = {json["width"].get<int>(), json["height"].get<int>()};
    else
        allFound = false;
    if (json.count("hexsidelength") > 0) m_hexsideLength = json["hexsidelength"].get<int>(); // Optional
    if (json.count("infinite") > 0) m_isInfinite = json["infinite"].get<bool>(); // Optional
    if (json.count("nextlayerid") > 0) m_nextLayerId = json["nextlayerid"].get<int>(); // Optional
    if (json.count("nextobjectid") > 0)
        m_nextObjectId = json["nextobjectid"].get<int>();
    else
        allFound = false;
    if (json.count("orientation") > 0)
        m_orientation = json["orientation"].get<std::string>();
    else
        allFound = false;
    if (json.count("renderorder") > 0) m_renderOrder = json["renderorder"].get<std::string>(); // Optional
    if (json.count("staggeraxis") > 0) m_staggerAxis = json["staggeraxis"].get<std::string>(); // Optional
    if (json.count("staggerindex") > 0) m_staggerIndex = json["staggerindex"].get<std::string>(); // Optional
    if (json.count("tiledversion") > 0)
        m_tiledVersion = json["tiledversion"].get<std::string>();
    else
        allFound = false;
    if (json.count("tilewidth") > 0 && json.count("tileheight") > 0)
        m_tileSize = {json["tilewidth"].get<int>(), json["tileheight"].get<int>()};
    else
        allFound = false;
    if (json.count("type") > 0) m_type = json["type"].get<std::string>(); // Optional
    if (json.count("class") > 0) m_classType = json["class"].get<std::string>(); // Optional
 
    // Removed - Changed from a float to string in Tiled v1.6, and old spec said int.
    // Reason for removal is that it seems to have no real use, as TiledVersion is stored in another variable.
    // if(json.count("version") > 0) m_version = json["version"].get<int>(); else allFound = false;
 
    // More advanced data
    if (json.count("layers") > 0 && json["layers"].isArray()) {
        auto &array = json.array("layers");
        std::for_each(array.begin(), array.end(), [&](std::unique_ptr<IJson> &item) { m_layers.emplace_back(*item, this); });
    }
 
    if (json.count("properties") > 0 && json["properties"].isArray()) {
        auto &array = json.array("properties");
        std::for_each(array.begin(), array.end(), [&](std::unique_ptr<IJson> &item) { m_properties.add(*item, m_project); });
    }
 
    tson::Vector2f parallaxOrigin {0.f, 0.f};
    if (json.count("parallaxoriginx") > 0) parallaxOrigin.x = json["parallaxoriginx"].get<float>();
    if (json.count("parallaxoriginy") > 0) parallaxOrigin.y = json["parallaxoriginy"].get<float>();
 
    m_parallaxOrigin = parallaxOrigin;
 
    if (!createTilesetData(json)) allFound = false;
 
    processData();
 
    return allFound;
}
 
bool tson::Map::createTilesetData(IJson &json)
{
    bool ok = true;
    if (json.count("tilesets") > 0 && json["tilesets"].isArray()) {
        // First created tileset objects
        auto &tilesets = json.array("tilesets");
        std::for_each(tilesets.begin(), tilesets.end(), [&](std::unique_ptr<IJson> &) { m_tilesets.emplace_back(); });
 
        int i = 0;
        // Then do the parsing
        std::for_each(tilesets.begin(), tilesets.end(), [&](std::unique_ptr<IJson> &item) {
            item->directory(json.directory());
            if (!m_tilesets[i].parse(*item, this)) ok = false;
 
            ++i;
        });
    }
    return ok;
}
 
void tson::Map::processData()
{
    m_tileMap.clear();
    for (auto &tileset : m_tilesets) {
        std::set<std::uint32_t> usedIds;
        for (auto &tile : tileset.getTiles()) {
            if (usedIds.count(tile.getGid()) != 0) {
                continue;
            }
            usedIds.insert(tile.getGid());
            m_tileMap[tile.getGid()] = &tile;
        }
    }
    std::for_each(m_layers.begin(), m_layers.end(), [&](tson::Layer &layer) {
        layer.assignTileMap(&m_tileMap);
        layer.createTileData(m_size, m_isInfinite);
        const std::set<uint32_t> &flaggedTiles = layer.getUniqueFlaggedTiles();
        for (uint32_t ftile : flaggedTiles) {
            tson::Tile tile {ftile, layer.getMap()};
            if (m_tileMap.count(tile.getGid())) {
                tson::Tile *originalTile = m_tileMap[tile.getGid()];
                tile.addTilesetAndPerformCalculations(originalTile->getTileset());
                tile.setProperties(originalTile->getProperties());
                m_flaggedTileMap[ftile] = tile;
                m_tileMap[ftile] = &m_flaggedTileMap[ftile];
            }
        }
        layer.resolveFlaggedTiles();
    });
}
 
const tson::Colori &tson::Map::getBackgroundColor() const
{
    return m_backgroundColor;
}
 
const tson::Vector2<int> &tson::Map::getSize() const
{
    return m_size;
}
 
int tson::Map::getHexsideLength() const
{
    return m_hexsideLength;
}
 
bool tson::Map::isInfinite() const
{
    return m_isInfinite;
}
 
int tson::Map::getNextLayerId() const
{
    return m_nextLayerId;
}
 
int tson::Map::getNextObjectId() const
{
    return m_nextObjectId;
}
 
const std::string &tson::Map::getOrientation() const
{
    return m_orientation;
}
 
const std::string &tson::Map::getRenderOrder() const
{
    return m_renderOrder;
}
 
const std::string &tson::Map::getStaggerAxis() const
{
    return m_staggerAxis;
}
 
const std::string &tson::Map::getStaggerIndex() const
{
    return m_staggerIndex;
}
 
const std::string &tson::Map::getTiledVersion() const
{
    return m_tiledVersion;
}
 
const tson::Vector2<int> &tson::Map::getTileSize() const
{
    return m_tileSize;
}
 
const std::string &tson::Map::getType() const
{
    return m_type;
}
 
// int tson::Map::getVersion() const
//{
//     return m_version;
// }
 
std::vector<tson::Layer> &tson::Map::getLayers()
{
    return m_layers;
}
 
tson::PropertyCollection &tson::Map::getProperties()
{
    return m_properties;
}
 
std::vector<tson::Tileset> &tson::Map::getTilesets()
{
    return m_tilesets;
}
 
tson::Layer *tson::Map::getLayer(const std::string &name)
{
    auto result = std::find_if(m_layers.begin(), m_layers.end(), [&](const tson::Layer &item) { return item.getName() == name; });
    if (result == m_layers.end()) return nullptr;
 
    return &result.operator*();
}
 
tson::Tileset *tson::Map::getTileset(const std::string &name)
{
    auto result = std::find_if(m_tilesets.begin(), m_tilesets.end(), [&](const tson::Tileset &item) { return item.getName() == name; });
    if (result == m_tilesets.end()) return nullptr;
 
    return &result.operator*();
}
 
tson::Tileset *tson::Map::getTilesetByGid(uint32_t gid)
{
    auto result = std::find_if(m_tilesets.begin(), m_tilesets.end(), [&](const tson::Tileset &tileset) {
        auto const firstId = static_cast<uint32_t>(tileset.getFirstgid()); // First tile id of the tileset
        auto const lastId = static_cast<uint32_t>((firstId + tileset.getTileCount()) - 1);
 
        return (gid >= firstId && gid <= lastId);
    });
    if (result == m_tilesets.end()) return nullptr;
 
    return &result.operator*();
}
 
tson::Property *tson::Map::getProp(const std::string &name)
{
    if (m_properties.hasProperty(name)) return m_properties.getProperty(name);
    return nullptr;
}
 
tson::ParseStatus tson::Map::getStatus() const
{
    return m_status;
}
 
const std::string &tson::Map::getStatusMessage() const
{
    return m_statusMessage;
}
 
const std::map<uint32_t, tson::Tile *> &tson::Map::getTileMap() const
{
    return m_tileMap;
}
 
tson::DecompressorContainer *tson::Map::getDecompressors()
{
    return m_decompressors;
}
 
int tson::Map::getCompressionLevel() const
{
    return m_compressionLevel;
}
 
const tson::Vector2f &tson::Map::getParallaxOrigin() const
{
    return m_parallaxOrigin;
}
 
tson::Project *tson::Map::getProject()
{
    return m_project;
}
 
const std::string &tson::Map::getClassType() const
{
    return m_classType;
}
 
    #endif // TILESON_MAP_HPP
 
 
 
    //
    // Created by robin on 06.06.22.
    //
 
    #ifndef TILESON_TILEDENUM_HPP
        #define TILESON_TILEDENUM_HPP
 
namespace tson {
    class EnumDefinition {
    public:
        inline explicit EnumDefinition(IJson &json);
        inline uint32_t getValue(const std::string &str);
        inline std::string getValue(uint32_t num);
        inline std::vector<std::string> getValues(uint32_t num);
        inline bool exists(const std::string &str);
        inline bool exists(uint32_t num);
 
        [[nodiscard]]
        inline uint32_t getId() const;
        [[nodiscard]]
        inline uint32_t getMaxValue() const;
        [[nodiscard]]
        inline const std::string &getName() const;
        [[nodiscard]]
        inline EnumStorageType getStorageType() const;
        [[nodiscard]]
        inline bool hasValuesAsFlags() const;
 
    private:
        inline bool hasFlag(uint32_t value, uint32_t flag) const;
        uint32_t m_id {};
        uint32_t m_maxValue {};
        std::string m_name {};
        std::map<uint32_t, std::string> m_values {};
        bool m_valuesAsFlags {false};
        EnumStorageType m_storageType {EnumStorageType::Unspecified};
    };
 
    EnumDefinition::EnumDefinition(IJson &json)
    {
        m_id = json.get<uint32_t>("id");
        m_name = json.get<std::string>("name");
        std::string type = json.get<std::string>("storageType");
        m_storageType = (type == "int") ? EnumStorageType::Int : (type == "string") ? EnumStorageType::String : EnumStorageType::Unspecified;
        m_valuesAsFlags = json.get<bool>("valuesAsFlags");
 
        if (json.count("values") > 0 && json["values"].isArray()) {
            m_values[0] = "None";
            uint32_t valueCounter = (m_valuesAsFlags) ? 1 : 0;
            uint8_t flagBit = 1;
            auto &array = json.array("values");
            std::for_each(array.begin(), array.end(), [&](std::unique_ptr<IJson> &item) {
                std::string v = item->get<std::string>();
                m_values[valueCounter] = v;
                if (m_valuesAsFlags) {
                    valueCounter = 1 << flagBit;
                    ++flagBit;
                } else {
                    ++valueCounter;
                }
            });
 
            m_maxValue = valueCounter;
        }
    }
 
    uint32_t EnumDefinition::getValue(const std::string &str)
    {
        auto result = std::find_if(m_values.begin(), m_values.end(), [&](const std::pair<uint32_t, std::string> &pair) { return pair.second == str; });
 
        if (result != m_values.end()) return result->first;
 
        return 0;
    }
 
    std::string EnumDefinition::getValue(uint32_t num)
    {
        return (m_values.count(num) > 0) ? m_values[num] : "";
    }
 
    bool EnumDefinition::hasValuesAsFlags() const
    {
        return m_valuesAsFlags;
    }
 
    bool EnumDefinition::exists(const std::string &str)
    {
        auto result = std::find_if(m_values.begin(), m_values.end(), [&](const std::pair<uint32_t, std::string> &pair) { return pair.second == str; });
 
        if (result != m_values.end()) return true;
 
        return false;
    }
 
    bool EnumDefinition::exists(uint32_t num)
    {
        return (m_values.count(num) > 0);
    }
 
    uint32_t EnumDefinition::getId() const
    {
        return m_id;
    }
 
    const std::string &EnumDefinition::getName() const
    {
        return m_name;
    }
 
    EnumStorageType EnumDefinition::getStorageType() const
    {
        return m_storageType;
    }
 
    uint32_t EnumDefinition::getMaxValue() const
    {
        return m_maxValue;
    }
 
    std::vector<std::string> EnumDefinition::getValues(uint32_t num)
    {
        std::vector<std::string> values;
        if (m_valuesAsFlags) {
            uint32_t flag = 0;
            uint32_t i = 0;
            while (flag < m_maxValue) {
                flag = 1 << i;
                ++i;
                if (m_values.count(flag) > 0 && hasFlag(num, flag)) {
                    values.emplace_back(m_values[flag]);
                }
            }
        } else {
            std::string v = getValue(num);
            if (!v.empty()) values.emplace_back();
        }
 
        return values;
    }
 
    bool EnumDefinition::hasFlag(uint32_t value, uint32_t flag) const
    {
        return ((value & flag) == flag);
    }
 
    class EnumValue {
    public:
        inline EnumValue() = default;
        inline EnumValue(uint32_t value, EnumDefinition *definition);
        inline EnumValue(const std::string &value, EnumDefinition *definition);
 
        [[nodiscard]]
        inline uint32_t getValue() const;
        inline std::string getValueName() const;
        [[nodiscard]]
        inline std::vector<std::string> getValueNames() const;
        [[nodiscard]]
        inline EnumDefinition *getDefinition() const;
 
        inline bool hasFlagValue(uint32_t flag) const;
        template<typename T>
        inline bool hasFlag(T flags) const;
        inline bool hasAnyFlagValue(uint32_t flags) const;
        template<typename T>
        inline bool hasAnyFlag(T flags) const;
        [[nodiscard]]
        inline bool containsValueName(const std::string &value) const;
 
    private:
        uint32_t m_value {0};
        EnumDefinition *m_definition = nullptr;
    };
 
    EnumValue::EnumValue(uint32_t value, EnumDefinition *definition) : m_value {value}, m_definition {definition} {}
 
    EnumValue::EnumValue(const std::string &value, EnumDefinition *definition) : m_definition {definition}
    {
        if (!value.empty() && definition != nullptr) {
            std::vector<std::string> values = Tools::SplitString(value, ',');
            for (auto &item : values) {
                uint32_t v = definition->getValue(item);
                m_value |= v;
            }
        }
    }
 
    bool EnumValue::hasFlagValue(uint32_t flags) const
    {
        if (m_definition->hasValuesAsFlags()) return ((m_value & flags) == flags) ? true : false;
 
        return m_value == flags;
    }
 
    bool EnumValue::hasAnyFlagValue(uint32_t flags) const
    {
        if (m_definition->hasValuesAsFlags()) return ((m_value & flags) != 0);
 
        return m_value == flags;
    }
 
    uint32_t EnumValue::getValue() const
    {
        return m_value;
    }
 
    std::string EnumValue::getValueName() const
    {
        return (m_definition == nullptr) ? "" : m_definition->getValue(m_value);
    }
 
    template<typename T>
    bool EnumValue::hasFlag(T flags) const
    {
        return hasFlagValue(static_cast<uint32_t>(flags));
    }
 
    template<typename T>
    bool EnumValue::hasAnyFlag(T flags) const
    {
        return hasAnyFlagValue(static_cast<uint32_t>(flags));
    }
 
    EnumDefinition *EnumValue::getDefinition() const
    {
        return m_definition;
    }
 
    std::vector<std::string> EnumValue::getValueNames() const
    {
        return (m_definition == nullptr) ? std::vector<std::string>() : m_definition->getValues(m_value);
    }
 
    bool EnumValue::containsValueName(const std::string &value) const
    {
        if (m_definition != nullptr) {
            if (m_definition->hasValuesAsFlags()) {
                std::vector<std::string> values = m_definition->getValues(m_value);
                auto it = std::find(values.begin(), values.end(), value);
                return it != values.end();
            }
            return m_definition->getValue(value) == m_value;
        }
        return false;
    }
} // namespace tson
 
    #endif // TILESON_TILEDENUM_HPP
 
 
 
    //
    // Created by robin on 06.06.22.
    //
 
    #ifndef TILESON_TILEDCLASS_HPP
        #define TILESON_TILEDCLASS_HPP
 
namespace tson {
    class TiledClass {
    public:
        inline explicit TiledClass() = default;
        inline explicit TiledClass(IJson &json, tson::Project *project = nullptr);
 
        [[nodiscard]]
        inline uint32_t getId() const;
        [[nodiscard]]
        inline const std::string &getName() const;
        [[nodiscard]]
        inline const std::string &getType() const;
        [[nodiscard]]
        inline const PropertyCollection &getMembers() const;
        inline void update(IJson &json);
        inline void update(PropertyCollection &properties);
 
        template<typename T>
        inline T get(const std::string &name);
        inline tson::Property *getMember(const std::string &name);
 
    private:
        uint32_t m_id {};
        std::string m_name {};
        std::string m_type {};
        PropertyCollection m_members {};
    };
 
    TiledClass::TiledClass(IJson &json, tson::Project *project)
    {
        if (json.count("id") > 0) m_id = json["id"].get<uint32_t>();
 
        if (json.count("name") > 0) m_name = json["name"].get<std::string>();
        if (json.count("type") > 0) m_type = json["type"].get<std::string>();
 
        if (json.count("members") > 0 && json["members"].isArray()) {
            auto &array = json.array("members");
            std::for_each(array.begin(), array.end(), [&](std::unique_ptr<IJson> &item) { m_members.add(*item, project); });
        }
    }
 
    uint32_t TiledClass::getId() const
    {
        return m_id;
    }
 
    const std::string &TiledClass::getName() const
    {
        return m_name;
    }
 
    const std::string &TiledClass::getType() const
    {
        return m_type;
    }
 
    const PropertyCollection &TiledClass::getMembers() const
    {
        return m_members;
    }
 
    template<typename T>
    T TiledClass::get(const std::string &name)
    {
        return m_members.getValue<T>(name);
    }
 
    tson::Property *TiledClass::getMember(const std::string &name)
    {
        if (m_members.hasProperty(name)) return m_members.getProperty(name);
        return nullptr;
    }
 
    void TiledClass::update(IJson &json)
    {
        for (Property *property : m_members.get()) {
            if (json.any(property->getName())) {
                property->setValueByType(json[property->getName()]);
            }
        }
    }
 
    void TiledClass::update(PropertyCollection &properties)
    {
        std::vector<Property *> toUpdate;
        for (Property *member : m_members.get()) {
            if (properties.hasProperty(member->getName())) {
                Property *property = properties.getProperty(member->getName());
                if (member->getType() == property->getType()) {
                    toUpdate.push_back(property);
                }
            }
        }
 
        std::for_each(toUpdate.begin(), toUpdate.end(), [&](Property *p) { m_members.setProperty(p->getName(), *p); });
    }
} // namespace tson
 
    #endif // TILESON_TILEDCLASS_HPP
 
 
 
    //
    // Created by robin on 01.08.2020.
    //
 
    #ifndef TILESON_PROJECT_HPP
        #define TILESON_PROJECT_HPP
 
        #include <fstream>
        #include <memory>
        #include <sstream>
 
 
        //
        // Created by robin on 01.08.2020.
        //
 
        #ifndef TILESON_WORLD_HPP
            #define TILESON_WORLD_HPP
 
 
            //
            // Created by robin on 01.08.2020.
            //
 
            #ifndef TILESON_WORLDMAPDATA_HPP
                #define TILESON_WORLDMAPDATA_HPP
 
namespace tson {
    class WorldMapData {
    public:
        inline WorldMapData(const fs::path &folder_, IJson &json);
        inline void parse(const fs::path &folder_, IJson &json);
        // inline WorldMapData(fs::path folder_, std::string fileName_) : folder {std::move(folder_)}, fileName {fileName_}
        //{
        //     path = folder / fileName;
        // }
 
        fs::path folder;
        fs::path path;
        std::string fileName;
        tson::Vector2i size;
        tson::Vector2i position;
    };
 
    WorldMapData::WorldMapData(const fs::path &folder_, IJson &json)
    {
        parse(folder_, json);
    }
 
    void WorldMapData::parse(const fs::path &folder_, IJson &json)
    {
        folder = folder_;
        if (json.count("fileName") > 0) fileName = json["fileName"].get<std::string>();
        if (json.count("height") > 0) size = {json["width"].get<int>(), json["height"].get<int>()};
        if (json.count("x") > 0) position = {json["x"].get<int>(), json["y"].get<int>()};
 
        path = (!fileName.empty()) ? folder / fileName : folder;
    }
} // namespace tson
 
            #endif // TILESON_WORLDMAPDATA_HPP
 
            #include <memory>
 
namespace tson {
    class Tileson;
 
    class World {
    public:
            #ifdef JSON11_IS_DEFINED
        inline explicit World(std::unique_ptr<tson::IJson> jsonParser = std::make_unique<tson::Json11>()) : m_json {std::move(jsonParser)} {}
 
        inline explicit World(const fs::path &path, std::unique_ptr<tson::IJson> jsonParser = std::make_unique<tson::Json11>());
            #else
        inline explicit World(std::unique_ptr<tson::IJson> jsonParser) : m_json {std::move(jsonParser)} {}
 
        inline explicit World(const fs::path &path, std::unique_ptr<tson::IJson> jsonParser);
            #endif
        inline bool parse(const fs::path &path);
        inline std::size_t loadMaps(tson::Tileson *parser); // tileson_forward.hpp
        inline bool contains(std::string_view filename);
        inline const WorldMapData *get(std::string_view filename) const;
 
        [[nodiscard]]
        inline const fs::path &getPath() const;
        [[nodiscard]]
        inline const fs::path &getFolder() const;
        [[nodiscard]]
        inline const std::vector<WorldMapData> &getMapData() const;
        [[nodiscard]]
        inline bool onlyShowAdjacentMaps() const;
        [[nodiscard]]
        inline const std::string &getType() const;
        [[nodiscard]]
        inline const std::vector<std::unique_ptr<tson::Map>> &getMaps() const;
 
    private:
        inline void parseJson(IJson &json);
 
        std::unique_ptr<IJson> m_json = nullptr;
        fs::path m_path;
        fs::path m_folder;
        std::vector<WorldMapData> m_mapData;
        std::vector<std::unique_ptr<tson::Map>> m_maps;
        bool m_onlyShowAdjacentMaps;
        std::string m_type;
    };
 
    World::World(const fs::path &path, std::unique_ptr<tson::IJson> jsonParser) : m_json {std::move(jsonParser)}
    {
        parse(path);
    }
 
    bool World::parse(const fs::path &path)
    {
        m_path = path;
        m_folder = m_path.parent_path();
 
        if (!m_json->parse(path)) return false;
 
        parseJson(*m_json);
        return true;
    }
 
    const fs::path &World::getPath() const
    {
        return m_path;
    }
 
    const std::vector<WorldMapData> &World::getMapData() const
    {
        return m_mapData;
    }
 
    bool World::onlyShowAdjacentMaps() const
    {
        return m_onlyShowAdjacentMaps;
    }
 
    const std::string &World::getType() const
    {
        return m_type;
    }
 
    void World::parseJson(IJson &json)
    {
        if (json.count("onlyShowAdjacentMaps") > 0) m_onlyShowAdjacentMaps = json["onlyShowAdjacentMaps"].get<bool>();
        if (json.count("type") > 0) m_type = json["type"].get<std::string>();
 
        if (json["maps"].isArray()) {
            auto &maps = json.array("maps");
            std::for_each(maps.begin(), maps.end(), [&](std::unique_ptr<IJson> &item) { m_mapData.emplace_back(m_folder, *item); });
        }
    }
 
    const fs::path &World::getFolder() const
    {
        return m_folder;
    }
 
    bool World::contains(std::string_view filename)
    {
        // Note: might be moved to std::ranges from C++20.
        return std::any_of(m_mapData.begin(), m_mapData.end(), [&](const auto &item) { return item.fileName == filename; });
    }
 
    const WorldMapData *World::get(std::string_view filename) const
    {
        auto iter = std::find_if(m_mapData.begin(), m_mapData.end(), [&](const auto &item) { return item.fileName == filename; });
        return (iter == m_mapData.end()) ? nullptr : iter.operator->();
    }
 
    const std::vector<std::unique_ptr<tson::Map>> &World::getMaps() const
    {
        return m_maps;
    }
 
} // namespace tson
 
        #endif // TILESON_WORLD_HPP
 
 
 
        //
        // Created by robin on 01.08.22.
        //
 
        #ifndef TILESON_PROJECTPROPERTYTYPES_HPP
            #define TILESON_PROJECTPROPERTYTYPES_HPP
 
namespace tson {
    class ProjectPropertyTypes {
    public:
        inline ProjectPropertyTypes() = default;
        inline bool parse(IJson &json, tson::Project *project);
 
        inline const std::vector<tson::EnumDefinition> &getEnums() const;
        inline const std::vector<tson::TiledClass> &getClasses() const;
        [[nodiscard]]
        inline tson::EnumDefinition *getEnumDefinition(std::string_view name);
        [[nodiscard]]
        inline tson::TiledClass *getClass(std::string_view name);
        inline bool isUnhandledContentFound() const;
 
    private:
        std::vector<tson::EnumDefinition> m_enums;
        std::vector<tson::TiledClass> m_classes;
        bool m_unhandledContentFound {false};
    };
 
    bool ProjectPropertyTypes::parse(IJson &json, tson::Project *project)
    {
        m_enums.clear();
        m_classes.clear();
        m_unhandledContentFound = false;
 
        if (json.count("propertyTypes") > 0 && json["propertyTypes"].isArray()) {
            auto &array = json.array("propertyTypes");
            std::vector<tson::IJson *> classes; // Classes must be handled after enums
            std::vector<tson::IJson *> other; // Unhandled stuff - just to keep track if something is missing...
            std::for_each(array.begin(), array.end(), [&](std::unique_ptr<IJson> &item) {
                IJson &j = *item;
                if (j.count("type") > 0) {
                    std::string t = j["type"].get<std::string>();
                    if (t == "enum") {
                        m_enums.emplace_back(j); // Can be resolved directly
                    } else if (t == "class") {
                        classes.push_back(item.get()); // Must be resolved later
                    } else
                        other.push_back(item.get()); // Only used to set flag for whether unhandled content was found.
                }
            });
 
            std::for_each(classes.begin(), classes.end(), [&](IJson *item) { m_classes.emplace_back(*item, project); });
 
            if (!other.empty()) m_unhandledContentFound = true;
        }
        return false;
    }
 
    const std::vector<tson::EnumDefinition> &ProjectPropertyTypes::getEnums() const
    {
        return m_enums;
    }
 
    const std::vector<tson::TiledClass> &ProjectPropertyTypes::getClasses() const
    {
        return m_classes;
    }
 
    bool ProjectPropertyTypes::isUnhandledContentFound() const
    {
        return m_unhandledContentFound;
    }
 
    tson::EnumDefinition *ProjectPropertyTypes::getEnumDefinition(std::string_view name)
    {
        auto it = std::find_if(m_enums.begin(), m_enums.end(), [&](const EnumDefinition &def) { return def.getName() == name; });
 
        if (it != m_enums.end()) return &it.operator*();
 
        return nullptr;
    }
 
    tson::TiledClass *ProjectPropertyTypes::getClass(std::string_view name)
    {
        auto it = std::find_if(m_classes.begin(), m_classes.end(), [&](const TiledClass &def) { return def.getName() == name; });
 
        if (it != m_classes.end()) return &it.operator*();
 
        return nullptr;
    }
} // namespace tson
 
        #endif // TILESON_PROJECTPROPERTYTYPES_HPP
 
 
 
        //
        // Created by robin on 01.08.2020.
        //
 
        #ifndef TILESON_PROJECTFOLDER_HPP
            #define TILESON_PROJECTFOLDER_HPP
 
namespace tson {
    class ProjectFolder {
    public:
        inline ProjectFolder(const fs::path &path);
 
        inline const fs::path &getPath() const;
        inline bool hasWorldFile() const;
        inline const std::vector<ProjectFolder> &getSubFolders() const;
        inline const std::vector<fs::path> &getFiles() const;
        inline const World &getWorld() const;
 
    private:
        inline void loadData();
        fs::path m_path;
        bool m_hasWorldFile;
        tson::World m_world;
        std::vector<ProjectFolder> m_subFolders;
        std::vector<fs::path> m_files;
    };
 
    ProjectFolder::ProjectFolder(const fs::path &path) : m_path {path}
    {
        loadData();
    }
 
    void ProjectFolder::loadData()
    {
        m_hasWorldFile = false;
        m_subFolders.clear();
        m_files.clear();
        // Search and see if there is a World file .world file
        fs::path worldPath;
        for (const auto &entry : fs::directory_iterator(m_path)) {
            if (fs::is_regular_file(entry.path())) {
                if (entry.path().extension() == ".world") {
                    m_hasWorldFile = true;
                    worldPath = entry.path();
                }
            }
        }
 
        if (m_hasWorldFile) m_world.parse(worldPath);
 
        for (const auto &entry : fs::directory_iterator(m_path)) {
            if (fs::is_directory(entry.path()))
                m_subFolders.emplace_back(entry.path()); //.loadData(); - loadData() is called in the constructor, so don't call again.
            else if (fs::is_regular_file(entry.path())) {
                if (m_hasWorldFile && m_world.contains(entry.path().filename().generic_string()))
                    m_files.emplace_back(entry.path());
                else if (!m_hasWorldFile)
                    m_files.emplace_back(entry.path());
            }
        }
    }
 
    const fs::path &ProjectFolder::getPath() const
    {
        return m_path;
    }
 
    bool ProjectFolder::hasWorldFile() const
    {
        return m_hasWorldFile;
    }
 
    const std::vector<ProjectFolder> &ProjectFolder::getSubFolders() const
    {
        return m_subFolders;
    }
 
    const std::vector<fs::path> &ProjectFolder::getFiles() const
    {
        return m_files;
    }
 
    const World &ProjectFolder::getWorld() const
    {
        return m_world;
    }
} // namespace tson
 
        #endif // TILESON_PROJECTFOLDER_HPP
 
 
        //
        // Created by robin on 01.08.2020.
        //
 
        #ifndef TILESON_PROJECTDATA_HPP
            #define TILESON_PROJECTDATA_HPP
 
namespace tson {
    class ProjectData {
    public:
        ProjectData() = default;
        std::string automappingRulesFile;
        std::vector<std::string> commands;
        std::string extensionsPath;
        std::vector<std::string> folders;
        std::string objectTypesFile;
        ProjectPropertyTypes projectPropertyTypes;
 
        // Tileson specific
        fs::path basePath;
        std::vector<tson::ProjectFolder> folderPaths;
    };
} // namespace tson
 
        #endif // TILESON_PROJECTDATA_HPP
 
namespace tson {
    class Project {
    public:
        #ifdef JSON11_IS_DEFINED
        inline explicit Project(std::unique_ptr<tson::IJson> jsonParser = std::make_unique<tson::Json11>()) : m_json {std::move(jsonParser)} {}
 
        inline explicit Project(const fs::path &path, std::unique_ptr<tson::IJson> jsonParser = std::make_unique<tson::Json11>());
        #else
        inline explicit Project(std::unique_ptr<tson::IJson> jsonParser) : m_json {std::move(jsonParser)} {}
 
        inline explicit Project(const fs::path &path, std::unique_ptr<tson::IJson> jsonParser);
        #endif
        inline bool parse(const fs::path &path);
        inline void parse();
 
        [[nodiscard]]
        inline const ProjectData &getData() const;
        [[nodiscard]]
        inline const fs::path &getPath() const;
        [[nodiscard]]
        inline const std::vector<ProjectFolder> &getFolders() const;
        [[nodiscard]]
        inline tson::EnumDefinition *getEnumDefinition(std::string_view name);
        [[nodiscard]]
        inline tson::TiledClass *getClass(std::string_view name);
 
    private:
        inline void parseJson(IJson &json);
        fs::path m_path;
        std::vector<ProjectFolder> m_folders;
        ProjectData m_data;
        std::unique_ptr<IJson> m_json = nullptr;
    };
 
    Project::Project(const fs::path &path, std::unique_ptr<tson::IJson> jsonParser) : m_json {std::move(jsonParser)}
    {
        parse(path);
    }
 
    bool Project::parse(const fs::path &path)
    {
        m_path = path;
        std::ifstream i(m_path.generic_string());
 
        try {
            if (!m_json->parse(path)) return false;
        } catch (const std::exception &error) {
            std::string message = "Parse error: ";
            message += std::string(error.what());
            message += std::string("\n");
            return false;
        }
        parseJson(*m_json);
        return true;
    }
 
    const ProjectData &Project::getData() const
    {
        return m_data;
    }
 
    void Project::parseJson(IJson &json)
    {
        m_data.basePath = (m_path.empty()) ? fs::path() : m_path.parent_path(); // The directory of the project file
 
        // Make sure these property types are read before any map is, so they can be resolved.
        if (json.count("propertyTypes") > 0) {
            m_data.projectPropertyTypes.parse(json, this);
        }
 
        if (json.count("automappingRulesFile") > 0) m_data.automappingRulesFile = json["automappingRulesFile"].get<std::string>();
        if (json.count("commands") > 0) {
            m_data.commands.clear();
            auto &commands = json.array("commands");
            std::for_each(commands.begin(), commands.end(), [&](std::unique_ptr<IJson> &item) { m_data.commands.emplace_back(item->get<std::string>()); });
        }
        if (json.count("extensionsPath") > 0) m_data.extensionsPath = json["extensionsPath"].get<std::string>();
        if (json.count("folders") > 0) {
            m_data.folders.clear();
            m_data.folderPaths.clear();
            auto &folders = json.array("folders");
            std::for_each(folders.begin(), folders.end(), [&](std::unique_ptr<IJson> &item) {
                std::string folder = item->get<std::string>();
                m_data.folders.emplace_back(folder);
                m_data.folderPaths.emplace_back(m_data.basePath / folder);
                m_folders.emplace_back(m_data.basePath / folder);
            });
        }
        if (json.count("objectTypesFile") > 0) m_data.objectTypesFile = json["objectTypesFile"].get<std::string>();
    }
 
    const fs::path &Project::getPath() const
    {
        return m_path;
    }
 
    const std::vector<ProjectFolder> &Project::getFolders() const
    {
        return m_folders;
    }
 
    tson::EnumDefinition *Project::getEnumDefinition(std::string_view name)
    {
        return m_data.projectPropertyTypes.getEnumDefinition(name);
    }
 
    tson::TiledClass *Project::getClass(std::string_view name)
    {
        return m_data.projectPropertyTypes.getClass(name);
    }
 
    void Project::parse()
    {
        parseJson(*m_json);
    }
 
} // namespace tson
 
    #endif // TILESON_PROJECT_HPP
 
 
namespace tson {
    class Tileson {
    public:
    #ifdef JSON11_IS_DEFINED
        inline explicit Tileson(std::unique_ptr<tson::IJson> jsonParser = std::make_unique<tson::Json11>(), bool includeBase64Decoder = true);
        inline explicit Tileson(
            tson::Project *project, std::unique_ptr<tson::IJson> jsonParser = std::make_unique<tson::Json11>(), bool includeBase64Decoder = true);
    #else
        inline explicit Tileson(std::unique_ptr<tson::IJson> jsonParser, bool includeBase64Decoder = true);
        inline explicit Tileson(tson::Project *project, std::unique_ptr<tson::IJson> jsonParser, bool includeBase64Decoder = true);
    #endif
 
        inline std::unique_ptr<tson::Map> parse(
            const fs::path &path, std::unique_ptr<IDecompressor<std::vector<uint8_t>, std::vector<uint8_t>>> decompressor = nullptr);
        inline std::unique_ptr<tson::Map> parse(
            const void *data, size_t size, std::unique_ptr<IDecompressor<std::vector<uint8_t>, std::vector<uint8_t>>> decompressor = nullptr);
        inline tson::DecompressorContainer *decompressors();
 
    private:
        inline std::unique_ptr<tson::Map> parseJson();
        std::unique_ptr<tson::IJson> m_json;
        tson::DecompressorContainer m_decompressors;
        tson::Project *m_project {nullptr};
    };
} // namespace tson
 
tson::Tileson::Tileson(std::unique_ptr<tson::IJson> jsonParser, bool includeBase64Decoder) : m_json {std::move(jsonParser)}
{
    if (includeBase64Decoder) m_decompressors.add<Base64Decompressor>();
}
 
tson::Tileson::Tileson(tson::Project *project, std::unique_ptr<tson::IJson> jsonParser, bool includeBase64Decoder) : m_json {std::move(jsonParser)}
{
    m_project = project;
    if (includeBase64Decoder) m_decompressors.add<Base64Decompressor>();
}
 
std::unique_ptr<tson::Map> tson::Tileson::parse(const fs::path &path, std::unique_ptr<IDecompressor<std::vector<uint8_t>, std::vector<uint8_t>>> decompressor)
{
    bool result = false;
 
    if (decompressor != nullptr) {
        std::vector<uint8_t> decompressed = decompressor->decompressFile(path);
        result = (decompressed.empty()) ? false : true;
        if (!result) return std::make_unique<tson::Map>(tson::ParseStatus::DecompressionError, "Error during decompression");
 
        result = m_json->parse(&decompressed[0], decompressed.size());
 
        if (result) return parseJson();
    } else if (m_json->parse(path)) {
        return parseJson();
    }
 
    std::string msg = "File not found: ";
    msg += std::string(path.generic_string());
    return std::make_unique<tson::Map>(tson::ParseStatus::FileNotFound, msg);
}
 
std::unique_ptr<tson::Map> tson::Tileson::parse(
    const void *data, size_t size, std::unique_ptr<IDecompressor<std::vector<uint8_t>, std::vector<uint8_t>>> decompressor)
{
    bool result = false;
 
    if (decompressor != nullptr) {
        std::vector<uint8_t> decompressed = decompressor->decompress(data, size);
        result = (decompressed.empty()) ? false : true;
        if (!result) return std::make_unique<tson::Map>(tson::ParseStatus::DecompressionError, "Error during decompression");
        result = m_json->parse(&decompressed[0], decompressed.size());
    } else
        result = m_json->parse(data, size);
 
    if (!result) return std::make_unique<tson::Map>(tson::ParseStatus::ParseError, "Memory error");
 
    return parseJson();
}
 
std::unique_ptr<tson::Map> tson::Tileson::parseJson()
{
    std::unique_ptr<tson::Map> map = std::make_unique<tson::Map>();
 
    if (map->parse(*m_json, &m_decompressors, m_project)) return map;
 
    return std::make_unique<tson::Map>(tson::ParseStatus::MissingData, "Missing map data...");
}
 
tson::DecompressorContainer *tson::Tileson::decompressors()
{
    return &m_decompressors;
}
 
#endif // TILESON_TILESON_PARSER_HPP
 
 
 
//
// Created by robin on 25.07.2020.
//
 
#ifndef TILESON_TILESON_FORWARD_HPP
    #define TILESON_TILESON_FORWARD_HPP
 
// M a p . h p p
// ----------------
 
tson::TiledClass *tson::Map::getClass()
{
    if (m_class == nullptr) {
        TiledClass *baseClass = (m_project != nullptr) ? m_project->getClass(m_classType) : nullptr;
        if (baseClass != nullptr) {
            m_class = std::make_shared<TiledClass>(*baseClass);
            m_class->update(m_properties);
        }
    }
    return (m_class != nullptr) ? m_class.get() : nullptr;
}
 
// T i l e . h p p
// ---------------------
 
const tson::Vector2i tson::Tile::getTileSize() const
{
    if (m_map != nullptr)
        return m_map->getTileSize();
    else
        return {0, 0};
}
 
bool tson::Tile::parseId(IJson &json)
{
    if (json.count("id") > 0) {
        m_id = json["id"].get<uint32_t>() + 1;
        if (m_tileset != nullptr)
            m_gid = m_tileset->getFirstgid() + m_id - 1;
        else
            m_gid = m_id;
        manageFlipFlagsByIdThenRemoveFlags(m_gid);
        return true;
    }
    return false;
}
 
void tson::Tile::performDataCalculations()
{
    if (m_tileset == nullptr || m_map == nullptr) return;
 
    int firstId = m_tileset->getFirstgid(); // First tile id of the tileset
    int columns = m_tileset->getColumns();
    int rows = m_tileset->getTileCount() / columns;
    int lastId = (m_tileset->getFirstgid() + m_tileset->getTileCount()) - 1;
 
    int const gid = static_cast<int>(getGid());
    if (gid >= firstId && gid <= lastId) {
        int const baseTilePosition = (gid - firstId);
 
        int const tileModX = (baseTilePosition % columns);
        int const currentRow = (baseTilePosition / columns);
        int const offsetX = (tileModX != 0) ? ((tileModX) *m_map->getTileSize().x) : (0 * m_map->getTileSize().x);
        int const offsetY = (currentRow < rows - 1) ? (currentRow * m_map->getTileSize().y) : ((rows - 1) * m_map->getTileSize().y);
 
        tson::Vector2i spacing = m_tileset->getMarginSpacingOffset({tileModX, currentRow});
        m_drawingRect = {offsetX + spacing.x, offsetY + spacing.y, m_map->getTileSize().x, m_map->getTileSize().y};
    } else
        m_drawingRect = {0, 0, 0, 0};
}
 
const tson::Vector2f tson::Tile::getPosition(const std::tuple<int, int> &tileDataPos)
{
    return {((float) std::get<0>(tileDataPos)) * m_drawingRect.width, ((float) std::get<1>(tileDataPos)) * m_drawingRect.height};
}
 
tson::TiledClass *tson::Tile::getClass()
{
    if (m_class == nullptr) {
        TiledClass *baseClass = (m_map != nullptr && m_map->getProject() != nullptr) ? m_map->getProject()->getClass(m_type) : nullptr;
        if (baseClass != nullptr) {
            m_class = std::make_shared<TiledClass>(*baseClass);
            m_class->update(m_properties);
        }
    }
    return (m_class != nullptr) ? m_class.get() : nullptr;
}
 
// T i l e s e t . h p p
// ------------------------
 
tson::TiledClass *tson::Tileset::getClass()
{
    if (m_class == nullptr) {
        TiledClass *baseClass = (m_map != nullptr && m_map->getProject() != nullptr) ? m_map->getProject()->getClass(m_classType) : nullptr;
        if (baseClass != nullptr) {
            m_class = std::make_shared<TiledClass>(*baseClass);
            m_class->update(m_properties);
        }
    }
    return (m_class != nullptr) ? m_class.get() : nullptr;
}
 
// T i l e O b j e c t . h p p
// ---------------------
 
void tson::TileObject::initialize(const std::tuple<int, int> &posInTileUnits, tson::Tile *tile)
{
    m_tile = tile;
    m_posInTileUnits = tile->getPositionInTileUnits(posInTileUnits);
    m_position = tile->getPosition(posInTileUnits);
}
 
const tson::Rect &tson::TileObject::getDrawingRect() const
{
    return m_tile->getDrawingRect();
}
 
// L a y e r . h p p
// -------------------
 
void tson::Layer::decompressData()
{
    tson::DecompressorContainer *container = m_map->getDecompressors();
    if (container->empty()) return;
 
    if (m_encoding.empty() && m_compression.empty()) return;
 
    std::string data = m_base64Data;
    bool hasBeenDecoded = false;
    if (!m_encoding.empty() && container->contains(m_encoding)) {
        data = container->get(m_encoding)->decompress(data);
        hasBeenDecoded = true;
    }
 
    if (!m_compression.empty() && container->contains(m_compression)) {
        data = container->get(m_compression)->decompress(data);
    }
 
    if (hasBeenDecoded) {
        std::vector<uint8_t> bytes = tson::Tools::Base64DecodedStringToBytes(data);
        m_data = tson::Tools::BytesToUnsignedInts(bytes);
    }
}
 
bool tson::Layer::parse(IJson &json, tson::Map *map)
{
    m_map = map;
 
    bool allFound = true;
    if (json.count("tintcolor") > 0) m_tintColor = tson::Colori(json["tintcolor"].get<std::string>()); // Optional
    if (json.count("compression") > 0) m_compression = json["compression"].get<std::string>(); // Optional
    if (json.count("draworder") > 0) m_drawOrder = json["draworder"].get<std::string>(); // Optional
    if (json.count("encoding") > 0) m_encoding = json["encoding"].get<std::string>(); // Optional
    if (json.count("id") > 0) m_id = json["id"].get<int>(); // Optional
    if (json.count("image") > 0) m_image = json["image"].get<std::string>(); // Optional
    if (json.count("name") > 0)
        m_name = json["name"].get<std::string>();
    else
        allFound = false;
    if (json.count("offsetx") > 0 && json.count("offsety") > 0) m_offset = {json["offsetx"].get<float>(), json["offsety"].get<float>()}; // Optional
    if (json.count("opacity") > 0)
        m_opacity = json["opacity"].get<float>();
    else
        allFound = false;
    if (json.count("width") > 0 && json.count("height") > 0)
        m_size = {json["width"].get<int>(), json["height"].get<int>()}; // else allFound = false; - Not mandatory for all layers!
    if (json.count("transparentcolor") > 0) m_transparentColor = tson::Colori(json["transparentcolor"].get<std::string>()); // Optional
    if (json.count("type") > 0)
        m_typeStr = json["type"].get<std::string>();
    else
        allFound = false;
    if (json.count("class") > 0) m_classType = json["class"].get<std::string>(); // Optional
    if (json.count("visible") > 0)
        m_visible = json["visible"].get<bool>();
    else
        allFound = false;
    if (json.count("x") > 0)
        m_x = json["x"].get<int>();
    else
        allFound = false;
    if (json.count("y") > 0)
        m_y = json["y"].get<int>();
    else
        allFound = false;
    if (json.count("repeatx") > 0) m_repeatX = json["repeatx"].get<bool>(); // Optional
    if (json.count("repeaty") > 0) m_repeatY = json["repeaty"].get<bool>(); // Optional
 
    tson::Vector2f parallax {1.f, 1.f};
    if (json.count("parallaxx") > 0) parallax.x = json["parallaxx"].get<float>();
    if (json.count("parallaxy") > 0) parallax.y = json["parallaxy"].get<float>();
 
    m_parallax = parallax;
 
    // Handle DATA (Optional)
    if (json.count("data") > 0) {
        if (json["data"].isArray()) {
            auto &array = json.array("data");
            std::for_each(array.begin(), array.end(), [&](std::unique_ptr<IJson> &item) { m_data.push_back(item->get<uint32_t>()); });
        } else {
            m_base64Data = json["data"].get<std::string>();
            decompressData();
        }
    }
 
    // More advanced data
    if (json.count("chunks") > 0 && json["chunks"].isArray()) {
        auto &chunks = json.array("chunks");
        std::for_each(chunks.begin(), chunks.end(), [&](std::unique_ptr<IJson> &item) { m_chunks.emplace_back(*item); });
    }
    if (json.count("layers") > 0 && json["layers"].isArray()) {
        auto &layers = json.array("layers");
        std::for_each(layers.begin(), layers.end(), [&](std::unique_ptr<IJson> &item) { m_layers.emplace_back(*item, m_map); });
    }
    if (json.count("objects") > 0 && json["objects"].isArray()) {
        auto &objects = json.array("objects");
        std::for_each(objects.begin(), objects.end(), [&](std::unique_ptr<IJson> &item) { m_objects.emplace_back(*item, m_map); });
    }
    if (json.count("properties") > 0 && json["properties"].isArray()) {
        auto &properties = json.array("properties");
        tson::Project *project = (m_map != nullptr) ? m_map->getProject() : nullptr;
        std::for_each(properties.begin(), properties.end(), [&](std::unique_ptr<IJson> &item) { m_properties.add(*item, project); });
    }
 
    setTypeByString();
 
    return allFound;
}
 
tson::TiledClass *tson::Layer::getClass()
{
    if (m_class == nullptr) {
        TiledClass *baseClass = (m_map != nullptr && m_map->getProject() != nullptr) ? m_map->getProject()->getClass(m_classType) : nullptr;
        if (baseClass != nullptr) {
            m_class = std::make_shared<TiledClass>(*baseClass);
            m_class->update(m_properties);
        }
    }
    return (m_class != nullptr) ? m_class.get() : nullptr;
}
 
// O b j e c t . h p p
// --------------------
 
// W a n g s e t . h p p
// ----------------------
tson::TiledClass *tson::WangSet::getClass()
{
    if (m_class == nullptr) {
        TiledClass *baseClass = (m_map != nullptr && m_map->getProject() != nullptr) ? m_map->getProject()->getClass(m_classType) : nullptr;
        if (baseClass != nullptr) {
            m_class = std::make_shared<TiledClass>(*baseClass);
            m_class->update(m_properties);
        }
    }
    return (m_class != nullptr) ? m_class.get() : nullptr;
}
 
// W a n g c o l o r . h p p
// ----------------------
tson::TiledClass *tson::WangColor::getClass()
{
    if (m_class == nullptr) {
        TiledClass *baseClass = (m_map != nullptr && m_map->getProject() != nullptr) ? m_map->getProject()->getClass(m_classType) : nullptr;
        if (baseClass != nullptr) {
            m_class = std::make_shared<TiledClass>(*baseClass);
            m_class->update(m_properties);
        }
    }
    return (m_class != nullptr) ? m_class.get() : nullptr;
}
 
tson::TiledClass *tson::Object::getClass()
{
    if (m_class == nullptr) {
        TiledClass *baseClass = (m_map != nullptr && m_map->getProject() != nullptr) ? m_map->getProject()->getClass(m_type) : nullptr;
        if (baseClass != nullptr) {
            m_class = std::make_shared<TiledClass>(*baseClass);
            m_class->update(m_properties);
        }
    }
    return (m_class != nullptr) ? m_class.get() : nullptr;
}
 
// W o r l d . h p p
// ------------------
 
std::size_t tson::World::loadMaps(tson::Tileson *parser)
{
    m_maps.clear();
    std::for_each(m_mapData.begin(), m_mapData.end(), [&](const tson::WorldMapData &data) {
        if (fs::exists(data.path)) {
            std::unique_ptr<tson::Map> map = parser->parse(data.path);
            m_maps.push_back(std::move(map));
        }
    });
 
    return m_maps.size();
}
 
// P r o p e r t y . h p p
// ------------------
void tson::Property::setValueByType(IJson &json)
{
    switch (m_type) {
        case Type::Color: m_value = Colori(json.get<std::string>()); break;
 
        case Type::File: m_value = fs::path(json.get<std::string>()); break;
 
        case Type::Int:
            if (!m_propertyType.empty()) {
                m_type = Type::Enum;
                tson::EnumDefinition *def = (m_project != nullptr) ? m_project->getEnumDefinition(m_propertyType) : nullptr;
                if (def != nullptr) {
                    uint32_t v = json.get<uint32_t>();
                    m_value = tson::EnumValue(v, def);
                } else
                    m_value = tson::EnumValue();
            } else
                m_value = json.get<int>();
 
            break;
 
        case Type::Boolean: m_value = json.get<bool>(); break;
 
        case Type::Float: m_value = json.get<float>(); break;
 
        case Type::String:
            if (!m_propertyType.empty()) {
                m_type = Type::Enum;
                tson::EnumDefinition *def = (m_project != nullptr) ? m_project->getEnumDefinition(m_propertyType) : nullptr;
                if (def != nullptr) {
                    std::string v = json.get<std::string>();
                    m_value = tson::EnumValue(v, def);
                } else
                    m_value = tson::EnumValue();
            } else
                setStrValue(json.get<std::string>());
 
            break;
 
        case Type::Class: {
            tson::TiledClass *baseClass = (m_project != nullptr) ? m_project->getClass(m_propertyType) : nullptr;
            if (baseClass != nullptr) {
                tson::TiledClass c = *baseClass;
                c.update(json);
                m_value = c;
            }
        } break;
 
        case Type::Object: m_value = json.get<uint32_t>(); break;
        default: setStrValue(json.get<std::string>()); break;
    }
}
 
#endif // TILESON_TILESON_FORWARD_HPP
 
 
#endif // TILESON_TILESON_H