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 <optional>
#include <string>
#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;
 
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       
};
 
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]]
    constexpr Cmper calcScrollViewCmper([[maybe_unused]]Cmper partId) const noexcept
    {
        // as of now, there is no calculation, but keep that assumption encapsulated.
        return BASE_SYSTEM_ID;
    }
 
    [[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]]
    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<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]]
    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; 
 
    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; 
 
    // Grant the factory class access to the private constructor
    friend class musx::factory::DocumentFactory;
};
 
} // namespace dom
} // namespace musx