BaseClasses.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 <cassert>
#include <filesystem>
#include <set>
 
#include "musx/dom/Fundamentals.h"
#include "musx/xml/XmlInterface.h"
#include "musx/util/Logger.h"
 
namespace musx {
 
namespace dom {
 
namespace others {
class PartDefinition;
}
 
class integrity_error : public std::runtime_error
{
public:
    using std::runtime_error::runtime_error;
};
 
class Document;
using DocumentPtr = std::shared_ptr<Document>;
using DocumentWeakPtr = std::weak_ptr<Document>;
 
class Base
{
public:
    using SharedNodes = std::set<std::string>;
 
    enum class ShareMode
    {
        // this enum was giving Doxygen fits until I switched to using the slash-splat-bang-lt comment commands.
        All,            
        Partial,        
        None            
    };
 
    virtual ~Base() noexcept(false) = default;
 
    DocumentPtr getDocument() const
    {
        auto document = m_document.lock();
        assert(document); // program bug if this pointer goes out of scope.
        if (!document) {
            throw std::logic_error("Document pointer is no longer valid.");
        }
        return document;
    }
 
    Cmper getPartId() const { return m_partId; }
 
    std::shared_ptr<others::PartDefinition> getPartDefinition() const;
 
    ShareMode getShareMode() const { return m_shareMode; }
 
    const SharedNodes& getUnlinkedNodes() const { return m_unlinkedNodes; }
 
    void addUnlinkedNode(const std::string& nodeName)
    {
        m_unlinkedNodes.insert(nodeName);
    }
 
    virtual void integrityCheck() { }
 
    virtual bool requireAllFields() const { return true; }
 
protected:
    Base(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode)
        : m_document(document), m_partId(partId), m_shareMode(shareMode) {}
 
    Base& operator=(const Base&) { return *this; }
 
private:
    const DocumentWeakPtr m_document;
    const Cmper m_partId;
    const ShareMode m_shareMode;
    SharedNodes m_unlinkedNodes;
};
 
class CommonClassBase : public Base
{
public:
    CommonClassBase(const DocumentWeakPtr& document)
        : Base(document, SCORE_PARTID, ShareMode::All) {}
 
protected:
    // Because the part ID and share mode are hard-coded for this category of classes,
    // these Base functions do not return useful results. However, we allow our subclasses
    // to use their own versions of these functions (esp. `getPartId`) to avoid promiscuous
    // hard-coding of SCORE_PARTID. The rules may change in the future.
    using Base::getPartDefinition;
    using Base::getPartId;
    using Base::getShareMode;
    using Base::getUnlinkedNodes;
};
 
class OptionsBase : public Base {
protected:
    OptionsBase(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode)
        : Base(document, partId, shareMode) {}
};
 
class OthersBase : public Base
{
protected:
    OthersBase(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper cmper, std::optional<Inci> inci = std::nullopt)
        : Base(document, partId, shareMode), m_cmper(cmper), m_inci(inci) {}
 
public:
    Cmper getCmper() const { return m_cmper; }
 
    std::optional<Inci> getInci() const { return m_inci; }
 
private:
    Cmper m_cmper;                  
    std::optional<Inci> m_inci;     
};
 
template <typename ElementType, size_t REQUIRED_SIZE = 0>
class OthersArray : public OthersBase
{
private:
    virtual std::string_view xmlTag() const = 0;
 
public:
    explicit OthersArray(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper cmper)
        : OthersBase(document, partId, shareMode, cmper)
    {
    }
 
    std::vector<ElementType> values;    
 
    void integrityCheck() override
    {
        OthersBase::integrityCheck();
        if constexpr (REQUIRED_SIZE) {
            const size_t originalSize = values.size();
            values.resize(REQUIRED_SIZE); // resize first, in case MUSX_INTEGRITY_ERROR throws. (Avoid unreachable code warning.)
            if (originalSize < REQUIRED_SIZE) {
                MUSX_INTEGRITY_ERROR("Array with xml tag " + std::string(xmlTag()) + " and cmper " + std::to_string(getCmper())
                    + " has fewer than " + std::to_string(REQUIRED_SIZE) + " elements.");
            }
        }
    }
};
 
class DetailsBase : public Base
{
protected:
    DetailsBase(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper cmper1, Cmper cmper2, std::optional<Inci> inci = std::nullopt)
        : Base(document, partId, shareMode), m_cmper1(cmper1), m_cmper2(cmper2), m_inci(inci) {}
 
public:
    Cmper getCmper1() const { return m_cmper1; }
 
    Cmper getCmper2() const { return m_cmper2; }
 
    std::optional<Inci> getInci() const { return m_inci; }
 
private:
    Cmper m_cmper1;                  
    Cmper m_cmper2;                  
    std::optional<Inci> m_inci;     
};
 
class EntryDetailsBase : public DetailsBase
{
protected:
    EntryDetailsBase(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, EntryNumber entnum, std::optional<Inci> inci = std::nullopt)
        : DetailsBase(document, partId, shareMode, Cmper(entnum >> 16), Cmper(entnum & 0xffff), inci) {}
 
public:
    EntryNumber getEntryNumber() const { return EntryNumber(getCmper1()) << 16 | EntryNumber(getCmper2()); }
 
private:
    using DetailsBase::getCmper1;
    using DetailsBase::getCmper2;
};
 
class NoteInfoPtr;
 
class NoteDetailsBase : public EntryDetailsBase
{
public:
    virtual NoteNumber getNoteId() const = 0;
 
protected:
    using EntryDetailsBase::EntryDetailsBase;
};
 
class FontInfo;
class TextsBase : public Base
{
public:
    TextsBase(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper textNumber)
        : Base(document, partId, shareMode), m_textNumber(textNumber) {}
 
    std::string text;    
 
    Cmper getTextNumber() const { return m_textNumber; }
 
    void setTextNumber(Cmper textNumber) { m_textNumber = textNumber; }
 
    std::shared_ptr<FontInfo> parseFirstFontInfo() const;
 
private:
    Cmper m_textNumber;             
};
 
} // namespace dom
} // namespace musx