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

(

)

{
   LoadDeviceXml();
   if (!device_xml_) { CreateDefaultDeviceXml(); }
   ProcessDataList();
}

~Devices()

Devices::~Devices

(

)

{
   try {
      /* open file with xml list of devices */
      const auto source {GetSource(MIDI2LR_UC_LITERAL("Controllers.xml"))};
      // ReSharper disable once CppExpressionWithoutSideEffects
      device_xml_->writeTo(source);
   }
   catch (const std::exception& e) {
      rsj::ExceptionResponse(e);
   }
   catch (...) {
      rsj::LogAndAlertError("Non-standard exception in ~Devices.");
   }
}

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
	)

{
   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");
         }
      }
      return success;
   }
   catch (const std::exception& e) {
      rsj::ExceptionResponse(e);
      throw;
   }
}

CreateDefaultDeviceXml()

void Devices::CreateDefaultDeviceXml ( )

private

{
   device_xml_ = juce::parseXML(R"===(<?xml version="1.0" encoding="UTF-8"?>
    <table_data>
        <heading>
            <column columnId="1" name="devicename" label="device name" width="200"/>
            <column columnId="2" name="systemid" label="system id" width="200"/>
            <column columnId="3" name="inputoutput" label="input/output" width="50"/>
            <column columnId="9" name="active" label="active" width="50"/>
        </heading>
        <data>
        </data>
    </table_data>)===");
}

Enabled()

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

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

EnabledOrNew()

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

{
   try {
      if (Add(info, io)) { return true; }
      return Enabled(info, io);
   }
   catch (const std::exception& e) {
      rsj::ExceptionResponse(e);
      throw;
   }
}

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);
      device_xml_.reset();
   }
}

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()) {
         device_listing_.emplace(DevInfo {dataElement->getStringAttribute("devicename"),
                                     dataElement->getStringAttribute("systemid"),
                                     dataElement->getStringAttribute("inputoutput")},
             dataElement->getIntAttribute("active"));
      }
   }
   else {
      data_list_ = device_xml_->createNewChildElement("data");
   }
}

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