Sequence.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 "BaseTypes.h"
#include "CommonClasses.h"
#include "Enumerations.h"
#include "EventMarkings.h"
 
namespace mnx {
 
class Sequence; // forward declaration
 
namespace sequence {
 
class AccidentalEnclosure : public Object
{
public:
    AccidentalEnclosure(const std::shared_ptr<json>& root, json_pointer pointer)
        : Object(root, pointer)
    {
    }
 
    AccidentalEnclosure(Base& parent, const std::string_view& key, AccidentalEnclosureSymbol inSymbol)
        : Object(parent, key)
    {
        set_symbol(inSymbol);
    }
 
    MNX_REQUIRED_PROPERTY(AccidentalEnclosureSymbol, symbol);      
};
 
class AccidentalDisplay : public Object
{
public:
    AccidentalDisplay(const std::shared_ptr<json>& root, json_pointer pointer)
        : Object(root, pointer)
    {
    }
 
    AccidentalDisplay(Base& parent, const std::string_view& key, bool showAcci)
        : Object(parent, key)
    {
        set_show(showAcci);
    }
 
    MNX_OPTIONAL_CHILD(AccidentalEnclosure, enclosure);     
    MNX_OPTIONAL_PROPERTY_WITH_DEFAULT(bool, force, false); 
    MNX_REQUIRED_PROPERTY(bool, show);                      
};
 
class Rest : public ArrayElementObject
{
public:
    using ArrayElementObject::ArrayElementObject;
 
    MNX_OPTIONAL_PROPERTY(int, staffPosition);              
};
 
class Pitch : public Object
{
public:
    Pitch(const std::shared_ptr<json>& root, json_pointer pointer)
        : Object(root, pointer)
    {
    }
 
    Pitch(Base& parent, const std::string_view& key, NoteStep inpStep, int inpOctave, std::optional<int> inpAlter = std::nullopt)
        : Object(parent, key)
    {
        set_step(inpStep);
        set_octave(inpOctave);
        if (inpAlter) {
            set_alter(inpAlter.value());
        }
    }
 
    MNX_OPTIONAL_PROPERTY(int, alter);          
    MNX_REQUIRED_PROPERTY(int, octave);         
    MNX_REQUIRED_PROPERTY(NoteStep, step);      
 
    bool isSamePitch(const Pitch& src) const;
};
 
class Slur : public ArrayElementObject
{
public:
    Slur(const std::shared_ptr<json>& root, json_pointer pointer)
        : ArrayElementObject(root, pointer)
    {
    }
 
    Slur(Base& parent, const std::string_view& key, const std::string& target)
        : ArrayElementObject(parent, key)
    {
        set_target(target);
    }
 
    MNX_OPTIONAL_PROPERTY(std::string, endNote);            
    MNX_OPTIONAL_PROPERTY(LineType, lineType);              
    MNX_OPTIONAL_PROPERTY(SlurTieSide, side);               
    MNX_OPTIONAL_PROPERTY(SlurTieSide, sideEnd);            
    MNX_OPTIONAL_PROPERTY(std::string, startNote);          
    MNX_REQUIRED_PROPERTY(std::string, target);             
};
 
class Tie : public ArrayElementObject
{
public:
    Tie(const std::shared_ptr<json>& root, json_pointer pointer)
        : ArrayElementObject(root, pointer)
    {
    }
 
    Tie(Base& parent, const std::string_view& key, const std::optional<std::string>& target = std::nullopt)
        : ArrayElementObject(parent, key)
    {
        if (target) {
            set_target(target.value());
        } else {
            set_lv(true);
        }
    }
 
    MNX_OPTIONAL_PROPERTY_WITH_DEFAULT(bool, lv, false);    
    MNX_OPTIONAL_PROPERTY(SlurTieSide, side);               
    MNX_OPTIONAL_PROPERTY(std::string, target);             
};
 
class Note : public ArrayElementObject
{
public:
    Note(const std::shared_ptr<json>& root, json_pointer pointer)
        : ArrayElementObject(root, pointer)
    {
    }
 
    Note(Base& parent, const std::string_view& key, NoteStep step, int octave, std::optional<int> alter = std::nullopt)
        : ArrayElementObject(parent, key)
    {
        create_pitch(step, octave, alter);
    }
 
    MNX_OPTIONAL_CHILD(AccidentalDisplay, accidentalDisplay);       
    MNX_OPTIONAL_NAMED_PROPERTY(std::string, styleClass, "class");  
    MNX_OPTIONAL_PROPERTY(std::string, id);                         
    MNX_REQUIRED_CHILD(Pitch, pitch);                               
    MNX_OPTIONAL_PROPERTY(std::string, smuflFont);                  
    MNX_OPTIONAL_PROPERTY(int, staff);                              
    MNX_OPTIONAL_CHILD(Array<Tie>, ties);                           
};
 
class EventLyricLine : public ArrayElementObject
{
public:
    EventLyricLine(const std::shared_ptr<json>& root, json_pointer pointer)
        : ArrayElementObject(root, pointer)
    {
    }
 
    EventLyricLine(Base& parent, const std::string_view& key, const std::string& syllableText)
        : ArrayElementObject(parent, key)
    {
        set_text(syllableText);
    }
 
    MNX_REQUIRED_PROPERTY(std::string, text);           
    MNX_OPTIONAL_PROPERTY(LyricLineType, type);         
};
 
class EventLyrics : public Object
{
public:
    using Object::Object;
 
    MNX_OPTIONAL_CHILD(Dictionary<EventLyricLine>, lines);      
};
 
class Event : public ContentObject
{
public:
    Event(const std::shared_ptr<json>& root, json_pointer pointer)
        : ContentObject(root, pointer)
    {
    }
 
    Event(Base& parent, const std::string_view& key, std::optional<NoteValue::Initializer> noteValue = std::nullopt)
        : ContentObject(parent, key)
    {
        // per the specification, either noteValue or the full-measure boolean *must* be supplied.
        if (noteValue) {
            create_duration(noteValue.value());
        } else {
            set_measure(true);
        }
    }
 
    MNX_OPTIONAL_CHILD(NoteValue, duration);                
    MNX_OPTIONAL_PROPERTY(std::string, id);                 
    MNX_OPTIONAL_CHILD(EventLyrics, lyrics);                
    MNX_OPTIONAL_CHILD(EventMarkings, markings);            
    MNX_OPTIONAL_PROPERTY_WITH_DEFAULT(bool, measure, false); 
    MNX_OPTIONAL_CHILD(Array<Note>, notes);                 
    MNX_OPTIONAL_CHILD(Rest, rest);                         
    MNX_OPTIONAL_CHILD(Array<Slur>, slurs);                 
    MNX_OPTIONAL_PROPERTY(int, staff);                      
    MNX_OPTIONAL_PROPERTY(StemDirection, stemDirection);    
 
    std::optional<Note> findNote(const std::string& noteId) const;
 
    bool isGrace() const;
 
    Sequence getSequence() const;
 
    static constexpr std::string_view ContentTypeValue = ContentObject::ContentTypeValueDefault; 
};
 
class Space : public ContentObject
{
public:
    Space(const std::shared_ptr<json>& root, json_pointer pointer)
        : ContentObject(root, pointer)
    {
    }
 
    Space(Base& parent, const std::string_view& key, const Fraction::Initializer& duration)
        : ContentObject(parent, key)
    {
        create_duration(duration);
    }
 
    MNX_REQUIRED_CHILD(Fraction, duration);               
 
    static constexpr std::string_view ContentTypeValue = "space";   
};
 
class Grace : public ContentObject
{
public:
    Grace(const std::shared_ptr<json>& root, json_pointer pointer)
        : ContentObject(root, pointer)
    {
    }
 
    Grace(Base& parent, const std::string_view& key)
        : ContentObject(parent, key)
    {
        create_content();
    }
 
    MNX_OPTIONAL_NAMED_PROPERTY(std::string, styleClass, "class");  
    MNX_OPTIONAL_PROPERTY(std::string, color);                      
    MNX_REQUIRED_CHILD(ContentArray, content);                      
    MNX_OPTIONAL_PROPERTY_WITH_DEFAULT(bool, slash, true);          
 
    static constexpr std::string_view ContentTypeValue = "grace";   
};
 
class Tuplet : public ContentObject
{
public:
    Tuplet(const std::shared_ptr<json>& root, json_pointer pointer)
        : ContentObject(root, pointer)
    {
    }
 
    Tuplet(Base& parent, const std::string_view& key,
        unsigned innerCount, const NoteValue::Initializer& innerNoteValue,
        unsigned outerCount, const NoteValue::Initializer& outerNoteValue)
        : ContentObject(parent, key)
    {
        create_inner(innerCount, innerNoteValue);
        create_outer(outerCount, outerNoteValue);
        create_content();
    }
 
    MNX_OPTIONAL_PROPERTY_WITH_DEFAULT(AutoYesNo, bracket, AutoYesNo::Auto); 
    MNX_REQUIRED_CHILD(ContentArray, content);                      
    MNX_REQUIRED_CHILD(NoteValueQuantity, inner);                   
    MNX_REQUIRED_CHILD(NoteValueQuantity, outer);                   
    MNX_OPTIONAL_PROPERTY_WITH_DEFAULT(TupletDisplaySetting, showNumber, TupletDisplaySetting::Inner); 
    MNX_OPTIONAL_PROPERTY_WITH_DEFAULT(TupletDisplaySetting, showValue, TupletDisplaySetting::NoNumber); 
    MNX_OPTIONAL_PROPERTY(int, staff);                              
 
    static constexpr std::string_view ContentTypeValue = "tuplet";   
};
 
} // namespace sequence
 
class Sequence : public ArrayElementObject
{
public:
    Sequence(const std::shared_ptr<json>& root, json_pointer pointer)
        : ArrayElementObject(root, pointer)
    {
    }
 
    Sequence(Base& parent, const std::string_view& key)
        : ArrayElementObject(parent, key)
    {
        create_content();
    }
 
    MNX_REQUIRED_CHILD(ContentArray, content);      
    MNX_OPTIONAL_PROPERTY(int, staff);              
    MNX_OPTIONAL_PROPERTY(std::string, voice);      
};
 
} // namespace mnx