include/Options.h

#ifndef OPTIONS_H_
#define OPTIONS_H_

#include <initializer_list>
#include <sstream>
#include <stdexcept>
#include <string>

#include <boost/program_options.hpp>
#include <yaml-cpp/yaml.h>

#include <Logger.h>
#include <HZZException.h>


class Options {
 public:
  class Error : public HZZException {
   public:
    Error(std::string const &message) : HZZException{message} {};
  };

  using Group = boost::program_options::options_description;

  Options(int argc, char **argv,
          std::initializer_list<Group> const &optionGroups);

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

  template<typename T>
  T GetAs(std::string const &label) const;

  template<typename T, typename Checker>
  T GetAsChecked(std::string const &label, Checker const &checker) const;

  YAML::Node const &GetConfig() const;

  template<typename T>
  static T NodeAs(YAML::Node const &node,
                  std::initializer_list<std::string> const keys = {});

  template<typename T, typename Checker>
  static T NodeAsChecked(YAML::Node const &node, Checker const &checker,
                         std::initializer_list<std::string> const keys = {});

 private:
  void PrintUsage() const;

  std::string programName_;

  boost::program_options::options_description allOptions_;

  boost::program_options::variables_map optionMap_;

  YAML::Node config_;
};


template<typename T>
T Options::GetAs(std::string const &label) const {
  if (not Exists(label)) {
    std::ostringstream message;
    message << "Unknown option \"" << label << "\"";
    LOG_DEBUG << message.str();
    throw Error(message.str());
  }

  return optionMap_[label].as<T>();
}


template<typename T, typename Checker>
T Options::GetAsChecked(std::string const &label,
                        Checker const &checker) const {
  T const value = GetAs<T>(label);

  if (not checker(value)) {
    std::ostringstream message;
    message << "Invalid value read for option \"" << label << "\": " << value;
    LOG_DEBUG << message.str();
    throw Error(message.str());
  }

  return value;
}


template<typename T>
T Options::NodeAs(YAML::Node const &node,
                  std::initializer_list<std::string> const keys) {
  if (not node)
    throw Error("The node does not exist.");

  // In order to check wether proveded keys are available in the node, and
  // spot the missing key, the content of the node has to be changed repatedly.
  // For avoid destroying the origin node, checking process must be done on
  // a copy of the origin node. YAML::Clone allows creating a deep copy of
  // the origin node (see: https://github.com/jbeder/yaml-cpp/issues/162)
  YAML::Node copyNode = YAML::Clone(node);
  unsigned short int counter = 0;
  for (auto &key : keys) {
    counter++;
    copyNode = copyNode[key];
    if (not copyNode) break;
  }

  if (not copyNode) {
    std::ostringstream message;
    message << "The node ";

    for (auto key = keys.begin(); key != keys.begin() + counter; ++key)
      message << "["  << *key << "]";
    message << " does not exist.";
    throw Error(message.str());
  }

  return copyNode.as<T>();
}


template<typename T, typename Checker>
T Options::NodeAsChecked(YAML::Node const &node, Checker const &checker,
                         std::initializer_list<std::string> const keys) {
  T const value = NodeAs<T>(node, keys);

  if (not checker(value)) {
    std::ostringstream message;
    message << "Invalid value found for node: " << value;
    throw Error(message.str());
  }

  return value;
}

#endif  // OPTIONS_H_

---