ObjectPool.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 <string>
#include <map>
#include <unordered_map>
#include <vector>
#include <memory>
#include <tuple>
#include <variant>
#include <stdexcept>
#include <functional>
#include <limits>
 
#include "MusxInstance.h"
 
#include "BaseClasses.h"
#include "Others.h"
#include "Details.h"
#include "Entries.h"
#include "ShapeDesigner.h"
#include "SmartShape.h"
#include "Staff.h"
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
namespace bench {
template<class> class PoolAccessor;
}; // namespace bench
#endif
 
namespace musx {
namespace dom {
 
template <typename Pool, typename T>
struct is_pool_type : std::false_type {};  // default: not valid
 
template <typename Pool, typename T>
inline constexpr bool is_pool_type_v = is_pool_type<Pool, T>::value;
 
template <typename ObjectBaseType>
class ObjectPool
{
public:
    using ObjectPtr = std::shared_ptr<ObjectBaseType>;
    struct ObjectKey {
        std::string_view nodeId;        
        Cmper partId;                   
        std::optional<Cmper> cmper1;    
        std::optional<Cmper> cmper2;    
        // Use `int` instead of `Inci` to work around GCC spurious -Wmaybe-uninitialized warning
        std::optional<int> inci;        
 
        ObjectKey(std::string_view n,
            Cmper p,
            std::optional<Cmper> c1 = std::nullopt,
            std::optional<Cmper> c2 = std::nullopt,
            std::optional<int> i = std::nullopt) : nodeId(n), partId(p), cmper1(c1), cmper2(c2), inci(i)
        {
        }
 
        bool operator<(const ObjectKey& other) const
        {
            if (nodeId != other.nodeId) {
                return nodeId < other.nodeId;
            }
            if (partId != other.partId) {
                return partId < other.partId;
            }
            if (cmper1 != other.cmper1) {
                return cmper1 < other.cmper1;
            }
            if (cmper2 != other.cmper2) {
                return cmper2 < other.cmper2;
            }
            return inci < other.inci;
        }
 
        std::string description() const
        {
            std::string result = std::string(nodeId) + " part " + std::to_string(partId);
            if (cmper1) {
                if (cmper2) {
                    result += " cmpers [" + std::to_string(cmper1.value()) + ", " + std::to_string(cmper2.value()) + "]";
                } else {
                    result += " cmper " + std::to_string(cmper1.value());
                }
            }
            if (inci) {
                result += " inci " + std::to_string(inci.value());
            }
            return result;
        }
    };
 
private:
    template <typename T>
    std::shared_ptr<const T> bindWithPartId(std::shared_ptr<const T> obj, Cmper requestedPartId) const
    {
        if constexpr (std::is_base_of_v<OthersBase, T> || std::is_base_of_v<DetailsBase, T>) {
            if (obj && obj->getRequestedPartId() != requestedPartId) {
                return PartContextCloner::copyWithPartId(obj, requestedPartId);
            }
        }
        return obj;
    }
 
    inline static ObjectKey makeEndKey(const ObjectKey& key)
    {
        return ObjectKey{
            key.nodeId,
            key.partId,
            key.cmper1.value_or((std::numeric_limits<Cmper>::max)()),
            key.cmper2.value_or((std::numeric_limits<Cmper>::max)()),
            key.inci.value_or((std::numeric_limits<Inci>::max)())
        };
    }
 
    template <typename T>
    inline static MusxInstance<T> checkedStaticCast([[maybe_unused]]const ObjectKey& key, const ObjectPtr& p)
    {
        static_assert(std::is_base_of_v<ObjectBaseType, T>, "T must derive from ObjectBaseType");
        if constexpr (!std::is_same_v<T, ObjectBaseType>) {
            assert(T::XmlNodeName == key.nodeId && "nodeId/type mismatch: pool invariant violated");
        }
    #ifndef NDEBUG
        // Optional paranoia while refactoring:
        //assert(std::dynamic_pointer_cast<T>(p));
    #endif
        return std::static_pointer_cast<T>(p);
    }
 
    inline static bool logicalLess(const ObjectKey& a, const ObjectKey& b)
    {
        return std::tie(a.cmper1, a.cmper2, a.inci) < std::tie(b.cmper1, b.cmper2, b.inci);
    }
 
    inline static bool logicalEq(const ObjectKey& a, const ObjectKey& b)
    {
        return a.cmper1 == b.cmper1 && a.cmper2 == b.cmper2 && a.inci == b.inci;
    }
 
public:
    virtual ~ObjectPool() = default;
 
    void add(ObjectKey key, ObjectPtr object)
    {
        if (key.inci.has_value()) {
            ObjectKey noInciKey = key;
            noInciKey.inci = std::nullopt;
            auto currentIncis = getArray<ObjectBaseType>(noInciKey, key.partId);
            if (key.inci.value() != int(currentIncis.size())) {
                MUSX_INTEGRITY_ERROR("Node " + std::string(key.nodeId) + " has inci " + std::to_string(key.inci.value()) + " that is out of sequence.");
            }
        }
        auto shareModeIt = m_shareMode.find(key.nodeId);
        auto [poolIt, emplaced] = m_pool.emplace(std::move(key), object);
        if (!emplaced) {
            MUSX_INTEGRITY_ERROR("Attempted to add same key more than once: " + poolIt->first.description());
        }
        if (shareModeIt == m_shareMode.end()) {
            m_shareMode.emplace(poolIt->first.nodeId, object->getShareMode());
        } else if (object->getShareMode() != shareModeIt->second && object->getShareMode() != Base::ShareMode::All) {
            if (shareModeIt->second == Base::ShareMode::All) {
                m_shareMode[poolIt->first.nodeId] = object->getShareMode();
            } else {
                MUSX_INTEGRITY_ERROR("Share mode for added " + std::string(poolIt->first.nodeId) + " object [" + std::to_string(int(object->getShareMode()))
                    + "] does not match previous [" + std::to_string(int(shareModeIt->second)) + "]");
            }
        }
    }
 
    template <typename T>
    MusxInstanceList<T> getArray(const ObjectKey& key, Cmper requestedPartId) const
    {
        MusxInstanceList<T> result(m_document, requestedPartId);
 
        auto rangeStart = m_pool.lower_bound(key);
        auto rangeEnd = m_pool.upper_bound(makeEndKey(key));
 
        for (auto it = rangeStart; it != rangeEnd; ++it) {
            auto typedPtr = bindWithPartId<T>(checkedStaticCast<T>(key, it->second), requestedPartId);
            result.push_back(typedPtr);
        }
        return result;
    }
 
    template <typename T>
    MusxInstanceList<T> getArrayForPart(const ObjectKey& key) const
    {
        Base::ShareMode forShareMode = Base::ShareMode::All;
        if (key.partId != SCORE_PARTID) {
            auto it = m_shareMode.find(key.nodeId);
            // If the nodeId is not found in m_shareMode, it means the document contains no instances,
            // and every path will return an empty vector. We can safely ignore this case.
            if (it != m_shareMode.end()) {
                forShareMode = it->second;
            }
        }
 
        if (key.partId == SCORE_PARTID || forShareMode == Base::ShareMode::None) {
            return getArray<T>(key, key.partId);
        }
        ObjectKey scoreKey(key);
        scoreKey.partId = SCORE_PARTID;
        if (forShareMode == Base::ShareMode::All) {
            return getArray<T>(scoreKey, key.partId);
        }
 
        const auto partStart = m_pool.lower_bound(key);
        const auto partEnd   = m_pool.upper_bound(makeEndKey(key));
 
        const auto scoreStart = m_pool.lower_bound(scoreKey);
        const auto scoreEnd   = m_pool.upper_bound(makeEndKey(scoreKey));
 
        auto partIt = partStart;
        auto scoreIt = scoreStart;
 
        MusxInstanceList<T> result(m_document, key.partId);
        auto pushInstance = [&](const auto& it) {
            auto typed = bindWithPartId<T>(checkedStaticCast<T>(key, it->second), key.partId);
            result.push_back(typed);
        };
        while (partIt != partEnd || scoreIt != scoreEnd) {
            if (scoreIt == scoreEnd) {
                pushInstance(partIt++);
                continue;
            }
            if (partIt == partEnd) {
                pushInstance(scoreIt++); // bind score record to requested part
                continue;
            }
            const ObjectKey& pk = partIt->first;
            const ObjectKey& sk = scoreIt->first;
            if (logicalEq(pk, sk)) {
                pushInstance(partIt++); // prefer part instance
                scoreIt++;
            } else if (logicalLess(pk, sk)) {
                pushInstance(partIt++);
            } else {
                pushInstance(scoreIt++); // score fallback
            }
        }
        return result;
    }
 
    template <typename T>
    MusxInstance<T> getSource(const ObjectKey& key) const
    {
        auto it = m_pool.find(key);
        if (it == m_pool.end()) {
            return nullptr;
        }
        return checkedStaticCast<T>(key, it->second);
    }
 
    template <typename T>
    MusxInstance<T> getEffectiveSourceForPart(const ObjectKey& key) const
    {
        if (auto partVersion = getSource<T>(key)) {
            return partVersion;
        }
        if (key.partId == SCORE_PARTID) {
            // if this is already the score version, there is nothing to return.
            return nullptr;
        } else {
            // if this is for a part, do not search score for unshared types.
            auto it = m_shareMode.find(key.nodeId);
            if (it != m_shareMode.end() && it->second == Base::ShareMode::None) {
                return nullptr;
            }
        }
        ObjectKey scoreKey(key);
        scoreKey.partId = SCORE_PARTID;
        return getSource<T>(scoreKey);
    }
 
    template <typename T>
    MusxInstance<T> getEffectiveForPart(const ObjectKey& key) const
    {
        return bindWithPartId<T>(getEffectiveSourceForPart<T>(key), key.partId);
    }
 
    ObjectPool(const DocumentWeakPtr& document, const std::unordered_map<std::string_view, dom::Base::ShareMode>& knownShareModes = {})
        : m_document(document), m_shareMode(knownShareModes) {}
 
private:
    DocumentWeakPtr m_document;
    std::unordered_map<std::string_view, dom::Base::ShareMode> m_shareMode;
 
    std::map<ObjectKey, ObjectPtr> m_pool;
};
 
class OptionsPool
{
    ObjectPool<OptionsBase> m_pool;
    friend class bench::PoolAccessor<OptionsPool>;
 
public:
    OptionsPool(const DocumentWeakPtr& document) : m_pool(document) {}
 
    void add(std::string_view nodeName, const std::shared_ptr<OptionsBase>& instance)
    {
        const Base* basePtr = instance.get();
        if (basePtr->getSourcePartId() != SCORE_PARTID) {
            MUSX_INTEGRITY_ERROR("Options node " + std::string(nodeName) + " hase non-score part id [" + std::to_string(basePtr->getSourcePartId()) + "]");
        }
        m_pool.add({ nodeName, basePtr->getSourcePartId() }, instance);
    }
 
    template <typename T>
    MusxInstanceList<T> getArray() const
    {
        static_assert(is_pool_type_v<OptionsPool, T>, "Type T is not registered in OptionsPool");
        return m_pool.getArray<T>({ T::XmlNodeName, SCORE_PARTID }, SCORE_PARTID);
    }
 
    template <typename T>
    MusxInstance<T> get() const
    {
        static_assert(is_pool_type_v<OptionsPool, T>, "Type T is not registered in OptionsPool");
        return m_pool.getSource<T>({ T::XmlNodeName, SCORE_PARTID });
    }
};
using OptionsPoolPtr = std::shared_ptr<OptionsPool>;
 
class OthersPool
{
    ObjectPool<OthersBase> m_pool;
    friend class bench::PoolAccessor<OthersPool>;
    friend MusxInstance<others::StaffComposite> others::StaffComposite::createCurrent(const DocumentPtr& document, Cmper partId, StaffCmper staffId, MeasCmper measId, Edu eduPosition);
 
    MusxInstance<others::Staff> getRawStaff(Cmper partId, StaffCmper staffId)
    {
        return m_pool.getEffectiveSourceForPart<others::Staff>({ std::string(others::Staff::XmlNodeName), partId, staffId, std::nullopt, std::nullopt });
    }
 
public:
    OthersPool(const DocumentWeakPtr& document) : m_pool(document, {
        { others::BeatChartElement::XmlNodeName, Base::ShareMode::None },
        { others::StaffUsed::XmlNodeName, Base::ShareMode::None },
        { others::SystemLock::XmlNodeName, Base::ShareMode::None },
        { others::MultimeasureRest::XmlNodeName, Base::ShareMode::None },
        { others::MultiStaffGroupId::XmlNodeName, Base::ShareMode::None },
        { others::Page::XmlNodeName, Base::ShareMode::None },
        { others::PartGlobals::XmlNodeName, Base::ShareMode::None },
        { others::PartVoicing::XmlNodeName, Base::ShareMode::None },
        { others::StaffSystem::XmlNodeName, Base::ShareMode::None },
        { others::StaffStyleAssign::XmlNodeName, Base::ShareMode::None },
        // add other known sharemode none items as they are identified.
    }) {}
 
    void add(std::string_view nodeName, const std::shared_ptr<OthersBase>& instance)
    { m_pool.add({nodeName, instance->getSourcePartId(), instance->getCmper(), std::nullopt, instance->getInci()}, instance); }
 
    template <typename T>
    MusxInstanceList<T> getArray(Cmper partId, std::optional<Cmper> cmper = std::nullopt) const
    {
        static_assert(is_pool_type_v<OthersPool, T>, "Type T is not registered in OthersPool");
        return m_pool.getArrayForPart<T>({ T::XmlNodeName, partId, cmper });
    }
 
    template <typename T>
    MusxInstance<T> get(Cmper partId, Cmper cmper, std::optional<Inci> inci = std::nullopt) const
    {
        static_assert(is_pool_type_v<OthersPool, T>, "Type T is not registered in OthersPool");
        return m_pool.getEffectiveForPart<T>({ T::XmlNodeName, partId, cmper, std::nullopt, inci });
    }
};
using OthersPoolPtr = std::shared_ptr<OthersPool>;
 
class DetailsPool
{
    ObjectPool<DetailsBase> m_pool;
    friend class bench::PoolAccessor<DetailsPool>;
 
public:
    DetailsPool(const DocumentWeakPtr& document) : m_pool(document, {
        { details::CenterShape::XmlNodeName, Base::ShareMode::None },
        { details::StaffGroup::XmlNodeName, Base::ShareMode::None },
        { details::StaffSize::XmlNodeName, Base::ShareMode::None },
        // add other known sharemode none items as they are identified.
    }) {}
 
    void add(std::string_view nodeName, const std::shared_ptr<DetailsBase>& instance)
    { m_pool.add({nodeName, instance->getSourcePartId(), instance->getCmper1(), instance->getCmper2(), instance->getInci()}, instance); }
 
    template <typename T, typename = std::enable_if_t<is_pool_type_v<DetailsPool, T>>>
    MusxInstanceList<T> getArray(Cmper partId) const
    { return m_pool.template getArrayForPart<T>({ T::XmlNodeName, partId }); }
 
    template <typename T, typename std::enable_if_t<!std::is_base_of_v<EntryDetailsBase, T>, int> = 0>
    MusxInstanceList<T> getArray(Cmper partId, Cmper cmper1, std::optional<Cmper> cmper2 = std::nullopt) const
    {
        static_assert(is_pool_type_v<DetailsPool, T>, "Type T is not registered in DetailsPool");
        return m_pool.template getArrayForPart<T>({ T::XmlNodeName, partId, cmper1, cmper2 });
    }
 
    template <typename T, typename std::enable_if_t<std::is_base_of_v<EntryDetailsBase, T>, int> = 0>
    MusxInstanceList<T> getArray(Cmper partId, EntryNumber entnum) const
    {
        static_assert(is_pool_type_v<DetailsPool, T>, "Type T is not registered in DetailsPool");
        return m_pool.template getArrayForPart<T>({ T::XmlNodeName, partId, Cmper(entnum >> 16), Cmper(entnum & 0xffff) });
    }
 
    template <typename T, typename std::enable_if_t<!std::is_base_of_v<EntryDetailsBase, T>, int> = 0>
    MusxInstance<T> get(Cmper partId, Cmper cmper1, Cmper cmper2, std::optional<Inci> inci = std::nullopt) const
    {
        static_assert(is_pool_type_v<DetailsPool, T>, "Type T is not registered in DetailsPool");
        return m_pool.getEffectiveForPart<T>({ T::XmlNodeName, partId, cmper1, cmper2, inci });
    }
 
    template <typename T, typename std::enable_if_t<std::is_base_of_v<EntryDetailsBase, T>, int> = 0>
    MusxInstance<T> get(Cmper partId, EntryNumber entnum, std::optional<Inci> inci = std::nullopt) const
    {
        static_assert(is_pool_type_v<DetailsPool, T>, "Type T is not registered in DetailsPool");
        return m_pool.getEffectiveForPart<T>({ T::XmlNodeName, partId, Cmper(entnum >> 16), Cmper(entnum & 0xffff), inci });
    }
 
    template <typename T, typename std::enable_if_t<std::is_base_of_v<NoteDetailsBase, T>, int> = 0>
    MusxInstance<T> getForNote(const NoteInfoPtr& noteInfo, const std::optional<Cmper>& forPartId = std::nullopt)
    {
        static_assert(is_pool_type_v<DetailsPool, T>, "Type T is not registered in DetailsPool");
        auto details = getArray<T>(
            forPartId.value_or(noteInfo.getEntryInfo().getFrame()->getRequestedPartId()),
            noteInfo.getEntryInfo()->getEntry()->getEntryNumber()
        );
        for (const auto& detail : details) {
            if (detail->getNoteId() == noteInfo->getNoteId()) {
                return detail;
            }
        }
        return nullptr;
    }
};
 
using DetailsPoolPtr = std::shared_ptr<DetailsPool>;
 
class EntryPool // uses different implementation than other pools for more efficient access
{
public:
    EntryPool(const DocumentWeakPtr& document) : m_document(document) {}
 
    void add(EntryNumber entryNumber, const std::shared_ptr<Entry>& instance)
    {
        auto [it, emplaced] = m_pool.emplace(entryNumber, instance);
        if (!emplaced) {
            MUSX_INTEGRITY_ERROR("Entry number " + std::to_string(entryNumber) + " added twice.");
        }
    }
 
    MusxInstance<Entry> get(EntryNumber entryNumber) const
    {
        const auto it = m_pool.find(entryNumber);
        if (it == m_pool.end()) {
            return nullptr;
        }
        return it->second;
    }
 
private:
    DocumentWeakPtr m_document;
    std::unordered_map<EntryNumber, std::shared_ptr<Entry>> m_pool;
 
    friend class bench::PoolAccessor<EntryPool>;
};
using EntryPoolPtr = std::shared_ptr<EntryPool>;
 
class TextsPool
{
    ObjectPool<TextsBase> m_pool;
    friend class bench::PoolAccessor<TextsPool>;
 
public:
    TextsPool(const DocumentWeakPtr& document) : m_pool(document) {}
 
    void add(std::string_view nodeName, const std::shared_ptr<TextsBase>& instance)
    {
        const Base* basePtr = instance.get();
        if (basePtr->getSourcePartId() != SCORE_PARTID) {
            MUSX_INTEGRITY_ERROR("Texts node " + std::string(nodeName) + " hase non-score part id [" + std::to_string(basePtr->getSourcePartId()) + "]");
        }
        m_pool.add({ nodeName, basePtr->getSourcePartId(), instance->getTextNumber() }, instance);
    }
 
    template <typename T>
    MusxInstanceList<T> getArray(std::optional<Cmper> cmper = std::nullopt) const
    {
        static_assert(is_pool_type_v<TextsPool, T>, "Type T is not registered in TextsPool");
        return m_pool.getArray<T>({ T::XmlNodeName, SCORE_PARTID, cmper }, SCORE_PARTID);
    }
 
    template <typename T>
    MusxInstance<T> get(Cmper cmper) const
    {
        static_assert(is_pool_type_v<TextsPool, T>, "Type T is not registered in TextsPool");
        return m_pool.getSource<T>({ T::XmlNodeName, SCORE_PARTID, cmper, std::nullopt, std::nullopt });
    }
};
using TextsPoolPtr = std::shared_ptr<TextsPool>;
 
} // namespace dom
} // namespace musx