Instrument.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 <cstddef>
#include <map>
#include <string_view>
#include <unordered_map>
#include <vector>
 
#include "CommonClasses.h"
 
namespace musx {
namespace dom {
 
namespace others {
class StaffComposite;
}
 
using InstrumentUuid = std::string_view;
 
enum class InstrumentFamily
{
    Unspecified,
    Brass,
    Keyboard,
    Organ,
    Percussion,
    PitchedPercussion,
    PluckedStrings,
    Strings,
    Voice,
    Woodwinds,
    Synth,
    Other
};
 
InstrumentFamily instrumentFamilyFromUuid(InstrumentUuid uuid);
 
class InstrumentMap;
 
class InstrumentInfo : public DocumentElement
{
public:
    struct InstrumentIdentity {
        std::string instUuid; 
 
        bool operator==(const InstrumentIdentity& other) const
        { return instUuid == other.instUuid; }
 
        bool operator<(const InstrumentIdentity& other) const
        { return instUuid < other.instUuid; }
    };
 
    struct InstrumentChange {
        InstrumentIdentity identity;                               
        MusxInstance<others::StaffComposite> topStaffComposite;    
    };
 
    using InstrumentChangeEvents = std::map<MusicPoint, InstrumentChange>;
 
    explicit InstrumentInfo(const DocumentWeakPtr& document, Cmper partId = SCORE_PARTID)
        : DocumentElement(document, partId) {}
 
    std::unordered_map<StaffCmper, size_t> staves;  
    Cmper staffGroupId{};                           
    Cmper multistaffGroupId{};                      
 
    std::vector<StaffCmper> getSequentialStaves() const;
 
    InstrumentChangeEvents getChanges() const;
 
    std::vector<InstrumentIdentity> getInstrumentIdentities() const;
 
    InstrumentIdentity getInstrumentIdentityAt(MusicPoint point) const;
};
 
class InstrumentMap : public DocumentElement, private std::unordered_map<StaffCmper, InstrumentInfo>
{
    // Private inheritance keeps the map implementation detail out of the public API and avoids any
    // accidental polymorphic use of a standard container with a non-virtual destructor.
public:
    using typename std::unordered_map<StaffCmper, InstrumentInfo>::key_type;
    using typename std::unordered_map<StaffCmper, InstrumentInfo>::mapped_type;
    using typename std::unordered_map<StaffCmper, InstrumentInfo>::value_type;
    using typename std::unordered_map<StaffCmper, InstrumentInfo>::hasher;
    using typename std::unordered_map<StaffCmper, InstrumentInfo>::key_equal;
    using typename std::unordered_map<StaffCmper, InstrumentInfo>::allocator_type;
    using typename std::unordered_map<StaffCmper, InstrumentInfo>::size_type;
    using typename std::unordered_map<StaffCmper, InstrumentInfo>::difference_type;
    using typename std::unordered_map<StaffCmper, InstrumentInfo>::reference;
    using typename std::unordered_map<StaffCmper, InstrumentInfo>::const_reference;
    using typename std::unordered_map<StaffCmper, InstrumentInfo>::pointer;
    using typename std::unordered_map<StaffCmper, InstrumentInfo>::const_pointer;
    using typename std::unordered_map<StaffCmper, InstrumentInfo>::iterator;
    using typename std::unordered_map<StaffCmper, InstrumentInfo>::const_iterator;
    using typename std::unordered_map<StaffCmper, InstrumentInfo>::local_iterator;
    using typename std::unordered_map<StaffCmper, InstrumentInfo>::const_local_iterator;
 
    explicit InstrumentMap(const DocumentWeakPtr& document, Cmper partId = SCORE_PARTID)
        : DocumentElement(document, partId) {}
 
    using std::unordered_map<StaffCmper, InstrumentInfo>::begin;
    using std::unordered_map<StaffCmper, InstrumentInfo>::end;
    using std::unordered_map<StaffCmper, InstrumentInfo>::empty;
    using std::unordered_map<StaffCmper, InstrumentInfo>::size;
    using std::unordered_map<StaffCmper, InstrumentInfo>::clear;
    using std::unordered_map<StaffCmper, InstrumentInfo>::find;
    using std::unordered_map<StaffCmper, InstrumentInfo>::count;
    using std::unordered_map<StaffCmper, InstrumentInfo>::emplace;
    using std::unordered_map<StaffCmper, InstrumentInfo>::insert;
    using std::unordered_map<StaffCmper, InstrumentInfo>::erase;
    using std::unordered_map<StaffCmper, InstrumentInfo>::operator[];
    using std::unordered_map<StaffCmper, InstrumentInfo>::at;
 
    const InstrumentInfo* getInstrumentForStaff(StaffCmper staffId) const;
};
 
} // namespace dom
} // namespace musx