dynamics.h

/*
 * Copyright (C) 2026, 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 <optional>
#include <string>
#include <string_view>
#include <vector>
 
#include "musx/musx.h"
 
namespace denigma {
namespace classify {
 
namespace dynamics {
 
enum class Dynamic
{
    None,
    Other,
    pppppp,
    ppppp,
    pppp,
    ppp,
    pp,
    p,
    mp,
    mf,
    f,
    ff,
    fff,
    ffff,
    fffff,
    ffffff,
    fp,
    ffp,
    fz,
    ffz,
    pf,
    sf,
    sfp,
    sfpp,
    sfz,
    sffz,
    sfzp,
    rf,
    rfz,
    n
};
 
enum class Change
{
    Absolute,
    RelativeIncrease,
    RelativeDecrease
};
 
enum class Reinforcement
{
    None,           
    Sforzando,      
    Rinforzando     
};
 
enum class Level
{
    None,           
    Other,          
    pppppp,
    ppppp,
    pppp,
    ppp,
    pp,
    p,
    mp,
    mf,
    f,
    ff,
    fff,
    ffff,
    fffff,
    ffffff,
    n
};
 
struct Composition
{
    Reinforcement reinforcement{ Reinforcement::None };
    Level level{ Level::None };
    bool forzato{};
    Level subsequent{ Level::None };
};
 
struct Mark
{
    Dynamic dynamic{};
    Composition composition;
    std::vector<std::string> glyphs;
};
 
} // namespace dynamics
 
std::optional<dynamics::Mark> classifyDynamicRun(const musx::util::EnigmaTextChunk& chunk);
dynamics::Composition dynamicComposition(dynamics::Dynamic dynamic);
dynamics::Composition dynamicCompositionFromLetters(std::string_view letters);
dynamics::Dynamic dynamicFromLevel(dynamics::Level level);
std::string dynamicCanonicalText(dynamics::Dynamic dynamic);
std::vector<std::string> dynamicCanonicalGlyphs(dynamics::Dynamic dynamic);
std::vector<std::string> dynamicCanonicalLetterGlyphs(dynamics::Dynamic dynamic);
std::vector<std::string> dynamicLettersToLetterGlyphs(std::string_view letters);
std::string dynamicGlyphsToLetters(const std::vector<std::string>& glyphs);
 
} // namespace classify
} // namespace denigma