CommonClasses.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 <utility>
 
#include "BaseTypes.h"
#include "Enumerations.h"
 
namespace mnx {
 
class Fraction : private Array<unsigned>
{
private:
    using NumType = unsigned;
    using ArrayType = Array<NumType>;
 
    static constexpr size_t NUMERATOR_INDEX = 0;
    static constexpr size_t DENOMINATOR_INDEX = 1;
 
public:
    using Initializer = std::pair<NumType, NumType>;    
    
    Fraction(const std::shared_ptr<json>& root, json_pointer pointer)
        : ArrayType(root, pointer)
    {
        if (size() != 2) {
            throw std::invalid_argument("mnx::Fraction must have exactly 2 elements.");
        }
    }
 
    Fraction(Base& parent, const std::string_view& key, const Initializer& value)
        : ArrayType(parent, key)
    {
        push_back(value.first);
        push_back(value.second);
    }
 
    MNX_ARRAY_ELEMENT_PROPERTY(NumType, numerator, NUMERATOR_INDEX);        
    MNX_ARRAY_ELEMENT_PROPERTY(NumType, denominator, DENOMINATOR_INDEX);    
 
    friend class Base;
};
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
 
inline bool operator==(const Fraction& a, const Fraction& b)
{
    return a.numerator() * b.denominator() == b.numerator() * a.denominator();
}
 
inline bool operator!=(const Fraction& a, const Fraction& b) {
    return !(a == b);
}
 
inline bool operator<(const Fraction& a, const Fraction& b) {
    return a.numerator() * b.denominator() < b.numerator() * a.denominator();
}
 
inline bool operator<=(const Fraction& a, const Fraction& b) {
    return !(b < a);
}
 
inline bool operator>(const Fraction& a, const Fraction& b) {
    return b < a;
}
 
inline bool operator>=(const Fraction& a, const Fraction& b) {
    return !(a < b);
}
 
#endif // DOXYGEN_SHOULD_IGNORE_THIS
 
class RhythmicPosition : public Object
{
public:
    RhythmicPosition(const std::shared_ptr<json>& root, json_pointer pointer)
        : Object(root, pointer)
    {
    }
    
    RhythmicPosition(Base& parent, const std::string_view& key, const Fraction::Initializer& position)
        : Object(parent, key)
    {
        create_fraction(position);
    }
 
    MNX_REQUIRED_CHILD(Fraction, fraction);             
    MNX_OPTIONAL_PROPERTY(unsigned, graceIndex);    
};
 
class MeasureRhythmicPosition : public Object
{
public:
    MeasureRhythmicPosition(const std::shared_ptr<json>& root, json_pointer pointer)
        : Object(root, pointer)
    {
    }
    
    MeasureRhythmicPosition(Base& parent, const std::string_view& key, int measureId, const Fraction::Initializer& position)
        : Object(parent, key)
    {
        set_measure(measureId);
        create_position(position);
    }
 
    MNX_REQUIRED_PROPERTY(int, measure);            
    MNX_REQUIRED_CHILD(RhythmicPosition, position); 
};
 
class Interval : public Object
{
public:
    Interval(const std::shared_ptr<json>& root, json_pointer pointer)
        : Object(root, pointer)
    {
    }
 
    Interval(Base& parent, const std::string_view& key, int staffDistance, int halfSteps)
        : Object(parent, key)
    {
        set_halfSteps(halfSteps);
        set_staffDistance(staffDistance);
    }
 
    MNX_REQUIRED_PROPERTY(int, halfSteps);      
    MNX_REQUIRED_PROPERTY(int, staffDistance);  
};
 
class KeySignature : public Object
{
public:
    KeySignature(const std::shared_ptr<json>& root, json_pointer pointer)
        : Object(root, pointer)
    {
    }
 
    KeySignature(Base& parent, const std::string_view& key, int fifths)
        : Object(parent, key)
    {
        set_fifths(fifths);
    }
 
    MNX_OPTIONAL_NAMED_PROPERTY(std::string, styleClass, "class"); 
    MNX_OPTIONAL_PROPERTY(std::string, color);                  
    MNX_REQUIRED_PROPERTY(int, fifths);                         
};
 
class NoteValue : public Object
{
public:
    class Initializer
    {
    public:
        NoteValueBase base;     
        unsigned dots;          
 
        Initializer(NoteValueBase inBase, unsigned inDots = 0) : base(inBase), dots(inDots) {}
    };
 
    NoteValue(const std::shared_ptr<json>& root, json_pointer pointer)
        : Object(root, pointer)
    {
    }
 
    NoteValue(Base& parent, const std::string_view& key, const Initializer& noteValue)
        : Object(parent, key)
    {
        set_base(noteValue.base);
        if (noteValue.dots) {
            set_dots(noteValue.dots);
        }
    }
 
    MNX_REQUIRED_PROPERTY(NoteValueBase, base);                 
    MNX_OPTIONAL_PROPERTY_WITH_DEFAULT(unsigned, dots, 0);      
 
    unsigned calcNumberOfFlags() const;
};
 
class NoteValueQuantity : public Object
{
public:
    NoteValueQuantity(const std::shared_ptr<json>& root, json_pointer pointer)
        : Object(root, pointer)
    {
    }
 
    NoteValueQuantity(Base& parent, const std::string_view& key, unsigned count, const NoteValue::Initializer& noteValue)
        : Object(parent, key)
    {
        set_multiple(count);
        create_duration(noteValue);
    }
 
    MNX_REQUIRED_CHILD(NoteValue, duration);                    
    MNX_REQUIRED_PROPERTY(unsigned, multiple);                  
};
 
class TimeSignature : public Object
{
public:
    TimeSignature(const std::shared_ptr<json>& root, json_pointer pointer)
        : Object(root, pointer)
    {
    }
 
    TimeSignature(Base& parent, const std::string_view& key, int count, TimeSignatureUnit unit)
        : Object(parent, key)
    {
        set_count(count);
        set_unit(unit);
    }
 
    MNX_REQUIRED_PROPERTY(int, count);                
    MNX_REQUIRED_PROPERTY(TimeSignatureUnit, unit);   
};
 
} // namespace mnx