clapp/examples/container_example.cpp at master · libclapp/clapp · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
#include <clapp/build_info.h>
#include <clapp/main_parser.h>
#include <clapp/option.h>
#include <clapp/parser_container.h>
#include <clapp/sub_parser.h>
#include <unistd.h>

#include <iostream>

clapp::value::found_func_t::ret_t print_version_and_exit(
    const std::string &option);

class cli_parser_t : public clapp::basic_main_parser_t {
   public:
    cli_parser_t();

    explicit cli_parser_t(const cli_parser_t &) = delete;
    explicit cli_parser_t(cli_parser_t &&) noexcept = delete;
    cli_parser_t &operator=(const cli_parser_t &) = delete;
    cli_parser_t &operator=(cli_parser_t &&) noexcept = delete;

    ~cli_parser_t() override;

    // if help is given, help is printed and exit(EXIT_SUCCESS) is requested
    clapp::help_option_t help{*this, "help", 'h', "Show help options."};

    // if version is given, print_version_and_exit() is called.
    clapp::bool_option_t version{
        *this, "version", "Show version info",
        clapp::value::found_func_t{print_version_and_exit}};

    class and_option_container_t : public clapp::option_container_t {
       public:
        using clapp::option_container_t::option_container_t;

        ~and_option_container_t() override;

        clapp::count_option_t verbose{*this,
                                      "verbose",
                                      'v',
                                      "Verbose option, can be given multiple "
                                      "times to increase verbosity.",
                                      clapp::min_max_value_t<std::size_t>{0, 7},
                                      clapp::default_value_t<std::size_t>{2},
                                      purpose_t::optional};

        // mandatory string option
        clapp::string_param_option_t string_param{
            *this, "string", std::vector<char>{'s', '1'}, "String option 1.",
            purpose_t::mandatory};

        class xor_option_container_t : public clapp::option_container_t {
           public:
            using clapp::option_container_t::option_container_t;

            ~xor_option_container_t() override;

            clapp::int32_param_option_t int32{*this, "i32", "Int32 option."};

            clapp::uint32_param_option_t uint32{*this, "u32", "UInt32 option."};

            explicit xor_option_container_t(const xor_option_container_t &) =
                delete;
            explicit xor_option_container_t(
                xor_option_container_t &&) noexcept = delete;
            xor_option_container_t &operator=(const xor_option_container_t &) =
                delete;
            xor_option_container_t &operator=(
                xor_option_container_t &&) noexcept = delete;
        };

        xor_option_container_t int_options{
            *this, clapp::parser::types::logic_operator_type_t::logic_xor};

        explicit and_option_container_t(const and_option_container_t &) =
            delete;
        explicit and_option_container_t(and_option_container_t &&) noexcept =
            delete;
        and_option_container_t &operator=(const and_option_container_t &) =
            delete;
        and_option_container_t &operator=(and_option_container_t &&) noexcept =
            delete;
    };

    and_option_container_t options{
        *this, clapp::parser::types::logic_operator_type_t::logic_and};
};

clapp::value::found_func_t::ret_t print_version_and_exit(
    const std::string & /*option*/) {
    std::cout << clapp::build_info::build_info_string << std::endl;
    return clapp::value::exit_t::exit(EXIT_SUCCESS);
}

cli_parser_t::cli_parser_t()
    : clapp::basic_main_parser_t{
          clapp::parser::types::logic_operator_type_t::logic_xor} {}

cli_parser_t::~cli_parser_t() = default;
cli_parser_t::and_option_container_t::~and_option_container_t() = default;
cli_parser_t::and_option_container_t::xor_option_container_t::
    ~xor_option_container_t() = default;

using parser_t = clapp::parser::basic_parser_container_t<cli_parser_t>;

int main(int argc, char **argv) {
    try {
        parser_t parser;
        const std::optional<clapp::value::exit_t> exit{
            parser.parse_and_validate(argc, argv)};
        if (exit) {
            return exit.value().get_exit_code();
        }

        if (parser->options.verbose
                .given()) {  // if the optional verbose-option is given
            std::cout << "verbose: " << parser->options.verbose.value() << "\n";
        } else {
            std::cout << "verbose: not given\n";
        }

        Expects(
            parser->options
                .string_param);  // parser ensures, that string-option is given
        std::cout << "string-param: " << parser->options.string_param.value()
                  << std::endl;
        if (parser->options.int_options.int32) {
            std::cout << "int32-param: "
                      << parser->options.int_options.int32.value() << std::endl;
        } else {
            std::cout << "uint32-param: "
                      << parser->options.int_options.uint32.value()
                      << std::endl;
        }
    } catch (clapp::exception::clapp_exception_t &e) {
        std::cout << "Caught ClaPP-Exception: " << e.what() << std::endl;
        return EXIT_FAILURE;
    } catch (std::exception &e) {
        std::cout << "Caught Exception: " << e.what() << std::endl;
        return EXIT_FAILURE;
    }
    return EXIT_SUCCESS;
}