From dd817b37a1139f0bbc1414c8b542734662c5da88 Mon Sep 17 00:00:00 2001 From: Boris Kolpackov Date: Wed, 21 Mar 2018 15:29:02 +0200 Subject: Implement group_scanner --- cli/options.ixx | 1222 ++++++++++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 1220 insertions(+), 2 deletions(-) (limited to 'cli/options.ixx') diff --git a/cli/options.ixx b/cli/options.ixx index 5e60a8c..d93957e 100644 --- a/cli/options.ixx +++ b/cli/options.ixx @@ -221,750 +221,1968 @@ 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; +} + inline const std::vector& options:: include_path () const { return this->include_path_; } +inline std::vector& options:: +include_path () +{ + return this->include_path_; +} + +inline void options:: +include_path(const std::vector& x) +{ + this->include_path_ = x; +} + inline bool options:: include_path_specified () const { return this->include_path_specified_; } +inline void options:: +include_path_specified(bool x) +{ + this->include_path_specified_ = x; +} + inline const std::string& options:: output_dir () const { return this->output_dir_; } +inline std::string& options:: +output_dir () +{ + return this->output_dir_; +} + +inline void options:: +output_dir(const std::string& x) +{ + this->output_dir_ = x; +} + inline bool options:: output_dir_specified () const { return this->output_dir_specified_; } +inline void options:: +output_dir_specified(bool x) +{ + this->output_dir_specified_ = x; +} + inline const cxx_version& options:: std () const { return this->std_; } +inline cxx_version& options:: +std () +{ + return this->std_; +} + +inline void options:: +std(const cxx_version& x) +{ + this->std_ = x; +} + inline bool options:: std_specified () const { return this->std_specified_; } +inline void options:: +std_specified(bool x) +{ + this->std_specified_ = x; +} + inline const bool& options:: generate_modifier () const { return this->generate_modifier_; } +inline bool& options:: +generate_modifier () +{ + return this->generate_modifier_; +} + +inline void options:: +generate_modifier(const bool& x) +{ + this->generate_modifier_ = x; +} + inline const bool& options:: generate_specifier () const { return this->generate_specifier_; } +inline bool& options:: +generate_specifier () +{ + return this->generate_specifier_; +} + +inline void options:: +generate_specifier(const bool& x) +{ + this->generate_specifier_ = x; +} + inline const bool& options:: generate_parse () const { return this->generate_parse_; } +inline bool& options:: +generate_parse () +{ + return this->generate_parse_; +} + +inline void options:: +generate_parse(const bool& x) +{ + this->generate_parse_ = x; +} + inline const bool& options:: generate_description () const { return this->generate_description_; } +inline bool& options:: +generate_description () +{ + return this->generate_description_; +} + +inline void options:: +generate_description(const bool& x) +{ + this->generate_description_ = x; +} + inline const bool& options:: generate_file_scanner () const { return this->generate_file_scanner_; } +inline bool& options:: +generate_file_scanner () +{ + return this->generate_file_scanner_; +} + +inline void options:: +generate_file_scanner(const bool& x) +{ + this->generate_file_scanner_ = x; +} + inline const bool& options:: generate_vector_scanner () const { return this->generate_vector_scanner_; } +inline bool& options:: +generate_vector_scanner () +{ + return this->generate_vector_scanner_; +} + +inline void options:: +generate_vector_scanner(const bool& x) +{ + this->generate_vector_scanner_ = x; +} + +inline const bool& options:: +generate_group_scanner () const +{ + return this->generate_group_scanner_; +} + +inline bool& options:: +generate_group_scanner () +{ + return this->generate_group_scanner_; +} + +inline void options:: +generate_group_scanner(const bool& x) +{ + this->generate_group_scanner_ = x; +} + inline const bool& options:: suppress_inline () const { return this->suppress_inline_; } +inline bool& options:: +suppress_inline () +{ + return this->suppress_inline_; +} + +inline void options:: +suppress_inline(const bool& x) +{ + this->suppress_inline_ = x; +} + inline const bool& options:: suppress_cli () const { return this->suppress_cli_; } +inline bool& options:: +suppress_cli () +{ + return this->suppress_cli_; +} + +inline void options:: +suppress_cli(const bool& x) +{ + this->suppress_cli_ = x; +} + inline const std::string& options:: cli_namespace () const { return this->cli_namespace_; } +inline std::string& options:: +cli_namespace () +{ + return this->cli_namespace_; +} + +inline void options:: +cli_namespace(const std::string& x) +{ + this->cli_namespace_ = x; +} + inline bool options:: cli_namespace_specified () const { return this->cli_namespace_specified_; } +inline void options:: +cli_namespace_specified(bool x) +{ + this->cli_namespace_specified_ = x; +} + inline const std::string& options:: ostream_type () const { return this->ostream_type_; } +inline std::string& options:: +ostream_type () +{ + return this->ostream_type_; +} + +inline void options:: +ostream_type(const std::string& x) +{ + this->ostream_type_ = x; +} + inline bool options:: ostream_type_specified () const { return this->ostream_type_specified_; } +inline void options:: +ostream_type_specified(bool x) +{ + this->ostream_type_specified_ = x; +} + inline const bool& options:: generate_cxx () const { return this->generate_cxx_; } +inline bool& options:: +generate_cxx () +{ + return this->generate_cxx_; +} + +inline void options:: +generate_cxx(const bool& x) +{ + this->generate_cxx_ = x; +} + inline const bool& options:: generate_man () const { return this->generate_man_; } +inline bool& options:: +generate_man () +{ + return this->generate_man_; +} + +inline void options:: +generate_man(const bool& x) +{ + this->generate_man_ = x; +} + inline const bool& options:: generate_html () const { return this->generate_html_; } +inline bool& options:: +generate_html () +{ + return this->generate_html_; +} + +inline void options:: +generate_html(const bool& x) +{ + this->generate_html_ = x; +} + inline const bool& options:: generate_txt () const { return this->generate_txt_; } +inline bool& options:: +generate_txt () +{ + return this->generate_txt_; +} + +inline void options:: +generate_txt(const bool& x) +{ + this->generate_txt_ = x; +} + inline const bool& options:: stdout_ () const { return this->stdout__; } +inline bool& options:: +stdout_ () +{ + return this->stdout__; +} + +inline void options:: +stdout_(const bool& x) +{ + this->stdout__ = x; +} + inline const bool& options:: suppress_undocumented () const { return this->suppress_undocumented_; } +inline bool& options:: +suppress_undocumented () +{ + return this->suppress_undocumented_; +} + +inline void options:: +suppress_undocumented(const bool& x) +{ + this->suppress_undocumented_ = x; +} + inline const bool& options:: suppress_usage () const { return this->suppress_usage_; } +inline bool& options:: +suppress_usage () +{ + return this->suppress_usage_; +} + +inline void options:: +suppress_usage(const bool& x) +{ + this->suppress_usage_ = x; +} + inline const bool& options:: long_usage () const { return this->long_usage_; } +inline bool& options:: +long_usage () +{ + return this->long_usage_; +} + +inline void options:: +long_usage(const bool& x) +{ + this->long_usage_ = x; +} + inline const bool& options:: short_usage () const { return this->short_usage_; } +inline bool& options:: +short_usage () +{ + return this->short_usage_; +} + +inline void options:: +short_usage(const bool& x) +{ + this->short_usage_ = x; +} + inline const std::string& options:: page_usage () const { return this->page_usage_; } +inline std::string& options:: +page_usage () +{ + return this->page_usage_; +} + +inline void options:: +page_usage(const std::string& x) +{ + this->page_usage_ = x; +} + inline bool options:: page_usage_specified () const { return this->page_usage_specified_; } +inline void options:: +page_usage_specified(bool x) +{ + this->page_usage_specified_ = x; +} + inline const std::size_t& options:: option_length () const { return this->option_length_; } +inline std::size_t& options:: +option_length () +{ + return this->option_length_; +} + +inline void options:: +option_length(const std::size_t& x) +{ + this->option_length_ = x; +} + inline bool options:: option_length_specified () const { return this->option_length_specified_; } +inline void options:: +option_length_specified(bool x) +{ + this->option_length_specified_ = x; +} + inline const bool& options:: ansi_color () const { return this->ansi_color_; } +inline bool& options:: +ansi_color () +{ + return this->ansi_color_; +} + +inline void options:: +ansi_color(const bool& x) +{ + this->ansi_color_ = x; +} + inline const bool& options:: exclude_base () const { return this->exclude_base_; } +inline bool& options:: +exclude_base () +{ + return this->exclude_base_; +} + +inline void options:: +exclude_base(const bool& x) +{ + this->exclude_base_ = x; +} + inline const bool& options:: include_base_last () const { return this->include_base_last_; } +inline bool& options:: +include_base_last () +{ + return this->include_base_last_; +} + +inline void options:: +include_base_last(const bool& x) +{ + this->include_base_last_ = x; +} + inline const std::map& options:: class_doc () const { return this->class_doc_; } +inline std::map& options:: +class_doc () +{ + return this->class_doc_; +} + +inline void options:: +class_doc(const std::map& x) +{ + this->class_doc_ = x; +} + inline bool options:: class_doc_specified () const { return this->class_doc_specified_; } +inline void options:: +class_doc_specified(bool x) +{ + this->class_doc_specified_ = x; +} + inline const std::vector& options:: class_ () const { return this->class__; } +inline std::vector& options:: +class_ () +{ + return this->class__; +} + +inline void options:: +class_(const std::vector& x) +{ + this->class__ = x; +} + inline bool options:: class__specified () const { return this->class__specified_; } +inline void options:: +class__specified(bool x) +{ + this->class__specified_ = x; +} + inline const std::map& options:: docvar () const { return this->docvar_; } +inline std::map& options:: +docvar () +{ + return this->docvar_; +} + +inline void options:: +docvar(const std::map& x) +{ + this->docvar_ = x; +} + inline bool options:: docvar_specified () const { return this->docvar_specified_; } +inline void options:: +docvar_specified(bool x) +{ + this->docvar_specified_ = x; +} + inline const std::vector& options:: link_regex () const { return this->link_regex_; } +inline std::vector& options:: +link_regex () +{ + return this->link_regex_; +} + +inline void options:: +link_regex(const std::vector& x) +{ + this->link_regex_ = x; +} + inline bool options:: link_regex_specified () const { return this->link_regex_specified_; } +inline void options:: +link_regex_specified(bool x) +{ + this->link_regex_specified_ = x; +} + inline const bool& options:: link_regex_trace () const { return this->link_regex_trace_; } +inline bool& options:: +link_regex_trace () +{ + return this->link_regex_trace_; +} + +inline void options:: +link_regex_trace(const bool& x) +{ + this->link_regex_trace_ = x; +} + inline const std::map& options:: html_heading_map () const { return this->html_heading_map_; } +inline std::map& options:: +html_heading_map () +{ + return this->html_heading_map_; +} + +inline void options:: +html_heading_map(const std::map& x) +{ + this->html_heading_map_ = x; +} + inline bool options:: html_heading_map_specified () const { return this->html_heading_map_specified_; } +inline void options:: +html_heading_map_specified(bool x) +{ + this->html_heading_map_specified_ = x; +} + inline const bool& options:: omit_link_check () const { return this->omit_link_check_; } +inline bool& options:: +omit_link_check () +{ + return this->omit_link_check_; +} + +inline void options:: +omit_link_check(const bool& x) +{ + this->omit_link_check_ = x; +} + inline const std::vector& options:: hxx_prologue () const { return this->hxx_prologue_; } +inline std::vector& options:: +hxx_prologue () +{ + return this->hxx_prologue_; +} + +inline void options:: +hxx_prologue(const std::vector& x) +{ + this->hxx_prologue_ = x; +} + inline bool options:: hxx_prologue_specified () const { return this->hxx_prologue_specified_; } +inline void options:: +hxx_prologue_specified(bool x) +{ + this->hxx_prologue_specified_ = x; +} + inline const std::vector& options:: ixx_prologue () const { return this->ixx_prologue_; } +inline std::vector& options:: +ixx_prologue () +{ + return this->ixx_prologue_; +} + +inline void options:: +ixx_prologue(const std::vector& x) +{ + this->ixx_prologue_ = x; +} + inline bool options:: ixx_prologue_specified () const { return this->ixx_prologue_specified_; } +inline void options:: +ixx_prologue_specified(bool x) +{ + this->ixx_prologue_specified_ = x; +} + inline const std::vector& options:: cxx_prologue () const { return this->cxx_prologue_; } +inline std::vector& options:: +cxx_prologue () +{ + return this->cxx_prologue_; +} + +inline void options:: +cxx_prologue(const std::vector& x) +{ + this->cxx_prologue_ = x; +} + inline bool options:: cxx_prologue_specified () const { return this->cxx_prologue_specified_; } +inline void options:: +cxx_prologue_specified(bool x) +{ + this->cxx_prologue_specified_ = x; +} + inline const std::vector& options:: man_prologue () const { return this->man_prologue_; } +inline std::vector& options:: +man_prologue () +{ + return this->man_prologue_; +} + +inline void options:: +man_prologue(const std::vector& x) +{ + this->man_prologue_ = x; +} + inline bool options:: man_prologue_specified () const { return this->man_prologue_specified_; } +inline void options:: +man_prologue_specified(bool x) +{ + this->man_prologue_specified_ = x; +} + inline const std::vector& options:: html_prologue () const { return this->html_prologue_; } +inline std::vector& options:: +html_prologue () +{ + return this->html_prologue_; +} + +inline void options:: +html_prologue(const std::vector& x) +{ + this->html_prologue_ = x; +} + inline bool options:: html_prologue_specified () const { return this->html_prologue_specified_; } +inline void options:: +html_prologue_specified(bool x) +{ + this->html_prologue_specified_ = x; +} + inline const std::vector& options:: txt_prologue () const { return this->txt_prologue_; } +inline std::vector& options:: +txt_prologue () +{ + return this->txt_prologue_; +} + +inline void options:: +txt_prologue(const std::vector& x) +{ + this->txt_prologue_ = x; +} + inline bool options:: txt_prologue_specified () const { return this->txt_prologue_specified_; } +inline void options:: +txt_prologue_specified(bool x) +{ + this->txt_prologue_specified_ = x; +} + inline const std::vector& options:: hxx_epilogue () const { return this->hxx_epilogue_; } +inline std::vector& options:: +hxx_epilogue () +{ + return this->hxx_epilogue_; +} + +inline void options:: +hxx_epilogue(const std::vector& x) +{ + this->hxx_epilogue_ = x; +} + inline bool options:: hxx_epilogue_specified () const { return this->hxx_epilogue_specified_; } +inline void options:: +hxx_epilogue_specified(bool x) +{ + this->hxx_epilogue_specified_ = x; +} + inline const std::vector& options:: ixx_epilogue () const { return this->ixx_epilogue_; } +inline std::vector& options:: +ixx_epilogue () +{ + return this->ixx_epilogue_; +} + +inline void options:: +ixx_epilogue(const std::vector& x) +{ + this->ixx_epilogue_ = x; +} + inline bool options:: ixx_epilogue_specified () const { return this->ixx_epilogue_specified_; } +inline void options:: +ixx_epilogue_specified(bool x) +{ + this->ixx_epilogue_specified_ = x; +} + inline const std::vector& options:: cxx_epilogue () const { return this->cxx_epilogue_; } +inline std::vector& options:: +cxx_epilogue () +{ + return this->cxx_epilogue_; +} + +inline void options:: +cxx_epilogue(const std::vector& x) +{ + this->cxx_epilogue_ = x; +} + inline bool options:: cxx_epilogue_specified () const { return this->cxx_epilogue_specified_; } +inline void options:: +cxx_epilogue_specified(bool x) +{ + this->cxx_epilogue_specified_ = x; +} + inline const std::vector& options:: man_epilogue () const { return this->man_epilogue_; } +inline std::vector& options:: +man_epilogue () +{ + return this->man_epilogue_; +} + +inline void options:: +man_epilogue(const std::vector& x) +{ + this->man_epilogue_ = x; +} + inline bool options:: man_epilogue_specified () const { return this->man_epilogue_specified_; } +inline void options:: +man_epilogue_specified(bool x) +{ + this->man_epilogue_specified_ = x; +} + inline const std::vector& options:: html_epilogue () const { return this->html_epilogue_; } +inline std::vector& options:: +html_epilogue () +{ + return this->html_epilogue_; +} + +inline void options:: +html_epilogue(const std::vector& x) +{ + this->html_epilogue_ = x; +} + inline bool options:: html_epilogue_specified () const { return this->html_epilogue_specified_; } +inline void options:: +html_epilogue_specified(bool x) +{ + this->html_epilogue_specified_ = x; +} + inline const std::vector& options:: txt_epilogue () const { return this->txt_epilogue_; } +inline std::vector& options:: +txt_epilogue () +{ + return this->txt_epilogue_; +} + +inline void options:: +txt_epilogue(const std::vector& x) +{ + this->txt_epilogue_ = x; +} + inline bool options:: txt_epilogue_specified () const { return this->txt_epilogue_specified_; } +inline void options:: +txt_epilogue_specified(bool x) +{ + this->txt_epilogue_specified_ = x; +} + inline const std::string& options:: hxx_prologue_file () const { return this->hxx_prologue_file_; } +inline std::string& options:: +hxx_prologue_file () +{ + return this->hxx_prologue_file_; +} + +inline void options:: +hxx_prologue_file(const std::string& x) +{ + this->hxx_prologue_file_ = x; +} + inline bool options:: hxx_prologue_file_specified () const { return this->hxx_prologue_file_specified_; } -inline const std::string& options:: -ixx_prologue_file () const +inline void options:: +hxx_prologue_file_specified(bool x) +{ + this->hxx_prologue_file_specified_ = x; +} + +inline const std::string& options:: +ixx_prologue_file () const +{ + return this->ixx_prologue_file_; +} + +inline std::string& options:: +ixx_prologue_file () { return this->ixx_prologue_file_; } +inline void options:: +ixx_prologue_file(const std::string& x) +{ + this->ixx_prologue_file_ = x; +} + inline bool options:: ixx_prologue_file_specified () const { return this->ixx_prologue_file_specified_; } +inline void options:: +ixx_prologue_file_specified(bool x) +{ + this->ixx_prologue_file_specified_ = x; +} + inline const std::string& options:: cxx_prologue_file () const { return this->cxx_prologue_file_; } +inline std::string& options:: +cxx_prologue_file () +{ + return this->cxx_prologue_file_; +} + +inline void options:: +cxx_prologue_file(const std::string& x) +{ + this->cxx_prologue_file_ = x; +} + inline bool options:: cxx_prologue_file_specified () const { return this->cxx_prologue_file_specified_; } +inline void options:: +cxx_prologue_file_specified(bool x) +{ + this->cxx_prologue_file_specified_ = x; +} + inline const std::string& options:: man_prologue_file () const { return this->man_prologue_file_; } +inline std::string& options:: +man_prologue_file () +{ + return this->man_prologue_file_; +} + +inline void options:: +man_prologue_file(const std::string& x) +{ + this->man_prologue_file_ = x; +} + inline bool options:: man_prologue_file_specified () const { return this->man_prologue_file_specified_; } +inline void options:: +man_prologue_file_specified(bool x) +{ + this->man_prologue_file_specified_ = x; +} + inline const std::string& options:: html_prologue_file () const { return this->html_prologue_file_; } +inline std::string& options:: +html_prologue_file () +{ + return this->html_prologue_file_; +} + +inline void options:: +html_prologue_file(const std::string& x) +{ + this->html_prologue_file_ = x; +} + inline bool options:: html_prologue_file_specified () const { return this->html_prologue_file_specified_; } +inline void options:: +html_prologue_file_specified(bool x) +{ + this->html_prologue_file_specified_ = x; +} + inline const std::string& options:: txt_prologue_file () const { return this->txt_prologue_file_; } +inline std::string& options:: +txt_prologue_file () +{ + return this->txt_prologue_file_; +} + +inline void options:: +txt_prologue_file(const std::string& x) +{ + this->txt_prologue_file_ = x; +} + inline bool options:: txt_prologue_file_specified () const { return this->txt_prologue_file_specified_; } +inline void options:: +txt_prologue_file_specified(bool x) +{ + this->txt_prologue_file_specified_ = x; +} + inline const std::string& options:: hxx_epilogue_file () const { return this->hxx_epilogue_file_; } +inline std::string& options:: +hxx_epilogue_file () +{ + return this->hxx_epilogue_file_; +} + +inline void options:: +hxx_epilogue_file(const std::string& x) +{ + this->hxx_epilogue_file_ = x; +} + inline bool options:: hxx_epilogue_file_specified () const { return this->hxx_epilogue_file_specified_; } +inline void options:: +hxx_epilogue_file_specified(bool x) +{ + this->hxx_epilogue_file_specified_ = x; +} + inline const std::string& options:: ixx_epilogue_file () const { return this->ixx_epilogue_file_; } +inline std::string& options:: +ixx_epilogue_file () +{ + return this->ixx_epilogue_file_; +} + +inline void options:: +ixx_epilogue_file(const std::string& x) +{ + this->ixx_epilogue_file_ = x; +} + inline bool options:: ixx_epilogue_file_specified () const { return this->ixx_epilogue_file_specified_; } +inline void options:: +ixx_epilogue_file_specified(bool x) +{ + this->ixx_epilogue_file_specified_ = x; +} + inline const std::string& options:: cxx_epilogue_file () const { return this->cxx_epilogue_file_; } +inline std::string& options:: +cxx_epilogue_file () +{ + return this->cxx_epilogue_file_; +} + +inline void options:: +cxx_epilogue_file(const std::string& x) +{ + this->cxx_epilogue_file_ = x; +} + inline bool options:: cxx_epilogue_file_specified () const { return this->cxx_epilogue_file_specified_; } +inline void options:: +cxx_epilogue_file_specified(bool x) +{ + this->cxx_epilogue_file_specified_ = x; +} + inline const std::string& options:: man_epilogue_file () const { return this->man_epilogue_file_; } +inline std::string& options:: +man_epilogue_file () +{ + return this->man_epilogue_file_; +} + +inline void options:: +man_epilogue_file(const std::string& x) +{ + this->man_epilogue_file_ = x; +} + inline bool options:: man_epilogue_file_specified () const { return this->man_epilogue_file_specified_; } +inline void options:: +man_epilogue_file_specified(bool x) +{ + this->man_epilogue_file_specified_ = x; +} + inline const std::string& options:: html_epilogue_file () const { return this->html_epilogue_file_; } +inline std::string& options:: +html_epilogue_file () +{ + return this->html_epilogue_file_; +} + +inline void options:: +html_epilogue_file(const std::string& x) +{ + this->html_epilogue_file_ = x; +} + inline bool options:: html_epilogue_file_specified () const { return this->html_epilogue_file_specified_; } +inline void options:: +html_epilogue_file_specified(bool x) +{ + this->html_epilogue_file_specified_ = x; +} + inline const std::string& options:: txt_epilogue_file () const { return this->txt_epilogue_file_; } +inline std::string& options:: +txt_epilogue_file () +{ + return this->txt_epilogue_file_; +} + +inline void options:: +txt_epilogue_file(const std::string& x) +{ + this->txt_epilogue_file_ = x; +} + inline bool options:: txt_epilogue_file_specified () const { return this->txt_epilogue_file_specified_; } +inline void options:: +txt_epilogue_file_specified(bool x) +{ + this->txt_epilogue_file_specified_ = x; +} + inline const std::string& options:: output_prefix () const { return this->output_prefix_; } +inline std::string& options:: +output_prefix () +{ + return this->output_prefix_; +} + +inline void options:: +output_prefix(const std::string& x) +{ + this->output_prefix_ = x; +} + inline bool options:: output_prefix_specified () const { return this->output_prefix_specified_; } +inline void options:: +output_prefix_specified(bool x) +{ + this->output_prefix_specified_ = x; +} + inline const std::string& options:: output_suffix () const { return this->output_suffix_; } +inline std::string& options:: +output_suffix () +{ + return this->output_suffix_; +} + +inline void options:: +output_suffix(const std::string& x) +{ + this->output_suffix_ = x; +} + inline bool options:: output_suffix_specified () const { return this->output_suffix_specified_; } +inline void options:: +output_suffix_specified(bool x) +{ + this->output_suffix_specified_ = x; +} + inline const std::string& options:: hxx_suffix () const { return this->hxx_suffix_; } +inline std::string& options:: +hxx_suffix () +{ + return this->hxx_suffix_; +} + +inline void options:: +hxx_suffix(const std::string& x) +{ + this->hxx_suffix_ = x; +} + inline bool options:: hxx_suffix_specified () const { return this->hxx_suffix_specified_; } +inline void options:: +hxx_suffix_specified(bool x) +{ + this->hxx_suffix_specified_ = x; +} + inline const std::string& options:: ixx_suffix () const { return this->ixx_suffix_; } +inline std::string& options:: +ixx_suffix () +{ + return this->ixx_suffix_; +} + +inline void options:: +ixx_suffix(const std::string& x) +{ + this->ixx_suffix_ = x; +} + inline bool options:: ixx_suffix_specified () const { return this->ixx_suffix_specified_; } +inline void options:: +ixx_suffix_specified(bool x) +{ + this->ixx_suffix_specified_ = x; +} + inline const std::string& options:: cxx_suffix () const { return this->cxx_suffix_; } +inline std::string& options:: +cxx_suffix () +{ + return this->cxx_suffix_; +} + +inline void options:: +cxx_suffix(const std::string& x) +{ + this->cxx_suffix_ = x; +} + inline bool options:: cxx_suffix_specified () const { return this->cxx_suffix_specified_; } +inline void options:: +cxx_suffix_specified(bool x) +{ + this->cxx_suffix_specified_ = x; +} + inline const std::string& options:: man_suffix () const { return this->man_suffix_; } +inline std::string& options:: +man_suffix () +{ + return this->man_suffix_; +} + +inline void options:: +man_suffix(const std::string& x) +{ + this->man_suffix_ = x; +} + inline bool options:: man_suffix_specified () const { return this->man_suffix_specified_; } +inline void options:: +man_suffix_specified(bool x) +{ + this->man_suffix_specified_ = x; +} + inline const std::string& options:: html_suffix () const { return this->html_suffix_; } +inline std::string& options:: +html_suffix () +{ + return this->html_suffix_; +} + +inline void options:: +html_suffix(const std::string& x) +{ + this->html_suffix_ = x; +} + inline bool options:: html_suffix_specified () const { return this->html_suffix_specified_; } +inline void options:: +html_suffix_specified(bool x) +{ + this->html_suffix_specified_ = x; +} + inline const std::string& options:: txt_suffix () const { return this->txt_suffix_; } +inline std::string& options:: +txt_suffix () +{ + return this->txt_suffix_; +} + +inline void options:: +txt_suffix(const std::string& x) +{ + this->txt_suffix_ = x; +} + inline bool options:: txt_suffix_specified () const { return this->txt_suffix_specified_; } +inline void options:: +txt_suffix_specified(bool x) +{ + this->txt_suffix_specified_ = x; +} + inline const std::string& options:: option_prefix () const { return this->option_prefix_; } +inline std::string& options:: +option_prefix () +{ + return this->option_prefix_; +} + +inline void options:: +option_prefix(const std::string& x) +{ + this->option_prefix_ = x; +} + inline bool options:: option_prefix_specified () const { return this->option_prefix_specified_; } +inline void options:: +option_prefix_specified(bool x) +{ + this->option_prefix_specified_ = x; +} + inline const std::string& options:: option_separator () const { return this->option_separator_; } +inline std::string& options:: +option_separator () +{ + return this->option_separator_; +} + +inline void options:: +option_separator(const std::string& x) +{ + this->option_separator_ = x; +} + inline bool options:: option_separator_specified () const { return this->option_separator_specified_; } +inline void options:: +option_separator_specified(bool x) +{ + this->option_separator_specified_ = x; +} + inline const bool& options:: include_with_brackets () const { return this->include_with_brackets_; } +inline bool& options:: +include_with_brackets () +{ + return this->include_with_brackets_; +} + +inline void options:: +include_with_brackets(const bool& x) +{ + this->include_with_brackets_ = x; +} + inline const std::string& options:: include_prefix () const { return this->include_prefix_; } +inline std::string& options:: +include_prefix () +{ + return this->include_prefix_; +} + +inline void options:: +include_prefix(const std::string& x) +{ + this->include_prefix_ = x; +} + inline bool options:: include_prefix_specified () const { return this->include_prefix_specified_; } +inline void options:: +include_prefix_specified(bool x) +{ + this->include_prefix_specified_ = x; +} + inline const std::string& options:: guard_prefix () const { return this->guard_prefix_; } +inline std::string& options:: +guard_prefix () +{ + return this->guard_prefix_; +} + +inline void options:: +guard_prefix(const std::string& x) +{ + this->guard_prefix_ = x; +} + inline bool options:: guard_prefix_specified () const { return this->guard_prefix_specified_; } +inline void options:: +guard_prefix_specified(bool x) +{ + this->guard_prefix_specified_ = x; +} + inline const std::map& options:: reserved_name () const { return this->reserved_name_; } +inline std::map& options:: +reserved_name () +{ + return this->reserved_name_; +} + +inline void options:: +reserved_name(const std::map& x) +{ + this->reserved_name_ = x; +} + inline bool options:: reserved_name_specified () const { return this->reserved_name_specified_; } +inline void options:: +reserved_name_specified(bool x) +{ + this->reserved_name_specified_ = x; +} + inline const std::string& options:: options_file () const { return this->options_file_; } +inline std::string& options:: +options_file () +{ + return this->options_file_; +} + +inline void options:: +options_file(const std::string& x) +{ + this->options_file_ = x; +} + inline bool options:: options_file_specified () const { return this->options_file_specified_; } +inline void options:: +options_file_specified(bool x) +{ + this->options_file_specified_ = x; +} + // Begin epilogue. // // -- cgit v1.1