Document.h

/*
 * Copyright (C) 2024, 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 <cstdint>
#include <filesystem>
#include <map>
#include <optional>
#include <string>
#include <type_traits>
#include <unordered_map>
#include <vector>
 
#include "Header.h"
#include "Instrument.h"
#include "ObjectPool.h"
#include "MusxInstance.h"
 
namespace musx {
 
namespace factory {
class DocumentFactory;
} // namespace factory
 
namespace dom {
 
using namespace header;
 
namespace others {
class MeasureExprAssign;
}
 
namespace texts {
class FileInfoText;
class LyricsTextBase;
}
 
enum class KnownShapeDefType;
using EmbeddedGraphicBlob = std::vector<uint8_t>; 
 
struct EmbeddedGraphicData
{
    std::string extension;          
    EmbeddedGraphicBlob bytes;      
};
 
using EmbeddedGraphicsMap = std::unordered_map<Cmper, EmbeddedGraphicData>; 
 
enum class PartVoicingPolicy
{
    Ignore,     
 
    Apply       
};
 
using RehearsalMarkKey = std::pair<MeasCmper, Cmper>;
 
struct RehearsalMarkInfo
{
    int rehearsalSequence{};  
};
 
using RehearsalMarkMap = std::map<RehearsalMarkKey, RehearsalMarkInfo>;
 
class Document
{
public:
    [[nodiscard]]
    HeaderPtr& getHeader() { return m_header; }
    [[nodiscard]]
    const HeaderPtr& getHeader() const { return m_header; }
 
    [[nodiscard]]
    OptionsPoolPtr& getOptions() { return m_options; }
    [[nodiscard]]
    const OptionsPoolPtr& getOptions() const { return m_options; }
 
    [[nodiscard]]
    OthersPoolPtr& getOthers() { return m_others; }
    [[nodiscard]]
    const OthersPoolPtr& getOthers() const { return m_others; }
 
    [[nodiscard]]
    DetailsPoolPtr& getDetails() { return m_details; }
    [[nodiscard]]
    const DetailsPoolPtr& getDetails() const { return m_details; }
 
    [[nodiscard]]
    EntryPoolPtr& getEntries() { return m_entries; }
    [[nodiscard]]
    const EntryPoolPtr& getEntries() const { return m_entries; }
 
    [[nodiscard]]
    TextsPoolPtr& getTexts() { return m_texts; }
    [[nodiscard]]
    const TextsPoolPtr& getTexts() const { return m_texts; }
 
    [[nodiscard]]
    PartVoicingPolicy getPartVoicingPolicy() const { return m_partVoicingPolicy; }
 
    [[nodiscard]]
    std::optional<double> getScoreDurationSeconds() const { return m_scoreDurationSeconds; }
 
    [[nodiscard]]
    const EmbeddedGraphicsMap& getEmbeddedGraphics() const { return m_embeddedGraphics; }
 
    [[nodiscard]]
    Cmper calcScrollViewCmper(Cmper partId) const noexcept;
 
    [[nodiscard]]
    bool isScrollViewCmper(Cmper partId, Cmper systemCmper) const noexcept { return systemCmper == calcScrollViewCmper(partId); }
 
    [[nodiscard]]
    MusxInstanceList<others::StaffUsed> getScrollViewStaves(Cmper partId) const;
 
    [[nodiscard]]
    MusxInstanceList<others::StaffUsed> getStudioViewStaves(Cmper partId) const;
 
    [[nodiscard]]
    std::optional<KnownShapeDefType> getCachedShapeRecognition(Cmper shapeCmper) const;
 
    void setCachedShapeRecognition(Cmper shapeCmper, KnownShapeDefType type) const;
 
    [[nodiscard]]
    std::optional<bool> getCachedFontIsSMuFL(Cmper fontId) const;
 
    void setCachedFontIsSMuFL(Cmper fontId, bool isSmufl) const;
 
    [[nodiscard]]
    MusxInstance<others::Page> calcPageFromMeasure(Cmper partId, MeasCmper measureId) const;
 
    [[nodiscard]]
    MusxInstance<others::StaffSystem> calcSystemFromMeasure(Cmper partId, MeasCmper measureId) const;
 
    [[nodiscard]]
    int getMaxBlankPages() const { return m_maxBlankPages; }
 
    [[nodiscard]]
    const InstrumentMap& getInstruments() const
    {
        MUSX_ASSERT_IF(!m_instruments.has_value()) {
            throw std::logic_error("Attempted to retrieve instrument map before it was constructed.");
        }
        return m_instruments.value();
    }
 
    [[nodiscard]]
    const std::optional<InstrumentMap>& getInstrumentsIfAvailable() const noexcept
    {
        return m_instruments;
    }
 
    [[nodiscard]]
    const std::optional<std::filesystem::path>& getSourcePath() const { return m_sourcePath; }
 
    [[nodiscard]]
    std::optional<std::filesystem::path> resolveExternalGraphicPath(Cmper fileDescId) const;
 
    [[nodiscard]]
    const InstrumentInfo& getInstrumentForStaff(StaffCmper staffId) const;
 
    [[nodiscard]]
    std::optional<InstrumentInfo> getInstrumentForStaff(Cmper partId, StaffCmper staffId) const;
 
    [[nodiscard]]
    std::optional<RehearsalMarkInfo> getRehearsalMarkInfo(MeasCmper measureId, Cmper textExpressionId) const;
 
    [[nodiscard]]
    InstrumentMap createInstrumentMap(Cmper forPartId) const;
 
    [[nodiscard]]
    bool calcHasVaryingSystemStaves(Cmper forPartId) const;
 
    [[nodiscard]]
    MusicRange calcEntireDocument() const;
 
    [[nodiscard]]
    std::vector<MeasCmper> calcJumpFromMeasures(Cmper partId, MeasCmper currentMeasure) const;
 
    bool iterateEntries(Cmper partId, std::function<bool(const EntryInfoPtr&)> iterator) const;
 
private:
    explicit Document() = default;
 
    DocumentWeakPtr m_self;     
 
    HeaderPtr m_header;         
    OptionsPoolPtr m_options;   
    OthersPoolPtr m_others;     
    DetailsPoolPtr m_details;   
    EntryPoolPtr m_entries;     
    TextsPoolPtr m_texts;       
 
    int m_maxBlankPages{};      
 
    std::optional<InstrumentMap> m_instruments = std::nullopt; 
 
    RehearsalMarkMap m_rehearsalMarks; 
    void createRehearsalMarkMap();
 
    PartVoicingPolicy m_partVoicingPolicy{};    
    std::optional<double> m_scoreDurationSeconds; 
    EmbeddedGraphicsMap m_embeddedGraphics;     
    std::optional<std::filesystem::path> m_sourcePath; 
 
    mutable std::unordered_map<Cmper, KnownShapeDefType> m_shapeRecognitionCache; 
    mutable std::unordered_map<Cmper, bool> m_isSmuflFontCache; 
 
    // Grant the factory class access to the private constructor
    friend class musx::factory::DocumentFactory;
};
 
namespace texts {
 
template <typename T>
[[nodiscard]]
std::optional<Cmper> importTextInto(const DocumentPtr& target,
    const MusxInstance<T>& source, const ImportObjectCallback& onImported)
{
    static_assert(is_pool_type_v<TextsPool, T>, "Type T is not registered in TextsPool");
    MUSX_ASSERT_IF(!target) {
        throw std::invalid_argument("importTextInto received a null target document");
    }
    MUSX_ASSERT_IF(!source) {
        throw std::invalid_argument("importTextInto received null text");
    }
 
    std::optional<Cmper> importedId;
    if constexpr (std::is_same_v<T, FileInfoText>) {
        importedId = source->getTextNumber();
        if (target->getTexts()->get<FileInfoText>(*importedId)) {
            return std::nullopt;
        }
    } else {
        importedId = target->getTexts()->nextFreeCmper<T>();
    }
    if (!importedId) {
        return std::nullopt;
    }
    auto imported = std::make_shared<T>(
        target, SCORE_PARTID, EnigmaBase::ShareMode::All, *importedId);
    *imported = *source;
    target->getTexts()->add(T::XmlNodeName, imported);
    if (onImported) {
        onImported(*imported);
    }
    if constexpr (std::is_base_of_v<LyricsTextBase, T>) {
        imported->createSyllableInfo(imported);
    }
    return importedId;
}
 
template <typename T>
[[nodiscard]]
std::optional<Cmper> importTextInto(const DocumentPtr& target,
    const MusxInstance<T>& source)
{
    return importTextInto(target, source, {});
}
 
} // namespace texts
 
} // namespace dom
} // namespace musx