options_description get_section_options(const string section_name, const string group_caption, const options_description &original_options_descriptions)
{

    const std::vector< shared_ptr<option_description> >&original_options = original_options_descriptions.options();

    options_description new_options(group_caption.c_str());

    std::vector< shared_ptr<option_description> >::const_iterator options_it;
    for(options_it = original_options.begin(); options_it != original_options.end(); ++options_it)
    {

        const option_description &t_option = *(*options_it);
        string new_name(section_name + ".");
        new_name += t_option.long_name();


        // IMPORTANT: in order for this line not to crash the original_options_descriptions needs to be a static declaration
        // otherwise t_option.semantic().get() will point to an invalid memory direction and
        // the application will raise a segmentation fault
        new_options.add_options()
                (new_name.c_str(), t_option.semantic().get(), t_option.description().c_str());

    }

    return new_options;
}

    basic_parsed_options<charT>
    parse_config_file(std::basic_istream<charT>& is, 
                      const options_description& desc,
                      bool allow_unregistered)
    {    
        set<string> allowed_options;

        const vector<shared_ptr<option_description> >& options = desc.options();
        for (unsigned i = 0; i < options.size(); ++i)
        {
            const option_description& d = *options[i];

            if (d.long_name().empty())
                pdalboost::throw_exception(
                    error("long name required for config file"));

            allowed_options.insert(d.long_name());
        }

        // Parser return char strings
        parsed_options result(&desc);        
        copy(detail::basic_config_file_iterator<charT>(
                 is, allowed_options, allow_unregistered), 
             detail::basic_config_file_iterator<charT>(), 
             back_inserter(result.options));
        // Convert char strings into desired type.
        return basic_parsed_options<charT>(result);
    }

/// \brief Add the block's non-hidden options to the provided options_description
///
/// This is a concrete definition of a virtual method that's pure in options_block
void old_ssap_options_block::do_add_visible_options_to_description(options_description &arg_desc ///< The options_description to which the options are added
                                                                   ) {
	const string dir_varname  { "<dir>"   };
	const string file_varname { "<file>"  };
	const string score_varname{ "<score>" };
	const string set_varname  { "<set>"   };

	const string protein_file_combns_str = join( get_all_protein_file_combn_strings(), ", " );
	arg_desc.add_options()
		( PO_DEBUG.c_str(),                bool_switch              ( &debug                        )                           ->default_value(DEF_BOOL      ),   "Output debugging information"                                                                                          )
		((PO_OUT_FILE+",o").c_str(),       value<path>              ( &output_filename              )->value_name(file_varname ),                                ( "[DEPRECATED] Output scores to " + file_varname + " rather than to stdout" ).c_str()                                    )

		( PO_CLIQUE_FILE.c_str(),          value<path>              ( &clique_file                  )->value_name(file_varname ),                                ( "Read clique from " + file_varname ).c_str()                                                                            )
		( PO_DOMIN_FILE.c_str(),           value<path>              ( &domin_file                   )->value_name(file_varname ),                                ( "Read domin from "  + file_varname ).c_str()                                                                            )

		( PO_MAX_SCORE_TO_REFAST.c_str(),  value<double>            ( &max_score_to_fast_ssap_rerun )->value_name(score_varname)->default_value(DEF_REFAST    ), ( "Run a second fast SSAP with looser cutoffs if the first fast SSAP's score falls below " + score_varname ).c_str()      )
		( PO_MAX_SCORE_TO_RESLOW.c_str(),  value<double>            ( &max_score_to_slow_ssap_rerun )->value_name(score_varname)->default_value(DEF_RESLOW    ), ( "Perform a slow SSAP if the (best) fast SSAP score falls below " + score_varname ).c_str()                              )
		( PO_SLOW_SSAP_ONLY.c_str(),       bool_switch              ( &slow_ssap_only               )                           ->default_value(DEF_BOOL      ),   "Don't try any fast SSAPs; only use slow SSAP"                                                                          )

		( PO_LOC_SSAP_SCORE.c_str(),       bool_switch              ( &use_local_ssap_score         )                           ->default_value(DEF_BOOL      ),   "[DEPRECATED] Normalise the SSAP score over the length of the smallest domain rather than the largest"                  )
		( PO_ALL_SCORES.c_str(),           bool_switch              ( &write_all_scores             )                           ->default_value(DEF_BOOL      ),   "[DEPRECATED] Output all SSAP scores from fast and slow runs, not just the highest"                                     )
		( PO_PROTEIN_SOURCE_FILES.c_str(), value<protein_file_combn>( &protein_source_files         )->value_name( set_varname )->default_value(DEF_PROT_SRCS ), ( "Read the protein data from the set of files "+set_varname+", of available sets:\n" + protein_file_combns_str ).c_str() )

		( PO_SUPN_DIR.c_str(),             value<path>              ( &superposition_dir            )->value_name( dir_varname ),                                ( "[DEPRECATED] Output a superposition to directory " + dir_varname ).c_str()                                             )
		( PO_ALIGN_DIR.c_str(),            value<path>              ( &alignment_dir                )->value_name( dir_varname )->default_value( path(".")    ), ( "Write alignment to directory " + dir_varname ).c_str()                                                                 )
		( PO_MIN_OUT_SCORE.c_str(),        value<double>            ( &min_score_for_writing_files  )->value_name(score_varname)->default_value(DEF_FILE_SC   ), ( "Only output alignment/superposition files if the SSAP score exceeds " + score_varname ).c_str()                        )
		( PO_MIN_SUP_SCORE.c_str(),        value<double>            ( &min_score_for_superposition  )->value_name(score_varname)->default_value(DEF_SUP       ), ( "[DEPRECATED] Calculate superposition based on the residue-pairs with scores greater than " + score_varname ).c_str()   )
		( PO_RASMOL_SCRIPT.c_str(),        bool_switch              ( &write_rasmol_script          )                           ->default_value(DEF_BOOL      ),   "[DEPRECATED] Write a rasmol superposition script to load and colour the superposed structures"                         )
		( PO_XML_SUP.c_str(),              bool_switch              ( &write_xml_sup                )                           ->default_value(DEF_BOOL      ),   "[DEPRECATED] Write a small xml superposition file, from which a larger superposition file can be reconstructed"        );
}

void http_client_plugin::set_program_options(options_description&, options_description& cfg) {
   cfg.add_options()
      ("https-client-root-cert", boost::program_options::value<vector<string>>()->composing()->multitoken(),
       "PEM encoded trusted root certificate (or path to file containing one) used to validate any TLS connections made.  (may specify multiple times)\n")
      ("https-client-validate-peers", boost::program_options::value<bool>()->default_value(true),
       "true: validate that the peer certificates are valid and trusted, false: ignore cert errors")
      ;

}

/// \brief Add this block's options to the provided options_description
void superposition_output_options_block::do_add_visible_options_to_description(options_description &arg_desc ///< The options_description to which the options are added
                                                                               ) {
	arg_desc.add_options()
		(PO_SUP_FILE.c_str(),          value<path>(&sup_to_pdb_file),                                     "Write the superposed structures to a single PDB file arg, separated using faked chain codes"  )
		(PO_SUP_FILES_DIR.c_str(),     value<path>(&sup_to_pdb_files_dir),                                "Write the superposed structures to separate PDB files in directory arg"                       )
		(PO_SUP_TO_STDOUT.c_str(),     bool_switch(&sup_to_stdout)->default_value(false),                 "Print the superposed structures to stdout, separated using faked chain codes"                 )
		(PO_SUP_TO_PYMOL.c_str(),      bool_switch(&sup_to_pymol )->default_value(false),                 "Start up PyMOL for viewing the superposition"                                                 )
		(PO_PYMOL_PROGRAM.c_str(),     value<path>(&pymol_program)->default_value(DEFAULT_PYMOL_PROGRAM), "Use arg as the PyMOL executable for viewing; may optionally include the full path"            )
		(PO_SUP_TO_PYMOL_FILE.c_str(), value<path>(&sup_to_pymol_file),                                   "Write the superposition to a PyMOL script arg\n(Recommended filename extension: .pml)"        )
		(PO_SUP_TO_JSON_FILE.c_str(),  value<path>(&json_file),                                           "Write the superposition to JSON superposition file\n(Recommended filename extension: .sup_json)"        );
}

    basic_parsed_options<charT>
    parse_config_file(std::basic_istream<charT>& is, 
                      const options_description& desc)
    {    
        set<string> allowed_options;
        set<string> pm = desc.primary_keys();
        for (set<string>::iterator i = pm.begin(); i != pm.end(); ++i) {
            const option_description& d = desc.find(*i);

            if (d.long_name().empty())
                throw error("long name required for config file");

            allowed_options.insert(d.long_name());
        }

        // Parser return char strings
        parsed_options result(&desc);        
        copy(detail::basic_config_file_iterator<charT>(is, allowed_options), 
             detail::basic_config_file_iterator<charT>(), 
             back_inserter(result.options));
        // Convert char strings into desired type.
        return basic_parsed_options<charT>(result);
    }

/// \brief Add this block's options to the provided options_description
void alignment_input_options_block::do_add_visible_options_to_description(options_description &arg_desc ///< The options_description to which the options are added
                                                                  ) {
	const string file_varname { "<file>" };

	const auto residue_name_align_notifier   = [&] (const bool &x) { the_alignment_input_spec.set_residue_name_align  ( x ); };
	const auto fasta_alignment_file_notifier = [&] (const path &x) { the_alignment_input_spec.set_fasta_alignment_file( x ); };
	const auto ssap_alignment_file_notifier  = [&] (const path &x) { the_alignment_input_spec.set_ssap_alignment_file ( x ); };
	const auto cora_alignment_file_notifier  = [&] (const path &x) { the_alignment_input_spec.set_cora_alignment_file ( x ); };
	const auto ssap_scores_file_notifier     = [&] (const path &x) { the_alignment_input_spec.set_ssap_scores_file    ( x ); };

	arg_desc.add_options()
		(
			PO_RES_NAME_ALIGN.c_str(),
			bool_switch()
				->notifier     ( residue_name_align_notifier                      )
				->default_value( alignment_input_spec::DEFAULT_RESIDUE_NAME_ALIGN ),
			"Align residues by simply matching their names (numbers+insert)\n(for multiple models of the same structure)"
		)
		(
			PO_FASTA_ALIGN_INFILE.c_str(),
			value<path>()
				->value_name( file_varname                  )
				->notifier  ( fasta_alignment_file_notifier ),
			( "Read FASTA alignment from file " + file_varname ).c_str()
		)
		(
			PO_SSAP_ALIGN_INFILE.c_str(),
			value<path>()
				->value_name( file_varname                 )
				->notifier  ( ssap_alignment_file_notifier ),
			( "Read SSAP alignment from file " + file_varname ).c_str()
		)
		(
			PO_CORA_ALIGN_INFILE.c_str(),
			value<path>()
				->value_name( file_varname                 )
				->notifier  ( cora_alignment_file_notifier ),
			( "Read CORA alignment from file " + file_varname ).c_str()
		)
		(
			PO_SSAP_SCORE_INFILE.c_str(),
			value<path>()
				->value_name( file_varname              )
				->notifier  ( ssap_scores_file_notifier ),
			( "Read SSAP scores from file " + file_varname + "\nAssumes all .list alignment files in same directory" ).c_str()
		);

	static_assert( ! alignment_input_spec::DEFAULT_RESIDUE_NAME_ALIGN,
		"If alignment_input_spec::DEFAULT_RESIDUE_NAME_ALIGN isn't false, it might mess up the bool switch in here" );
}

/// \brief Add this block's options to the provided options_description
void display_options_block::do_add_visible_options_to_description(options_description &arg_desc ///< The options_description to which the options are added
                                                                  ) {
	const string colrs_varname{ "<colrs>" };

	const auto display_colours_string_notifier    = [&] (const string &x) { the_display_spec.set_display_colours_string   ( x ); };
	const auto gradient_colour_alignment_notifier = [&] (const bool   &x) { the_display_spec.set_gradient_colour_alignment( x ); };
	const auto show_scores_if_present_notifier    = [&] (const bool   &x) { the_display_spec.set_show_scores_if_present   ( x ); };
	const auto scores_to_equivs_notifier          = [&] (const bool   &x) { the_display_spec.set_scores_to_equivs         ( x ); };
	const auto normalise_scores_notifier          = [&] (const bool   &x) { the_display_spec.set_normalise_scores         ( x ); };
	arg_desc.add_options()
		(
			PO_VIEWER_COLOURS.c_str(),
			value<string>()
				->value_name( colrs_varname                   )
				->notifier  ( display_colours_string_notifier ),
			( "Use " + colrs_varname + " to colour successive entries in the viewer\n"
			  "(format: colon-separated list of comma-separated triples of RGB values between 0 and 1)\n"
			  "(will wrap-around when it runs out of colours)" ).c_str()
		)
		(
			PO_GRADIENT_COLOUR_ALIGNMENT.c_str(),
			bool_switch()
				->notifier     ( gradient_colour_alignment_notifier )
				->default_value( false                              ),
			"Colour the length of the alignment with a rainbow gradient (blue -> red)"
		)
		(
			PO_SHOW_SCORES_IF_PRESENT.c_str(),
			bool_switch()
				->notifier     ( show_scores_if_present_notifier )
				->default_value( false                           ),
			( "Show the alignment scores\n(use with " + PO_GRADIENT_COLOUR_ALIGNMENT + ")" ).c_str()
		)
		(
			PO_SCORES_TO_EQUIVS.c_str(),
			bool_switch()
				->notifier     ( scores_to_equivs_notifier )
				->default_value( false                     ),
			( "Show the alignment scores to equivalent positions, which increases relative scores where few entries are aligned\n"
				"(use with --" + PO_GRADIENT_COLOUR_ALIGNMENT + " and --" + PO_SHOW_SCORES_IF_PRESENT + ")" ).c_str()
		)
		(
			PO_NORMALISE_SCORES.c_str(),
			bool_switch()
				->notifier     ( normalise_scores_notifier )
				->default_value( false                     ),
			( "When showing scores, normalise them to the highest score in the alignment\n"
				"(use with --" + PO_GRADIENT_COLOUR_ALIGNMENT + " and --" + PO_SHOW_SCORES_IF_PRESENT + ")" ).c_str() 
		);
}

    basic_parsed_options<charT>
    parse_xml(const options_description& desc) {
        using boost::shared_ptr;
        set<string> allowed_options;

        const vector<shared_ptr<option_description> >& options = desc.options();
        for (unsigned i = 0; i < options.size(); ++i) {
            const option_description& d = *options[i];

            if (d.long_name().empty())
                boost::throw_exception(
                    error("long name required for config file"));

            allowed_options.insert(d.long_name());
        }

        // Parser return char strings
        parsed_options result(&desc);
        result.options.push_back(basic_option<charT>("my_double", vector<string>(1, "10.1214")));
        //result.options.push_back(basic_option<charT>("my_string", vector<string>(1, "hello world")));
        return basic_parsed_options<charT>(result);
    }

 explicit AddOption(options_description& desc) : AddOptionBase(desc.add_options()) {}

inline AddOptionBase add(options_description& desc) {
  return desc.add_options();
}

 void history_plugin::set_program_options(options_description& cli, options_description& cfg) {
    cfg.add_options()
          ("filter_on_accounts,f", bpo::value<vector<string>>()->composing(),
           "Track only transactions whose scopes involve the listed accounts. Default is to track all transactions.")
          ;
 }

/// \brief Add this block's hidden options to the provided options_description
void check_pdb_options_block::do_add_hidden_options_to_description(options_description &arg_desc ///< The options_description to which the options are added
                                                                   ) {
	arg_desc.add_options()
		( PO_PDB_FILE.c_str(), value<path>( &pdb_file ), "PDB file to check" );
}

/// \brief Add this block's options to the provided options_description
///
/// This is a concrete definition of a virtual method that's pure in options_block
void check_pdb_options_block::do_add_visible_options_to_description(options_description &arg_desc ///< The options_description to which the options are added
                                                                    ) {
	arg_desc.add_options()
		( PO_PERMIT.c_str(), bool_switch( &permit_no_atoms )->default_value( false ), "Permit success for a file that has no ATOM records" );
}

void prepareParseMotorId(options_description& desc) {
  using namespace boost::program_options;
  desc.add_options()
    ("motor_id,i", value<int>()->default_value(1)->implicit_value(false)->required(), "the CAN id of the motor to test");
}

/// \brief Add any hidden options to the provided options_description
void old_ssap_options_block::do_add_hidden_options_to_description(options_description &arg_desc ///< The options_description to which the options are added
                                                                  ) {
	arg_desc.add_options()
		( PO_NAME.c_str(), value<str_vec>( &names ), "Structure names" );
}