Devices Class Reference

#include <Devices.h>

Classes
struct	DevInfo

Public Member Functions
	Devices ()
	Devices (const Devices &other)=delete
	Devices (Devices &&other) noexcept=default
	~Devices ()
bool	Add (const juce::MidiDeviceInfo &info, const juce::String &io)
bool	Enabled (const juce::MidiDeviceInfo &info, juce::String io) const
bool	EnabledOrNew (const juce::MidiDeviceInfo &info, const juce::String &io)
Devices &	operator= (const Devices &other)=delete
Devices &	operator= (Devices &&other) noexcept=default

Private Member Functions
void	CreateDefaultDeviceXml ()
void	LoadDeviceXml ()
void	ProcessDataList ()

Private Attributes
juce::XmlElement *	column_list_ {nullptr}
juce::XmlElement *	data_list_ {nullptr}
std::map< DevInfo, bool >	device_listing_
std::unique_ptr< juce::XmlElement >	device_xml_
int	num_rows_ {0}

Constructor & Destructor Documentation

Devices() [1/3]

Devices::Devices

(

)

        {

~Devices()

Devices::~Devices

(

)

{
   LoadDeviceXml();
   if (!device_xml_) { CreateDefaultDeviceXml(); }
   ProcessDataList();
}
 
Devices::~Devices()
{
   try {
      /* open file with xml list of devices */
      const auto source {GetSource(MIDI2LR_UC_LITERAL("Controllers.xml"))};

References CreateDefaultDeviceXml(), LoadDeviceXml(), and ProcessDataList().

Devices() [2/3]

Devices::Devices ( const Devices & other )

delete

Devices() [3/3]

Devices::Devices ( Devices && other )

defaultnoexcept

Member Function Documentation

Add()

bool Devices::Add	(	const juce::MidiDeviceInfo &	info,
		const juce::String &	io )

                                 {
      rsj::ExceptionResponse(e, std::source_location::current());
   }
   catch (...) {
      rsj::LogAndAlertError("Non-standard exception in ~Devices.", std::source_location::current());
   }
}
 
bool Devices::Add(const juce::MidiDeviceInfo& info, const juce::String& io)
{
   try {
      const auto [it, success] {device_listing_.try_emplace({info, io}, true)};
      if (success) {
         if (const auto new_element {data_list_->createNewChildElement("item")}) {
            new_element->setAttribute("devicename", info.name);
            new_element->setAttribute("systemid", info.identifier);
            new_element->setAttribute("inputoutput", io);
            new_element->setAttribute("active", "1");
         }
         else {
            rsj::Log("Failed to create new element in Devices::Add",

CreateDefaultDeviceXml()

void Devices::CreateDefaultDeviceXml ( )

private

{
   device_xml_ = juce::parseXML(R"===(<?xml version="1.0" encoding="UTF-8"?>
    <table_data>

Referenced by ~Devices().

Enabled()

bool Devices::Enabled ( const juce::MidiDeviceInfo & info, juce::String io ) const

nodiscard

                                 {
      rsj::ExceptionResponse(e, std::source_location::current());
      throw;
   }
}
 
bool Devices::Enabled(const juce::MidiDeviceInfo& info, juce::String io) const
{

EnabledOrNew()

bool Devices::EnabledOrNew ( const juce::MidiDeviceInfo & info, const juce::String & io )

nodiscard

                    {device_listing_.find({info, std::move(io)})};
      if (it == device_listing_.end()) { return true; }
      return it->second;
   }
   catch (const std::exception& e) {
      rsj::ExceptionResponse(e, std::source_location::current());
      throw;
   }
}
 
bool Devices::EnabledOrNew(const juce::MidiDeviceInfo& info, const juce::String& io)

LoadDeviceXml()

void Devices::LoadDeviceXml ( )

private

{
   try {
      auto deviceXmlSource {GetSource(MIDI2LR_UC_LITERAL("Controllers.xml"))};
      if (deviceXmlSource.existsAsFile()) { device_xml_ = juce::parseXML(deviceXmlSource); }
      else {
         deviceXmlSource = GetSource(MIDI2LR_UC_LITERAL("DisabledControllers.xml"));
         if (deviceXmlSource.existsAsFile()) {
            device_xml_ = juce::parseXML(deviceXmlSource);
            std::ignore = deviceXmlSource.deleteFile(); // don't want to use name again
         }
      }
   }
   catch (const std::exception& e) {
      rsj::ExceptionResponse(e, std::source_location::current());
      device_xml_.reset();
   }
}

Referenced by ~Devices().

operator=() [1/2]

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

delete

operator=() [2/2]

Devices & Devices::operator= ( Devices && other )

defaultnoexcept

ProcessDataList()

void Devices::ProcessDataList ( )

private

{
   column_list_ = device_xml_->getChildByName("heading");
   data_list_ = device_xml_->getChildByName("data");
   if (data_list_) {
      num_rows_ = data_list_->getNumChildElements();
      for (const gsl::not_null<const juce::XmlElement*> dataElement :
          data_list_->getChildIterator()) {

Referenced by ~Devices().

Member Data Documentation

column_list_

juce::XmlElement* Devices::column_list_ {nullptr}

private

{nullptr};

data_list_

juce::XmlElement* Devices::data_list_ {nullptr}

private

{nullptr};

device_listing_

std::map<DevInfo, bool> Devices::device_listing_

private

device_xml_

std::unique_ptr<juce::XmlElement> Devices::device_xml_

private

num_rows_

int Devices::num_rows_ {0}

private

{0};

---

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

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