ProfileManager Class Reference

#include <ProfileManager.h>

Inheritance diagram for ProfileManager:

Public Member Functions
	ProfileManager (const ProfileManager &other)=delete
	ProfileManager (ControlsModel &c_model, const Profile &profile, LrIpcOut &out, MidiReceiver &midi_receiver)
	ProfileManager (ProfileManager &&other)=delete
	~ProfileManager ()=default
template<class T>
void	AddCallback (_In_ T *const object, _In_ void(T::*const mf)(juce::XmlElement *, const juce::String &))
const juce::String &	GetProfileDirectory () const noexcept
ProfileManager &	operator= (const ProfileManager &other)=delete
ProfileManager &	operator= (ProfileManager &&other)=delete
void	SetProfileDirectory (const juce::File &directory)
void	SwitchToProfile (const juce::String &profile)
void	SwitchToProfile (int profile_index)

Private Types
enum class	SwitchState { kNone , kPrev , kNext }

Private Member Functions
void	ConnectionCallback (bool, bool)
void	handleAsyncUpdate () override
void	MapCommand (rsj::MidiMessageId msg)
void	MidiCmdCallback (rsj::MidiMessage mm)
void	SwitchToNextProfile ()
void	SwitchToPreviousProfile ()

Private Attributes
std::vector< std::function< void(juce::XmlElement *, const juce::String &)> >	callbacks_
ControlsModel &	controls_model_
const Profile &	current_profile_
int	current_profile_index_ {0}
LrIpcOut &	lr_ipc_out_
juce::File	profile_location_
std::vector< juce::String >	profiles_
std::atomic< SwitchState >	switch_state_ {SwitchState::kNone}

Member Enumeration Documentation

SwitchState

enum class ProfileManager::SwitchState

strongprivate

Enumerator
kNone
kPrev
kNext

                          {
      kNone,
      kPrev,
      kNext,
   };

Constructor & Destructor Documentation

ProfileManager() [1/3]

ProfileManager::ProfileManager	(	ControlsModel &	c_model,
		const Profile &	profile,
		LrIpcOut &	out,
		MidiReceiver &	midi_receiver )

    : current_profile_ {profile}, controls_model_ {c_model}, lr_ipc_out_ {out}
{
   /* add ourselves as a listener to LR_IPC_OUT so that we can send plugin settings on connection */
   midi_receiver.AddCallback(this, &ProfileManager::MidiCmdCallback);
   lr_ipc_out_.AddCallback(this, &ProfileManager::ConnectionCallback);
}

References current_profile_.

~ProfileManager()

ProfileManager::~ProfileManager ( )

default

ProfileManager() [2/3]

ProfileManager::ProfileManager ( const ProfileManager & other )

delete

ProfileManager() [3/3]

ProfileManager::ProfileManager ( ProfileManager && other )

delete

Member Function Documentation

AddCallback()

template<class T>

void ProfileManager::AddCallback ( _In_ T *const object, _In_ void(T::* mf )(juce::XmlElement *, const juce::String &) )

inline

   {
      if (object && mf) { callbacks_.emplace_back(std::bind_front(mf, object)); }
   }

References callbacks_.

ConnectionCallback()

void ProfileManager::ConnectionCallback ( bool connected, bool blocked )

private

{
   try {
      if (connected && !blocked) {
         lr_ipc_out_.SendCommand(fmt::format("ChangedToDirectory {}\n",
             juce::File::addTrailingSeparator(profile_location_.getFullPathName()).toStdString()));
      }
   }
   catch (const std::exception& e) {
      rsj::ExceptionResponse(e, std::source_location::current());
      throw;
   }
}

GetProfileDirectory()

const juce::String & ProfileManager::GetProfileDirectory ( ) const

inlinenodiscardnoexcept

   {
      return profile_location_.getFullPathName();
   }

handleAsyncUpdate()

void ProfileManager::handleAsyncUpdate ( )

overrideprivate

{
   try {
      const auto state = switch_state_.load(std::memory_order_acquire);
      switch (state) {
      case SwitchState::kPrev:
         SwitchToPreviousProfile();
         break;
      case SwitchState::kNext:
         SwitchToNextProfile();
         break;
      case SwitchState::kNone:
         break;
      }
      switch_state_.store(SwitchState::kNone, std::memory_order_release);
   }
   catch (const std::exception& e) {
      rsj::ExceptionResponse(e, std::source_location::current());
      throw;
   }
}

References kNext, kNone, kPrev, SwitchToNextProfile(), and SwitchToPreviousProfile().

MapCommand()

void ProfileManager::MapCommand ( rsj::MidiMessageId msg )

private

{
   try {
      using namespace std::string_literals;
      const auto cmd {current_profile_.GetCommandForMessage(msg)};
      if (cmd == "PrevPro"s) {
         switch_state_.store(SwitchState::kPrev, std::memory_order_release);
         triggerAsyncUpdate();
      }
      else if (cmd == "NextPro"s) {
         switch_state_.store(SwitchState::kNext, std::memory_order_release);
         triggerAsyncUpdate();
      }
      else { /* no action needed */
      }
   }
   catch (const std::exception& e) {
      rsj::ExceptionResponse(e, std::source_location::current());
      throw;
   }
}

Referenced by MidiCmdCallback().

MidiCmdCallback()

void ProfileManager::MidiCmdCallback ( rsj::MidiMessage mm )

private

{
   try {
      const rsj::MidiMessageId cc {mm};
      /* return if the value isn't high enough (notes may be < 1), or the command isn't a valid
       * profile-related command */
      if (controls_model_.ControllerToPlugin(mm, false) < 0.4
          || !current_profile_.MessageExistsInMap(cc)) {
         return;
      }
      MapCommand(cc);
   }
   catch (const std::exception& e) {
      rsj::ExceptionResponse(e, std::source_location::current());
      throw;
   }
}

References rsj::MidiMessageId::MidiMessageId(), ControlsModel::ControllerToPlugin(), controls_model_, current_profile_, MapCommand(), and Profile::MessageExistsInMap().

operator=() [1/2]

ProfileManager & ProfileManager::operator= ( const ProfileManager & other )

delete

operator=() [2/2]

ProfileManager & ProfileManager::operator= ( ProfileManager && other )

delete

SetProfileDirectory()

void ProfileManager::SetProfileDirectory

(

const juce::File &

directory

)

{
   try {
      profile_location_ = directory;
      auto file_array {directory.findChildFiles(juce::File::findFiles, false, "*.xml")};
      file_array.sort();
      profiles_.resize(file_array.size());
      std::ranges::transform(file_array, profiles_.begin(),
          [](const auto& file) { return file.getFileName(); });
   }
   catch (const std::exception& e) {
      rsj::ExceptionResponse(e, std::source_location::current());
      throw;
   }
}

SwitchToNextProfile()

void ProfileManager::SwitchToNextProfile ( )

private

{
   try {
      if (!profiles_.empty()) {
         const auto profiles_size {gsl::narrow_cast<int>(profiles_.size())};
         current_profile_index_ = (current_profile_index_ + 1) % profiles_size;
         SwitchToProfile(current_profile_index_);
      }
   }
   catch (const std::exception& e) {
      rsj::ExceptionResponse(e, std::source_location::current());
      throw;
   }
}

References current_profile_index_, and SwitchToProfile().

Referenced by handleAsyncUpdate().

SwitchToPreviousProfile()

void ProfileManager::SwitchToPreviousProfile ( )

private

{
   try {
      if (!profiles_.empty()) {
         const auto profiles_size {gsl::narrow_cast<int>(profiles_.size())};
         current_profile_index_ = (current_profile_index_ + profiles_size - 1) % profiles_size;
         SwitchToProfile(current_profile_index_);
      }
   }
   catch (const std::exception& e) {
      rsj::ExceptionResponse(e, std::source_location::current());
      throw;
   }
}

References current_profile_index_, and SwitchToProfile().

Referenced by handleAsyncUpdate().

SwitchToProfile() [1/2]

void ProfileManager::SwitchToProfile

(

const juce::String &

profile

)

{
   try {
      const auto profile_file {profile_location_.getChildFile(profile)};
      if (profile_file.exists()) {
         if (const auto parsed {juce::parseXML(profile_file)}) {
            for (const auto& cb : callbacks_) { cb(parsed.get(), profile); }
            lr_ipc_out_.SendCommand(fmt::format("ChangedToDirectory {}\n",
                juce::File::addTrailingSeparator(profile_location_.getFullPathName())
                    .toStdString()));
            lr_ipc_out_.SendCommand(fmt::format("ChangedToFile {}\n", profile.toStdString()));
         }
      }
   }
   catch (const std::exception& e) {
      rsj::ExceptionResponse(e, std::source_location::current());
      throw;
   }
}

SwitchToProfile() [2/2]

void ProfileManager::SwitchToProfile

(

int

profile_index

)

{
   try {
      if (profile_index >= 0 && std::cmp_less(profile_index, profiles_.size())) {
         SwitchToProfile(profiles_.at(gsl::narrow_cast<size_t>(profile_index)));
         current_profile_index_ = profile_index;
      }
   }
   catch (const std::exception& e) {
      rsj::ExceptionResponse(e, std::source_location::current());
      throw;
   }
}

References current_profile_index_.

Referenced by MainContentComponent::Init(), LrIpcIn::ProcessLine(), SwitchToNextProfile(), and SwitchToPreviousProfile().

Member Data Documentation

callbacks_

std::vector<std::function<void(juce::XmlElement*, const juce::String&)> > ProfileManager::callbacks_

private

Referenced by AddCallback().

controls_model_

ControlsModel& ProfileManager::controls_model_

private

Referenced by MidiCmdCallback().

current_profile_

const Profile& ProfileManager::current_profile_

private

Referenced by ProfileManager(), and MidiCmdCallback().

current_profile_index_

int ProfileManager::current_profile_index_ {0}

private

{0};

Referenced by SwitchToNextProfile(), SwitchToPreviousProfile(), and SwitchToProfile().

lr_ipc_out_

LrIpcOut& ProfileManager::lr_ipc_out_

private

profile_location_

juce::File ProfileManager::profile_location_

private

profiles_

std::vector<juce::String> ProfileManager::profiles_

private

switch_state_

std::atomic<SwitchState> ProfileManager::switch_state_ {SwitchState::kNone}

private

{SwitchState::kNone};

---

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

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