Profile Class Reference

#include <Profile.h>

Public Member Functions
	Profile (const CommandSet &command_set) noexcept
bool	CommandHasAssociatedMessage (const std::string &command) const
void	FromXml (const juce::XmlElement *root)
const std::string &	GetCommandForMessage (rsj::MidiMessageId message) const
rsj::MidiMessageId	GetMessageForNumber (size_t num) const
std::vector< rsj::MidiMessageId >	GetMessagesForCommand (const std::string &command) const
int	GetRowForMessage (rsj::MidiMessageId message) const
void	InsertOrAssign (const std::string &command, rsj::MidiMessageId message)
void	InsertOrAssign (size_t command, rsj::MidiMessageId message)
void	InsertUnassigned (rsj::MidiMessageId message)
bool	MessageExistsInMap (rsj::MidiMessageId message) const
bool	ProfileUnsaved () const
void	RemoveAllRows ()
void	RemoveMessage (rsj::MidiMessageId message)
void	RemoveRow (size_t row)
void	RemoveUnassignedMessages ()
void	Resort (std::pair< int, bool > new_order)
size_t	Size () const
void	ToXmlFile (const juce::File &file)

Private Types
using	mm_abbrv_lmnt_t = std::pair< rsj::MidiMessageId, std::string >

Private Member Functions
void	InsertOrAssignI (const std::string &command, const rsj::MidiMessageId &message)
bool	MessageExistsInMapI (rsj::MidiMessageId message) const
void	SortI ()

Private Attributes
const CommandSet &	command_set_
std::pair< int, bool >	current_sort_ {2, true}
std::vector< mm_abbrv_lmnt_t >	mm_abbrv_table_ {}
std::shared_mutex	mutex_
bool	profile_unsaved_ {false}
std::vector< mm_abbrv_lmnt_t >	saved_mm_abbrv_table_ {}
std::mutex	saved_table_mtx_

Member Typedef Documentation

mm_abbrv_lmnt_t

using Profile::mm_abbrv_lmnt_t = std::pair<rsj::MidiMessageId, std::string>

private

Constructor & Destructor Documentation

Profile()

Profile::Profile ( const CommandSet &  command_set )

inlineexplicitnoexcept

: command_set_ {command_set} {}

Member Function Documentation

CommandHasAssociatedMessage()

bool Profile::CommandHasAssociatedMessage ( const std::string &  command ) const

inline

{
   auto guard {std::shared_lock {mutex_}};
#ifdef __cpp_lib_ranges_contains
   return std::ranges::contains(mm_abbrv_table_, command, &mm_abbrv_lmnt_t::second);
#else
   return std::ranges::any_of(mm_abbrv_table_,
       [&command](const auto& p) { return p.second == command; });
#endif
}

FromXml()

void Profile::FromXml

(

const juce::XmlElement *

root

)

{
   /* external use only, but will either use external versions of Profile calls to lock individual
    * accesses or manually lock any internal calls instead of using mutex for entire method */
   try {
      using namespace std::string_literals;
      if (!root || root->getTagName().compare("settings") != 0) { return; }
      RemoveAllRows();
      for (const auto* setting : root->getChildIterator()) {
         auto command {setting->getStringAttribute("command_string").toStdString()};
         if (const auto b {command.back()}; b == '2' || b == 'e') { // assumes only e,2 end old
                                                                    // strings
            for (const auto& i : replace_me) {
               if (command == i.first) {
                  command = i.second;
                  break;
               }
            }
         }
         if (setting->hasAttribute("controller")) {
            const rsj::MidiMessageId message {setting->getIntAttribute("channel"),
                setting->getIntAttribute("controller"), rsj::MessageType::kCc};
            InsertOrAssign(command, message);
         }
         else if (setting->hasAttribute("note")) {
            const rsj::MidiMessageId note {setting->getIntAttribute("channel"),
                setting->getIntAttribute("note"), rsj::MessageType::kNoteOn};
            InsertOrAssign(command, note);
         }
         else if (setting->hasAttribute("pitchbend")) {
            const rsj::MidiMessageId pb {
                setting->getIntAttribute("channel"), 0, rsj::MessageType::kPw};
            InsertOrAssign(command, pb);
         }
         else { /* no action needed */
         }
      }
      auto guard {std::unique_lock {mutex_}};
      SortI();
      saved_mm_abbrv_table_ = mm_abbrv_table_;
      profile_unsaved_ = false;
   }
   catch (const std::exception& e) {
      rsj::ExceptionResponse(e);
      throw;
   }
}

GetCommandForMessage()

const std::string & Profile::GetCommandForMessage ( rsj::MidiMessageId  message ) const

inline

{
   auto guard {std::shared_lock {mutex_}};
   const auto found {std::ranges::find(mm_abbrv_table_, message, &mm_abbrv_lmnt_t::first)};
   if (found != mm_abbrv_table_.end()) { return found->second; }
   return CommandSet::kUnassigned;
}

GetMessageForNumber()

rsj::MidiMessageId Profile::GetMessageForNumber ( size_t  num ) const

inline

{
   auto guard {std::shared_lock {mutex_}};
   return mm_abbrv_table_.at(num).first;
}

GetMessagesForCommand()

std::vector< rsj::MidiMessageId > Profile::GetMessagesForCommand

(

const std::string &

command

)

const

{
   try {
      auto guard {std::shared_lock {mutex_}};
      const auto filt {[&command](const auto& p) { return p.second == command; }};
#ifdef __cpp_lib_ranges_to_container
      auto mm {mm_abbrv_table_ | std::views::filter(filt)
               | std::views::elements<0> | std::ranges::to<std::vector>()};
#else
      std::vector<rsj::MidiMessageId> mm;
      std::ranges::copy(mm_abbrv_table_ | std::views::filter(filt) | std::views::elements<0>,
          std::back_inserter(mm));
#endif
      return mm;
   }
   catch (const std::exception& e) {
      rsj::ExceptionResponse(e);
      throw;
   }
}

GetRowForMessage()

int Profile::GetRowForMessage ( rsj::MidiMessageId  message ) const

inline

{
   auto guard {std::shared_lock {mutex_}};
   return gsl::narrow_cast<int>(std::ranges::find(mm_abbrv_table_, message, &mm_abbrv_lmnt_t::first)
                                - mm_abbrv_table_.begin());
}

InsertOrAssign() [1/2]

void Profile::InsertOrAssign ( const std::string &  command, rsj::MidiMessageId  message  )

inline

{
   auto guard {std::unique_lock {mutex_}};
   InsertOrAssignI(command, message);
}

InsertOrAssign() [2/2]

void Profile::InsertOrAssign ( size_t  command, rsj::MidiMessageId  message  )

inline

{
   if (command < command_set_.CommandAbbrevSize()) {
      auto guard {std::unique_lock {mutex_}};
      InsertOrAssignI(command_set_.CommandAbbrevAt(command), message);
   }
}

InsertOrAssignI()

void Profile::InsertOrAssignI ( const std::string &  command, const rsj::MidiMessageId &  message  )

private

{
   try {
      const auto found {std::ranges::find(mm_abbrv_table_, message, &mm_abbrv_lmnt_t::first)};
      if (found != mm_abbrv_table_.end()) { found->second = command; }
      else {
         mm_abbrv_table_.emplace_back(message, command);
      }
      SortI();
      profile_unsaved_ = true;
   }
   catch (const std::exception& e) {
      rsj::ExceptionResponse(e);
      throw;
   }
}

InsertUnassigned()

void Profile::InsertUnassigned

(

rsj::MidiMessageId

message

)

{
   try {
      auto guard {std::unique_lock {mutex_}};
      if (!MessageExistsInMapI(message)) {
         mm_abbrv_table_.emplace_back(message, CommandSet::kUnassigned);
         SortI();
         profile_unsaved_ = true;
      }
   }
   catch (const std::exception& e) {
      rsj::ExceptionResponse(e);
      throw;
   }
}

MessageExistsInMap()

bool Profile::MessageExistsInMap ( rsj::MidiMessageId  message ) const

inline

{
   auto guard {std::shared_lock {mutex_}};
   return MessageExistsInMapI(message);
}

MessageExistsInMapI()

bool Profile::MessageExistsInMapI ( rsj::MidiMessageId  message ) const

inlineprivate

{
#ifdef __cpp_lib_ranges_contains
   return std::ranges::contains(mm_abbrv_table_, message, &mm_abbrv_lmnt_t::first);
#else
   return std::ranges::any_of(mm_abbrv_table_, [message](auto& p) { return p.first == message; });
#endif
}

ProfileUnsaved()

bool Profile::ProfileUnsaved ( ) const

inline

{ /* technically, should check std::is_permutation, but much quicker to check if saved==current,
     accept occasional false positive for much better program responsiveness */
   auto abbrv_lock {std::scoped_lock {saved_table_mtx_}};
   auto guard {std::shared_lock {mutex_}};
   return profile_unsaved_ && !mm_abbrv_table_.empty() && mm_abbrv_table_ != saved_mm_abbrv_table_;
}

RemoveAllRows()

void Profile::RemoveAllRows

(

)

{
   try {
      auto guard {std::unique_lock {mutex_}};
      mm_abbrv_table_.clear();
      /*avoid repeated allocations when building*/
      mm_abbrv_table_.reserve(128);
      /* no reason for profile_unsaved_ here. nothing to save */
      profile_unsaved_ = false;
   }
   catch (const std::exception& e) {
      rsj::ExceptionResponse(e);
      throw;
   }
}

RemoveMessage()

void Profile::RemoveMessage

(

rsj::MidiMessageId

message

)

{
   try {
      auto guard {std::unique_lock {mutex_}};
      const auto found {std::ranges::find(mm_abbrv_table_, message, &mm_abbrv_lmnt_t::first)};
      if (found != mm_abbrv_table_.end()) [[likely]] {
         mm_abbrv_table_.erase(found);
         profile_unsaved_ = true;
      }
      else {
         rsj::Log(fmt::format(FMT_STRING("Error in Profile::RemoveMessage. Message not found. "
                                         "Message is: channel {} control number {} type {}."),
             message.channel, message.control_number, message.msg_id_type));
      }
   }
   catch (const std::exception& e) {
      rsj::ExceptionResponse(e);
      throw;
   }
}

RemoveRow()

void Profile::RemoveRow

(

size_t

row

)

{
   try {
      auto guard {std::unique_lock {mutex_}};
      mm_abbrv_table_.erase(mm_abbrv_table_.begin() + gsl::narrow_cast<std::ptrdiff_t>(row));
      profile_unsaved_ = true;
   }
   catch (const std::exception& e) {
      rsj::ExceptionResponse(e);
      throw;
   }
}

RemoveUnassignedMessages()

void Profile::RemoveUnassignedMessages

(

)

{
   try {
      auto guard {std::unique_lock {mutex_}};
      if (std::erase_if(mm_abbrv_table_,
              [](const auto& p) { return p.second == CommandSet::kUnassigned; })) {
         profile_unsaved_ = true;
      }
   }
   catch (const std::exception& e) {
      rsj::ExceptionResponse(e);
      throw;
   }
}

Resort()

void Profile::Resort

(

std::pair< int, bool >

new_order

)

{
   try {
      auto guard {std::unique_lock {mutex_}};
      current_sort_ = new_order;
      SortI();
   }
   catch (const std::exception& e) {
      rsj::ExceptionResponse(e);
      throw;
   }
}

Size()

size_t Profile::Size ( ) const

inline

{
   auto guard {std::shared_lock {mutex_}};
   return mm_abbrv_table_.size();
}

SortI()

void Profile::SortI ( )

private

{
   try {
      const auto projection {
          [this](const auto& a) { return command_set_.CommandTextIndex(a.second); }};
      if (current_sort_.first == 1) {
         if (current_sort_.second) { std::ranges::sort(mm_abbrv_table_); }
         else {
            std::ranges::sort(mm_abbrv_table_ | std::views::reverse);
         }
      }
      else if (current_sort_.second) {
         std::ranges::stable_sort(mm_abbrv_table_, {}, projection);
      }
      else {
         std::ranges::stable_sort(mm_abbrv_table_ | std::views::reverse, {}, projection);
      }
   }
   catch (const std::exception& e) {
      rsj::ExceptionResponse(e);
      throw;
   }
}

ToXmlFile()

void Profile::ToXmlFile

(

const juce::File &

file

)

{
   try { /* except for saved_mm_abbrv_table_ and profile_unsaved_, doesn't alter anything, so to
            allow for better responsiveness in slow serialization and file write, use shared_lock +
            mtx solely guarding the two members that are overwritten */
      auto abbrv_lock {std::scoped_lock {saved_table_mtx_}};
      auto guard {std::shared_lock {mutex_}};
      /* don't bother if map is empty */
      if (!mm_abbrv_table_.empty()) {
         /* save the contents of the command map to an xml file */
         juce::XmlElement root {"settings"};
         for (const auto& [msg_id, cmd_str] : mm_abbrv_table_) {
            auto setting {std::make_unique<juce::XmlElement>("setting")};
            setting->setAttribute("channel", msg_id.channel);
            switch (msg_id.msg_id_type) {
            case rsj::MessageType::kNoteOn:
               setting->setAttribute("note", msg_id.control_number);
               break;
            case rsj::MessageType::kCc:
               setting->setAttribute("controller", msg_id.control_number);
               break;
            case rsj::MessageType::kPw:
               setting->setAttribute("pitchbend", 0);
               break;
            case rsj::MessageType::kChanPressure:
            case rsj::MessageType::kKeyPressure:
            case rsj::MessageType::kNoteOff:
            case rsj::MessageType::kPgmChange:
            case rsj::MessageType::kSystem:
               /* can't handle other types */
               continue;
            }
            setting->setAttribute("command_string", cmd_str);
            root.prependChildElement(setting.release());
         }
         if (!root.writeTo(file)) {
            /* Give feedback if file-save doesn't work */
            const auto& p {file.getFullPathName()};
            rsj::LogAndAlertError(juce::translate("Unable to save file. Choose a different "
                                                  "location and try again.")
                                      + ' ' + p,
                "Unable to save file. Choose a different location and try again. " + p);
         }
         else {
            /*could use shared_mutex above if it were upgradable to unique here*/
            saved_mm_abbrv_table_ = mm_abbrv_table_;
            profile_unsaved_ = false;
         }
      }
   }
   catch (const std::exception& e) {
      rsj::ExceptionResponse(e);
      throw;
   }
}

Member Data Documentation

command_set_

const CommandSet& Profile::command_set_

private

current_sort_

std::pair<int, bool> Profile::current_sort_ {2, true}

private

{2, true};

mm_abbrv_table_

std::vector<mm_abbrv_lmnt_t> Profile::mm_abbrv_table_ {}

private

{};

mutex_

std::shared_mutex Profile::mutex_

mutableprivate

profile_unsaved_

bool Profile::profile_unsaved_ {false}

private

{false};

saved_mm_abbrv_table_

std::vector<mm_abbrv_lmnt_t> Profile::saved_mm_abbrv_table_ {}

private

{};

saved_table_mtx_

std::mutex Profile::saved_table_mtx_

mutableprivate

---

The documentation for this class was generated from the following files:

• C:/Users/rsjaf/source/repos/MIDI2LR/src/application/Profile.h
• C:/Users/rsjaf/source/repos/MIDI2LR/src/application/Profile.cpp