Others.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 <unordered_map>
#include <vector>
#include <memory>
#include <stdexcept>
#include <map>
#include <tuple>
 
#include "musx/util/EnigmaString.h"
#include "musx/util/Logger.h"
#include "musx/util/Fraction.h"
#include "musx/util/PseudoTieUtils.h"
#include "musx/dom/PercussionNoteType.h"
 
#include "BaseClasses.h"
#include "CommonClasses.h"
#include "Options.h"
 // do not add other dom class dependencies. Use Implementations.cpp for implementations that need total class access.
 
namespace musx {
namespace utils {
enum class PseudoTieMode;
} // namespace utils
 
namespace dom {
 
class Entry;
class NoteInfoPtr;
 
enum class KnownShapeDefType;
 
namespace details {
class FretboardDiagram;
class GFrameHold;
class IndependentStaffDetails;
class StaffGroup;
}
 
namespace others {
 
class ShapeDef;
class Staff;
class StaffComposite;
class StaffList;
class StaffListCategoryScore;
class StaffListCategoryParts;
class StaffListRepeatScore;
class StaffListRepeatParts;
class StaffListRepeatScoreForced;
class StaffListRepeatPartsForced;
 
template<class ScoreList, class PartsList, class ScoreForcedList, class PartsForcedList>
class StaffListSet;
 
using CategoryStaffListSet = StaffListSet<StaffListCategoryScore, StaffListCategoryParts, void, void>;
 
using RepeatStaffListSet = StaffListSet<StaffListRepeatScore, StaffListRepeatParts, StaffListRepeatScoreForced, StaffListRepeatPartsForced>;
 
class AcciAmountFlats : public OthersArray<int, 7>
{
    std::string_view xmlTag() const override { return XmlNodeName; }
 
public:
    using OthersArray::OthersArray;
 
    constexpr static std::string_view XmlNodeName = "acciAmountFlats"; 
    static const xml::XmlElementArray<AcciAmountFlats>& xmlMappingArray(); 
};
 
class AcciAmountSharps : public OthersArray<int, 7>
{
    std::string_view xmlTag() const override { return XmlNodeName; }
 
public:
    using OthersArray::OthersArray;
 
    constexpr static std::string_view XmlNodeName = "acciAmountSharps"; 
    static const xml::XmlElementArray<AcciAmountSharps>& xmlMappingArray(); 
};
 
class AcciOrderFlats : public OthersArray<unsigned, 7>
{
    std::string_view xmlTag() const override { return XmlNodeName; }
 
public:
    using OthersArray::OthersArray;
 
    constexpr static std::string_view XmlNodeName = "acciOrderFlats"; 
    static const xml::XmlElementArray<AcciOrderFlats>& xmlMappingArray(); 
};
 
class AcciOrderSharps : public OthersArray<unsigned, 7>
{
    std::string_view xmlTag() const override { return XmlNodeName; }
 
public:
    using OthersArray::OthersArray;
 
    constexpr static std::string_view XmlNodeName = "acciOrderSharps"; 
    static const xml::XmlElementArray<AcciOrderSharps>& xmlMappingArray(); 
};
 
class ArticulationDef : public OthersBase
{
public:
    enum class AutoVerticalMode
    {
        AlwaysNoteheadSide,         
        AutoNoteStem,               
        StemSide,                   
        AlwaysOnStem,               
        AboveEntry,                 
        BelowEntry,                 
    };
 
    enum class CopyMode
    {
        None,                       
        Vertical,                   
        Horizontal                  
    };
 
    enum class SlurInteractionMode
    {
        Ignore,             
        InsideSlur,
        AvoidSlur
    };
 
    struct SelectedSymbol
    {
        bool usesAlternate{};                    
        bool isShape{};                          
        Cmper shapeId{};                         
        Evpu xOffset{};                          
        Evpu yOffset{};                          
        char32_t character{};                    
        std::shared_ptr<FontInfo> font;          
    };
 
    explicit ArticulationDef(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper cmper)
        : OthersBase(document, partId, shareMode, cmper), fontMain(new FontInfo(document)), fontAlt(new FontInfo(document)) {}
 
    char32_t charMain{};                           
    std::shared_ptr<FontInfo> fontMain;            
    CopyMode copyMode{};                           
    bool useTopNote{};                             
    bool autoHorz{};                               
    bool autoVert{};                               
    AutoVerticalMode autoVertMode{};               
    bool outsideStaff{};                           
    bool aboveSymbolAlt{};                         
    bool belowSymbolAlt{};                         
    bool insideSlur{};                             
    bool noPrint{};                                
    bool autoStack{};                              
    bool centerOnStem{};                           
    SlurInteractionMode slurInteractionMode{};     
    char32_t charAlt{};                            
    std::shared_ptr<FontInfo> fontAlt;             
    Evpu xOffsetMain{};                            
    Evpu yOffsetMain{};                            
    Evpu defVertPos{};                             
    bool avoidStaffLines{};                        
    bool isStemSideWhenMultipleLayers{};           
    bool playArtic{};                              
    Evpu xOffsetAlt{};                             
    Evpu yOffsetAlt{};                             
    bool mainIsShape{};                            
    bool altIsShape{};                             
    Cmper mainShape{};                             
    Cmper altShape{};                              
    int startTopNoteDelta{};                       
    int startBotNoteDelta{};                       
    int startTopNotePercent{};                     
    int startBotNotePercent{};                     
    int durTopNoteDelta{};                         
    int durBotNoteDelta{};                         
    int durTopNotePercent{};                       
    int durBotNotePercent{};                       
    int ampTopNoteDelta{};                         
    int ampBotNoteDelta{};                         
    int ampTopNotePercent{};                       
    int ampBotNotePercent{};                       
    Evpu distanceFromStemEnd{};                    
 
    [[nodiscard]] SelectedSymbol calcSelectedSymbol(bool placeAbove) const;
 
    constexpr static std::string_view XmlNodeName = "articDef"; 
    static const xml::XmlElementArray<ArticulationDef>& xmlMappingArray(); 
};
 
class BeatChartElement : public OthersBase
{
public:
    explicit BeatChartElement(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper cmper, Inci inci)
        : OthersBase(document, partId, shareMode, cmper, inci)
    {
    }
 
    class Control
    {
    public:
        Edu totalDur{};     
        Evpu totalWidth{};  
        Evpu minWidth{};    
        Evpu allotWidth{};  
 
        static const xml::XmlElementArray<Control>& xmlMappingArray(); 
    };
 
    // Populated only when the XML node includes a <control> element
    std::shared_ptr<Control> control;  
 
    // Populated for standard beat entries (inci > 0)
    Edu dur{};         
    Evpu pos{};        
    Evpu endPos{};     
    Evpu minPos{};     
 
    void integrityCheck(const std::shared_ptr<EnigmaBase>& ptrToThis) override
    {
        OthersBase::integrityCheck(ptrToThis);
        if (control && getInci() != 0) {
            MUSX_INTEGRITY_ERROR("Beat chart for measure " + std::to_string(getCmper()) + " has a control instance in inci " + std::to_string(*getInci()));
        }
        if (getInci() == 0 && !control) {
            control = std::make_shared<Control>();
            MUSX_INTEGRITY_ERROR("Beat chart for measure " + std::to_string(getCmper()) + " is missing its control instance.");
        }
    }
 
    constexpr static std::string_view XmlNodeName = "beatChart"; 
    static const xml::XmlElementArray<BeatChartElement>& xmlMappingArray(); 
};
 
class ChordSuffixElement : public OthersBase
{
public:
    enum class Prefix
    {
        None,   
        Minus,  
        Plus,   
        Sharp,  
        Flat    
    };
 
    explicit ChordSuffixElement(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper cmper, Inci inci)
        : OthersBase(document, partId, shareMode, cmper, inci), font(new FontInfo(document))
    {
    }
 
    std::shared_ptr<FontInfo> font; 
    char32_t symbol{};              
    Evpu xdisp{};                   
    Evpu ydisp{};                   
    bool isNumber{};                
    Prefix prefix{};                
 
    constexpr static std::string_view XmlNodeName = "chordSuffix"; 
    static const xml::XmlElementArray<ChordSuffixElement>& xmlMappingArray(); 
};
 
class ChordSuffixPlayback : public OthersArray<int16_t>
{
    std::string_view xmlTag() const override { return XmlNodeName; }
 
public:
    using OthersArray::OthersArray;
 
    constexpr static std::string_view XmlNodeName = "chordSuffixPlay"; 
    static const xml::XmlElementArray<ChordSuffixPlayback>& xmlMappingArray(); 
};
 
class ClefList : public OthersBase
{
public:
    explicit ClefList(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper cmper, Inci inci)
        : OthersBase(document, partId, shareMode, cmper, inci)
    {
    }
 
    // Public properties corresponding to the XML structure, in the same order as in the XML.
    ClefIndex clefIndex{};  
    Edu xEduPos{};          
    Evpu yEvpuPos{};        
    int percent{};          
    int xEvpuOffset{};      
    ShowClefMode clefMode{}; 
    bool unlockVert{};      
    bool afterBarline{};    
 
    constexpr static std::string_view XmlNodeName = "clefEnum"; 
    static const xml::XmlElementArray<ClefList>& xmlMappingArray(); 
};
 
class DrumStaff : public OthersBase
{
public:
    explicit DrumStaff(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper cmper)
        : OthersBase(document, partId, shareMode, cmper) {}
 
    Cmper whichDrumLib{};       
 
    constexpr static std::string_view XmlNodeName = "drumStaff"; 
    static const xml::XmlElementArray<DrumStaff>& xmlMappingArray();    
};
 
class DrumStaffStyle : public DrumStaff
{
public:
    using DrumStaff::DrumStaff;
 
    constexpr static std::string_view XmlNodeName = "drumStaffStyle"; 
};
 
class FontDefinition : public OthersBase
{
public:
    static constexpr uint32_t SYMBOL_CHARSET_MAC = 0xfff; 
    static constexpr uint32_t SYMBOL_CHARSET_WIN = 2;     
    explicit FontDefinition(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper cmper)
        : OthersBase(document, partId, shareMode, cmper) {}
 
    enum class CharacterSetBank
    {
        MacOS,          
        Windows         
    };
 
    // Public properties corresponding to the XML structure
    CharacterSetBank charsetBank{}; 
    int charsetVal{};               
    int pitch{};                    
    int family{};                   
    std::string name;               
 
    bool calcIsSymbolFont() const
    {
        if (charsetBank == CharacterSetBank::MacOS && charsetVal == SYMBOL_CHARSET_MAC) {
            return true;
        }
        if (charsetBank == CharacterSetBank::Windows && charsetVal == SYMBOL_CHARSET_WIN) {
            return true;
        }
        return false;
    }
 
    constexpr static std::string_view XmlNodeName = "fontName"; 
    static const xml::XmlElementArray<FontDefinition>& xmlMappingArray(); 
};
 
class Frame : public OthersBase
{
public:
    explicit Frame(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper cmper, Inci inci = 0)
        : OthersBase(document, partId, shareMode, cmper, inci) {}
 
    EntryNumber startEntry{}; 
    EntryNumber endEntry{};   
    Edu startTime{};          
 
    bool iterateRawEntries(std::function<bool(const MusxInstance<Entry>& entry)> iterator) const;
 
    MusxInstanceList<Entry> getEntries() const;
 
    void integrityCheck(const std::shared_ptr<EnigmaBase>& ptrToThis) override
    {
        this->OthersBase::integrityCheck(ptrToThis);
        if (startTime && (startEntry || endEntry)) {
            MUSX_INTEGRITY_ERROR("Frame " + std::to_string(getCmper()) + " has non-zero startTime and non-zero startEntry or endEntry.");
        }
        if (!startTime && !startEntry) {
            MUSX_INTEGRITY_ERROR("Frame " + std::to_string(getCmper()) + " has no start entry.");
        }
        if (!startTime && !endEntry) {
            MUSX_INTEGRITY_ERROR("Frame " + std::to_string(getCmper()) + " has no end entry.");
        }
    }
 
    constexpr static std::string_view XmlNodeName = "frameSpec"; 
    static const xml::XmlElementArray<Frame>& xmlMappingArray();    
};
 
class FretInstrument;
class FretboardGroup : public OthersBase
{
public:
    explicit FretboardGroup(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper cmper, Inci inci)
        : OthersBase(document, partId, shareMode, cmper, inci)
    {
    }
 
    Cmper fretInstId{};   
    std::string name;     
 
    MusxInstance<FretInstrument> getFretInstrument() const;
 
    MusxInstanceList<details::FretboardDiagram> getFretboardDiagrams() const;
 
    constexpr static std::string_view XmlNodeName = "fretGroup"; 
    static const xml::XmlElementArray<FretboardGroup>& xmlMappingArray(); 
};
 
class FretboardStyle : public OthersBase
{
public:
    explicit FretboardStyle(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper cmper)
        : OthersBase(document, partId, shareMode, cmper)
    {
    }
 
    bool showLastFret{};     
    bool rotate{};           
    bool fingNumWhite{};     
    Cmper fingStrShapeId{};  
    Cmper openStrShapeId{};  
    Cmper muteStrShapeId{};  
    Cmper barreShapeId{};    
    Cmper customShapeId{};   
    int defNumFrets{};       
    Efix stringGap{};        
    Efix fretGap{};          
    Efix stringWidth{};      
    Efix fretWidth{};        
    Efix nutWidth{};         
    Efix vertTextOff{};      
    Efix horzTextOff{};      
    Efix horzHandleOff{};    
    Efix vertHandleOff{};    
    Efix whiteout{};         
    std::shared_ptr<FontInfo> fretNumFont; 
    std::shared_ptr<FontInfo> fingNumFont; 
    Efix horzFingNumOff{};   
    Efix vertFingNumOff{};   
    std::string name;        
    std::string fretNumText; 
 
    void integrityCheck(const std::shared_ptr<EnigmaBase>& ptrToThis) override
    {
        this->OthersBase::integrityCheck(ptrToThis);
        if (!fretNumFont) {
            fretNumFont = std::make_shared<FontInfo>(getDocument());
        }
        if (!fingNumFont) {
            fingNumFont = std::make_shared<FontInfo>(getDocument());
        }
    }
 
    constexpr static std::string_view XmlNodeName = "fretStyle"; 
    static const xml::XmlElementArray<FretboardStyle>& xmlMappingArray(); 
};
 
class FretInstrument : public OthersBase
{
public:
    explicit FretInstrument(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper cmper)
        : OthersBase(document, partId, shareMode, cmper)
    {
    }
 
    class StringInfo
    {
    public:
        int  pitch{};       
        int  nutOffset{};   
 
        static const xml::XmlElementArray<StringInfo>& xmlMappingArray(); 
    };
 
    int numFrets{};                 
    int numStrings{};               
    std::string name;               
    std::vector<std::shared_ptr<StringInfo>> strings;  
    std::vector<int> fretSteps;     
    ClefIndex speedyClef{};         
 
    void integrityCheck(const std::shared_ptr<EnigmaBase>& ptrToThis) override
    {
        this->OthersBase::integrityCheck(ptrToThis);
        if (numStrings != int(strings.size())) {
            MUSX_INTEGRITY_ERROR("Fret instrument " + std::to_string(getCmper()) + " specifies " + std::to_string(numStrings)
                + " strings but has " + std::to_string(strings.size()) + " StringInfo instances.");
        }
        if (!fretSteps.empty() && numFrets != int(fretSteps.size())) {
            util::Logger::log(util::Logger::LogLevel::Info, "Fret instrument " + std::to_string(getCmper()) + " specifies " + std::to_string(numFrets)
                + " frets but has " + std::to_string(fretSteps.size()) + " diatonic fret steps specified.");
        }
    }
 
    constexpr static std::string_view XmlNodeName = "fretInst"; 
    static const xml::XmlElementArray<FretInstrument>& xmlMappingArray(); 
};
 
class KeyFormat : public OthersBase {
public:
    explicit KeyFormat(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper cmper)
        : OthersBase(document, partId, shareMode, cmper) {}
 
    unsigned semitones{};       
    unsigned scaleTones{};      
 
    constexpr static std::string_view XmlNodeName = "keyFormat"; 
    static const xml::XmlElementArray<KeyFormat>& xmlMappingArray(); 
};
 
class KeyMapArray : public OthersBase {
public:
    explicit KeyMapArray(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper cmper)
        : OthersBase(document, partId, shareMode, cmper) {}
 
    class StepElement {
    public:
        bool diatonic{};    
        unsigned hlevel{};  
 
        static const xml::XmlElementArray<StepElement>& xmlMappingArray(); 
    };
 
    std::vector<std::shared_ptr<StepElement>> steps; 
 
    unsigned countDiatonicSteps() const
    {
        return static_cast<unsigned>(std::count_if(steps.begin(), steps.end(), [](const auto& step) {
            return step->diatonic;
        }));
    }
 
    constexpr static std::string_view XmlNodeName = "keyMap"; 
    static const xml::XmlElementArray<KeyMapArray>& xmlMappingArray(); 
};
 
class KeyAttributes : public OthersBase {
public:
    explicit KeyAttributes(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper cmper)
        : OthersBase(document, partId, shareMode, cmper) {}
 
    // Public properties corresponding to the XML structure
    int harmRefer{};        
    int middleCKey{};       
    Cmper fontSym{};        
    int gotoKey{};          
    Cmper symbolList{};     
    bool hasClefOctv{};     
 
    constexpr static std::string_view XmlNodeName = "keysAttrib"; 
    static const xml::XmlElementArray<KeyAttributes>& xmlMappingArray(); 
};
 
class LayerAttributes : public OthersBase {
public:
    explicit LayerAttributes(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper cmper)
        : OthersBase(document, partId, shareMode, cmper) {}
 
    // Public properties corresponding to the XML structure
    int restOffset{};                   
    bool freezTiesToStems{};            
    bool onlyIfOtherLayersHaveNotes{};  
    bool useRestOffset{};               
    bool freezeStemsUp{};               
    bool freezeLayer{};                 
    bool playback{};                    
    bool affectSpacing{};               
    bool ignoreHiddenNotesOnly{};       
    bool ignoreHiddenLayers{};          
    bool hideLayer{};                   
 
    constexpr static std::string_view XmlNodeName = "layerAtts"; 
    static const xml::XmlElementArray<LayerAttributes>& xmlMappingArray(); 
};
 
enum class RehearsalMarkStyle
{
    None,                       
    Letters,                    
    LetterNumbers,              
    LettersLowerCase,           
    LettersNumbersLowerCase,    
    Numbers,                    
    MeasureNumber               
};
 
enum class PlaybackType
{
    None,                   
    Tempo,                  
    MidiController,         
    KeyVelocity,            
    Transpose,              
    Channel,                
    MidiPatchChange,        
    PercussionMidiMap,      
    MidiPitchWheel,         
    ChannelPressure,        
    RestrikeKeys,           
    Dump,                   
    PlayTempoToolChanges,   
    IgnoreTempoToolChanges, 
    Swing,                  
    SmartPlaybackOn,        
    SmartPlaybackOff,       
};
 
enum class HorizontalMeasExprAlign
{
    LeftBarline,            
    Manual,                 
    LeftOfAllNoteheads,     
    LeftOfPrimaryNotehead,  
    Stem,                   
    CenterPrimaryNotehead,  
    CenterAllNoteheads,     
    RightOfAllNoteheads,    
    StartTimeSig,           
    AfterClefKeyTime,       
    StartOfMusic,           
    CenterOverBarlines,     
    CenterOverMusic,        
    RightBarline            
};
 
enum class VerticalMeasExprAlign
{
    AboveStaff,          
    Manual,              
    RefLine,             
    BelowStaff,          
    TopNote,             
    BottomNote,          
    AboveEntry,          
    BelowEntry,          
    AboveStaffOrEntry,   
    BelowStaffOrEntry    
};
 
class ShapeExpressionDef;
class TextExpressionDef;
 
class MarkingCategory : public OthersBase {
public:
    enum class CategoryType : Cmper
    {
        Invalid,            
        Dynamics,           
        TempoMarks,         
        TempoAlterations,   
        ExpressiveText,     
        TechniqueText,      
        RehearsalMarks,     
        Misc                
    };
 
    explicit MarkingCategory(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper cmper)
        : OthersBase(document, partId, shareMode, cmper) {}
 
    CategoryType categoryType{}; 
 
    // Font information for the marking category
    std::shared_ptr<FontInfo> textFont;      
    std::shared_ptr<FontInfo> musicFont;     
    std::shared_ptr<FontInfo> numberFont;    
 
    HorizontalMeasExprAlign horzAlign{};     
    VerticalMeasExprAlign vertAlign{};       
    AlignJustify justification{};            
 
    // Vertical and horizontal offsets for positioning adjustments
    Evpu horzOffset{};         
    Evpu vertOffsetBaseline{}; 
    Evpu vertOffsetEntry{};    
 
    // Usage flags representing certain behaviors and visual elements
    bool usesTextFont{};      
    bool usesMusicFont{};     
    bool usesNumberFont{};    
    bool usesPositioning{};   
    bool usesStaffList{};     
    bool usesBreakMmRests{};  
    bool breakMmRest{};       
    bool userCreated{};       
 
    // Staff list represented as an integer
    Cmper staffList{};        
 
    std::map<Cmper, MusxInstanceWeak<ShapeExpressionDef>> shapeExpressions;
 
    std::map<Cmper, MusxInstanceWeak<TextExpressionDef>> textExpressions;
 
    std::string getName() const;
 
    CategoryStaffListSet createStaffListSet() const;
 
    void integrityCheck(const std::shared_ptr<EnigmaBase>& ptrToThis) override
    {
        this->OthersBase::integrityCheck(ptrToThis);
        if (!textFont) {
            textFont = std::make_shared<FontInfo>(ptrToThis->getDocument());
            MUSX_INTEGRITY_ERROR("Marking category " + std::to_string(getCmper()) + " is missing text font.");
        }
        if (!musicFont) {
            musicFont = std::make_shared<FontInfo>(ptrToThis->getDocument());
            MUSX_INTEGRITY_ERROR("Marking category " + std::to_string(getCmper()) + " is missing music font.");
        }
        if (!numberFont) {
            numberFont = std::make_shared<FontInfo>(ptrToThis->getDocument());
            util::Logger::log(util::Logger::LogLevel::Info, "Marking category " + std::to_string(getCmper()) + " is missing number font.");
        }
    }
 
    constexpr static std::string_view XmlNodeName = "markingsCategory"; 
    static const xml::XmlElementArray<MarkingCategory>& xmlMappingArray(); 
};
 
class MarkingCategoryName : public OthersName {
public:
    using OthersName::OthersName;
 
    constexpr static std::string_view XmlNodeName = "markingsCategoryName"; 
};
 
[[nodiscard]]
std::optional<Cmper> importMarkingCategoryInto(const DocumentPtr& target,
    const DocumentPtr& source, Cmper cmper, const ImportObjectCallback& onImported = {});
 
class MeasureNumberRegion;
class Measure : public OthersBase {
public:
    explicit Measure(const DocumentWeakPtr& document, Cmper measureId, ShareMode shareMode, Cmper cmper)
        : OthersBase(document, measureId, shareMode, cmper) {}
 
    enum class PositioningType
    {
        Manual,                     
        TimeSignature,              
        BeatChart,                  
        TimeSigPlusPositioning,     
        BeatChartPlusPositioning    
    };
 
    enum class BarlineType
    {
        None,                   
        OptionsDefault,         
        Normal,                 
        Double,                 
        Final,                  
        Solid,                  
        Dashed,                 
        Tick,                   
        Custom                  
    };
 
    enum class ShowKeySigMode
    {
        IfNeeded,               
        Always,                 
        Never                   
    };
 
    enum class ShowTimeSigMode
    {
        IfNeeded,               
        Always,                 
        Never                   
    };
 
    Evpu width{};               
    std::shared_ptr<KeySignature> globalKeySig; 
    Cmper beats{};              
    Cmper divBeat{};            
    Cmper dispBeats{};          
    Cmper dispDivbeat{};        
    Cmper customBarShape{};     
    Cmper customLeftBarShape{}; 
    Evpu frontSpaceExtra{};     
    Evpu backSpaceExtra{};      
    bool breakWordExt{};        
    bool hideCaution{};         
    bool hasSmartShape{};       
    bool groupBarlineOverride{}; 
    bool showFullNames{};       
    bool hasMeasNumbIndivPos{}; 
    bool allowSplitPoints{};    
    bool compositeNumerator{};  
    bool compositeDenominator{}; 
    ShowKeySigMode showKey{};   
    ShowTimeSigMode showTime{}; 
    bool evenlyAcrossMeasure{}; 
    PositioningType positioningMode{}; 
    bool beginNewSystem{};      
    bool hasExpression{};       
    bool breakMmRest{};         
    bool noMeasNum{};           
    bool hasOssia{};            
    bool hasTextBlock{};        
    BarlineType barlineType{};  
    bool forwardRepeatBar{};    
    bool backwardsRepeatBar{};  
    bool hasEnding{};           
    bool hasTextRepeat{};       
    bool abbrvTime{};           
    bool useDisplayTimesig{};   
    bool hasChord{};            
    BarlineType leftBarlineType{}; 
    bool compositeDispNumerator{};  
    bool compositeDispDenominator{}; 
    bool pageBreak{};           
 
    bool calcShouldShowFullNames() const
    { return getCmper() == 1 || showFullNames; }
 
    MusxInstance<MeasureNumberRegion> findMeasureNumberRegion() const;
 
    std::optional<int> calcDisplayNumber() const;
 
    std::optional<std::string> calcDisplayNumberText() const;
 
    MusxInstance<KeySignature> createKeySignature(const std::optional<StaffCmper>& forStaff = std::nullopt) const;
 
    MusxInstance<TimeSignature> createTimeSignature(const std::optional<StaffCmper>& forStaff = std::nullopt) const;
 
    MusxInstance<TimeSignature> createDisplayTimeSignature(const std::optional<StaffCmper>& forStaff = std::nullopt) const;
 
    util::Fraction calcMinLegacyPickupSpacer(StaffCmper forStaffId) const;
 
    std::optional<Duration> calcDefaultPickupRestValue() const;
 
    util::Fraction calcMinLegacyPickupSpacer() const;
 
    util::Fraction calcDuration(const std::optional<StaffCmper>& forStaff = std::nullopt) const;
 
    util::Fraction calcTimeStretch(StaffCmper forStaff) const
    {
        return calcDuration() / calcDuration(forStaff);
    }
 
    static void checkMeasureCmperSequence(const DocumentPtr& document);
 
    void integrityCheck(const std::shared_ptr<EnigmaBase>& ptrToThis) override
    {
        this->OthersBase::integrityCheck(ptrToThis);
        if (!globalKeySig) {
            globalKeySig = std::make_shared<KeySignature>(getDocument());
        }
    }
 
    constexpr static std::string_view XmlNodeName = "measSpec"; 
    static const xml::XmlElementArray<Measure>& xmlMappingArray(); 
};
 
class MeasureExprAssign : public OthersBase
{
private:
    [[nodiscard]] std::optional<HorizontalMeasExprAlign> calcEntryAlignmentType() const;
 
    [[nodiscard]] std::optional<utils::PseudoTieShapeInfo> calcPseudoTieShape() const;
 
public:
    explicit MeasureExprAssign(const DocumentWeakPtr& document, Cmper ID, ShareMode shareMode, Cmper cmper, Inci inci)
        : OthersBase(document, ID, shareMode, cmper, inci) {}
 
    enum class ChannelSwitchTarget
    {
        Current,            
        ToLayer1,           
        ToLayer2,           
        ToLayer3,           
        ToLayer4,           
        ToChord,            
        ToExpression,       
    };
 
    enum class PlaybackStart
    {
        BeginningOfMeasure,     
        AlignmentPoint,         
        PositionInMeasure       
    };
 
    enum class ShowStaffList
    {
        ScoreAndPart,           
        ScoreOnly,              
        PartOnly,               
    };
 
    // Public properties corresponding to the XML structure
    Cmper textExprId{};                     
    Cmper shapeExprId{};                    
    Evpu horzEvpuOff{};                     
    Edu eduPosition{};                      
    Evpu vertEvpuOff{};                     
    StaffCmper staffAssign{};               
    int layer{};                            
    bool voice2{};                          
    ChannelSwitchTarget channelSwitch{};    
    bool dontScaleWithEntry{};              
    PlaybackStart playbackStart{};          
    ShowStaffList showStaffList{};          
    bool createdByHp{};                     
    bool hidden{};                          
    int staffGroup{};                       
    Cmper staffList{};                      
    unsigned graceNoteIndex{};              
    int rehearsalMarkOffset{};              
 
    [[nodiscard]] bool calcIsSameDefinition(const MeasureExprAssign& src) const;
 
    [[nodiscard]] bool calcIsPseudoTie(utils::PseudoTieMode mode, const EntryInfoPtr& forStartEntry) const;
 
    MusxInstance<TextExpressionDef> getTextExpression() const;
 
    MusxInstance<ShapeExpressionDef> getShapeExpression() const;
 
    MusxInstance<MarkingCategory> getMarkingCategory() const;
 
    CategoryStaffListSet createStaffListSet() const;
 
    bool calcIsPartOfStaffListAssignment() const;
 
    StaffCmper calcAssignedStaffId(bool forPageView = true) const;
 
    MusxInstance<StaffComposite> createCurrentStaff(bool forPageView = true) const;
 
    EntryInfoPtr calcAssociatedEntry() const;
 
    bool calcIsAssignedInRequestedPart() const;
 
    bool calcAppliesToLayer(LayerIndex layerIndex) const;
 
    bool calcIsHiddenByAlternateNotation() const;
 
    [[nodiscard]] std::optional<Evpu> calcBaselinePosition(bool forAbove) const;
 
    [[nodiscard]] std::optional<Evpu> calcDefaultVerticalPosition() const;
 
    [[nodiscard]] VerticalPlacement calcVerticalPlacement() const;
 
    util::EnigmaParsingContext getRawTextCtx(Cmper forPartId) const;
 
    void integrityCheck(const std::shared_ptr<EnigmaBase>& ptrToThis) override
    {
        this->OthersBase::integrityCheck(ptrToThis);
        if (!textExprId && !shapeExprId) {
            MUSX_INTEGRITY_ERROR("Expression assignment at measure " + std::to_string(getCmper()) + " inci " + std::to_string(getInci().value_or(-1))
                + " has no expression definition ID.");
        } else if (textExprId && shapeExprId) {
            MUSX_INTEGRITY_ERROR("Expression assignment at measure " + std::to_string(getCmper()) + " inci " + std::to_string(getInci().value_or(-1))
                + " has both text expr ID " + std::to_string(textExprId) + " and shape expr ID " + std::to_string(shapeExprId));
        }
    }
 
    constexpr static std::string_view XmlNodeName = "measExprAssign"; 
    static const xml::XmlElementArray<MeasureExprAssign>& xmlMappingArray(); 
};
 
class MeasureNumberRegion : public OthersBase {
public:
    explicit MeasureNumberRegion(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper cmper)
        : OthersBase(document, partId, shareMode, cmper) {}
 
    enum class TimePrecision
    {
        WholeSeconds,   
        Tenths,
        Hundredths,
        Thousandths,
    };
 
    class ScorePartData : public ContainedClassBase
    {
    public:
        using ContainedClassBase::ContainedClassBase;
 
        std::shared_ptr<FontInfo> startFont;          
        std::shared_ptr<FontInfo> multipleFont;       
        std::shared_ptr<FontInfo> mmRestFont;         
        std::shared_ptr<Enclosure> startEnclosure;    
        std::shared_ptr<Enclosure> multipleEnclosure; 
 
        Evpu startXdisp{};         
        Evpu startYdisp{};         
        Evpu multipleXdisp{};      
        Evpu multipleYdisp{};      
        Evpu mmRestXdisp{};        
        Evpu mmRestYdisp{};        
        char32_t leftMmBracketChar{};  
        char32_t rightMmBracketChar{}; 
        int startWith{};           
        int incidence{};           
        AlignJustify startAlign{};  
        AlignJustify multipleAlign{}; 
        AlignJustify mmRestAlign{}; 
        bool showOnStart{};        
        bool showOnEvery{};        
        bool hideFirstMeasure{};   
        bool showMmRange{};        
        bool showOnMmRest{};       
        bool useStartEncl{};       
        bool useMultipleEncl{};    
        bool showOnTop{};          
        bool showOnBottom{};       
        bool excludeOthers{};      
        bool breakMmRest{};        
        AlignJustify startJustify{}; 
        AlignJustify multipleJustify{}; 
        AlignJustify mmRestJustify{}; 
 
        void integrityCheck(const std::shared_ptr<EnigmaBase>& ptrToThis) override
        {
            this->ContainedClassBase::integrityCheck(ptrToThis);
            if (!startFont) {
                startFont = std::make_shared<FontInfo>(ptrToThis->getDocument());
                //MUSX_INTEGRITY_ERROR("Measure number region score part data is missing start font.");
            }
            if (!multipleFont) {
                multipleFont = std::make_shared<FontInfo>(ptrToThis->getDocument());
                MUSX_INTEGRITY_ERROR("Measure number region score part data is missing multiple numbers font.");
            }
            if (!mmRestFont) {
                mmRestFont = std::make_shared<FontInfo>(ptrToThis->getDocument());
                MUSX_INTEGRITY_ERROR("Measure number region score part data is missing multimeasure rest range font.");
            }
        }
 
        static const xml::XmlElementArray<ScorePartData>& xmlMappingArray(); 
    };
 
    // No fixture has a part-specific MeasureNumberRegion. If partial sharing is observed,
    // scoreData and partData must be copied and rebound before their nested fields are overlaid.
    // See PartContextRebinder<details::CenterShape> and the CenterShape field mappings for the pattern.
 
    // Public properties
    std::shared_ptr<ScorePartData> scoreData; 
    std::shared_ptr<ScorePartData> partData;  
 
    MeasCmper startMeas{};      
    MeasCmper endMeas{};        
    char32_t startChar{};       
    int base{};                 
    int numberOffset{};         
    std::string prefix;         
    std::string suffix;         
 
    bool countFromOne{};        
    bool noZero{};              
    bool doubleUp{};            
    bool time{};                
    bool includeHours{};        
    bool smpteFrames{};         
    bool useScoreInfoForPart{}; 
    int region{};               
    TimePrecision timePrecision{}; 
    bool hideScroll{};          
    bool hidePage{};            
 
    [[nodiscard]] bool calcIncludesMeasure(MeasCmper measureId) const
    {
        return measureId >= startMeas && measureId < endMeas; // endMeas is non-inclusive!
    }
 
    [[nodiscard]] int getStartNumber() const { return int(numberOffset + 1); }
 
    [[nodiscard]] std::optional<int> calcDisplayNumberFor(MeasCmper measureId) const;
 
    [[nodiscard]] std::optional<std::string> calcDisplayNumberTextFor(MeasCmper measureId) const;
 
    [[nodiscard]] std::optional<MeasCmper> calcFirstDisplayedMeasureId() const;
 
    [[nodiscard]] std::optional<MeasCmper> calcLastDisplayedMeasureId() const;
 
    [[nodiscard]] std::optional<int> calcFirstDisplayNumber() const;
 
    [[nodiscard]] std::optional<int> calcLastDisplayNumber() const;
    
    void integrityCheck(const std::shared_ptr<EnigmaBase>& ptrToThis) override
    {
        this->OthersBase::integrityCheck(ptrToThis);
        if (startMeas >= endMeas) {
            MUSX_INTEGRITY_ERROR("Measure number region " + std::to_string(getCmper())
                + " has an invalid measure range: start measure " + std::to_string(startMeas)
                + " is not before end measure " + std::to_string(endMeas) + ".");
        }
        if (!scoreData) {
            scoreData = std::make_shared<ScorePartData>(ptrToThis);
            MUSX_INTEGRITY_ERROR("Measure number region " + std::to_string(getCmper()) + " is missing score data.");
        }
        if (!partData) {
            partData = std::make_shared<ScorePartData>(ptrToThis);
            MUSX_INTEGRITY_ERROR("Measure number region " + std::to_string(getCmper()) + " is missing part data.");
        }
        scoreData->integrityCheck(scoreData);
        partData->integrityCheck(partData);
    }
 
    constexpr static std::string_view XmlNodeName = "measNumbRegion"; 
    static const xml::XmlElementArray<MeasureNumberRegion>& xmlMappingArray(); 
};
 
class MultimeasureRest : public OthersBase {
public:
    explicit MultimeasureRest(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper startMeasure)
        : OthersBase(document, partId, shareMode, startMeasure) {}
 
    Evpu measWidth{};           
    MeasCmper nextMeas{};       
    Evpu numVertAdj{};          
    Cmper shapeDef{};           
    int numStart{};             
    int symbolThreshold{};      
    Evpu symbolSpacing{};       
    Evpu numHorzAdj{};          
    Evpu shapeStartAdjust{};    
    Evpu shapeEndAdjust{};      
    bool useSymbols{};          
    bool noHorizontalStretch{}; 
 
    MeasCmper getStartMeasure() const { return getCmper(); }
 
    int calcNumberOfMeasures() const { return (std::max)(nextMeas - getStartMeasure(), 0); }
 
    bool calcUsesSymbols() const;
 
    bool calcIsNumberVisible() const { return calcNumberOfMeasures() >= numStart; }
 
    void integrityCheck(const std::shared_ptr<EnigmaBase>& ptrToThis) override
    {
        this->OthersBase::integrityCheck(ptrToThis);
        if (nextMeas <= getStartMeasure()) {
            MUSX_INTEGRITY_ERROR("Multimeasure rest at " + std::to_string(getCmper()) + " in part " + std::to_string(getSourcePartId()) + " spans 0 or fewer measures.");
        }
    }
 
    constexpr static std::string_view XmlNodeName = "mmRest"; 
    static const xml::XmlElementArray<MultimeasureRest>& xmlMappingArray(); 
};
 
class MultiStaffGroupId : public OthersBase {
public:
    explicit MultiStaffGroupId(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper cmper)
        : OthersBase(document, partId, shareMode, cmper) {}
 
    Cmper staffGroupId{}; 
 
    constexpr static std::string_view XmlNodeName = "multiStaffGroupID"; 
    static const xml::XmlElementArray<MultiStaffGroupId>& xmlMappingArray(); 
};
 
class MultiStaffInstrumentGroup : public OthersBase {
public:
    explicit MultiStaffInstrumentGroup(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper cmper)
        : OthersBase(document, partId, shareMode, cmper) {}
 
    std::vector<StaffCmper> staffNums; 
 
    MusxInstance<Staff> getStaffInstanceAtIndex(size_t x) const;
 
    MusxInstance<Staff> getFirstStaffInstance() const;
 
    std::optional<size_t> getIndexOf(StaffCmper staffId) const
    {
        for (size_t x = 0; x < staffNums.size(); x++) {
            if (staffNums[x] == staffId) return x;
        }
        return std::nullopt;
    }
 
    MusxInstance<details::StaffGroup> getStaffGroup(Cmper forPartId) const;
 
    static void calcAllMultiStaffGroupIds(const DocumentPtr& document);
 
    void integrityCheck(const std::shared_ptr<EnigmaBase>& ptrToThis) override
    {
        OthersBase::integrityCheck(ptrToThis);
        if (staffNums.empty()) {
            MUSX_INTEGRITY_ERROR("MultiStaffInstrumentGroup " + std::to_string(getCmper()) + " contains no staves.");
        } else if (staffNums.size() > 3) {
            MUSX_INTEGRITY_ERROR("MultiStaffInstrumentGroup " + std::to_string(getCmper()) + " contains more than 3 staves.");
        }
    }
 
    constexpr static std::string_view XmlNodeName = "multiStaffInstGroup"; 
    static const xml::XmlElementArray<MultiStaffInstrumentGroup>& xmlMappingArray(); 
};
 
class NamePositionAbbreviated : public NamePositioning
{
public:
    using NamePositioning::NamePositioning;
 
    constexpr static std::string_view XmlNodeName = "namePosAbbrv"; 
};
 
class NamePositionStyleAbbreviated : public NamePositioning
{
public:
    using NamePositioning::NamePositioning;
 
    constexpr static std::string_view XmlNodeName = "namePosAbbrvStyle"; 
};
 
class NamePositionFull : public NamePositioning
{
public:
    using NamePositioning::NamePositioning;
 
    constexpr static std::string_view XmlNodeName = "namePosFull"; 
};
 
class NamePositionStyleFull : public NamePositioning
{
public:
    using NamePositioning::NamePositioning;
 
    constexpr static std::string_view XmlNodeName = "namePosFullStyle"; 
};
 
class Page : public OthersBase {
public:
    explicit Page(const DocumentWeakPtr& document, PageCmper pageId, ShareMode shareMode, Cmper cmper)
        : OthersBase(document, pageId, shareMode, cmper) {}
 
    Evpu height{};              
    Evpu width{};               
    int percent{};              
    SystemCmper firstSystemId{}; 
    bool holdMargins{};         
    Evpu margTop{};             
    Evpu margLeft{};            
    Evpu margBottom{};          
    Evpu margRight{};           
 
    std::optional<SystemCmper> lastSystemId;    
    std::optional<MeasCmper> firstMeasureId;    
    std::optional<MeasCmper> lastMeasureId;     
 
    bool isBlank() const { return firstSystemId == -1; }
 
    bool isLayoutCalculated() const
    {
        return isBlank() || (firstSystemId > 0 && lastSystemId && firstMeasureId && lastMeasureId);
    }
 
    util::Fraction calcPageScaling() const
    { return util::Fraction::fromPercent(percent); }
 
    static void calcSystemInfo(const DocumentPtr& document);
 
    constexpr static std::string_view XmlNodeName = "pageSpec"; 
    static const xml::XmlElementArray<Page>& xmlMappingArray(); 
};
 
class TextBlock;
class PageTextAssign : public OthersBase
{
public:
    enum class PageAssignType
    {
        AllPages,       
        Even,
        Odd
    };
 
    using HorizontalAlignment = options::TextOptions::HorizontalAlignment;  
    using VerticalAlignment = options::TextOptions::VerticalAlignment;      
 
    explicit PageTextAssign(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper cmper, Inci inci)
        : OthersBase(document, partId, shareMode, cmper, inci)
    {
    }
 
    Cmper block{};                  
    Evpu xDisp{};                   
    Evpu yDisp{};                   
    PageCmper startPage{};          
    PageCmper endPage{};            
    PageAssignType oddEven{};       
    HorizontalAlignment hPosLp{};   
    HorizontalAlignment hPosRp{};   
    bool hidden{};                  
    VerticalAlignment vPos{};       
    bool hPosPageEdge{};            
    bool vPosPageEdge{};            
    bool indRpPos{};                
    Evpu rightPgXDisp{};            
    Evpu rightPgYDisp{};            
 
    MusxInstance<TextBlock> getTextBlock() const;
 
    std::optional<PageCmper> calcStartPageNumber(Cmper forPartId) const;
 
    std::optional<PageCmper> calcEndPageNumber(Cmper forPartId) const;
 
    util::EnigmaParsingContext getRawTextCtx(Cmper forPartId, std::optional<Cmper> forPageId = std::nullopt) const;
 
    bool isMultiPage() const
    { return getCmper() == 0 && startPage != endPage; }
 
    bool isMultiAssignedThruLastPage() const
    { return isMultiPage() && endPage == 0; }
 
    void integrityCheck(const std::shared_ptr<EnigmaBase>& ptrToThis) override
    {
        this->OthersBase::integrityCheck(ptrToThis);
        if (getCmper() != 0) {
            if (startPage != getCmper() || endPage != getCmper()) {
                MUSX_INTEGRITY_ERROR("PageTextAssign " + std::to_string(getCmper()) + " inci " + std::to_string(getInci().value_or(0)) +
                    " has startPage or endPage value that does not match.");
            }
        }
    }
 
    static MusxInstance<others::PageTextAssign> getForPageId(const DocumentPtr& document, Cmper partId, PageCmper pageId, Inci inci);
 
    static MusxInstanceList<others::PageTextAssign> getArrayForPageId(const DocumentPtr& document, Cmper partId, PageCmper pageId);
 
    constexpr static std::string_view XmlNodeName = "pageTextAssign"; 
    static const xml::XmlElementArray<PageTextAssign>& xmlMappingArray(); 
};
 
class PartDefinition : public OthersBase
{
public:
    explicit PartDefinition(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper cmper)
        : OthersBase(document, partId, shareMode, cmper) {}
 
    // Public properties corresponding to the XML structure
    Cmper nameId{};                     
    int partOrder{};                    
    int copies{};                       
    bool printPart{};                   
    bool extractPart{};                 
    bool applyFormat{};                 
    bool needsRecalc{};                 
    bool useAsSmpInst{};                
    bool unlinkInsts{};                 
    int smartMusicInst{};               
    Cmper defaultNameStaff{};           
    Cmper defaultNameGroup{};           
 
    int numberOfLeadingBlankPages{};    
    int numberOfPages{};                
 
    util::EnigmaParsingContext getNameRawTextCtx() const;
 
    std::string getName(util::EnigmaString::AccidentalStyle accidentalStyle = util::EnigmaString::AccidentalStyle::Ascii) const;
 
    bool isLayoutCalculated() const;
 
    bool isScore() const { return getCmper() == SCORE_PARTID; }
 
    Cmper calcScrollViewCmper() const;
 
    std::optional<PageCmper> calcPageNumberFromAssignmentId(PageCmper pageAssignmentId) const;
 
    PageCmper calcAssignmentIdFromPageNumber(PageCmper pageId) const;
 
    static MusxInstance<PartDefinition> getScore(const DocumentPtr& document);
 
    static MusxInstanceList<PartDefinition> getInUserOrder(const DocumentPtr& document);
 
    constexpr static std::string_view XmlNodeName = "partDef"; 
    static const xml::XmlElementArray<PartDefinition>& xmlMappingArray(); 
};
 
class PartGlobals : public OthersBase {
public:
    explicit PartGlobals(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper cmper)
        : OthersBase(document, partId, shareMode, cmper) {}
 
    // Public properties corresponding to the XML structure
    bool showTransposed{};                  
    Cmper scrollViewIUlist{};               
    Cmper studioViewIUlist{};               
    Cmper specialPartExtractionIUList{};
 
    Cmper calcScrollViewCmper() const;
 
    constexpr static std::string_view XmlNodeName = "partGlobals"; 
    static const xml::XmlElementArray<PartGlobals>& xmlMappingArray(); 
};
 
class PartVoicing : public OthersBase {
public:
    explicit PartVoicing(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper staff)
        : OthersBase(document, partId, shareMode, staff) {}
 
    enum class VoicingType
    {
        UseSingleLayer,             
        UseMultipleLayers           
    };
 
    enum class SingleLayerVoiceType
    {
        AllNotes,                   
        TopNote,                    
        BottomNote,                 
        SelectedNotes               
    };
 
    bool enabled{};                             
    VoicingType voicingType{};                  
    SingleLayerVoiceType singleLayerVoiceType{}; 
    bool select1st{};                           
    bool select2nd{};                           
    bool select3rd{};                           
    bool select4th{};                           
    bool select5th{};                           
    bool selectFromBottom{};                    
    bool selectSingleNote{};                    
    LayerIndex singleLayer{};                   
    LayerIndex multiLayer{};                    
 
    bool calcShowsLayer(LayerIndex layerIndex, bool frameIsMultilayerInScore) const;
 
    bool calcShowsNote(const NoteInfoPtr& noteInfoPtr) const;
 
    constexpr static std::string_view XmlNodeName = "voicingDef"; 
    static const xml::XmlElementArray<PartVoicing>& xmlMappingArray(); 
};
 
class PercussionNoteInfo : public OthersBase {
public:
    explicit PercussionNoteInfo(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper cmper, Inci inci)
        : OthersBase(document, partId, shareMode, cmper, inci) {}
 
    PercussionNoteTypeId percNoteType{};    
    int staffPosition{};                    
    char32_t closedNotehead{};              
    char32_t halfNotehead{};                
    char32_t wholeNotehead{};               
    char32_t dwholeNotehead{};              
 
    int calcStaffReferencePosition() const { return staffPosition - 10; }
 
    PercussionNoteTypeId getBaseNoteTypeId() const
    { return percNoteType & 0xfff; }
 
    unsigned getNoteTypeOrderId() const
    { return(percNoteType & 0xf000) >> 12; }
 
    const percussion::PercussionNoteType& getNoteType() const;
 
    constexpr static std::string_view XmlNodeName = "percussionNoteInfo"; 
    static const xml::XmlElementArray<PercussionNoteInfo>& xmlMappingArray(); 
};
 
enum class RepeatActionType
{
    JumpAuto,               
    JumpAbsolute,           
    JumpRelative,           
    JumpToMark,             
    Stop,                   
    NoJump                  
};
 
enum class RepeatTriggerType
{
    Always,                 
    OnPass,                 
    UntilPass               
};
 
class RepeatIndividualPositioning;
 
class RepeatBack : public OthersBase {
public:
    explicit RepeatBack(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper cmper)
        : OthersBase(document, partId, shareMode, cmper) {}
 
    // Public properties corresponding to the XML structure
    int passNumber{};               
    int targetValue{};              
    Evpu leftHPos{};                
    Evpu leftVPos{};                
    bool individualPlacement{};     
    bool topStaffOnly{};            
    bool hidden{};                  
    bool resetOnAction{};           
    RepeatActionType jumpAction{};  
    RepeatTriggerType trigger{};    
    Cmper staffList{};              
    Evpu rightHPos{};               
    Evpu rightVPos{};               
 
    MusxInstance<RepeatIndividualPositioning> getIndividualPositioning(StaffCmper staffId) const;
 
    RepeatStaffListSet createStaffListSet() const;
 
    std::optional<MeasCmper> calcTargetMeasure() const;
 
    constexpr static std::string_view XmlNodeName = "repeatBack"; 
    static const xml::XmlElementArray<RepeatBack>& xmlMappingArray(); 
};
 
class RepeatEndingStart : public OthersBase
{
public:
    explicit RepeatEndingStart(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper cmper)
        : OthersBase(document, partId, shareMode, cmper)
    {
    }
 
    Cmper staffList{};              
    int targetValue{};              
    Evpu textHPos{};                
    Evpu leftHPos{};                
    Evpu leftVPos{};                
    bool individualPlacement{};     
    bool topStaffOnly{};            
    bool hidden{};                  
    RepeatActionType jumpAction{};  
    RepeatTriggerType trigger{};    
    bool jumpIfIgnoring{};          
    Evpu endLineVPos{};             
    Evpu textVPos{};                
    Evpu rightHPos{};               
    Evpu rightVPos{};               
 
    int calcEndingLength() const;
 
    std::optional<MeasCmper> calcTargetMeasure() const;
 
    bool calcIsOpen() const;
 
    MusxInstance<RepeatIndividualPositioning> getIndividualPositioning(StaffCmper staffId) const;
 
    MusxInstance<RepeatIndividualPositioning> getTextIndividualPositioning(StaffCmper staffId) const;
 
    std::string createEndingText() const;
 
    RepeatStaffListSet createStaffListSet() const;
 
    void integrityCheck(const std::shared_ptr<EnigmaBase>& ptrToThis) override
    {
        OthersBase::integrityCheck(ptrToThis);
        if (trigger != RepeatTriggerType::OnPass) {
            MUSX_INTEGRITY_ERROR("RepeatEndingStart at measure " + std::to_string(getCmper()) + " has an unexpected trigger value " +
                std::to_string(int(trigger)));
        }
    }
 
    constexpr static std::string_view XmlNodeName = "repeatEndingStart"; 
    static const xml::XmlElementArray<RepeatEndingStart>& xmlMappingArray(); 
};
 
class RepeatEndingText : public OthersBase {
public:
    explicit RepeatEndingText(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper cmper)
        : OthersBase(document, partId, shareMode, cmper) {}
 
    std::string text; 
 
    constexpr static std::string_view XmlNodeName = "repeatEndingText"; 
    static const xml::XmlElementArray<RepeatEndingText>& xmlMappingArray(); 
};
 
class RepeatPassList : public OthersArray<int>
{
    std::string_view xmlTag() const override { return XmlNodeName; }
 
public:
    using OthersArray::OthersArray;
 
    constexpr static std::string_view XmlNodeName = "repeatPassList"; 
    static const xml::XmlElementArray<RepeatPassList>& xmlMappingArray(); 
};
 
class RepeatIndividualPositioning : public OthersBase
{
public:
    explicit RepeatIndividualPositioning(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper cmper, Inci inci)
        : OthersBase(document, partId, shareMode, cmper, inci) {}
 
    StaffCmper staffId{};       
    MeasCmper  measureId{};     
    bool       hidden{};        
    Evpu       x1add{};         
    Evpu       y1add{};         
    Evpu       x2add{};         
    Evpu       y2add{};         
 
    static const xml::XmlElementArray<RepeatIndividualPositioning>& xmlMappingArray();
};
 
class RepeatBackIndividualPositioning : public RepeatIndividualPositioning
{
public:
    using RepeatIndividualPositioning::RepeatIndividualPositioning;
 
    constexpr static std::string_view XmlNodeName = "separatesRepeatBack"; 
};
class RepeatEndingStartIndividualPositioning : public RepeatIndividualPositioning
{
public:
    using RepeatIndividualPositioning::RepeatIndividualPositioning;
 
    constexpr static std::string_view XmlNodeName = "separatesRepeatEndingLine"; 
};
 
class RepeatEndingTextIndividualPositioning : public RepeatIndividualPositioning
{
public:
    using RepeatIndividualPositioning::RepeatIndividualPositioning;
 
    constexpr static std::string_view XmlNodeName = "separatesRepeatEndingText"; 
};
 
class TextRepeatIndividualPositioning : public RepeatIndividualPositioning
{
public:
    using RepeatIndividualPositioning::RepeatIndividualPositioning;
 
    constexpr static std::string_view XmlNodeName = "separatesTextRepeat"; 
};
 
class ShapeExpressionDef : public OthersBase
{
public:
    explicit ShapeExpressionDef(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper cmper)
        : OthersBase(document, partId, shareMode, cmper) {}
 
    Cmper shapeDef{};                               
    Cmper categoryId{};                             
    RehearsalMarkStyle rehearsalMarkStyle{};        
    int value{};                                    
    Cmper execShape{};                              
    int auxData1{};                                 
    int playPass{};                                 
    bool breakMmRest{};                             
    bool useAuxData{};                              
    bool masterShape{};                             
    bool noPrint{};                                 
    bool noHorzStretch{};                           
    PlaybackType playbackType{};                    
    HorizontalMeasExprAlign horzMeasExprAlign{};    
    VerticalMeasExprAlign vertMeasExprAlign{};      
    AlignJustify horzExprJustification{};           
    Evpu measXAdjust{};                             
    Evpu yAdjustEntry{};                            
    Evpu yAdjustBaseline{};                         
    bool useCategoryFonts{};                        
    bool useCategoryPos{};                          
    std::string description;                        
 
    MusxInstance<ShapeDef> getShape() const;
 
    constexpr static std::string_view XmlNodeName = "shapeExprDef"; 
    static const xml::XmlElementArray<ShapeExpressionDef>& xmlMappingArray(); 
};
 
class SplitMeasure : public OthersArray<Evpu>
{
    std::string_view xmlTag() const override { return XmlNodeName; }
 
public:
    using OthersArray::OthersArray;
 
    constexpr static std::string_view XmlNodeName = "splitMeas"; 
    static const xml::XmlElementArray<SplitMeasure>& xmlMappingArray(); 
};
 
class StaffList : public OthersArray<StaffCmper>
{
public:
    using OthersArray::OthersArray;
 
    enum class FloatingValues : StaffCmper
    {
        TopStaff = -1,          
        BottomStaff = -2        
    };
 
    static const xml::XmlElementArray<StaffList>& xmlMappingArray(); 
};
 
class StaffListCategoryName : public OthersName
{
public:
    using OthersName::OthersName;
 
    constexpr static std::string_view XmlNodeName = "categoryStaffListName"; 
};
 
class StaffListCategoryParts : public StaffList
{
    std::string_view xmlTag() const override { return XmlNodeName; }
 
public:
    using StaffList::StaffList;
 
    constexpr static std::string_view XmlNodeName = "categoryStaffListParts"; 
};
 
class StaffListCategoryScore : public StaffList
{
    std::string_view xmlTag() const override { return XmlNodeName; }
 
public:
    using StaffList::StaffList;
 
    constexpr static std::string_view XmlNodeName = "categoryStaffListScore"; 
};
 
[[nodiscard]]
std::optional<Cmper> importCategoryStaffListInto(const DocumentPtr& target, const DocumentPtr& source,
    Cmper cmper, const ImportObjectCallback& onImported = {});
 
class StaffListRepeatName : public OthersName
{
public:
    using OthersName::OthersName;
 
    constexpr static std::string_view XmlNodeName = "repeatStaffListName"; 
};
 
class StaffListRepeatParts : public StaffList
{
    std::string_view xmlTag() const override { return XmlNodeName; }
 
public:
    using StaffList::StaffList;
 
    constexpr static std::string_view XmlNodeName = "repeatStaffListParts"; 
};
 
class StaffListRepeatPartsForced : public StaffList
{
    std::string_view xmlTag() const override { return XmlNodeName; }
 
public:
    using StaffList::StaffList;
 
    constexpr static std::string_view XmlNodeName = "repeatStaffListPartsOverride"; 
};
 
class StaffListRepeatScore : public StaffList
{
    std::string_view xmlTag() const override { return XmlNodeName; }
 
public:
    using StaffList::StaffList;
 
    constexpr static std::string_view XmlNodeName = "repeatStaffListScore"; 
};
 
class StaffListRepeatScoreForced : public StaffList
{
    std::string_view xmlTag() const override { return XmlNodeName; }
 
public:
    using StaffList::StaffList;
 
    constexpr static std::string_view XmlNodeName = "repeatStaffListScoreOverride"; 
};
 
template<class ScoreList, class PartsList, class ScoreForcedList = void, class PartsForcedList  = void>
class StaffListSet
{
public:
    StaffListSet(const DocumentPtr& document, Cmper partId, Cmper staffListId) noexcept;
 
    bool contains(StaffCmper staffId, const MusxInstanceList<StaffUsed>& systemStaves, bool isHidden = false) const noexcept;
 
private:
    MusxInstance<StaffList> m_staffList;
    MusxInstance<StaffList> m_forcedStaffList;
};
 
class StaffSystem : public OthersBase
{
public:
    explicit StaffSystem(const DocumentWeakPtr& document, Cmper staffSystemId, ShareMode shareMode, Cmper cmper)
        : OthersBase(document, staffSystemId, shareMode, cmper)
    {
    }
 
    MeasCmper startMeas{};          
    MeasCmper endMeas{};            
    double horzPercent{};           
    int ssysPercent{};              
    Efix staffHeight{};             
    Evpu top{};                     
    Evpu left{};                    
    Evpu right{};                   
    Evpu bottom{};                  
    bool noNames{};                 
    bool hasStaffScaling{};         
    bool placeEndSpaceBeforeBarline{}; 
    bool scaleVert{};               
    bool holdMargins{};             
    Evpu distanceToPrev{};          
    Evpu extraStartSystemSpace{};   
    Evpu extraEndSystemSpace{};     
 
    PageCmper pageId{};             
 
    MeasCmper getLastMeasure() const { return endMeas - 1; }
 
    int calcNumMeasures() const { return endMeas - startMeas; }
 
    MusxInstance<others::Page> getPage() const;
 
    util::Fraction calcSystemScaling() const
    { return util::Fraction::fromPercent(ssysPercent) * util::Fraction(staffHeight, 4 * int(EFIX_PER_SPACE)); }
 
    util::Fraction calcStaffScaling(StaffCmper staffId) const;
 
    util::Fraction calcEffectiveScaling() const;
 
    std::pair<util::Fraction, util::Fraction> calcMinMaxStaffSizes() const;
 
    void integrityCheck(const std::shared_ptr<EnigmaBase>& ptrToThis) override
    {
        this->OthersBase::integrityCheck(ptrToThis);
        if (startMeas == 0 || endMeas == 0) {
            if (getSourcePartId() == SCORE_PARTID) {
                util::Logger::log(util::Logger::LogLevel::Info, "Layout for system " + std::to_string(getCmper())
                    + " of part " + std::to_string(getSourcePartId()) + " has not been calculated.");
            } else {
                // Finale can retain zero-valued system placeholders until a linked-part layout is updated.
                util::Logger::log(util::Logger::LogLevel::Verbose, "Layout for system " + std::to_string(getCmper())
                    + " of part " + std::to_string(getSourcePartId()) + " has not been calculated.");
            }
        }
    }
 
    constexpr static std::string_view XmlNodeName = "staffSystemSpec"; 
    static const xml::XmlElementArray<StaffSystem>& xmlMappingArray(); 
};
 
class StaffUsed : public OthersBase {
public:
    explicit StaffUsed(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper cmper, Inci inci)
        : OthersBase(document, partId, shareMode, cmper, inci) {}
 
    StaffCmper staffId{};                   
    Evpu distFromTop{};                     
    std::shared_ptr<EnigmaMusicRange> range;      
 
    util::Fraction calcEffectiveScaling() const;
 
    MusxInstance<Staff> getStaffInstance() const;
 
    MusxInstance<StaffComposite> getStaffInstance(MeasCmper measureId, Edu eduPosition = 0) const;
 
    constexpr static std::string_view XmlNodeName = "instUsed"; 
    static const xml::XmlElementArray<StaffUsed>& xmlMappingArray(); 
};
 
class SystemLock : public OthersBase
{
public:
    explicit SystemLock(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper cmper)
        : OthersBase(document, partId, shareMode, cmper) {}
 
    MeasCmper endMeas{}; 
 
    constexpr static std::string_view XmlNodeName = "lockMeas"; 
    static const xml::XmlElementArray<SystemLock>& xmlMappingArray(); 
};
 
class TempoChange : public OthersBase
{
public:
    explicit TempoChange(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper cmper, Inci inci)
        : OthersBase(document, partId, shareMode, cmper, inci)
    {
    }
 
    int ratio{};                    
    Edu eduPosition{};              
    int unit{};                     
    bool isRelative{};              
 
    double getAbsoluteTempo(NoteType noteType = NoteType::Quarter) const;
 
    constexpr static std::string_view XmlNodeName = "tempoDef"; 
    static const xml::XmlElementArray<TempoChange>& xmlMappingArray(); 
};
 
class TextBlock : public OthersBase
{
public:
    using TextJustify = options::TextOptions::TextJustify; 
 
    enum class TextType
    {
        Block,      
        Expression  
    };
 
    explicit TextBlock(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper cmper)
        : OthersBase(document, partId, shareMode, cmper) {}
 
    // Public properties corresponding to the XML structure
    Cmper textId{};                    
    Cmper shapeId{};                   
    Evpu width{};                      
    Evpu height{};                     
    std::optional<int> lineSpacingPercentage;
    std::optional<Evpu> lineSpacingEvpu;  
    Evpu xAdd{};                       
    Evpu yAdd{};                       
    TextJustify justify{};             
    bool newPos36{};                   
    bool showShape{};                  
    bool noExpandSingleWord{};         
    bool wordWrap{};                   
    Efix inset{};                      
    Efix stdLineThickness{};           
    bool roundCorners{};               
    Efix cornerRadius{};               
    TextType textType{};               
 
    util::EnigmaParsingContext getRawTextCtx(Cmper forPartId, std::optional<Cmper> forPageId = std::nullopt,
        util::EnigmaString::TextInsertCallback defaultInsertFunc = util::EnigmaString::defaultInsertsCallback) const;
 
    static std::string getText(const DocumentPtr& document, const Cmper textId, Cmper forPartId, bool trimTags = false,
        util::EnigmaString::AccidentalStyle accidentalStyle = util::EnigmaString::AccidentalStyle::Ascii);
 
    void integrityCheck(const std::shared_ptr<EnigmaBase>& ptrToThis) override
    {
        this->OthersBase::integrityCheck(ptrToThis);
        if (lineSpacingPercentage && lineSpacingEvpu) {
            lineSpacingEvpu.reset();
            MUSX_INTEGRITY_ERROR("Text options specify both a percent and an absolute line spacing. "
                "The absolute value was discarded.");
        } else if (!lineSpacingPercentage && !lineSpacingEvpu) {
            // this is what Finale reads when neither lineSpacingPercentage nor lineSpacingEvpu is present
            lineSpacingEvpu = 0;
        }
    }
 
    constexpr static std::string_view XmlNodeName = "textBlock"; 
    static const xml::XmlElementArray<TextBlock>& xmlMappingArray(); 
};
 
class TextExpressionDef : public OthersBase {
public:
    explicit TextExpressionDef(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper cmper)
        : OthersBase(document, partId, shareMode, cmper) {}
 
    Cmper textIdKey{};                              
    Cmper categoryId{};                             
    RehearsalMarkStyle rehearsalMarkStyle{};        
    int value{};                                    
    Cmper execShape{};                              
    int auxData1{};                                 
    int playPass{};                                 
    bool hideMeasureNum{};                          
    bool matchPlayback{};                           
    bool useAuxData{};                              
    bool hasEnclosure{};                            
    bool breakMmRest{};                             
    bool createdByHp{};                             
    PlaybackType playbackType{};                    
    HorizontalMeasExprAlign horzMeasExprAlign{};    
    VerticalMeasExprAlign vertMeasExprAlign{};      
    AlignJustify horzExprJustification{};           
    Evpu measXAdjust{};                             
    Evpu yAdjustEntry{};                            
    Evpu yAdjustBaseline{};                         
    bool useCategoryFonts{};                        
    bool useCategoryPos{};                          
    std::string description;                        
 
    MusxInstance<TextBlock> getTextBlock() const;
 
    util::EnigmaParsingContext getRawTextCtx(Cmper forPartId,
        util::EnigmaString::TextInsertCallback defaultInsertFunc = util::EnigmaString::defaultInsertsCallback) const;
 
    MusxInstance<Enclosure> getEnclosure() const;
 
    constexpr static std::string_view XmlNodeName = "textExprDef"; 
    static const xml::XmlElementArray<TextExpressionDef>& xmlMappingArray(); 
};
 
class TextExpressionEnclosure : public Enclosure {
public:
    using Enclosure::Enclosure;
 
    constexpr static std::string_view XmlNodeName = "textExpressionEnclosure"; 
    static const xml::XmlElementArray<TextExpressionEnclosure>& xmlMappingArray(); 
};
 
class TextRepeatAssign : public OthersBase
{
public:
    explicit TextRepeatAssign(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper cmper, Inci inci)
        : OthersBase(document, partId, shareMode, cmper, inci)
    {
    }
 
    // Public properties corresponding to the XML structure
    Evpu horzPos{};                 
    int passNumber{};               
    int targetValue{};              
    Cmper textRepeatId{};           
    Evpu vertPos{};                 
    bool individualPlacement{};     
    bool topStaffOnly{};            
    bool hidden{};                  
    bool resetOnAction{};           
    bool jumpOnMultiplePasses{};    
    RepeatActionType jumpAction{};  
    bool autoUpdate{};              
    RepeatTriggerType trigger{};    
    bool jumpIfIgnoring{};          
    Cmper staffList{};              
 
    MusxInstance<RepeatIndividualPositioning> getIndividualPositioning(StaffCmper staffId) const;
 
    RepeatStaffListSet createStaffListSet() const;
 
    std::optional<MeasCmper> calcTargetMeasure() const;
 
    constexpr static std::string_view XmlNodeName = "textRepeatAssign"; 
    static const xml::XmlElementArray<TextRepeatAssign>& xmlMappingArray(); 
};
 
class TextRepeatDef : public OthersBase
{
public:
    enum class PoundReplaceOption
    {
        Passes,             
        RepeatID,           
        MeasureNumber       
    };
 
    explicit TextRepeatDef(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper cmper)
        : OthersBase(document, partId, shareMode, cmper), font(new FontInfo(document))
    {
    }
 
    // Public properties corresponding to the XML structure
    std::shared_ptr<FontInfo> font;                 
    bool hasEnclosure{};                            
    bool useThisFont{};                             
    PoundReplaceOption poundReplace{};              
    AlignJustify justification{};                   
    std::vector<int> passList;                      
 
    constexpr static std::string_view XmlNodeName = "textRepeatDef"; 
    static const xml::XmlElementArray<TextRepeatDef>& xmlMappingArray(); 
};
 
class TextRepeatEnclosure : public Enclosure
{
public:
    using Enclosure::Enclosure;
 
    constexpr static std::string_view XmlNodeName = "textRepeatEnclosure"; 
    static const xml::XmlElementArray<TextRepeatEnclosure>& xmlMappingArray(); 
};
 
class TextRepeatText : public OthersBase
{
public:
    explicit TextRepeatText(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper cmper)
        : OthersBase(document, partId, shareMode, cmper)
    {
    }
 
    std::string text; 
 
    constexpr static std::string_view XmlNodeName = "textRepeatText"; 
    static const xml::XmlElementArray<TextRepeatText>& xmlMappingArray(); 
};
 
class TimeCompositeLower : public OthersBase
{
public:
    explicit TimeCompositeLower(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper cmper)
        : OthersBase(document, partId, shareMode, cmper)
    {
    }
 
    class CompositeItem
    {
    public:
        Edu unit{};             
        bool startGroup{};      
 
        static const xml::XmlElementArray<CompositeItem>& xmlMappingArray(); 
    };
 
    std::vector<std::shared_ptr<CompositeItem>> items;  
 
    constexpr static std::string_view XmlNodeName = "timeLower"; 
    static const xml::XmlElementArray<TimeCompositeLower>& xmlMappingArray(); 
};
 
class TimeCompositeUpper : public OthersBase
{
public:
    explicit TimeCompositeUpper(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper cmper)
        : OthersBase(document, partId, shareMode, cmper)
    {
    }
 
    class CompositeItem
    {
    public:
        Edu beats{};                
        util::Fraction fraction{};  
        bool startGroup{};          
 
        util::Fraction fullFraction() const { return fraction + beats; }
 
        static const xml::XmlElementArray<CompositeItem>& xmlMappingArray(); 
    };
 
    std::vector<std::shared_ptr<CompositeItem>> items;  
 
    constexpr static std::string_view XmlNodeName = "timeUpper"; 
    static const xml::XmlElementArray<TimeCompositeUpper>& xmlMappingArray(); 
};
 
class TonalCenterFlats : public OthersArray<unsigned, 8>
{
    std::string_view xmlTag() const override { return XmlNodeName; }
 
public:
    using OthersArray::OthersArray;
 
    constexpr static std::string_view XmlNodeName = "fstKeyFlats"; 
    static const xml::XmlElementArray<TonalCenterFlats>& xmlMappingArray(); 
};
 
class TonalCenterSharps : public OthersArray<unsigned, 8>
{
    std::string_view xmlTag() const override { return XmlNodeName; }
 
public:
    using OthersArray::OthersArray;
 
    constexpr static std::string_view XmlNodeName = "fstKeySharps"; 
    static const xml::XmlElementArray<TonalCenterSharps>& xmlMappingArray(); 
};
 
} // namespace others
} // namespace dom
} // namespace musx