MultipleChoiceSelection.h

Go to the documentation of this file.

#ifndef LARDATAALG_UTILITIES_MULTIPLECHOICESELECTION_H
#define LARDATAALG_UTILITIES_MULTIPLECHOICESELECTION_H

// C/C++ standard library
#include <algorithm> // std::equal(), std::lexicographical_compare()
#include <cassert>
#include <cctype>    // std::tolower()
#include <cstddef>   // std::size_t
#include <exception> // std::exception
#include <limits>
#include <map>
#include <optional>
#include <ostream>
#include <string>
#include <type_traits> // std::conjunction_v, std::is_convertible...
#include <vector>

// -----------------------------------------------------------------------------
namespace util::details {

  // ---------------------------------------------------------------------------
  template <typename... Strings>
  constexpr auto AllConvertibleToStrings_v =
    std::conjunction_v<std::is_convertible<Strings, std::string>...>;

  // ---------------------------------------------------------------------------
  struct CaseInsensitiveComparer {

    static bool equal(std::string const& a, std::string const& b);

    static bool less(std::string const& a, std::string const& b);

  private:
    static bool cmp_lower(unsigned char a, unsigned char b);
    static bool eq_lower(unsigned char a, unsigned char b);

  }; // struct CaseInsensitiveComparer

  // ---------------------------------------------------------------------------
  template <typename Comparer>
  struct SorterFrom {
    bool operator()(std::string const& a, std::string const& b) const;
  }; // struct SorterFrom<>

  // ---------------------------------------------------------------------------
  template <typename Value, typename = void>
  struct ValueToString;

  // ---------------------------------------------------------------------------
  template <typename Choices>
  class MultipleChoiceSelectionOption_t {

    using Comparer_t = CaseInsensitiveComparer;

  public:
    using Choices_t = Choices;
    using Option_t = MultipleChoiceSelectionOption_t<Choices_t>;

    template <typename... Aliases>
    MultipleChoiceSelectionOption_t(Choices_t value, std::string name, Aliases... aliases);

    template <typename... Aliases>
    std::enable_if_t<AllConvertibleToStrings_v<Aliases...>, Option_t&> addAlias(
      std::string alias,
      Aliases... moreAliases);

    bool match(std::string const& label) const;

    Choices_t value() const { return fValue; }

    std::string name() const { return labels().front(); }

    std::vector<std::string> const& labels() const { return fLabels; }

    operator std::string() const { return name(); }

    operator Choices_t() const { return value(); }

    std::string value_as_string() const;

    std::string value_as_string(std::string const& defValue) const;

    std::string dump() const;

    bool operator==(Option_t const& option) const
    {
      return (value() == option.value()) && equal(name(), option.name());
    }

    bool operator!=(Option_t const& option) const
    {
      return (value() != option.value()) || !equal(name(), option.name());
    }

    static std::optional<std::string> value_as_string(Choices_t value);

    static std::string value_as_string(Choices_t value, std::string const& defValue);

  private:
    Choices_t fValue;                 
    std::vector<std::string> fLabels; 

    static bool equal(std::string const& a, std::string const& b)
    {
      return Comparer_t::equal(a, b);
    }

  }; // MultipleChoiceSelectionOption_t

  // ---------------------------------------------------------------------------

} // namespace util::details

// -----------------------------------------------------------------------------
namespace util {
  class MultipleChoiceSelectionBase;
}

class util::MultipleChoiceSelectionBase {

public:
  // --- BEGIN -- Exceptions ---------------------------------------------------

  struct Exception : std::exception {
    Exception(std::string const& s) : s(s) {}
    virtual const char* what() const noexcept override { return s.c_str(); }

    std::string s;
  }; // Exception

  struct UnknownOptionError : Exception {
    UnknownOptionError() : Exception("") {}
    UnknownOptionError(std::string const& label) : Exception(label) {}

    std::string const& label() const { return s; }
  }; // UnknownOptionError

  struct OptionAlreadyExistsError : Exception {
    OptionAlreadyExistsError() : Exception("") {}
    OptionAlreadyExistsError(std::string const& label) : Exception(label) {}

    std::string const& label() const { return s; }
  }; // OptionAlreadyExistsError

  // --- END -- Exceptions -----------------------------------------------------

}; // class MultipleChoiceSelectionBase

// -----------------------------------------------------------------------------
namespace util {
  template <typename>
  class MultipleChoiceSelection;
}
template <typename Choices>
class util::MultipleChoiceSelection : public util::MultipleChoiceSelectionBase {

  using Selector_t = MultipleChoiceSelection<Choices>; 

public:
  using Choices_t = Choices; 

  using Option_t = details::MultipleChoiceSelectionOption_t<Choices_t>;

  // --- BEGIN -- Constructors -------------------------------------------------

  MultipleChoiceSelection() = default;

  template <typename... Options>
  MultipleChoiceSelection(std::initializer_list<Option_t> options);

  // --- END -- Constructors ---------------------------------------------------

  // --- BEGIN -- Option management --------------------------------------------

  std::size_t size() const;

  bool empty() const;

  template <typename... Aliases>
  Option_t const& addOption(Choices_t value, std::string label, Aliases... aliases);

  template <typename... Aliases>
  std::enable_if_t<details::AllConvertibleToStrings_v<Aliases...>, Option_t const&> addAlias(
    Choices_t value,
    Aliases... aliases);

  template <typename... Aliases>
  std::enable_if_t<details::AllConvertibleToStrings_v<Aliases...>, Option_t const&> addAlias(
    Option_t const& option,
    Aliases... aliases);

  bool hasOption(Choices_t value) const;

  bool hasOption(std::string const& label) const;

  bool hasOption(Option_t const& option) const;

  // --- END -- Option management ----------------------------------------------

  // --- BEGIN -- Option access ------------------------------------------------

  Option_t const& get(Choices_t value) const;

  Option_t const& get(std::string const& label) const;

  Option_t const& parse(std::string const& label) const;

  // --- END -- Option access --------------------------------------------------


  std::string optionListString(std::string const& sep = ", ") const;

  std::string optionListDump(std::string const& indent, std::string const& firstIndent) const;

  std::string optionListDump(std::string const& indent = "") const
  {
    return optionListDump(indent, indent);
  }


private:
  using OptionList_t = std::vector<Option_t>;

  using OptionLabelMap_t =
    std::map<std::string, std::size_t, details::SorterFrom<details::CaseInsensitiveComparer>>;

  OptionList_t fOptions; 

  OptionLabelMap_t fLabelToOptionIndex;

  Option_t const& addOption(Option_t&& option);

  void recordLabel(std::string&& label, std::size_t index);

  template <typename... Aliases>
  std::enable_if_t<details::AllConvertibleToStrings_v<Aliases...>>
  recordLabels(std::size_t index, std::string alias, Aliases... moreAliases);

  void unregisterLabel(std::string const& label);

  typename OptionList_t::const_iterator findOption(Choices_t value) const;

  typename OptionList_t::iterator findOption(Choices_t value);

  std::size_t findOptionIndex(Choices_t value) const;

  std::size_t findOptionIndex(std::string const& label) const;

  static constexpr auto npos = std::numeric_limits<std::size_t>::max();

}; // class util::MultipleChoiceSelection

// -----------------------------------------------------------------------------
namespace util::details {


  template <typename Choices>
  bool operator==(MultipleChoiceSelectionOption_t<Choices> const& option, Choices const value);
  template <typename Choices>
  bool operator==(Choices const value, MultipleChoiceSelectionOption_t<Choices> const& option);

  template <typename Choices>
  bool operator!=(MultipleChoiceSelectionOption_t<Choices> const& option, Choices const value);
  template <typename Choices>
  bool operator!=(Choices const value, MultipleChoiceSelectionOption_t<Choices> const& option);

  template <typename Choices>
  bool operator==(MultipleChoiceSelectionOption_t<Choices> const& option, std::string const& label);
  template <typename Choices>
  bool operator==(std::string const& label, MultipleChoiceSelectionOption_t<Choices> const& option);

  template <typename Choices>
  bool operator!=(MultipleChoiceSelectionOption_t<Choices> const& option, std::string const& label);
  template <typename Choices>
  bool operator!=(std::string const& label, MultipleChoiceSelectionOption_t<Choices> const& option);


  template <typename Choices>
  std::ostream& operator<<(std::ostream& out,
                           MultipleChoiceSelectionOption_t<Choices> const& option);

} // namespace util

// =============================================================================
// ---  template implementation
// =============================================================================
// -----------------------------------------------------------------------------
// ---  (details)
// -----------------------------------------------------------------------------
template <typename B1, typename E1, typename B2, typename E2, typename Comp>
bool my_lexicographical_compare(B1 b1, E1 e1, B2 b2, E2 e2, Comp less)
{

  while (b1 != e1) {
    if (b2 == e2) return false; // shorter is less

    if (less(*b1, *b2)) return true;
    if (less(*b2, *b1)) return false;
    // equal so far...
    ++b1;
    ++b2;
  }            // while
  return true; // 1 is shorter
} // my_lexicographical_compare()

inline bool util::details::CaseInsensitiveComparer::equal(std::string const& a,
                                                          std::string const& b)
{
  return std::equal(a.begin(), a.end(), b.begin(), b.end(), eq_lower);
}

// -----------------------------------------------------------------------------
inline bool util::details::CaseInsensitiveComparer::less(std::string const& a, std::string const& b)
{
  return std::lexicographical_compare(a.begin(), a.end(), b.begin(), b.end(), cmp_lower);
} // util::details::CaseInsensitiveComparer::less()

// -----------------------------------------------------------------------------
inline bool util::details::CaseInsensitiveComparer::cmp_lower(unsigned char a, unsigned char b)
{
  return std::tolower(a) < std::tolower(b);
}

// -----------------------------------------------------------------------------
inline bool util::details::CaseInsensitiveComparer::eq_lower(unsigned char a, unsigned char b)
{
  return std::tolower(a) == std::tolower(b);
}

// -----------------------------------------------------------------------------
template <typename Comparer>
bool util::details::SorterFrom<Comparer>::operator()(std::string const& a,
                                                     std::string const& b) const
{
  return Comparer::less(a, b);
}

// -----------------------------------------------------------------------------
namespace util::details {

  template <typename Value, typename /* = void */>
  struct ValueToString {
    static constexpr bool can_convert = false;

    template <typename T>
    static std::optional<std::string> convert(T const&)
    {
      return {};
    }
  }; // struct ValueToString

  // enumerators
  template <typename Value>
  struct ValueToString<Value, std::enable_if_t<std::is_enum_v<Value>>> {
    static constexpr bool can_convert = true;

    template <typename T>
    static std::optional<std::string> convert(T const& value)
    {
      return {std::to_string(static_cast<std::underlying_type_t<T>>(value))};
    }
  }; // ValueToString(enum)

  // whatever converts to `std::to_string`
  template <typename Value>
  struct ValueToString<Value,
                       std::enable_if_t<std::is_convertible_v<Value, std::string> ||
                                        std::is_constructible_v<std::string, Value>>> {
    static constexpr bool can_convert = true;
    template <typename T>
    static std::optional<std::string> convert(T const& value)
    {
      return {std::string{value}};
    }
  }; // ValueToString(string)

  // whatever supports `std::to_string`
  template <typename Value>
  struct ValueToString<Value, std::void_t<decltype(std::to_string(std::declval<Value>()))>> {
    static constexpr bool can_convert = true;
    template <typename T>
    static std::optional<std::string> convert(T const& value)
    {
      return {std::to_string(value)};
    }
  }; // ValueToString(to_string)

} // namespace util::details

// -----------------------------------------------------------------------------
// --- util::details::MultipleChoiceSelectionOption_t
// -----------------------------------------------------------------------------
template <typename Choices>
template <typename... Aliases>
util::details::MultipleChoiceSelectionOption_t<Choices>::MultipleChoiceSelectionOption_t(
  Choices_t value,
  std::string name,
  Aliases... aliases)
  : fValue(value)
{
  fLabels.reserve(1U + sizeof...(aliases));
  addAlias(std::move(name), std::move(aliases)...);
} // util::details::MultipleChoiceSelectionOption_t<>::MultipleChoiceSelectionOption_t

// -----------------------------------------------------------------------------
template <typename Choices>
template <typename... Aliases>
auto util::details::MultipleChoiceSelectionOption_t<Choices>::addAlias(std::string alias,
                                                                       Aliases... moreAliases)
  -> std::enable_if_t<AllConvertibleToStrings_v<Aliases...>, Option_t&>
{
  fLabels.push_back(std::move(alias));
  if constexpr (sizeof...(moreAliases) > 0)
    return addAlias(std::move(moreAliases)...);
  else
    return *this;
} // util::details::MultipleChoiceSelectionOption_t<>::addAlias()

// -----------------------------------------------------------------------------
template <typename Choices>
bool util::details::MultipleChoiceSelectionOption_t<Choices>::match(std::string const& label) const
{
  return std::find_if(fLabels.begin(), fLabels.end(), [&label](std::string const& alias) {
           return equal(label, alias);
         }) != fLabels.end();
} // util::details::MultipleChoiceSelectionOption_t<>::match()

// -----------------------------------------------------------------------------
template <typename Choices>
std::string util::details::MultipleChoiceSelectionOption_t<Choices>::value_as_string(
  std::string const& defValue) const
{
  return value_as_string(value(), defValue);
}

// -----------------------------------------------------------------------------
template <typename Choices>
std::string util::details::MultipleChoiceSelectionOption_t<Choices>::value_as_string() const
{
  return value_as_string(name());
}

// -----------------------------------------------------------------------------
template <typename Choices>
std::optional<std::string> util::details::MultipleChoiceSelectionOption_t<Choices>::value_as_string(
  Choices_t value)
{
  return details::ValueToString<std::decay_t<Choices_t>>::convert(value);
} // util::details::MultipleChoiceSelectionOption_t<>::value_as_string()

// -----------------------------------------------------------------------------
template <typename Choices>
std::string util::details::MultipleChoiceSelectionOption_t<Choices>::value_as_string(
  Choices_t value,
  std::string const& defValue)
{
  return value_as_string(value).value_or(defValue);
} // util::details::MultipleChoiceSelectionOption_t<>::value_as_string()

// -----------------------------------------------------------------------------
template <typename Choices>
std::string util::details::MultipleChoiceSelectionOption_t<Choices>::dump() const
{
  auto iLabel = fLabels.begin();
  auto const lend = fLabels.end();
  std::string s{'"'};
  s += *iLabel;
  s += '"';
  auto const valueStr = value_as_string();
  if (valueStr != *iLabel) {
    s += " [=";
    s += valueStr;
    s += "]";
  }
  if (++iLabel != lend) {
    s += " (aliases: \"";
    s += *iLabel;
    s += '"';
    while (++iLabel != lend) {
      s += " \"";
      s += *iLabel;
      s += '"';
    } // while
    s += ')';
  } // if aliases

  return s;
} // util::details::MultipleChoiceSelectionOption_t<>::dump()

// -----------------------------------------------------------------------------
template <typename Choices>
bool util::details::operator==(MultipleChoiceSelectionOption_t<Choices> const& option,
                               Choices const value)
{
  return option.value() == value;
}

template <typename Choices>
bool util::details::operator==(Choices const value,
                               MultipleChoiceSelectionOption_t<Choices> const& option)
{
  return option == value;
}

// -----------------------------------------------------------------------------
template <typename Choices>
bool util::details::operator!=(MultipleChoiceSelectionOption_t<Choices> const& option,
                               Choices const value)
{
  return option.value() != value;
}

template <typename Choices>
bool util::details::operator!=(Choices const value,
                               MultipleChoiceSelectionOption_t<Choices> const& option)
{
  return option != value;
}

// -----------------------------------------------------------------------------
template <typename Choices>
bool util::details::operator==(MultipleChoiceSelectionOption_t<Choices> const& option,
                               std::string const& label)
{
  return option.match(label);
}

template <typename Choices>
bool util::details::operator==(std::string const& label,
                               MultipleChoiceSelectionOption_t<Choices> const& option)
{
  return option == label;
}

// -----------------------------------------------------------------------------
template <typename Choices>
bool util::details::operator!=(MultipleChoiceSelectionOption_t<Choices> const& option,
                               std::string const& label)
{
  return !option.match(label);
}

template <typename Choices>
bool util::details::operator!=(std::string const& label,
                               MultipleChoiceSelectionOption_t<Choices> const& option)
{
  return option != label;
}

// -----------------------------------------------------------------------------
template <typename Choices>
std::ostream& util::details::operator<<(std::ostream& out,
                                        MultipleChoiceSelectionOption_t<Choices> const& option)
{
  out << option.name();
  return out;
}

// -----------------------------------------------------------------------------
// --- util::MultipleChoiceSelection
// -----------------------------------------------------------------------------
template <typename Choices>
template <typename... Options>
util::MultipleChoiceSelection<Choices>::MultipleChoiceSelection(
  std::initializer_list<Option_t> options)
{
  for (Option_t option : options)
    addOption(std::move(option));
} // util::MultipleChoiceSelection<>::MultipleChoiceSelection()

// -----------------------------------------------------------------------------
template <typename Choices>
std::size_t util::MultipleChoiceSelection<Choices>::size() const
{
  return fOptions.size();
}

// -----------------------------------------------------------------------------
template <typename Choices>
bool util::MultipleChoiceSelection<Choices>::empty() const
{
  return fOptions.empty();
}

// -----------------------------------------------------------------------------
template <typename Choices>
template <typename... Aliases>
auto util::MultipleChoiceSelection<Choices>::addOption(Choices_t value,
                                                       std::string label,
                                                       Aliases... aliases) -> Option_t const&
{
  return addOption({value, std::move(label), std::move(aliases)...});
} // util::MultipleChoiceSelection<>::addOption()

// -----------------------------------------------------------------------------
template <typename Choices>
template <typename... Aliases>
auto util::MultipleChoiceSelection<Choices>::addAlias(Choices_t value, Aliases... aliases)
  -> std::enable_if_t<details::AllConvertibleToStrings_v<Aliases...>, Option_t const&>
{
  std::size_t const index = findOptionIndex(value);
  if (index >= fOptions.size()) throw UnknownOptionError(Option_t::value_as_string(value, ""));
  recordLabels(index, aliases...);
  return fOptions[index].addAlias(std::move(aliases)...);
} // util::MultipleChoiceSelection<>::addAlias()

// -----------------------------------------------------------------------------
template <typename Choices>
template <typename... Aliases>
auto util::MultipleChoiceSelection<Choices>::addAlias(Option_t const& option, Aliases... aliases)
  -> std::enable_if_t<details::AllConvertibleToStrings_v<Aliases...>, Option_t const&>
{
  return addAlias(option.value(), std::move(aliases)...);
} // util::MultipleChoiceSelection<>::addAlias()

// -----------------------------------------------------------------------------
template <typename Choices>
bool util::MultipleChoiceSelection<Choices>::hasOption(Choices_t value) const
{
  return findOption(value) != fOptions.end();
}

// -----------------------------------------------------------------------------
template <typename Choices>
bool util::MultipleChoiceSelection<Choices>::hasOption(std::string const& label) const
{
  return fLabelToOptionIndex.find(label) != fLabelToOptionIndex.end();
} // util::MultipleChoiceSelection<>::hasOption(string)

// -----------------------------------------------------------------------------
template <typename Choices>
bool util::MultipleChoiceSelection<Choices>::hasOption(Option_t const& option) const
{
  return hasOption(option.value());
}

// -----------------------------------------------------------------------------
template <typename Choices>
auto util::MultipleChoiceSelection<Choices>::get(Choices_t value) const -> Option_t const&
{
  auto const iOption = findOption(value);
  if (iOption == fOptions.end())
    throw UnknownOptionError(Option_t::value_as_string(value).value_or(""));
  return *iOption;
} // util::MultipleChoiceSelection<>::get(value)

// -----------------------------------------------------------------------------
template <typename Choices>
auto util::MultipleChoiceSelection<Choices>::get(std::string const& label) const -> Option_t const&
{
  auto const iLabelIndexPair = fLabelToOptionIndex.find(label);
  if (iLabelIndexPair == fLabelToOptionIndex.end()) { throw UnknownOptionError(label); }
  assert(iLabelIndexPair->second < fOptions.size());
  return fOptions[iLabelIndexPair->second];
} // util::MultipleChoiceSelection<>::get(string)

// -----------------------------------------------------------------------------
template <typename Choices>
auto util::MultipleChoiceSelection<Choices>::parse(std::string const& label) const
  -> Option_t const&
{
  return get(label);
} // util::MultipleChoiceSelection<>::parse()

// -----------------------------------------------------------------------------
template <typename Choices>
std::string util::MultipleChoiceSelection<Choices>::optionListString(
  std::string const& sep /* = ", " */) const
{
  using namespace std::string_literals;

  auto iOption = fOptions.begin();
  auto const oend = fOptions.end();

  if (iOption == oend) return "<no options>"s;

  std::string s{*iOption};
  while (++iOption != oend) {
    s += sep;
    s += *iOption;
  } // while
  return s;
} // util::MultipleChoiceSelection<>::optionListString()

// -----------------------------------------------------------------------------
template <typename Choices>
std::string util::MultipleChoiceSelection<Choices>::optionListDump(
  std::string const& indent,
  std::string const& firstIndent) const
{
  using namespace std::string_literals;

  auto iOption = fOptions.begin();
  auto const oend = fOptions.end();

  if (iOption == oend) return firstIndent + "<no options>\n"s;

  std::string s{firstIndent};
  s += iOption->dump();
  s += '\n';
  while (++iOption != oend) {
    s += indent;
    s += iOption->dump();
    s += '\n';
  } // while
  return s;
} // util::MultipleChoiceSelection<>::optionListDump()

// -----------------------------------------------------------------------------
template <typename Choices>
auto util::MultipleChoiceSelection<Choices>::addOption(Option_t&& option) -> Option_t const&
{
  std::size_t const newOptionIndex = size();

  fOptions.push_back(std::move(option));
  Option_t const& newOption = fOptions.back();
  auto const& labels = newOption.labels();
  for (auto iLabel = labels.begin(); iLabel != labels.end(); ++iLabel) {
    try {
      recordLabel(std::string{*iLabel}, newOptionIndex);
    }
    catch (OptionAlreadyExistsError const&) {
      // we attempt to offer a strong guarantee here,
      // that the object is restored in the state it was before the call

      // remove the new entries from the index
      // (*iLabel was not inserted, and all labels before it were new)
      for (auto iNewLabel = labels.begin(); iNewLabel != iLabel; ++iNewLabel)
        unregisterLabel(*iNewLabel);

      // remove the new option from the list
      fOptions.pop_back();

      // let the caller handle the rest
      throw;
    } // try ... catch
  }   // for labels

  return newOption;
} // util::MultipleChoiceSelection<>::addOption()

// -----------------------------------------------------------------------------
template <typename Choices>
void util::MultipleChoiceSelection<Choices>::recordLabel(std::string&& label, std::size_t index)
{

  auto const iOption = fLabelToOptionIndex.lower_bound(label);

  // check for duplicate entries: if iOption is not `end()`, it points to an
  // element whose key is either greater or equal (equivalent) to `label`;
  // if the key is greater than `label`, we are good:
  // we check it by requiring that `label` is smaller than the key;
  // `key_compare(a, b)` comparison is equivalent to `a < b`,
  if ((iOption != fLabelToOptionIndex.end()) &&
      !OptionLabelMap_t::key_compare()(label, iOption->first)) {
    throw OptionAlreadyExistsError(label); // maybe too terse?
  }

  // the actual recording, at last:
  fLabelToOptionIndex.emplace_hint(iOption, std::move(label), index);

} // util::MultipleChoiceSelection<>::recordLabel()

// -----------------------------------------------------------------------------
template <typename Choices>
template <typename... Aliases>
auto util::MultipleChoiceSelection<Choices>::recordLabels(std::size_t index,
                                                          std::string alias,
                                                          Aliases... moreAliases)
  -> std::enable_if_t<details::AllConvertibleToStrings_v<Aliases...>>
{
  try {
    recordLabel(std::move(alias), index);
    if constexpr (sizeof...(moreAliases) > 0U) recordLabels(index, std::move(moreAliases)...);
  }
  catch (OptionAlreadyExistsError const&) {
    unregisterLabel(alias); // if recordLabel() call threw alias is still intact
    throw;
  }
} // util::MultipleChoiceSelection<>::recordLabels()

// -----------------------------------------------------------------------------
template <typename Choices>
void util::MultipleChoiceSelection<Choices>::unregisterLabel(std::string const& label)
{
  fLabelToOptionIndex.erase(label);
}

// -----------------------------------------------------------------------------
template <typename Choices>
auto util::MultipleChoiceSelection<Choices>::findOption(Choices_t value) const ->
  typename OptionList_t::const_iterator
{
  auto const matchValue = [value](Option_t const& option) { return option.value() == value; };
  return std::find_if(fOptions.begin(), fOptions.end(), matchValue);
} // util::MultipleChoiceSelection<>::findOption(value) const

// -----------------------------------------------------------------------------
template <typename Choices>
auto util::MultipleChoiceSelection<Choices>::findOption(Choices_t value) ->
  typename OptionList_t::iterator
{
  auto const matchValue = [value](Option_t const& option) { return option.value() == value; };
  return std::find_if(fOptions.begin(), fOptions.end(), matchValue);
} // util::MultipleChoiceSelection<>::findOption(value)

// -----------------------------------------------------------------------------
template <typename Choices>
std::size_t util::MultipleChoiceSelection<Choices>::findOptionIndex(Choices_t value) const
{
  auto const d = static_cast<std::size_t>(std::distance(fOptions.begin(), findOption(value)));
  return (d >= size()) ? npos : d;
} // util::MultipleChoiceSelection<>::findOptionIndex(value) const

// -----------------------------------------------------------------------------
template <typename Choices>
std::size_t util::MultipleChoiceSelection<Choices>::findOptionIndex(std::string const& label) const
{
  auto const iOption = fLabelToOptionIndex.find(label);
  return (iOption == fLabelToOptionIndex.end()) ? npos : iOption->second;
} // util::MultipleChoiceSelection<>::findOptionIndex(string) const

// -----------------------------------------------------------------------------

// =============================================================================

#endif // LARDATAALG_UTILITIES_MULTIPLECHOICESELECTION_H