BaseTypes.h

/*
 * Copyright (C) 2025, Robert Patterson
 *
 * 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 <memory>
#include <unordered_map>
#include <cassert>
#include <iostream>
#include <optional>
#include <string>
#include <string_view>
#include <type_traits>
#include <utility>
 
// mnxdom provides enum (de)serialization; disable nlohmann's generic enum support.
#if defined(NLOHMANN_JSON_HPP) && !defined(JSON_DISABLE_ENUM_SERIALIZATION)
#error "nlohmann/json.hpp included before mnxdom without JSON_DISABLE_ENUM_SERIALIZATION=1"
#endif
 
#ifndef JSON_DISABLE_ENUM_SERIALIZATION
#define JSON_DISABLE_ENUM_SERIALIZATION 1
#endif
 
#ifdef NLOHMANN_JSON_SYSTEM
#include <nlohmann/json.hpp>
#else
#include "nlohmann/json.hpp"
#endif
#include "BoilerplateMacros.h"
 
namespace mnx {
 
[[nodiscard]] const std::string& getMnxSchemaId();
 
[[nodiscard]] int getMnxSchemaVersion();
 
inline const int MNX_VERSION = getMnxSchemaVersion();
 
using json = nlohmann::json;                
using json_pointer = json::json_pointer;    
 
class Object;
class Document;
class Base;
template <typename T> class Array;
template <typename T> class Dictionary;
 
namespace sequence {
class Event;
class Space;
class MultiNoteTremolo;
class Tuplet;
} // namespace sequence
 
namespace validation {
class SemanticValidator;
}; // namespace validation
 
#ifndef DOXYGEN_SHOULD_IGNOR_THIS
 
namespace scope {
struct Default {};
struct SequenceContent {};
struct LayoutContent {};
} // namespace scope
 
#endif
 
namespace detail {
 
template <typename T, auto MakeFunc>
struct ArrayAppendFromMake;
 
template <typename T, typename R, typename... Args, R(*MakeFunc)(Args...)>
struct ArrayAppendFromMake<T, MakeFunc>
{
    T append(Args... args)
    {
        return static_cast<Array<T>&>(*this).template appendImpl<T>(std::forward<Args>(args)...);
    }
};
 
template <typename Derived, typename T>
struct ArrayAppendBase
{
    template <typename U = T, typename... Args,
              std::enable_if_t<std::is_base_of_v<Base, U>, int> = 0>
    U append(Args&&... args)
    {
        return static_cast<Derived&>(*this).template appendImpl<U>(std::forward<Args>(args)...);
    }
};
 
template <typename Derived, typename T, typename = void>
struct ArrayAppendOverloads : ArrayAppendBase<Derived, T> {};
 
template <typename Derived, typename T>
struct ArrayAppendOverloads<Derived, T, std::void_t<decltype(&T::make)>>
    : ArrayAppendBase<Derived, T>,
      ArrayAppendFromMake<T, &T::make>
{
    using ArrayAppendBase<Derived, T>::append;
    using ArrayAppendFromMake<T, &T::make>::append;
};
 
template <typename T, auto MakeFunc>
struct DictionaryAppendFromMake;
 
template <typename T, typename R, typename... Args, R(*MakeFunc)(Args...)>
struct DictionaryAppendFromMake<T, MakeFunc>
{
    T append(std::string_view key, Args... args)
    {
        return static_cast<Dictionary<T>&>(*this).template appendImpl<T>(key, std::forward<Args>(args)...);
    }
};
 
template <typename Derived, typename T>
struct DictionaryAppendBase
{
    template <typename U = T, typename... Args,
              std::enable_if_t<std::is_base_of_v<Base, U>, int> = 0>
    U append(std::string_view key, Args&&... args)
    {
        return static_cast<Derived&>(*this).template appendImpl<U>(key, std::forward<Args>(args)...);
    }
};
 
template <typename Derived, typename T, typename = void>
struct DictionaryAppendOverloads : DictionaryAppendBase<Derived, T> {};
 
template <typename Derived, typename T>
struct DictionaryAppendOverloads<Derived, T, std::void_t<decltype(&T::make)>>
    : DictionaryAppendBase<Derived, T>,
      DictionaryAppendFromMake<T, &T::make>
{
    using DictionaryAppendBase<Derived, T>::append;
    using DictionaryAppendFromMake<T, &T::make>::append;
};
 
} // namespace detail
 
 
class Base
{
public:
    virtual ~Base() = default;
 
    Base(const Base& src) : m_root(src.m_root), m_pointer(src.m_pointer)
    {}
 
    Base(Base&& src) noexcept : m_root(src.m_root),    // m_root must be copied (not moved)
        m_pointer(std::move(src.m_pointer))
    {}
 
    Base& operator=(const Base& src)
    {
        if (this != &src) {
            if (m_root != src.m_root) {
                throw std::logic_error("Assignment from a different JSON document is not allowed.");
            }
            m_pointer = src.m_pointer;
        }
        return *this;
    }
 
    Base& operator=(Base&& src)
    {
        if (this != &src) {
            if (m_root != src.m_root) {
                throw std::logic_error("Assignment from a different JSON document is not allowed.");
            }
            m_pointer = std::move(src.m_pointer);
        }
        return *this;
    }
 
    [[nodiscard]] std::string dump(int indents = -1) const
    {
        return ref().dump(indents);
    }
 
    template <typename T>
    [[nodiscard]] T parent() const
    {
        static_assert(std::is_base_of_v<Base, T>, "Template type mush be derived from Base.");
        return T(m_root, m_pointer.parent_pointer());
    }
 
    template <typename T, typename Scope = scope::Default>
    [[nodiscard]] std::optional<T> getEnclosingElement() const;
 
    [[nodiscard]] json_pointer pointer() const { return m_pointer; }
 
    [[nodiscard]] Document document() const;
 
protected:
    [[nodiscard]] json& ref() const { return resolve_pointer(); }
 
    [[nodiscard]] json& ref() { return resolve_pointer(); }
 
    [[nodiscard]] const std::shared_ptr<json>& root() const { return m_root; }
 
    Base(const std::shared_ptr<json>& root, json_pointer pointer)
        : m_root(root), m_pointer(std::move(pointer)) {}
 
    Base(json&& jsonRef, Base& parent, std::string_view key)
        : m_root(parent.m_root), m_pointer(parent.m_pointer / std::string(key))
    {
        (*m_root)[m_pointer] = std::move(jsonRef);
    }
 
    template <typename T>
    [[nodiscard]] T getChild(std::string_view key) const
    {
        static_assert(std::is_base_of_v<Base, T>, "template type must be derived from Base");
 
        json_pointer childPointer = m_pointer / std::string(key);
        if (!checkKeyIsValid<T>(childPointer)) {
            throw std::out_of_range("Child node not found: " + std::string(key));
        }
 
        return T(m_root, childPointer);
    }
 
    template <typename T>
    T setChild(std::string_view key, const T& value)
    {
        static_assert(std::is_base_of_v<Base, T>, "template type must be derived from Base");
 
        json_pointer childPointer = m_pointer / std::string(key);
        (*m_root)[childPointer] = value.ref();
        return T(m_root, childPointer);
    }
 
    template <typename T>
    [[nodiscard]] std::optional<T> getOptionalChild(std::string_view key) const
    {
        static_assert(std::is_base_of_v<Base, T>, "template type must be derived from Base");
 
        json_pointer childPointer = m_pointer / std::string(key);
        if (!checkKeyIsValid<T>(childPointer)) {
            return std::nullopt;
        }
 
        return T(m_root, childPointer);
    }
 
private:
    template <typename T>
    [[nodiscard]] bool checkKeyIsValid(const json_pointer& pointer) const
    {
        if (!(*m_root).contains(pointer)) {
            return false;
        }
 
        const json& node = (*m_root).at(pointer);
 
        if constexpr (std::is_base_of_v<Object, T>) {
            if (!node.is_object()) {
                throw std::runtime_error("Expected an object for: " + pointer.to_string());
            }
        } else if constexpr (std::is_base_of_v<Array<typename T::value_type>, T>) {
            if (!node.is_array()) {
                throw std::runtime_error("Expected an array for: " + pointer.to_string());
            }
        }
 
        return true;
    }
 
    [[nodiscard]] json& resolve_pointer() const
    {
        return (*m_root).at(m_pointer);  // Throws if invalid
    }
 
    const std::shared_ptr<json> m_root;  
    json_pointer m_pointer;          
 
    friend class validation::SemanticValidator;
};
 
using ErrorHandler = std::function<void(const std::string& message, const Base& location)>;
 
class Object : public Base
{
public:
    Object(const std::shared_ptr<json>& root, json_pointer pointer) : Base(root, pointer)
    {
        if (!ref().is_object()) {
            throw std::invalid_argument("mnx::Object must wrap a JSON object.");
        }
    }
 
    Object(Base& parent, std::string_view key)
        : Base(json::object(), parent, key) {}
 
    MNX_OPTIONAL_PROPERTY(std::string, _c);     
    MNX_OPTIONAL_CHILD(Object, _x);             
    MNX_OPTIONAL_PROPERTY(std::string, id);     
 
    void setExtension(const std::string& key, const json& value)
    {
        auto extensions = ensure__x();
        extensions.ref()[key] = value;
    }
 
    [[nodiscard]] std::optional<json> getExtension(const std::string& key) const
    {
        if (auto extensions = _x()) {
            const auto it = extensions->ref().find(key);
            if (it != extensions->ref().end()) {
                return *it;
            }
        }
        return std::nullopt;
    }
};
 
template <typename T, std::enable_if_t<!std::is_base_of_v<Base, T>, int> = 0>
class SimpleType : public Base
{
    static_assert(std::is_arithmetic_v<T> || std::is_same_v<T, std::string>, "This template is for simple JSON classes");
 
public:
    using value_type = T; 
 
    SimpleType(const std::shared_ptr<json>& root, json_pointer pointer) : Base(root, pointer)
    {
    }
 
    operator T() const
    {
        return ref().template get<T>();
    }
 
    SimpleType& operator=(const T& src)
    {
        ref() = src;
        return *this;
    }
 
    bool operator==(const T& src) const
    {
        return src == ref().template get<T>();
    }
};
 
class ArrayElementObject;
template <typename T>
class Array : public Base,
              public detail::ArrayAppendOverloads<Array<T>, T>
{
    static_assert(std::is_arithmetic_v<T> || std::is_same_v<T, std::string> ||
                  std::is_base_of_v<ArrayElementObject, T>, "Invalid MNX array element type.");
 
private:    
    template<typename ArrayType>
    struct iter
    {
    private:
        ArrayType* m_ptr;
        mutable size_t m_idx;
 
    public:
        using iterator_category = std::input_iterator_tag;
        using value_type        = T;
        using difference_type   = std::ptrdiff_t;
        using pointer           = void; // not meaningful for proxy/value-returning iterators
        using reference         = T;    // since operator* returns by value
 
        iter(ArrayType* ptr, size_t idx) : m_ptr(ptr), m_idx(idx) {}
        T operator*() const { return (*m_ptr)[m_idx]; }
        iter& operator++() { ++m_idx; return *this; }
        bool operator!=(const iter& o) const { return m_idx != o.m_idx; }
    };
 
public:
    using value_type = T;
 
    using iterator = iter<Array>;               
    using const_iterator = iter<const Array>;   
 
    Array(const std::shared_ptr<json>& root, json_pointer pointer) : Base(root, pointer)
    {
        if (!ref().is_array()) {
            throw std::invalid_argument("mnx::Array must wrap a JSON array.");
        }
    }
 
    Array(Base& parent, std::string_view key)
        : Base(json::array(), parent, key) {}
 
    [[nodiscard]] size_t size() const { return ref().size(); }
 
    [[nodiscard]] bool empty() const { return ref().empty(); }
 
    void clear() { ref().clear(); }
 
    [[nodiscard]] T at(size_t index) const
    {
        return operator[](index);
    }
 
    [[nodiscard]] T front() const { return (*this)[0]; }
 
    [[nodiscard]] T back() const { return (*this)[size() - 1]; }
    
    [[nodiscard]] auto operator[](size_t index) const
    {
        checkIndex(index);
        if constexpr (std::is_base_of_v<Base, T>) {
            return getChild<T>(std::to_string(index));
        } else {
            return getChild<SimpleType<T>>(std::to_string(index));
        }
    }
 
    [[nodiscard]] auto operator[](size_t index)
    {
        checkIndex(index);
        if constexpr (std::is_base_of_v<Base, T>) {
            return getChild<T>(std::to_string(index));
        } else {
            return getChild<SimpleType<T>>(std::to_string(index));
        }
    }
 
    template <typename U = T>
    std::enable_if_t<!std::is_base_of_v<Base, U>, void>
    push_back(const U& value)
    {
        ref().push_back(value);
    }
 
    void erase(size_t index)
    {
        checkIndex(index);
        ref().erase(ref().begin() + index);
    }
 
    template <typename U = T>
    std::enable_if_t<!std::is_base_of_v<Base, U>, std::vector<U>>
    toStdVector() const
    { return std::vector<U>(begin(), end()); }
 
    [[nodiscard]] auto begin() { return iterator(this, 0); }
 
    [[nodiscard]] auto end() { return iterator(this, size()); }
 
    [[nodiscard]] auto begin() const { return const_iterator(this, 0); }
 
    [[nodiscard]] auto end() const { return const_iterator(this, size()); }
 
protected:
    void checkIndex(size_t index) const
    {
        assert(index < ref().size());
        if (index >= ref().size()) {
            throw std::out_of_range("Index out of range");
        }
    }
 
private:
    template <typename U, typename... Args>
    U appendImpl(Args&&... args)
    {
        static_assert(std::is_base_of_v<Base, U>, "Array::appendImpl requires a Base-derived element type.");
        if constexpr (std::is_base_of_v<Object, U>) {
            ref().push_back(json::object());
        } else {
            ref().push_back(json::array());
        }
        return U(*this, std::to_string(ref().size() - 1), std::forward<Args>(args)...);
    }
 
    template <typename, auto>
    friend struct detail::ArrayAppendFromMake;
    template <typename, typename>
    friend struct detail::ArrayAppendBase;
};
 
class ArrayElementObject : public Object
{
public:
    using Object::Object;
 
    size_t calcArrayIndex() const
    {
        return std::stoul(pointer().back());
    }
 
    template <typename ContainerType>
    ContainerType container() const;
};
 
class ContentArray;
class ContentObject : public ArrayElementObject
{
protected:
    static constexpr std::string_view ContentTypeValueDefault = "event"; 
 
public:
    using ArrayElementObject::ArrayElementObject;
 
    MNX_OPTIONAL_PROPERTY_WITH_DEFAULT(std::string, type, std::string(ContentTypeValueDefault));   
 
    template <typename T, std::enable_if_t<std::is_base_of_v<ContentObject, T>, int> = 0>
    [[nodiscard]] T get() const
    {
        return getTypedObject<T>();
    }
 
    template <typename T, std::enable_if_t<std::is_base_of_v<ContentObject, T>, int> = 0>
    [[nodiscard]] T getTypedObject() const
    {
        if (type() != T::ContentTypeValue) {
            throw std::invalid_argument("Type mismatch: expected " + std::string(T::ContentTypeValue) +
                                        ", got " + type());
        }
        return T(root(), pointer());
    }
 
    friend class ContentArray;
};
 
template <typename ContainerType>
inline ContainerType ArrayElementObject::container() const
{
    if constexpr (std::is_base_of_v<ContainerType, ContentObject>) {
        const auto obj = parent<Array<ArrayElementObject>>().template parent<ContentObject>();
        if constexpr (std::is_same_v<ContainerType, ContentObject>) {
            return obj;
        } else {
            MNX_ASSERT_IF(obj.type() != ContainerType::ContentTypeValue) {
                throw std::invalid_argument(
                    "container(): requested type does not match underlying content object type");
            }
            return obj.template get<ContainerType>();
        }
    } else {
        return parent<Array<ArrayElementObject>>().template parent<ContainerType>();
    }
}
 
class ContentArray : public Array<ContentObject>
{
public:
    using BaseArray = Array<ContentObject>;     
    using BaseArray::BaseArray;  // Inherit constructors
 
    template <typename T, std::enable_if_t<std::is_base_of_v<ContentObject, T>, int> = 0>
    [[nodiscard]] T get(size_t index) const
    {
        this->checkIndex(index);
        return operator[](index).get<T>();
    }
 
    template <typename T,
              std::enable_if_t<std::is_base_of_v<ContentObject, T> &&
                               !std::is_same_v<T, sequence::Event> &&
                               !std::is_same_v<T, sequence::Space> &&
                               !std::is_same_v<T, sequence::MultiNoteTremolo> &&
                               !std::is_same_v<T, sequence::Tuplet>, int> = 0>
    T append()
    {
        return appendWithType<T>();
    }
 
    template <typename T, typename... Args,
              std::enable_if_t<std::is_base_of_v<ContentObject, T> && (sizeof...(Args) > 0), int> = 0>
    T append(const Args&... args)
    {
        static_assert(!std::is_same_v<T, T>,
                      "ContentArray::append requires explicit specialization for each content type.");
        return appendWithType<T>(args...);
    }
 
    // Prevent untemplated append() calls; callers must use append<T>(...).
    ContentObject append(...) = delete;
 
private:
    template <typename T, typename... Args>
    T appendWithType(Args&&... args)
    {
        auto result = BaseArray::append<T>(std::forward<Args>(args)...);
        if constexpr (T::ContentTypeValue != ContentObject::ContentTypeValueDefault) {
            result.set_type(std::string(T::ContentTypeValue));
        }
        return result;
    }
 
    template <typename T, std::enable_if_t<std::is_base_of_v<ContentObject, T>, int> = 0>
    [[nodiscard]] T getTypedObject(size_t index) const
    {
        this->checkIndex(index);
        auto element = (*this)[index];
        if (element.type() != T::ContentTypeValue) {
            throw std::invalid_argument("Type mismatch: expected " + std::string(T::ContentTypeValue) +
                                        ", got " + element.type());
        }
        return T(root(), pointer() / std::to_string(index));
    }
};
 
template <typename E, typename = std::enable_if_t<std::is_enum_v<E>>>
struct EnumStringMapping
{
    static const std::unordered_map<std::string, E> stringToEnum();     
 
    static const std::unordered_map<E, std::string> enumToString()
    {
        static const std::unordered_map<E, std::string> reverseMap = []() {
            std::unordered_map<E, std::string> result;
            for (const auto& element : EnumStringMapping<E>::stringToEnum()) {
                result.emplace(element.second, element.first);
            }
            return result;
        }();
        return reverseMap;
    }
};
 
template <typename T>
class Dictionary : public Object,
                   public detail::DictionaryAppendOverloads<Dictionary<T>, T>
{
    static_assert(std::is_arithmetic_v<T> || std::is_same_v<T, std::string> ||
                  std::is_base_of_v<ArrayElementObject, T>, "Invalid MNX dictionary element type.");
 
private:    
    template <typename DictionaryType, typename IteratorType>
    struct iter
    {
        using value_type = std::pair<const std::string, T>;
        using difference_type = std::ptrdiff_t;
        using iterator_category = std::forward_iterator_tag;
        using pointer = value_type*;
        using reference = value_type&;
 
    private:
        DictionaryType* m_ptr {};
        IteratorType m_it {};
        mutable std::optional<value_type> m_pair; // cached key/value
 
        void update_pair() const
        {
            m_pair.reset();
            if (m_it != m_ptr->ref().end()) {
                m_pair.emplace(m_it.key(), m_ptr->valueForKey(m_it.key()));
            }
        }
 
    public:
        iter(DictionaryType* ptr, IteratorType it)
            : m_ptr(ptr), m_it(it)
        {
            update_pair();
        }
 
        [[nodiscard]] reference operator*() const { return *m_pair; }
        [[nodiscard]] pointer operator->() const { return &*m_pair; }
 
        iter& operator++() { ++m_it; update_pair(); return *this; }
        iter operator++(int) { iter tmp(*this); ++(*this); return tmp; }
 
        [[nodiscard]] bool operator!=(const iter& o) const { return m_it != o.m_it; }
        [[nodiscard]] bool operator==(const iter& o) const { return m_it == o.m_it; }
    };
 
public:
    using value_type = T;
 
    using iterator = iter<Dictionary, json::iterator>;  
    using const_iterator = iter<const Dictionary, json::const_iterator>; 
 
    Dictionary(const std::shared_ptr<json>& root, json_pointer pointer)
        : Object(root, pointer)
    {
    }
 
    Dictionary(Base& parent, std::string_view key)
        : Object(parent, key) {}
 
    [[nodiscard]] size_t size() const { return ref().size(); }
 
    [[nodiscard]] bool empty() const { return ref().empty(); }
 
    void clear() { ref().clear(); }
 
    [[nodiscard]] T at(std::string_view key) const
    { return valueForKey(key); }
 
    template <typename U = T>
    std::enable_if_t<!std::is_base_of_v<Base, U>, void>
    emplace(std::string_view key, const U& value)
    {
        ref()[key] = value;
    }
 
    void erase(std::string_view key)
    {
        ref().erase(key);
    }
 
    [[nodiscard]] auto find(std::string_view key)
    {
        auto it = ref().find(key);
        return (it != ref().end()) ? iterator(this, it) : end();
    }
 
    [[nodiscard]] auto find(std::string_view key) const
    {
        auto it = ref().find(key);
        return (it != ref().end()) ? const_iterator(this, it) : end();
    }
 
    [[nodiscard]] bool contains(std::string_view key) const
    { return find(key) != end(); }
 
    [[nodiscard]] auto begin() { return iterator(this, ref().begin()); }
 
    [[nodiscard]] auto end() { return iterator(this, ref().end()); }
 
    [[nodiscard]] auto begin() const { return const_iterator(this, ref().begin()); }
 
    [[nodiscard]] auto end() const { return const_iterator(this, ref().end()); }
 
private:
    [[nodiscard]] T valueForKey(std::string_view key) const
    {
        if constexpr (std::is_base_of_v<Base, T>) {
            return getChild<T>(key);
        } else {
            return getChild<SimpleType<T>>(key);
        }
    }
 
    template <typename U, typename... Args>
    U appendImpl(std::string_view key, Args&&... args)
    {
        static_assert(std::is_base_of_v<Base, U>, "Dictionary::appendImpl requires a Base-derived element type.");
        if constexpr (std::is_base_of_v<Object, U>) {
            ref()[key] = json::object();
        } else {
            ref()[key] = json::array();
        }
        return U(*this, key, std::forward<Args>(args)...);
    }
 
    template <typename, auto>
    friend struct detail::DictionaryAppendFromMake;
    template <typename, typename>
    friend struct detail::DictionaryAppendBase;
};
 
} // namespace mnx
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
 
namespace nlohmann {
 
#if defined(_WIN32)
// This general adl_serializer is enabled only for enum types.
// For some reason MSC does not like the direct function definitions below.
template<typename EnumType>
struct adl_serializer<EnumType, std::enable_if_t<std::is_enum_v<EnumType>>>
{
    template<typename BasicJsonType>
    static EnumType from_json(const BasicJsonType& j)
    {
        // Lookup the string in the specialized map.
        const auto& map = ::mnx::EnumStringMapping<EnumType>::stringToEnum();
        auto it = map.find(j.get<std::string>());
        if (it != map.end()) {
            return it->second;
        }
        return EnumType{};
    }
 
    template<typename BasicJsonType>
    static void to_json(BasicJsonType& j, const EnumType& value)
    {
        const auto& map = ::mnx::EnumStringMapping<EnumType>::enumToString();
        auto it = map.find(value);
        if (it == map.end()) {
            j = BasicJsonType();
            return;
        }
        j = it->second;
    }
};
#else
// Clang works with the adl_specialization above, but GCC does not.
namespace detail {
 
template<typename BasicJsonType, typename EnumType,
         std::enable_if_t<std::is_enum<EnumType>::value, int> = 0>
inline void from_json(const BasicJsonType& j, EnumType& value)
{
    // Lookup the string in the specialized map.
    const auto& map = ::mnx::EnumStringMapping<EnumType>::stringToEnum();
    auto it = map.find(j.template get<std::string>());
    if (it != map.end()) {
        value = it->second;
    } else {
        value = EnumType{};
    }
}
 
template<typename BasicJsonType, typename EnumType,
         std::enable_if_t<std::is_enum<EnumType>::value, int> = 0>
inline void to_json(BasicJsonType& j, EnumType value) noexcept
{
    const auto& map = ::mnx::EnumStringMapping<EnumType>::enumToString();
    auto it = map.find(value);
    if (it != map.end()) {
        j = it->second;
    } else {
        j = BasicJsonType();
    }
}
 
} // namespace detail
#endif // defined(_WIN32)
 
} // namespace nlohmann
 
#endif // DOXYGEN_SHOULD_IGNORE_THIS