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_
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);
}

~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::*)(juce::XmlElement *, const juce::String &)  mf  )

inline

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

ConnectionCallback()

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

private

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

GetProfileDirectory()

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

inlinenoexcept

   {
      return profile_location_.getFullPathName();
   }

handleAsyncUpdate()

void ProfileManager::handleAsyncUpdate ( )

overrideprivate

{
   try {
      switch (switch_state_) {
      case SwitchState::kPrev:
         SwitchToPreviousProfile();
         switch_state_ = SwitchState::kNone;
         break;
      case SwitchState::kNext:
         SwitchToNextProfile();
         switch_state_ = SwitchState::kNone;
         break;
      case SwitchState::kNone:
         break;
      }
   }
   catch (const std::exception& e) {
      rsj::ExceptionResponse(e);
      throw;
   }
}

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_ = SwitchState::kPrev;
         triggerAsyncUpdate();
      }
      else if (cmd == "NextPro"s) {
         switch_state_ = SwitchState::kNext;
         triggerAsyncUpdate();
      }
      else { /* no action needed */
      }
   }
   catch (const std::exception& e) {
      rsj::ExceptionResponse(e);
      throw;
   }
}

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);
      throw;
   }
}

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);
      throw;
   }
}

SwitchToNextProfile()

void ProfileManager::SwitchToNextProfile ( )

private

{
   try {
      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);
      throw;
   }
}

SwitchToPreviousProfile()

void ProfileManager::SwitchToPreviousProfile ( )

private

{
   try {
      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);
      throw;
   }
}

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(FMT_STRING("ChangedToDirectory {}\n"),
                juce::File::addTrailingSeparator(profile_location_.getFullPathName())
                    .toStdString()));
            lr_ipc_out_.SendCommand(fmt::format(FMT_STRING("ChangedToFile {}\n"),
                profile.toStdString()));
         }
      }
   }
   catch (const std::exception& e) {
      rsj::ExceptionResponse(e);
      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);
      throw;
   }
}

Member Data Documentation

callbacks_

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

private

controls_model_

ControlsModel& ProfileManager::controls_model_

private

current_profile_

const Profile& ProfileManager::current_profile_

private

current_profile_index_

int ProfileManager::current_profile_index_ {0}

private

{0};

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_

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