CommandSet Class Reference

#include <CommandSet.h>

Classes
class	Impl

Public Member Functions
	CommandSet ()
const auto &	CommandAbbrevAt (size_t index) const
auto	CommandAbbrevSize () const noexcept
auto	CommandLabelAt (size_t index) const
size_t	CommandTextIndex (const std::string &command) const
const auto &	GetLanguage () const noexcept
const auto &	GetMenuEntries () const noexcept
const auto &	GetMenus () const noexcept
const auto &	GetRepeats () const noexcept
const auto &	GetWraps () const noexcept

Static Public Member Functions
static const auto &	UnassignedTranslated ()

Static Public Attributes
static const std::string	kUnassigned {"Unassigned"}

Private Types
using	MenuStringT = juce::String

Private Member Functions
const Impl &	MakeImpl () const

Private Attributes
std::vector< std::string >	cmd_by_number_ {}
std::unordered_map< std::string, size_t >	cmd_idx_ {}
std::vector< std::string >	cmd_label_by_number_ {}
const Impl &	m_impl_
std::vector< std::vector< MenuStringT > >	menu_entries_ {}
std::vector< MenuStringT >	menus_ {}

Friends
class	cereal::access
struct	cereal::detail::Version< CommandSet::Impl >

Member Typedef Documentation

MenuStringT

using CommandSet::MenuStringT = juce::String

private

Constructor & Destructor Documentation

CommandSet()

CommandSet::CommandSet

(

)

                       : m_impl_(MakeImpl())
{
   /* manually insert unmapped at first position */
   try {
      rsj::Translate(m_impl_.language_); /* so UnassignedTranslated translated properly */
      const auto command_count {
          std::accumulate(m_impl_.allcommands_.begin(), m_impl_.allcommands_.end(), size_t {1},
              [](size_t sum, const auto& pair) { return sum + pair.second.size(); })};
      cmd_by_number_.reserve(command_count);
      cmd_label_by_number_.reserve(command_count);
      cmd_by_number_.push_back(kUnassigned);
      cmd_label_by_number_.push_back(UnassignedTranslated());
      cmd_idx_[kUnassigned] = 0;
      size_t idx {1};
      for (const auto& [cmd_group, cmd_abbrev_label] : m_impl_.allcommands_) {
         std::vector<MenuStringT> menu_items_temp {};
         menu_items_temp.reserve(cmd_abbrev_label.size());
         const auto group_colon {cmd_group + " : "}; /* concatenation optimization */
         for (const auto& [cmd_abbrev, cmd_label] : cmd_abbrev_label) {
            cmd_by_number_.push_back(cmd_abbrev);
            cmd_label_by_number_.push_back(group_colon + cmd_label);
            cmd_idx_.emplace(cmd_abbrev, idx++);
            menu_items_temp.emplace_back(cmd_label);
         }
         menus_.emplace_back(cmd_group);
         menu_entries_.push_back(std::move(menu_items_temp));
      }
   }
   catch (const std::exception& e) {
      rsj::ExceptionResponse(e);
      throw;
   }
}

Member Function Documentation

CommandAbbrevAt()

const auto & CommandSet::CommandAbbrevAt ( size_t  index ) const

inline

   {
      return cmd_by_number_.at(index);
   }

CommandAbbrevSize()

auto CommandSet::CommandAbbrevSize ( ) const

inlinenoexcept

{ return cmd_by_number_.size(); }

CommandLabelAt()

auto CommandSet::CommandLabelAt ( size_t  index ) const

inline

{ return cmd_label_by_number_.at(index); }

CommandTextIndex()

size_t CommandSet::CommandTextIndex

(

const std::string &

command

)

const

{
   try {
      using namespace std::string_literals;
      if (const auto found {cmd_idx_.find(command)}; found != cmd_idx_.end()) {
         return found->second;
      }
      if (command != "Unmapped"s) { /*Old version of Unassigned*/
         rsj::Log(fmt::format(FMT_STRING("Command not found in CommandTextIndex: {}."), command));
      }
      return 0;
   }
   catch (const std::exception& e) {
      rsj::ExceptionResponse(e);
      throw;
   }
}

GetLanguage()

const auto & CommandSet::GetLanguage ( ) const

inlinenoexcept

{ return m_impl_.language_; }

GetMenuEntries()

const auto & CommandSet::GetMenuEntries ( ) const

inlinenoexcept

{ return menu_entries_; }

GetMenus()

const auto & CommandSet::GetMenus ( ) const

inlinenoexcept

{ return menus_; }

GetRepeats()

const auto & CommandSet::GetRepeats ( ) const

inlinenoexcept

{ return m_impl_.repeat_messages_; }

GetWraps()

const auto & CommandSet::GetWraps ( ) const

inlinenoexcept

{ return m_impl_.wraps_; }

MakeImpl()

const CommandSet::Impl & CommandSet::MakeImpl ( ) const

private

{
   try {
      static const Impl kImpl;
      return kImpl;
   }
   catch (const std::exception& e) {
      rsj::ExceptionResponse(e);
      throw;
   }
}

UnassignedTranslated()

static const auto & CommandSet::UnassignedTranslated ( )

inlinestatic

   {
      static const auto unassigned {juce::translate("Unassigned").toStdString()};
      return unassigned;
   }

Friends And Related Symbol Documentation

cereal::access

friend class cereal::access

friend

cereal::detail::Version< CommandSet::Impl >

friend struct cereal::detail::Version< CommandSet::Impl >

friend

Member Data Documentation

cmd_by_number_

std::vector<std::string> CommandSet::cmd_by_number_ {}

private

{}; /* use for command_set_.CommandAbbrevAt, .size */

cmd_idx_

std::unordered_map<std::string, size_t> CommandSet::cmd_idx_ {}

private

{}; /* for CommandTextIndex */

cmd_label_by_number_

std::vector<std::string> CommandSet::cmd_label_by_number_ {}

private

{};

kUnassigned

const std::string CommandSet::kUnassigned {"Unassigned"}

inlinestatic

{"Unassigned"};

m_impl_

const Impl& CommandSet::m_impl_

private

menu_entries_

std::vector<std::vector<MenuStringT> > CommandSet::menu_entries_ {}

private

{}; /* use for commandmenu */

menus_

std::vector<MenuStringT> CommandSet::menus_ {}

private

{};                  /* use for commandmenu */

---

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

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