// -*- C++ -*-
//
// This file was generated by CLI, a command line interface
// compiler for C++.
//

// Begin prologue.
//
//
// End prologue.

#include <cassert>

namespace cli
{
  // usage_para
  //
  inline usage_para::
  usage_para (value v)
  : v_ (v)
  {
  }

  // unknown_mode
  //
  inline unknown_mode::
  unknown_mode (value v)
  : v_ (v)
  {
  }

  // exception
  //
  inline ::std::ostream&
  operator<< (::std::ostream& os, const exception& e)
  {
    e.print (os);
    return os;
  }

  // unknown_option
  //
  inline unknown_option::
  unknown_option (const std::string& option)
  : option_ (option)
  {
  }

  inline const std::string& unknown_option::
  option () const
  {
    return option_;
  }

  // unknown_argument
  //
  inline unknown_argument::
  unknown_argument (const std::string& argument)
  : argument_ (argument)
  {
  }

  inline const std::string& unknown_argument::
  argument () const
  {
    return argument_;
  }

  // missing_value
  //
  inline missing_value::
  missing_value (const std::string& option)
  : option_ (option)
  {
  }

  inline const std::string& missing_value::
  option () const
  {
    return option_;
  }

  // invalid_value
  //
  inline invalid_value::
  invalid_value (const std::string& option,
                 const std::string& value,
                 const std::string& message)
  : option_ (option),
    value_ (value),
    message_ (message)
  {
  }

  inline const std::string& invalid_value::
  option () const
  {
    return option_;
  }

  inline const std::string& invalid_value::
  value () const
  {
    return value_;
  }

  inline const std::string& invalid_value::
  message () const
  {
    return message_;
  }

  // argv_scanner
  //
  inline argv_scanner::
  argv_scanner (int& argc,
                char** argv,
                bool erase,
                std::size_t sp)
  : start_position_ (sp + 1),
    i_ (1),
    argc_ (argc),
    argv_ (argv),
    erase_ (erase)
  {
  }

  inline argv_scanner::
  argv_scanner (int start,
                int& argc,
                char** argv,
                bool erase,
                std::size_t sp)
  : start_position_ (sp + static_cast<std::size_t> (start)),
    i_ (start),
    argc_ (argc),
    argv_ (argv),
    erase_ (erase)
  {
  }

  inline int argv_scanner::
  end () const
  {
    return i_;
  }
}

// options
//

inline const bool& options::
ignore_unknown () const
{
  return this->ignore_unknown_;
}

inline bool& options::
ignore_unknown ()
{
  return this->ignore_unknown_;
}

inline void options::
ignore_unknown (const bool& x)
{
  this->ignore_unknown_ = x;
}

inline const bool& options::
force () const
{
  return this->force_;
}

inline bool& options::
force ()
{
  return this->force_;
}

inline void options::
force (const bool& x)
{
  this->force_ = x;
}

inline const bool& options::
shallow () const
{
  return this->shallow_;
}

inline bool& options::
shallow ()
{
  return this->shallow_;
}

inline void options::
shallow (const bool& x)
{
  this->shallow_ = x;
}

inline const bool& options::
ignore_unresolved_tests () const
{
  return this->ignore_unresolved_tests_;
}

inline bool& options::
ignore_unresolved_tests ()
{
  return this->ignore_unresolved_tests_;
}

inline void options::
ignore_unresolved_tests (const bool& x)
{
  this->ignore_unresolved_tests_ = x;
}

inline const std::string& options::
tenant () const
{
  return this->tenant_;
}

inline std::string& options::
tenant ()
{
  return this->tenant_;
}

inline void options::
tenant (const std::string& x)
{
  this->tenant_ = x;
}

inline bool options::
tenant_specified () const
{
  return this->tenant_specified_;
}

inline void options::
tenant_specified (bool x)
{
  this->tenant_specified_ = x;
}

inline const bool& options::
private_ () const
{
  return this->private__;
}

inline bool& options::
private_ ()
{
  return this->private__;
}

inline void options::
private_ (const bool& x)
{
  this->private__ = x;
}

inline const std::string& options::
interactive () const
{
  return this->interactive_;
}

inline std::string& options::
interactive ()
{
  return this->interactive_;
}

inline void options::
interactive (const std::string& x)
{
  this->interactive_ = x;
}

inline bool options::
interactive_specified () const
{
  return this->interactive_specified_;
}

inline void options::
interactive_specified (bool x)
{
  this->interactive_specified_ = x;
}

inline const std::string& options::
service_id () const
{
  return this->service_id_;
}

inline std::string& options::
service_id ()
{
  return this->service_id_;
}

inline void options::
service_id (const std::string& x)
{
  this->service_id_ = x;
}

inline bool options::
service_id_specified () const
{
  return this->service_id_specified_;
}

inline void options::
service_id_specified (bool x)
{
  this->service_id_specified_ = x;
}

inline const std::string& options::
service_type () const
{
  return this->service_type_;
}

inline std::string& options::
service_type ()
{
  return this->service_type_;
}

inline void options::
service_type (const std::string& x)
{
  this->service_type_ = x;
}

inline bool options::
service_type_specified () const
{
  return this->service_type_specified_;
}

inline void options::
service_type_specified (bool x)
{
  this->service_type_specified_ = x;
}

inline const std::string& options::
service_data () const
{
  return this->service_data_;
}

inline std::string& options::
service_data ()
{
  return this->service_data_;
}

inline void options::
service_data (const std::string& x)
{
  this->service_data_ = x;
}

inline bool options::
service_data_specified () const
{
  return this->service_data_specified_;
}

inline void options::
service_data_specified (bool x)
{
  this->service_data_specified_ = x;
}

inline const brep::path& options::
overrides_file () const
{
  return this->overrides_file_;
}

inline brep::path& options::
overrides_file ()
{
  return this->overrides_file_;
}

inline void options::
overrides_file (const brep::path& x)
{
  this->overrides_file_ = x;
}

inline bool options::
overrides_file_specified () const
{
  return this->overrides_file_specified_;
}

inline void options::
overrides_file_specified (bool x)
{
  this->overrides_file_specified_ = x;
}

inline const std::string& options::
db_user () const
{
  return this->db_user_;
}

inline std::string& options::
db_user ()
{
  return this->db_user_;
}

inline void options::
db_user (const std::string& x)
{
  this->db_user_ = x;
}

inline bool options::
db_user_specified () const
{
  return this->db_user_specified_;
}

inline void options::
db_user_specified (bool x)
{
  this->db_user_specified_ = x;
}

inline const std::string& options::
db_password () const
{
  return this->db_password_;
}

inline std::string& options::
db_password ()
{
  return this->db_password_;
}

inline void options::
db_password (const std::string& x)
{
  this->db_password_ = x;
}

inline bool options::
db_password_specified () const
{
  return this->db_password_specified_;
}

inline void options::
db_password_specified (bool x)
{
  this->db_password_specified_ = x;
}

inline const std::string& options::
db_name () const
{
  return this->db_name_;
}

inline std::string& options::
db_name ()
{
  return this->db_name_;
}

inline void options::
db_name (const std::string& x)
{
  this->db_name_ = x;
}

inline bool options::
db_name_specified () const
{
  return this->db_name_specified_;
}

inline void options::
db_name_specified (bool x)
{
  this->db_name_specified_ = x;
}

inline const std::string& options::
db_host () const
{
  return this->db_host_;
}

inline std::string& options::
db_host ()
{
  return this->db_host_;
}

inline void options::
db_host (const std::string& x)
{
  this->db_host_ = x;
}

inline bool options::
db_host_specified () const
{
  return this->db_host_specified_;
}

inline void options::
db_host_specified (bool x)
{
  this->db_host_specified_ = x;
}

inline const std::uint16_t& options::
db_port () const
{
  return this->db_port_;
}

inline std::uint16_t& options::
db_port ()
{
  return this->db_port_;
}

inline void options::
db_port (const std::uint16_t& x)
{
  this->db_port_ = x;
}

inline bool options::
db_port_specified () const
{
  return this->db_port_specified_;
}

inline void options::
db_port_specified (bool x)
{
  this->db_port_specified_ = x;
}

inline const brep::path& options::
bpkg () const
{
  return this->bpkg_;
}

inline brep::path& options::
bpkg ()
{
  return this->bpkg_;
}

inline void options::
bpkg (const brep::path& x)
{
  this->bpkg_ = x;
}

inline bool options::
bpkg_specified () const
{
  return this->bpkg_specified_;
}

inline void options::
bpkg_specified (bool x)
{
  this->bpkg_specified_ = x;
}

inline const brep::strings& options::
bpkg_option () const
{
  return this->bpkg_option_;
}

inline brep::strings& options::
bpkg_option ()
{
  return this->bpkg_option_;
}

inline void options::
bpkg_option (const brep::strings& x)
{
  this->bpkg_option_ = x;
}

inline bool options::
bpkg_option_specified () const
{
  return this->bpkg_option_specified_;
}

inline void options::
bpkg_option_specified (bool x)
{
  this->bpkg_option_specified_ = x;
}

inline const brep::path& options::
openssl () const
{
  return this->openssl_;
}

inline brep::path& options::
openssl ()
{
  return this->openssl_;
}

inline void options::
openssl (const brep::path& x)
{
  this->openssl_ = x;
}

inline bool options::
openssl_specified () const
{
  return this->openssl_specified_;
}

inline void options::
openssl_specified (bool x)
{
  this->openssl_specified_ = x;
}

inline const brep::strings& options::
openssl_option () const
{
  return this->openssl_option_;
}

inline brep::strings& options::
openssl_option ()
{
  return this->openssl_option_;
}

inline void options::
openssl_option (const brep::strings& x)
{
  this->openssl_option_ = x;
}

inline bool options::
openssl_option_specified () const
{
  return this->openssl_option_specified_;
}

inline void options::
openssl_option_specified (bool x)
{
  this->openssl_option_specified_ = x;
}

inline const std::string& options::
pager () const
{
  return this->pager_;
}

inline std::string& options::
pager ()
{
  return this->pager_;
}

inline void options::
pager (const std::string& x)
{
  this->pager_ = x;
}

inline bool options::
pager_specified () const
{
  return this->pager_specified_;
}

inline void options::
pager_specified (bool x)
{
  this->pager_specified_ = x;
}

inline const std::vector<std::string>& options::
pager_option () const
{
  return this->pager_option_;
}

inline std::vector<std::string>& options::
pager_option ()
{
  return this->pager_option_;
}

inline void options::
pager_option (const std::vector<std::string>& x)
{
  this->pager_option_ = x;
}

inline bool options::
pager_option_specified () const
{
  return this->pager_option_specified_;
}

inline void options::
pager_option_specified (bool x)
{
  this->pager_option_specified_ = x;
}

inline const bool& options::
help () const
{
  return this->help_;
}

inline bool& options::
help ()
{
  return this->help_;
}

inline void options::
help (const bool& x)
{
  this->help_ = x;
}

inline const bool& options::
version () const
{
  return this->version_;
}

inline bool& options::
version ()
{
  return this->version_;
}

inline void options::
version (const bool& x)
{
  this->version_ = x;
}

// Begin epilogue.
//
//
// End epilogue.