IdMapping.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 <unordered_map>
#include <memory>
#include <string>
#include <tuple>
#include <stdexcept>
#include <type_traits>
#include <optional>
#include <sstream>
 
#include "BaseTypes.h"
#include "Global.h"
#include "Layout.h"
#include "Part.h"
#include "Score.h"
 
namespace mnx::util {
 
class mapping_error : public std::runtime_error
{
    using runtime_error::runtime_error;
};
 
class IdMapping {
public:
    explicit IdMapping(std::shared_ptr<json> documentRoot, const std::optional<ErrorHandler>& errorHandler = std::nullopt)
        : m_root(documentRoot), m_errorHandler(errorHandler) {}
 
    template <typename T, typename IdType>
    T get(const IdType& id, const std::optional<Base>& errorLocation = std::nullopt) const
    {
        const auto& map = getMap<T>();
        auto it = map.find(id);
        if (it == map.end()) {
            mapping_error err("ID " + formatKeyString(id) + " not found in ID mapping");
            if (m_errorHandler) {
                m_errorHandler.value()(err.what(), errorLocation.value_or(Document(m_root)));
            }
            throw err;
        }
        if (it->second.typeName != T::JsonSchemaTypeName) {
            mapping_error err("ID " + formatKeyString(id) + " has type \"" + std::string(it->second.typeName)
                + "\", but the requested type is \"" + std::string(T::JsonSchemaTypeName) + "\".");
            if (m_errorHandler) {
                m_errorHandler.value()(err.what(), errorLocation.value_or(Document(m_root)));
            }
            throw err;
        }
        return T(m_root, it->second.location);
    }
 
    template <typename T, typename IdType>
    bool exists(const IdType& id) const
    {
        const auto& map = getMap<T>();
        return map.find(id) != map.end();
    }
 
    template <typename T, typename IdType>
    void add(const IdType& id, const T& value)
    {
        auto result = getMap<T>().emplace(id, MappedLocation{ value.pointer(), T::JsonSchemaTypeName });
        if (!result.second) {
            mapping_error err("ID " + formatKeyString(id) + " already exists for type \"" + std::string(result.first->second.typeName)
                + "\" at " + result.first->second.location.to_string());
            if (m_errorHandler) {
                m_errorHandler.value()(err.what(), value);
            } else {
                throw err;
            }
        }
    }
    
private:
    std::shared_ptr<json> m_root;
    std::optional<ErrorHandler> m_errorHandler;
 
    using MappedLocation = struct
    {
        json_pointer location;          
        std::string_view typeName;      
    };
    std::unordered_map<std::string, MappedLocation> m_objectMap;
    std::unordered_map<int, MappedLocation> m_globalMeasures;
    
    template <typename T, typename Self>
    static auto& getMapImpl(Self& self) {
        if constexpr (std::is_same_v<T, mnx::global::Measure>) {
            return self.m_globalMeasures;
        } else {
            return self.m_objectMap;
        }
    }
 
    template <typename T>
    const auto& getMap() const
    { return getMapImpl<T>(*this); }
 
    template <typename T>
    auto& getMap()
    { return getMapImpl<T>(*this); }
 
    template <typename KeyType>
    static std::string formatKeyString(const KeyType& key) {
        if constexpr (std::is_same_v<KeyType, std::string>) {
            return "\"" + key + "\"";
        } else {
            std::ostringstream oss;
            oss << key;
            return oss.str();
        }
    }
};
 
} // namespace mnx::util