Builder

qargparser

Struct Builder 

Source 
pub struct Builder { /* private fields */ }
Expand description

Parser option/argument specification builder.

Implementations§

Source§

impl Builder

Source

pub fn new() -> Self

Examples found in repository?
examples/conflict.rs (line 18)
17fn main() -> Result<(), Box<dyn std::error::Error>> {
18  let help_spec = arg::Builder::new()
19    .sopt('h')
20    .lopt("help")
21    .exit(true)
22    .help(&["Show this help."])
23    .build(help_proc);
24  let coll_spec = arg::Builder::new()
25    .sopt('h')
26    .lopt("hulp")
27    .exit(true)
28    .help(&["Show this help."])
29    .build(help_proc);
30
31
32  let ctx = MyContext {
33    ..Default::default()
34  };
35  let mut prsr = arg::Parser::from_env(ctx);
36
37  prsr.add(help_spec)?;
38  prsr.add(coll_spec)?;
39
40  prsr.parse()?;
41
42  //let ctx = prsr.into_ctx();
43  if prsr.get_ctx().do_help == true {
44    prsr.usage(&mut std::io::stdout());
45    std::process::exit(0);
46  }
47
48  println!("{:?}", prsr.get_ctx());
49
50  Ok(())
51}
More examples
Hide additional examples
examples/remaining.rs (line 38)
37fn main() -> Result<(), Box<dyn std::error::Error>> {
38  let help_spec = arg::Builder::new()
39    .sopt('h')
40    .lopt("help")
41    .exit(true)
42    .help(&["Show this help."])
43    .build(help_proc);
44  let exec_spec = arg::Builder::new()
45    .name("exec")
46    .nargs(arg::Nargs::Count(1), &["PRG"])
47    .help(&["The executable to run."])
48    .build(exec_proc);
49  let eargs_spec = arg::Builder::new()
50    .name("execargs")
51    .nargs(arg::Nargs::Remainder, &["PRGARG"])
52    .help(&["arguments to pass to the executable."])
53    .build(eargs_proc);
54
55  let ctx = MyContext {
56    ..Default::default()
57  };
58  let mut prsr = arg::Parser::from_env(ctx);
59
60  prsr.add(help_spec)?;
61  prsr.add(exec_spec)?;
62  prsr.add(eargs_spec)?;
63
64  prsr.parse()?;
65
66  if prsr.get_ctx().do_help == true {
67    prsr.usage(&mut std::io::stdout());
68    std::process::exit(0);
69  }
70
71  let ctx = prsr.into_ctx();
72
73  println!("{:?}", &ctx);
74
75  Ok(())
76}
examples/hidden.rs (line 12)
11fn main() -> Result<(), Box<dyn std::error::Error>> {
12  let help_spec = arg::Builder::new()
13    .sopt('h')
14    .lopt("help")
15    .exit(true)
16    .help(&["Show this help."])
17    .build(
18      |_spec: &arg::Spec<MyContext>,
19       ctx: &mut MyContext,
20       _args: &Vec<String>| ctx.do_help = true
21    );
22  let version_spec = arg::Builder::new()
23    .sopt('V')
24    .lopt("version")
25    .exit(true)
26    .help(&["Output tool version and exit."])
27    .build(
28      |_spec: &arg::Spec<MyContext>,
29       ctx: &mut MyContext,
30       _args: &Vec<String>| ctx.do_version = true
31    );
32  let secret_spec = arg::Builder::new()
33    .sopt('s')
34    .lopt("secret")
35    .hidden(true)
36    .help(&["A hidden option."])
37    .build(
38      |_spec: &arg::Spec<MyContext>,
39       ctx: &mut MyContext,
40       _args: &Vec<String>| ctx.do_secret = true
41    );
42
43
44  let ctx = MyContext {
45    ..Default::default()
46  };
47  let mut prsr = arg::Parser::from_env(ctx);
48
49  prsr.add(help_spec)?;
50  prsr.add(version_spec)?;
51  prsr.add(secret_spec)?;
52
53  prsr.parse()?;
54
55  if prsr.get_ctx().do_help == true {
56    prsr.usage(&mut std::io::stdout());
57    std::process::exit(0);
58  }
59
60  let ctx = prsr.into_ctx();
61
62  println!("{:?}", &ctx);
63
64  Ok(())
65}
examples/usage.rs (line 20)
19fn main() -> Result<(), Box<dyn std::error::Error>> {
20  let help_spec = arg::Builder::new()
21    .sopt('h')
22    .lopt("help")
23    .exit(true)
24    .help(&["Show this help."])
25    .build(|_spec, ctx: &mut MyContext, _args| {
26      ctx.do_help = true;
27    });
28  let version_spec = arg::Builder::new()
29    .sopt('V')
30    .lopt("version")
31    .exit(true)
32    .help(&["Output tool version and exit."])
33    .build(
34      |_spec: &arg::Spec<MyContext>,
35       ctx: &mut MyContext,
36       _args: &Vec<String>| ctx.do_version = true
37    );
38  let tophelp_spec = arg::Builder::new()
39    .sopt('t')
40    .lopt("tophelp")
41    .help(&["Show top help."])
42    .build(|_spec, ctx: &mut MyContext, _args| {
43      ctx.tophelp = true;
44    });
45  let bottomhelp_spec = arg::Builder::new()
46    .sopt('b')
47    .lopt("bottomhelp")
48    .help(&["Show bottom help."])
49    .build(|_spec, ctx: &mut MyContext, _args| {
50      ctx.bottomhelp = true;
51    });
52
53  let ctx = MyContext {
54    ..Default::default()
55  };
56  let mut prsr = arg::Parser::from_env(ctx);
57
58  prsr.add(help_spec)?;
59  prsr.add(version_spec)?;
60  prsr.add(tophelp_spec)?;
61  prsr.add(bottomhelp_spec)?;
62
63  prsr.parse()?;
64
65  if prsr.get_ctx().do_help == true {
66    prsr.usage(&mut std::io::stdout());
67    std::process::exit(0);
68  }
69
70  if prsr.get_ctx().do_version == true {
71    const VERSION: &'static str = env!("CARGO_PKG_VERSION");
72    println!("usage {}", VERSION);
73    std::process::exit(0);
74  }
75
76  let ctx = prsr.into_ctx();
77
78  println!("{:?}", &ctx);
79
80  usage_test(ctx)?;
81
82  Ok(())
83}
84
85
86fn usage_test(ctx: MyContext) -> Result<(), Box<dyn std::error::Error>> {
87  let help_spec = arg::Builder::new()
88    .sopt('h')
89    .lopt("help")
90    .exit(true)
91    .help(&["Show this help."])
92    .build(|_spec, ctx: &mut MyContext, _args| {
93      ctx.do_help = true;
94    });
95  let version_spec = arg::Builder::new()
96    .sopt('V')
97    .lopt("version")
98    .exit(true)
99    .help(&["Output tool version and exit."])
100    .build(
101      |_spec: &arg::Spec<MyContext>,
102       ctx: &mut MyContext,
103       _args: &Vec<String>| ctx.do_version = true
104    );
105  let file_spec = arg::Builder::new()
106    .sopt('f')
107    .lopt("file")
108    .help(&["Use data in FILE."])
109    .nargs(arg::Nargs::Count(1), &["FILE"])
110    .build(|_spec, ctx: &mut MyContext, args| {
111      ctx.fname = args[0].clone();
112    });
113  let param_spec = arg::Builder::new()
114    .sopt('p')
115    .lopt("param")
116    .help(&["Add a key/value parameter field. The key must be unique."])
117    .nargs(arg::Nargs::Count(2), &["KEY", "VALUE"])
118    .build(|_spec, ctx: &mut MyContext, args| {
119      ctx.params.insert(args[0].clone(), args[1].clone());
120    });
121  let cmd_spec = arg::Builder::new()
122    .name("command")
123    .required(true)
124    .nargs(arg::Nargs::Count(1), &["COMMAND"])
125    .help(&["The command to run."])
126    .build(|_spec, ctx: &mut MyContext, args| {
127      ctx.cmd = args[0].clone();
128    });
129  let subcmd_spec = arg::Builder::new()
130    .name("subcmd")
131    .nargs(arg::Nargs::Count(1), &["SUBCMD"])
132    .help(&["Command-specific sub-command."])
133    .build(|_spec, ctx: &mut MyContext, args| {
134      ctx.subcmd = args[0].clone();
135    });
136
137  let ctx2 = MyContext {
138    ..Default::default()
139  };
140  let mut prsr = arg::Parser::from_args("hello", &["--help"], ctx2);
141
142  if ctx.tophelp {
143    prsr.set_tophelp(&[
144      "\"You know,\" said Arthur, \"it's at times like this, when I'm \
145       trapped in a Vogon airlock with a man from Betelgeuse, and about to \
146       die of asphyxiation in deep space that I really wish I'd listened to \
147       what my mother told me when I was young.\"",
148      "\"Why, what did she tell you?\"",
149      "\"I don't know, I didn't listen.\""
150    ]);
151  }
152  if ctx.bottomhelp {
153    prsr.set_bottomhelp(&[
154      "\"So this is it,\" said Arthur, \"We are going to die.\"",
155      "\"Yes,\" said Ford, \"except... no! Wait a minute!\" He suddenly \
156       lunged across the chamber at something behind Arthur's line of \
157       vision. \"What's this switch?\" he cried.",
158      "\"What? Where?\" cried Arthur, twisting round.",
159      "\"No, I was only fooling,\" said Ford, \"we are going to die after \
160       all.\""
161    ]);
162  }
163
164  prsr.add(help_spec)?;
165  prsr.add(version_spec)?;
166  prsr.add(file_spec)?;
167  prsr.add(param_spec)?;
168  prsr.add(cmd_spec)?;
169  prsr.add(subcmd_spec)?;
170
171  prsr.parse()?;
172
173  if prsr.get_ctx().do_help == true {
174    prsr.usage(&mut std::io::stdout());
175    std::process::exit(0);
176  }
177
178  let ctx = prsr.into_ctx();
179
180  println!("{:?}", &ctx);
181
182  Ok(())
183}
examples/simple.rs (line 73)
72fn main() -> Result<(), Box<dyn std::error::Error>> {
73  let help_spec = arg::Builder::new()
74    .sopt('h')
75    .lopt("help")
76    .exit(true)
77    .help(&["Show this help."])
78    .build(help_proc);
79  let verbose_spec = arg::Builder::new()
80    .sopt('v')
81    .lopt("verbose")
82    .help(&["Increase level of verbosity.", "Be quiet by default."])
83    .build(verbose_proc);
84  let version_spec = arg::Builder::new()
85    .sopt('V')
86    .lopt("version")
87    .exit(true)
88    .help(&["Output tool version and exit."])
89    .build(
90      |_spec: &arg::Spec<MyContext>,
91       ctx: &mut MyContext,
92       _args: &Vec<String>| ctx.do_version = true
93    );
94  let file_spec = arg::Builder::new()
95    .sopt('f')
96    .lopt("file")
97    .help(&["Use data in FILE."])
98    .nargs(arg::Nargs::Count(1), &["FILE"])
99    .build(file_proc);
100  let param_spec = arg::Builder::new()
101    .sopt('p')
102    .lopt("param")
103    .help(&["Add a key/value parameter field. The key must be unique."])
104    .nargs(arg::Nargs::Count(2), &["KEY", "VALUE"])
105    .build(param_proc);
106  let cmd_spec = arg::Builder::new()
107    .name("command")
108    .required(true)
109    .nargs(arg::Nargs::Count(1), &["COMMAND"])
110    .help(&["The command to run."])
111    .build(cmd_proc);
112  let subcmd_spec = arg::Builder::new()
113    .name("subcmd")
114    .nargs(arg::Nargs::Count(1), &["SUBCMD"])
115    .help(&["Command-specific sub-command."])
116    .build(subcmd_proc);
117
118
119  let ctx = MyContext {
120    ..Default::default()
121  };
122  let mut prsr = arg::Parser::from_env(ctx);
123
124  prsr.add(help_spec)?;
125  prsr.add(verbose_spec)?;
126  prsr.add(version_spec)?;
127  prsr.add(file_spec)?;
128  prsr.add(param_spec)?;
129  prsr.add(cmd_spec)?;
130  prsr.add(subcmd_spec)?;
131
132  prsr.parse()?;
133
134  if prsr.get_ctx().do_help == true {
135    prsr.usage(&mut std::io::stdout());
136    std::process::exit(0);
137  }
138
139  let ctx = prsr.into_ctx();
140
141  println!("{:?}", &ctx);
142
143  Ok(())
144}
Source

pub fn sopt(&mut self, sopt: char) -> &mut Self

Make argument specification a single-character option.

Examples found in repository?
examples/conflict.rs (line 19)
17fn main() -> Result<(), Box<dyn std::error::Error>> {
18  let help_spec = arg::Builder::new()
19    .sopt('h')
20    .lopt("help")
21    .exit(true)
22    .help(&["Show this help."])
23    .build(help_proc);
24  let coll_spec = arg::Builder::new()
25    .sopt('h')
26    .lopt("hulp")
27    .exit(true)
28    .help(&["Show this help."])
29    .build(help_proc);
30
31
32  let ctx = MyContext {
33    ..Default::default()
34  };
35  let mut prsr = arg::Parser::from_env(ctx);
36
37  prsr.add(help_spec)?;
38  prsr.add(coll_spec)?;
39
40  prsr.parse()?;
41
42  //let ctx = prsr.into_ctx();
43  if prsr.get_ctx().do_help == true {
44    prsr.usage(&mut std::io::stdout());
45    std::process::exit(0);
46  }
47
48  println!("{:?}", prsr.get_ctx());
49
50  Ok(())
51}
More examples
Hide additional examples
examples/remaining.rs (line 39)
37fn main() -> Result<(), Box<dyn std::error::Error>> {
38  let help_spec = arg::Builder::new()
39    .sopt('h')
40    .lopt("help")
41    .exit(true)
42    .help(&["Show this help."])
43    .build(help_proc);
44  let exec_spec = arg::Builder::new()
45    .name("exec")
46    .nargs(arg::Nargs::Count(1), &["PRG"])
47    .help(&["The executable to run."])
48    .build(exec_proc);
49  let eargs_spec = arg::Builder::new()
50    .name("execargs")
51    .nargs(arg::Nargs::Remainder, &["PRGARG"])
52    .help(&["arguments to pass to the executable."])
53    .build(eargs_proc);
54
55  let ctx = MyContext {
56    ..Default::default()
57  };
58  let mut prsr = arg::Parser::from_env(ctx);
59
60  prsr.add(help_spec)?;
61  prsr.add(exec_spec)?;
62  prsr.add(eargs_spec)?;
63
64  prsr.parse()?;
65
66  if prsr.get_ctx().do_help == true {
67    prsr.usage(&mut std::io::stdout());
68    std::process::exit(0);
69  }
70
71  let ctx = prsr.into_ctx();
72
73  println!("{:?}", &ctx);
74
75  Ok(())
76}
examples/hidden.rs (line 13)
11fn main() -> Result<(), Box<dyn std::error::Error>> {
12  let help_spec = arg::Builder::new()
13    .sopt('h')
14    .lopt("help")
15    .exit(true)
16    .help(&["Show this help."])
17    .build(
18      |_spec: &arg::Spec<MyContext>,
19       ctx: &mut MyContext,
20       _args: &Vec<String>| ctx.do_help = true
21    );
22  let version_spec = arg::Builder::new()
23    .sopt('V')
24    .lopt("version")
25    .exit(true)
26    .help(&["Output tool version and exit."])
27    .build(
28      |_spec: &arg::Spec<MyContext>,
29       ctx: &mut MyContext,
30       _args: &Vec<String>| ctx.do_version = true
31    );
32  let secret_spec = arg::Builder::new()
33    .sopt('s')
34    .lopt("secret")
35    .hidden(true)
36    .help(&["A hidden option."])
37    .build(
38      |_spec: &arg::Spec<MyContext>,
39       ctx: &mut MyContext,
40       _args: &Vec<String>| ctx.do_secret = true
41    );
42
43
44  let ctx = MyContext {
45    ..Default::default()
46  };
47  let mut prsr = arg::Parser::from_env(ctx);
48
49  prsr.add(help_spec)?;
50  prsr.add(version_spec)?;
51  prsr.add(secret_spec)?;
52
53  prsr.parse()?;
54
55  if prsr.get_ctx().do_help == true {
56    prsr.usage(&mut std::io::stdout());
57    std::process::exit(0);
58  }
59
60  let ctx = prsr.into_ctx();
61
62  println!("{:?}", &ctx);
63
64  Ok(())
65}
examples/usage.rs (line 21)
19fn main() -> Result<(), Box<dyn std::error::Error>> {
20  let help_spec = arg::Builder::new()
21    .sopt('h')
22    .lopt("help")
23    .exit(true)
24    .help(&["Show this help."])
25    .build(|_spec, ctx: &mut MyContext, _args| {
26      ctx.do_help = true;
27    });
28  let version_spec = arg::Builder::new()
29    .sopt('V')
30    .lopt("version")
31    .exit(true)
32    .help(&["Output tool version and exit."])
33    .build(
34      |_spec: &arg::Spec<MyContext>,
35       ctx: &mut MyContext,
36       _args: &Vec<String>| ctx.do_version = true
37    );
38  let tophelp_spec = arg::Builder::new()
39    .sopt('t')
40    .lopt("tophelp")
41    .help(&["Show top help."])
42    .build(|_spec, ctx: &mut MyContext, _args| {
43      ctx.tophelp = true;
44    });
45  let bottomhelp_spec = arg::Builder::new()
46    .sopt('b')
47    .lopt("bottomhelp")
48    .help(&["Show bottom help."])
49    .build(|_spec, ctx: &mut MyContext, _args| {
50      ctx.bottomhelp = true;
51    });
52
53  let ctx = MyContext {
54    ..Default::default()
55  };
56  let mut prsr = arg::Parser::from_env(ctx);
57
58  prsr.add(help_spec)?;
59  prsr.add(version_spec)?;
60  prsr.add(tophelp_spec)?;
61  prsr.add(bottomhelp_spec)?;
62
63  prsr.parse()?;
64
65  if prsr.get_ctx().do_help == true {
66    prsr.usage(&mut std::io::stdout());
67    std::process::exit(0);
68  }
69
70  if prsr.get_ctx().do_version == true {
71    const VERSION: &'static str = env!("CARGO_PKG_VERSION");
72    println!("usage {}", VERSION);
73    std::process::exit(0);
74  }
75
76  let ctx = prsr.into_ctx();
77
78  println!("{:?}", &ctx);
79
80  usage_test(ctx)?;
81
82  Ok(())
83}
84
85
86fn usage_test(ctx: MyContext) -> Result<(), Box<dyn std::error::Error>> {
87  let help_spec = arg::Builder::new()
88    .sopt('h')
89    .lopt("help")
90    .exit(true)
91    .help(&["Show this help."])
92    .build(|_spec, ctx: &mut MyContext, _args| {
93      ctx.do_help = true;
94    });
95  let version_spec = arg::Builder::new()
96    .sopt('V')
97    .lopt("version")
98    .exit(true)
99    .help(&["Output tool version and exit."])
100    .build(
101      |_spec: &arg::Spec<MyContext>,
102       ctx: &mut MyContext,
103       _args: &Vec<String>| ctx.do_version = true
104    );
105  let file_spec = arg::Builder::new()
106    .sopt('f')
107    .lopt("file")
108    .help(&["Use data in FILE."])
109    .nargs(arg::Nargs::Count(1), &["FILE"])
110    .build(|_spec, ctx: &mut MyContext, args| {
111      ctx.fname = args[0].clone();
112    });
113  let param_spec = arg::Builder::new()
114    .sopt('p')
115    .lopt("param")
116    .help(&["Add a key/value parameter field. The key must be unique."])
117    .nargs(arg::Nargs::Count(2), &["KEY", "VALUE"])
118    .build(|_spec, ctx: &mut MyContext, args| {
119      ctx.params.insert(args[0].clone(), args[1].clone());
120    });
121  let cmd_spec = arg::Builder::new()
122    .name("command")
123    .required(true)
124    .nargs(arg::Nargs::Count(1), &["COMMAND"])
125    .help(&["The command to run."])
126    .build(|_spec, ctx: &mut MyContext, args| {
127      ctx.cmd = args[0].clone();
128    });
129  let subcmd_spec = arg::Builder::new()
130    .name("subcmd")
131    .nargs(arg::Nargs::Count(1), &["SUBCMD"])
132    .help(&["Command-specific sub-command."])
133    .build(|_spec, ctx: &mut MyContext, args| {
134      ctx.subcmd = args[0].clone();
135    });
136
137  let ctx2 = MyContext {
138    ..Default::default()
139  };
140  let mut prsr = arg::Parser::from_args("hello", &["--help"], ctx2);
141
142  if ctx.tophelp {
143    prsr.set_tophelp(&[
144      "\"You know,\" said Arthur, \"it's at times like this, when I'm \
145       trapped in a Vogon airlock with a man from Betelgeuse, and about to \
146       die of asphyxiation in deep space that I really wish I'd listened to \
147       what my mother told me when I was young.\"",
148      "\"Why, what did she tell you?\"",
149      "\"I don't know, I didn't listen.\""
150    ]);
151  }
152  if ctx.bottomhelp {
153    prsr.set_bottomhelp(&[
154      "\"So this is it,\" said Arthur, \"We are going to die.\"",
155      "\"Yes,\" said Ford, \"except... no! Wait a minute!\" He suddenly \
156       lunged across the chamber at something behind Arthur's line of \
157       vision. \"What's this switch?\" he cried.",
158      "\"What? Where?\" cried Arthur, twisting round.",
159      "\"No, I was only fooling,\" said Ford, \"we are going to die after \
160       all.\""
161    ]);
162  }
163
164  prsr.add(help_spec)?;
165  prsr.add(version_spec)?;
166  prsr.add(file_spec)?;
167  prsr.add(param_spec)?;
168  prsr.add(cmd_spec)?;
169  prsr.add(subcmd_spec)?;
170
171  prsr.parse()?;
172
173  if prsr.get_ctx().do_help == true {
174    prsr.usage(&mut std::io::stdout());
175    std::process::exit(0);
176  }
177
178  let ctx = prsr.into_ctx();
179
180  println!("{:?}", &ctx);
181
182  Ok(())
183}
examples/simple.rs (line 74)
72fn main() -> Result<(), Box<dyn std::error::Error>> {
73  let help_spec = arg::Builder::new()
74    .sopt('h')
75    .lopt("help")
76    .exit(true)
77    .help(&["Show this help."])
78    .build(help_proc);
79  let verbose_spec = arg::Builder::new()
80    .sopt('v')
81    .lopt("verbose")
82    .help(&["Increase level of verbosity.", "Be quiet by default."])
83    .build(verbose_proc);
84  let version_spec = arg::Builder::new()
85    .sopt('V')
86    .lopt("version")
87    .exit(true)
88    .help(&["Output tool version and exit."])
89    .build(
90      |_spec: &arg::Spec<MyContext>,
91       ctx: &mut MyContext,
92       _args: &Vec<String>| ctx.do_version = true
93    );
94  let file_spec = arg::Builder::new()
95    .sopt('f')
96    .lopt("file")
97    .help(&["Use data in FILE."])
98    .nargs(arg::Nargs::Count(1), &["FILE"])
99    .build(file_proc);
100  let param_spec = arg::Builder::new()
101    .sopt('p')
102    .lopt("param")
103    .help(&["Add a key/value parameter field. The key must be unique."])
104    .nargs(arg::Nargs::Count(2), &["KEY", "VALUE"])
105    .build(param_proc);
106  let cmd_spec = arg::Builder::new()
107    .name("command")
108    .required(true)
109    .nargs(arg::Nargs::Count(1), &["COMMAND"])
110    .help(&["The command to run."])
111    .build(cmd_proc);
112  let subcmd_spec = arg::Builder::new()
113    .name("subcmd")
114    .nargs(arg::Nargs::Count(1), &["SUBCMD"])
115    .help(&["Command-specific sub-command."])
116    .build(subcmd_proc);
117
118
119  let ctx = MyContext {
120    ..Default::default()
121  };
122  let mut prsr = arg::Parser::from_env(ctx);
123
124  prsr.add(help_spec)?;
125  prsr.add(verbose_spec)?;
126  prsr.add(version_spec)?;
127  prsr.add(file_spec)?;
128  prsr.add(param_spec)?;
129  prsr.add(cmd_spec)?;
130  prsr.add(subcmd_spec)?;
131
132  prsr.parse()?;
133
134  if prsr.get_ctx().do_help == true {
135    prsr.usage(&mut std::io::stdout());
136    std::process::exit(0);
137  }
138
139  let ctx = prsr.into_ctx();
140
141  println!("{:?}", &ctx);
142
143  Ok(())
144}
Source

pub fn lopt(&mut self, lopt: &str) -> &mut Self

Make argument specification a long option name.

Examples found in repository?
examples/conflict.rs (line 20)
17fn main() -> Result<(), Box<dyn std::error::Error>> {
18  let help_spec = arg::Builder::new()
19    .sopt('h')
20    .lopt("help")
21    .exit(true)
22    .help(&["Show this help."])
23    .build(help_proc);
24  let coll_spec = arg::Builder::new()
25    .sopt('h')
26    .lopt("hulp")
27    .exit(true)
28    .help(&["Show this help."])
29    .build(help_proc);
30
31
32  let ctx = MyContext {
33    ..Default::default()
34  };
35  let mut prsr = arg::Parser::from_env(ctx);
36
37  prsr.add(help_spec)?;
38  prsr.add(coll_spec)?;
39
40  prsr.parse()?;
41
42  //let ctx = prsr.into_ctx();
43  if prsr.get_ctx().do_help == true {
44    prsr.usage(&mut std::io::stdout());
45    std::process::exit(0);
46  }
47
48  println!("{:?}", prsr.get_ctx());
49
50  Ok(())
51}
More examples
Hide additional examples
examples/remaining.rs (line 40)
37fn main() -> Result<(), Box<dyn std::error::Error>> {
38  let help_spec = arg::Builder::new()
39    .sopt('h')
40    .lopt("help")
41    .exit(true)
42    .help(&["Show this help."])
43    .build(help_proc);
44  let exec_spec = arg::Builder::new()
45    .name("exec")
46    .nargs(arg::Nargs::Count(1), &["PRG"])
47    .help(&["The executable to run."])
48    .build(exec_proc);
49  let eargs_spec = arg::Builder::new()
50    .name("execargs")
51    .nargs(arg::Nargs::Remainder, &["PRGARG"])
52    .help(&["arguments to pass to the executable."])
53    .build(eargs_proc);
54
55  let ctx = MyContext {
56    ..Default::default()
57  };
58  let mut prsr = arg::Parser::from_env(ctx);
59
60  prsr.add(help_spec)?;
61  prsr.add(exec_spec)?;
62  prsr.add(eargs_spec)?;
63
64  prsr.parse()?;
65
66  if prsr.get_ctx().do_help == true {
67    prsr.usage(&mut std::io::stdout());
68    std::process::exit(0);
69  }
70
71  let ctx = prsr.into_ctx();
72
73  println!("{:?}", &ctx);
74
75  Ok(())
76}
examples/hidden.rs (line 14)
11fn main() -> Result<(), Box<dyn std::error::Error>> {
12  let help_spec = arg::Builder::new()
13    .sopt('h')
14    .lopt("help")
15    .exit(true)
16    .help(&["Show this help."])
17    .build(
18      |_spec: &arg::Spec<MyContext>,
19       ctx: &mut MyContext,
20       _args: &Vec<String>| ctx.do_help = true
21    );
22  let version_spec = arg::Builder::new()
23    .sopt('V')
24    .lopt("version")
25    .exit(true)
26    .help(&["Output tool version and exit."])
27    .build(
28      |_spec: &arg::Spec<MyContext>,
29       ctx: &mut MyContext,
30       _args: &Vec<String>| ctx.do_version = true
31    );
32  let secret_spec = arg::Builder::new()
33    .sopt('s')
34    .lopt("secret")
35    .hidden(true)
36    .help(&["A hidden option."])
37    .build(
38      |_spec: &arg::Spec<MyContext>,
39       ctx: &mut MyContext,
40       _args: &Vec<String>| ctx.do_secret = true
41    );
42
43
44  let ctx = MyContext {
45    ..Default::default()
46  };
47  let mut prsr = arg::Parser::from_env(ctx);
48
49  prsr.add(help_spec)?;
50  prsr.add(version_spec)?;
51  prsr.add(secret_spec)?;
52
53  prsr.parse()?;
54
55  if prsr.get_ctx().do_help == true {
56    prsr.usage(&mut std::io::stdout());
57    std::process::exit(0);
58  }
59
60  let ctx = prsr.into_ctx();
61
62  println!("{:?}", &ctx);
63
64  Ok(())
65}
examples/usage.rs (line 22)
19fn main() -> Result<(), Box<dyn std::error::Error>> {
20  let help_spec = arg::Builder::new()
21    .sopt('h')
22    .lopt("help")
23    .exit(true)
24    .help(&["Show this help."])
25    .build(|_spec, ctx: &mut MyContext, _args| {
26      ctx.do_help = true;
27    });
28  let version_spec = arg::Builder::new()
29    .sopt('V')
30    .lopt("version")
31    .exit(true)
32    .help(&["Output tool version and exit."])
33    .build(
34      |_spec: &arg::Spec<MyContext>,
35       ctx: &mut MyContext,
36       _args: &Vec<String>| ctx.do_version = true
37    );
38  let tophelp_spec = arg::Builder::new()
39    .sopt('t')
40    .lopt("tophelp")
41    .help(&["Show top help."])
42    .build(|_spec, ctx: &mut MyContext, _args| {
43      ctx.tophelp = true;
44    });
45  let bottomhelp_spec = arg::Builder::new()
46    .sopt('b')
47    .lopt("bottomhelp")
48    .help(&["Show bottom help."])
49    .build(|_spec, ctx: &mut MyContext, _args| {
50      ctx.bottomhelp = true;
51    });
52
53  let ctx = MyContext {
54    ..Default::default()
55  };
56  let mut prsr = arg::Parser::from_env(ctx);
57
58  prsr.add(help_spec)?;
59  prsr.add(version_spec)?;
60  prsr.add(tophelp_spec)?;
61  prsr.add(bottomhelp_spec)?;
62
63  prsr.parse()?;
64
65  if prsr.get_ctx().do_help == true {
66    prsr.usage(&mut std::io::stdout());
67    std::process::exit(0);
68  }
69
70  if prsr.get_ctx().do_version == true {
71    const VERSION: &'static str = env!("CARGO_PKG_VERSION");
72    println!("usage {}", VERSION);
73    std::process::exit(0);
74  }
75
76  let ctx = prsr.into_ctx();
77
78  println!("{:?}", &ctx);
79
80  usage_test(ctx)?;
81
82  Ok(())
83}
84
85
86fn usage_test(ctx: MyContext) -> Result<(), Box<dyn std::error::Error>> {
87  let help_spec = arg::Builder::new()
88    .sopt('h')
89    .lopt("help")
90    .exit(true)
91    .help(&["Show this help."])
92    .build(|_spec, ctx: &mut MyContext, _args| {
93      ctx.do_help = true;
94    });
95  let version_spec = arg::Builder::new()
96    .sopt('V')
97    .lopt("version")
98    .exit(true)
99    .help(&["Output tool version and exit."])
100    .build(
101      |_spec: &arg::Spec<MyContext>,
102       ctx: &mut MyContext,
103       _args: &Vec<String>| ctx.do_version = true
104    );
105  let file_spec = arg::Builder::new()
106    .sopt('f')
107    .lopt("file")
108    .help(&["Use data in FILE."])
109    .nargs(arg::Nargs::Count(1), &["FILE"])
110    .build(|_spec, ctx: &mut MyContext, args| {
111      ctx.fname = args[0].clone();
112    });
113  let param_spec = arg::Builder::new()
114    .sopt('p')
115    .lopt("param")
116    .help(&["Add a key/value parameter field. The key must be unique."])
117    .nargs(arg::Nargs::Count(2), &["KEY", "VALUE"])
118    .build(|_spec, ctx: &mut MyContext, args| {
119      ctx.params.insert(args[0].clone(), args[1].clone());
120    });
121  let cmd_spec = arg::Builder::new()
122    .name("command")
123    .required(true)
124    .nargs(arg::Nargs::Count(1), &["COMMAND"])
125    .help(&["The command to run."])
126    .build(|_spec, ctx: &mut MyContext, args| {
127      ctx.cmd = args[0].clone();
128    });
129  let subcmd_spec = arg::Builder::new()
130    .name("subcmd")
131    .nargs(arg::Nargs::Count(1), &["SUBCMD"])
132    .help(&["Command-specific sub-command."])
133    .build(|_spec, ctx: &mut MyContext, args| {
134      ctx.subcmd = args[0].clone();
135    });
136
137  let ctx2 = MyContext {
138    ..Default::default()
139  };
140  let mut prsr = arg::Parser::from_args("hello", &["--help"], ctx2);
141
142  if ctx.tophelp {
143    prsr.set_tophelp(&[
144      "\"You know,\" said Arthur, \"it's at times like this, when I'm \
145       trapped in a Vogon airlock with a man from Betelgeuse, and about to \
146       die of asphyxiation in deep space that I really wish I'd listened to \
147       what my mother told me when I was young.\"",
148      "\"Why, what did she tell you?\"",
149      "\"I don't know, I didn't listen.\""
150    ]);
151  }
152  if ctx.bottomhelp {
153    prsr.set_bottomhelp(&[
154      "\"So this is it,\" said Arthur, \"We are going to die.\"",
155      "\"Yes,\" said Ford, \"except... no! Wait a minute!\" He suddenly \
156       lunged across the chamber at something behind Arthur's line of \
157       vision. \"What's this switch?\" he cried.",
158      "\"What? Where?\" cried Arthur, twisting round.",
159      "\"No, I was only fooling,\" said Ford, \"we are going to die after \
160       all.\""
161    ]);
162  }
163
164  prsr.add(help_spec)?;
165  prsr.add(version_spec)?;
166  prsr.add(file_spec)?;
167  prsr.add(param_spec)?;
168  prsr.add(cmd_spec)?;
169  prsr.add(subcmd_spec)?;
170
171  prsr.parse()?;
172
173  if prsr.get_ctx().do_help == true {
174    prsr.usage(&mut std::io::stdout());
175    std::process::exit(0);
176  }
177
178  let ctx = prsr.into_ctx();
179
180  println!("{:?}", &ctx);
181
182  Ok(())
183}
examples/simple.rs (line 75)
72fn main() -> Result<(), Box<dyn std::error::Error>> {
73  let help_spec = arg::Builder::new()
74    .sopt('h')
75    .lopt("help")
76    .exit(true)
77    .help(&["Show this help."])
78    .build(help_proc);
79  let verbose_spec = arg::Builder::new()
80    .sopt('v')
81    .lopt("verbose")
82    .help(&["Increase level of verbosity.", "Be quiet by default."])
83    .build(verbose_proc);
84  let version_spec = arg::Builder::new()
85    .sopt('V')
86    .lopt("version")
87    .exit(true)
88    .help(&["Output tool version and exit."])
89    .build(
90      |_spec: &arg::Spec<MyContext>,
91       ctx: &mut MyContext,
92       _args: &Vec<String>| ctx.do_version = true
93    );
94  let file_spec = arg::Builder::new()
95    .sopt('f')
96    .lopt("file")
97    .help(&["Use data in FILE."])
98    .nargs(arg::Nargs::Count(1), &["FILE"])
99    .build(file_proc);
100  let param_spec = arg::Builder::new()
101    .sopt('p')
102    .lopt("param")
103    .help(&["Add a key/value parameter field. The key must be unique."])
104    .nargs(arg::Nargs::Count(2), &["KEY", "VALUE"])
105    .build(param_proc);
106  let cmd_spec = arg::Builder::new()
107    .name("command")
108    .required(true)
109    .nargs(arg::Nargs::Count(1), &["COMMAND"])
110    .help(&["The command to run."])
111    .build(cmd_proc);
112  let subcmd_spec = arg::Builder::new()
113    .name("subcmd")
114    .nargs(arg::Nargs::Count(1), &["SUBCMD"])
115    .help(&["Command-specific sub-command."])
116    .build(subcmd_proc);
117
118
119  let ctx = MyContext {
120    ..Default::default()
121  };
122  let mut prsr = arg::Parser::from_env(ctx);
123
124  prsr.add(help_spec)?;
125  prsr.add(verbose_spec)?;
126  prsr.add(version_spec)?;
127  prsr.add(file_spec)?;
128  prsr.add(param_spec)?;
129  prsr.add(cmd_spec)?;
130  prsr.add(subcmd_spec)?;
131
132  prsr.parse()?;
133
134  if prsr.get_ctx().do_help == true {
135    prsr.usage(&mut std::io::stdout());
136    std::process::exit(0);
137  }
138
139  let ctx = prsr.into_ctx();
140
141  println!("{:?}", &ctx);
142
143  Ok(())
144}
Source

pub fn name(&mut self, name: &str) -> &mut Self

Assign argument specification a name. This is required for positional arguments.

Examples found in repository?
examples/remaining.rs (line 45)
37fn main() -> Result<(), Box<dyn std::error::Error>> {
38  let help_spec = arg::Builder::new()
39    .sopt('h')
40    .lopt("help")
41    .exit(true)
42    .help(&["Show this help."])
43    .build(help_proc);
44  let exec_spec = arg::Builder::new()
45    .name("exec")
46    .nargs(arg::Nargs::Count(1), &["PRG"])
47    .help(&["The executable to run."])
48    .build(exec_proc);
49  let eargs_spec = arg::Builder::new()
50    .name("execargs")
51    .nargs(arg::Nargs::Remainder, &["PRGARG"])
52    .help(&["arguments to pass to the executable."])
53    .build(eargs_proc);
54
55  let ctx = MyContext {
56    ..Default::default()
57  };
58  let mut prsr = arg::Parser::from_env(ctx);
59
60  prsr.add(help_spec)?;
61  prsr.add(exec_spec)?;
62  prsr.add(eargs_spec)?;
63
64  prsr.parse()?;
65
66  if prsr.get_ctx().do_help == true {
67    prsr.usage(&mut std::io::stdout());
68    std::process::exit(0);
69  }
70
71  let ctx = prsr.into_ctx();
72
73  println!("{:?}", &ctx);
74
75  Ok(())
76}
More examples
Hide additional examples
examples/simple.rs (line 107)
72fn main() -> Result<(), Box<dyn std::error::Error>> {
73  let help_spec = arg::Builder::new()
74    .sopt('h')
75    .lopt("help")
76    .exit(true)
77    .help(&["Show this help."])
78    .build(help_proc);
79  let verbose_spec = arg::Builder::new()
80    .sopt('v')
81    .lopt("verbose")
82    .help(&["Increase level of verbosity.", "Be quiet by default."])
83    .build(verbose_proc);
84  let version_spec = arg::Builder::new()
85    .sopt('V')
86    .lopt("version")
87    .exit(true)
88    .help(&["Output tool version and exit."])
89    .build(
90      |_spec: &arg::Spec<MyContext>,
91       ctx: &mut MyContext,
92       _args: &Vec<String>| ctx.do_version = true
93    );
94  let file_spec = arg::Builder::new()
95    .sopt('f')
96    .lopt("file")
97    .help(&["Use data in FILE."])
98    .nargs(arg::Nargs::Count(1), &["FILE"])
99    .build(file_proc);
100  let param_spec = arg::Builder::new()
101    .sopt('p')
102    .lopt("param")
103    .help(&["Add a key/value parameter field. The key must be unique."])
104    .nargs(arg::Nargs::Count(2), &["KEY", "VALUE"])
105    .build(param_proc);
106  let cmd_spec = arg::Builder::new()
107    .name("command")
108    .required(true)
109    .nargs(arg::Nargs::Count(1), &["COMMAND"])
110    .help(&["The command to run."])
111    .build(cmd_proc);
112  let subcmd_spec = arg::Builder::new()
113    .name("subcmd")
114    .nargs(arg::Nargs::Count(1), &["SUBCMD"])
115    .help(&["Command-specific sub-command."])
116    .build(subcmd_proc);
117
118
119  let ctx = MyContext {
120    ..Default::default()
121  };
122  let mut prsr = arg::Parser::from_env(ctx);
123
124  prsr.add(help_spec)?;
125  prsr.add(verbose_spec)?;
126  prsr.add(version_spec)?;
127  prsr.add(file_spec)?;
128  prsr.add(param_spec)?;
129  prsr.add(cmd_spec)?;
130  prsr.add(subcmd_spec)?;
131
132  prsr.parse()?;
133
134  if prsr.get_ctx().do_help == true {
135    prsr.usage(&mut std::io::stdout());
136    std::process::exit(0);
137  }
138
139  let ctx = prsr.into_ctx();
140
141  println!("{:?}", &ctx);
142
143  Ok(())
144}
examples/usage.rs (line 122)
86fn usage_test(ctx: MyContext) -> Result<(), Box<dyn std::error::Error>> {
87  let help_spec = arg::Builder::new()
88    .sopt('h')
89    .lopt("help")
90    .exit(true)
91    .help(&["Show this help."])
92    .build(|_spec, ctx: &mut MyContext, _args| {
93      ctx.do_help = true;
94    });
95  let version_spec = arg::Builder::new()
96    .sopt('V')
97    .lopt("version")
98    .exit(true)
99    .help(&["Output tool version and exit."])
100    .build(
101      |_spec: &arg::Spec<MyContext>,
102       ctx: &mut MyContext,
103       _args: &Vec<String>| ctx.do_version = true
104    );
105  let file_spec = arg::Builder::new()
106    .sopt('f')
107    .lopt("file")
108    .help(&["Use data in FILE."])
109    .nargs(arg::Nargs::Count(1), &["FILE"])
110    .build(|_spec, ctx: &mut MyContext, args| {
111      ctx.fname = args[0].clone();
112    });
113  let param_spec = arg::Builder::new()
114    .sopt('p')
115    .lopt("param")
116    .help(&["Add a key/value parameter field. The key must be unique."])
117    .nargs(arg::Nargs::Count(2), &["KEY", "VALUE"])
118    .build(|_spec, ctx: &mut MyContext, args| {
119      ctx.params.insert(args[0].clone(), args[1].clone());
120    });
121  let cmd_spec = arg::Builder::new()
122    .name("command")
123    .required(true)
124    .nargs(arg::Nargs::Count(1), &["COMMAND"])
125    .help(&["The command to run."])
126    .build(|_spec, ctx: &mut MyContext, args| {
127      ctx.cmd = args[0].clone();
128    });
129  let subcmd_spec = arg::Builder::new()
130    .name("subcmd")
131    .nargs(arg::Nargs::Count(1), &["SUBCMD"])
132    .help(&["Command-specific sub-command."])
133    .build(|_spec, ctx: &mut MyContext, args| {
134      ctx.subcmd = args[0].clone();
135    });
136
137  let ctx2 = MyContext {
138    ..Default::default()
139  };
140  let mut prsr = arg::Parser::from_args("hello", &["--help"], ctx2);
141
142  if ctx.tophelp {
143    prsr.set_tophelp(&[
144      "\"You know,\" said Arthur, \"it's at times like this, when I'm \
145       trapped in a Vogon airlock with a man from Betelgeuse, and about to \
146       die of asphyxiation in deep space that I really wish I'd listened to \
147       what my mother told me when I was young.\"",
148      "\"Why, what did she tell you?\"",
149      "\"I don't know, I didn't listen.\""
150    ]);
151  }
152  if ctx.bottomhelp {
153    prsr.set_bottomhelp(&[
154      "\"So this is it,\" said Arthur, \"We are going to die.\"",
155      "\"Yes,\" said Ford, \"except... no! Wait a minute!\" He suddenly \
156       lunged across the chamber at something behind Arthur's line of \
157       vision. \"What's this switch?\" he cried.",
158      "\"What? Where?\" cried Arthur, twisting round.",
159      "\"No, I was only fooling,\" said Ford, \"we are going to die after \
160       all.\""
161    ]);
162  }
163
164  prsr.add(help_spec)?;
165  prsr.add(version_spec)?;
166  prsr.add(file_spec)?;
167  prsr.add(param_spec)?;
168  prsr.add(cmd_spec)?;
169  prsr.add(subcmd_spec)?;
170
171  prsr.parse()?;
172
173  if prsr.get_ctx().do_help == true {
174    prsr.usage(&mut std::io::stdout());
175    std::process::exit(0);
176  }
177
178  let ctx = prsr.into_ctx();
179
180  println!("{:?}", &ctx);
181
182  Ok(())
183}
Source

pub fn nargs<I, S>(&mut self, nargs: Nargs, metanames: I) -> &mut Self
where I: IntoIterator<Item = S>, S: AsRef<str>,

Declare that this argument specification takes arguments.

Examples found in repository?
examples/remaining.rs (line 46)
37fn main() -> Result<(), Box<dyn std::error::Error>> {
38  let help_spec = arg::Builder::new()
39    .sopt('h')
40    .lopt("help")
41    .exit(true)
42    .help(&["Show this help."])
43    .build(help_proc);
44  let exec_spec = arg::Builder::new()
45    .name("exec")
46    .nargs(arg::Nargs::Count(1), &["PRG"])
47    .help(&["The executable to run."])
48    .build(exec_proc);
49  let eargs_spec = arg::Builder::new()
50    .name("execargs")
51    .nargs(arg::Nargs::Remainder, &["PRGARG"])
52    .help(&["arguments to pass to the executable."])
53    .build(eargs_proc);
54
55  let ctx = MyContext {
56    ..Default::default()
57  };
58  let mut prsr = arg::Parser::from_env(ctx);
59
60  prsr.add(help_spec)?;
61  prsr.add(exec_spec)?;
62  prsr.add(eargs_spec)?;
63
64  prsr.parse()?;
65
66  if prsr.get_ctx().do_help == true {
67    prsr.usage(&mut std::io::stdout());
68    std::process::exit(0);
69  }
70
71  let ctx = prsr.into_ctx();
72
73  println!("{:?}", &ctx);
74
75  Ok(())
76}
More examples
Hide additional examples
examples/simple.rs (line 98)
72fn main() -> Result<(), Box<dyn std::error::Error>> {
73  let help_spec = arg::Builder::new()
74    .sopt('h')
75    .lopt("help")
76    .exit(true)
77    .help(&["Show this help."])
78    .build(help_proc);
79  let verbose_spec = arg::Builder::new()
80    .sopt('v')
81    .lopt("verbose")
82    .help(&["Increase level of verbosity.", "Be quiet by default."])
83    .build(verbose_proc);
84  let version_spec = arg::Builder::new()
85    .sopt('V')
86    .lopt("version")
87    .exit(true)
88    .help(&["Output tool version and exit."])
89    .build(
90      |_spec: &arg::Spec<MyContext>,
91       ctx: &mut MyContext,
92       _args: &Vec<String>| ctx.do_version = true
93    );
94  let file_spec = arg::Builder::new()
95    .sopt('f')
96    .lopt("file")
97    .help(&["Use data in FILE."])
98    .nargs(arg::Nargs::Count(1), &["FILE"])
99    .build(file_proc);
100  let param_spec = arg::Builder::new()
101    .sopt('p')
102    .lopt("param")
103    .help(&["Add a key/value parameter field. The key must be unique."])
104    .nargs(arg::Nargs::Count(2), &["KEY", "VALUE"])
105    .build(param_proc);
106  let cmd_spec = arg::Builder::new()
107    .name("command")
108    .required(true)
109    .nargs(arg::Nargs::Count(1), &["COMMAND"])
110    .help(&["The command to run."])
111    .build(cmd_proc);
112  let subcmd_spec = arg::Builder::new()
113    .name("subcmd")
114    .nargs(arg::Nargs::Count(1), &["SUBCMD"])
115    .help(&["Command-specific sub-command."])
116    .build(subcmd_proc);
117
118
119  let ctx = MyContext {
120    ..Default::default()
121  };
122  let mut prsr = arg::Parser::from_env(ctx);
123
124  prsr.add(help_spec)?;
125  prsr.add(verbose_spec)?;
126  prsr.add(version_spec)?;
127  prsr.add(file_spec)?;
128  prsr.add(param_spec)?;
129  prsr.add(cmd_spec)?;
130  prsr.add(subcmd_spec)?;
131
132  prsr.parse()?;
133
134  if prsr.get_ctx().do_help == true {
135    prsr.usage(&mut std::io::stdout());
136    std::process::exit(0);
137  }
138
139  let ctx = prsr.into_ctx();
140
141  println!("{:?}", &ctx);
142
143  Ok(())
144}
examples/usage.rs (line 109)
86fn usage_test(ctx: MyContext) -> Result<(), Box<dyn std::error::Error>> {
87  let help_spec = arg::Builder::new()
88    .sopt('h')
89    .lopt("help")
90    .exit(true)
91    .help(&["Show this help."])
92    .build(|_spec, ctx: &mut MyContext, _args| {
93      ctx.do_help = true;
94    });
95  let version_spec = arg::Builder::new()
96    .sopt('V')
97    .lopt("version")
98    .exit(true)
99    .help(&["Output tool version and exit."])
100    .build(
101      |_spec: &arg::Spec<MyContext>,
102       ctx: &mut MyContext,
103       _args: &Vec<String>| ctx.do_version = true
104    );
105  let file_spec = arg::Builder::new()
106    .sopt('f')
107    .lopt("file")
108    .help(&["Use data in FILE."])
109    .nargs(arg::Nargs::Count(1), &["FILE"])
110    .build(|_spec, ctx: &mut MyContext, args| {
111      ctx.fname = args[0].clone();
112    });
113  let param_spec = arg::Builder::new()
114    .sopt('p')
115    .lopt("param")
116    .help(&["Add a key/value parameter field. The key must be unique."])
117    .nargs(arg::Nargs::Count(2), &["KEY", "VALUE"])
118    .build(|_spec, ctx: &mut MyContext, args| {
119      ctx.params.insert(args[0].clone(), args[1].clone());
120    });
121  let cmd_spec = arg::Builder::new()
122    .name("command")
123    .required(true)
124    .nargs(arg::Nargs::Count(1), &["COMMAND"])
125    .help(&["The command to run."])
126    .build(|_spec, ctx: &mut MyContext, args| {
127      ctx.cmd = args[0].clone();
128    });
129  let subcmd_spec = arg::Builder::new()
130    .name("subcmd")
131    .nargs(arg::Nargs::Count(1), &["SUBCMD"])
132    .help(&["Command-specific sub-command."])
133    .build(|_spec, ctx: &mut MyContext, args| {
134      ctx.subcmd = args[0].clone();
135    });
136
137  let ctx2 = MyContext {
138    ..Default::default()
139  };
140  let mut prsr = arg::Parser::from_args("hello", &["--help"], ctx2);
141
142  if ctx.tophelp {
143    prsr.set_tophelp(&[
144      "\"You know,\" said Arthur, \"it's at times like this, when I'm \
145       trapped in a Vogon airlock with a man from Betelgeuse, and about to \
146       die of asphyxiation in deep space that I really wish I'd listened to \
147       what my mother told me when I was young.\"",
148      "\"Why, what did she tell you?\"",
149      "\"I don't know, I didn't listen.\""
150    ]);
151  }
152  if ctx.bottomhelp {
153    prsr.set_bottomhelp(&[
154      "\"So this is it,\" said Arthur, \"We are going to die.\"",
155      "\"Yes,\" said Ford, \"except... no! Wait a minute!\" He suddenly \
156       lunged across the chamber at something behind Arthur's line of \
157       vision. \"What's this switch?\" he cried.",
158      "\"What? Where?\" cried Arthur, twisting round.",
159      "\"No, I was only fooling,\" said Ford, \"we are going to die after \
160       all.\""
161    ]);
162  }
163
164  prsr.add(help_spec)?;
165  prsr.add(version_spec)?;
166  prsr.add(file_spec)?;
167  prsr.add(param_spec)?;
168  prsr.add(cmd_spec)?;
169  prsr.add(subcmd_spec)?;
170
171  prsr.parse()?;
172
173  if prsr.get_ctx().do_help == true {
174    prsr.usage(&mut std::io::stdout());
175    std::process::exit(0);
176  }
177
178  let ctx = prsr.into_ctx();
179
180  println!("{:?}", &ctx);
181
182  Ok(())
183}
Source

pub fn metanames<I, S>(&mut self, metanames: I) -> &mut Self
where I: IntoIterator<Item = S>, S: AsRef<str>,

Assign meta-names to the arguments.

Source

pub fn exit(&mut self, exit: bool) -> &mut Self

Specify if encountering this argument specification should terminate the parser.

This is useful for options that should terminate normal program behavor, such as --help or if a positional argumen has been encountered which should abort the parser because the rest of the arguments should be parsed by a different parser.

Examples found in repository?
examples/conflict.rs (line 21)
17fn main() -> Result<(), Box<dyn std::error::Error>> {
18  let help_spec = arg::Builder::new()
19    .sopt('h')
20    .lopt("help")
21    .exit(true)
22    .help(&["Show this help."])
23    .build(help_proc);
24  let coll_spec = arg::Builder::new()
25    .sopt('h')
26    .lopt("hulp")
27    .exit(true)
28    .help(&["Show this help."])
29    .build(help_proc);
30
31
32  let ctx = MyContext {
33    ..Default::default()
34  };
35  let mut prsr = arg::Parser::from_env(ctx);
36
37  prsr.add(help_spec)?;
38  prsr.add(coll_spec)?;
39
40  prsr.parse()?;
41
42  //let ctx = prsr.into_ctx();
43  if prsr.get_ctx().do_help == true {
44    prsr.usage(&mut std::io::stdout());
45    std::process::exit(0);
46  }
47
48  println!("{:?}", prsr.get_ctx());
49
50  Ok(())
51}
More examples
Hide additional examples
examples/remaining.rs (line 41)
37fn main() -> Result<(), Box<dyn std::error::Error>> {
38  let help_spec = arg::Builder::new()
39    .sopt('h')
40    .lopt("help")
41    .exit(true)
42    .help(&["Show this help."])
43    .build(help_proc);
44  let exec_spec = arg::Builder::new()
45    .name("exec")
46    .nargs(arg::Nargs::Count(1), &["PRG"])
47    .help(&["The executable to run."])
48    .build(exec_proc);
49  let eargs_spec = arg::Builder::new()
50    .name("execargs")
51    .nargs(arg::Nargs::Remainder, &["PRGARG"])
52    .help(&["arguments to pass to the executable."])
53    .build(eargs_proc);
54
55  let ctx = MyContext {
56    ..Default::default()
57  };
58  let mut prsr = arg::Parser::from_env(ctx);
59
60  prsr.add(help_spec)?;
61  prsr.add(exec_spec)?;
62  prsr.add(eargs_spec)?;
63
64  prsr.parse()?;
65
66  if prsr.get_ctx().do_help == true {
67    prsr.usage(&mut std::io::stdout());
68    std::process::exit(0);
69  }
70
71  let ctx = prsr.into_ctx();
72
73  println!("{:?}", &ctx);
74
75  Ok(())
76}
examples/hidden.rs (line 15)
11fn main() -> Result<(), Box<dyn std::error::Error>> {
12  let help_spec = arg::Builder::new()
13    .sopt('h')
14    .lopt("help")
15    .exit(true)
16    .help(&["Show this help."])
17    .build(
18      |_spec: &arg::Spec<MyContext>,
19       ctx: &mut MyContext,
20       _args: &Vec<String>| ctx.do_help = true
21    );
22  let version_spec = arg::Builder::new()
23    .sopt('V')
24    .lopt("version")
25    .exit(true)
26    .help(&["Output tool version and exit."])
27    .build(
28      |_spec: &arg::Spec<MyContext>,
29       ctx: &mut MyContext,
30       _args: &Vec<String>| ctx.do_version = true
31    );
32  let secret_spec = arg::Builder::new()
33    .sopt('s')
34    .lopt("secret")
35    .hidden(true)
36    .help(&["A hidden option."])
37    .build(
38      |_spec: &arg::Spec<MyContext>,
39       ctx: &mut MyContext,
40       _args: &Vec<String>| ctx.do_secret = true
41    );
42
43
44  let ctx = MyContext {
45    ..Default::default()
46  };
47  let mut prsr = arg::Parser::from_env(ctx);
48
49  prsr.add(help_spec)?;
50  prsr.add(version_spec)?;
51  prsr.add(secret_spec)?;
52
53  prsr.parse()?;
54
55  if prsr.get_ctx().do_help == true {
56    prsr.usage(&mut std::io::stdout());
57    std::process::exit(0);
58  }
59
60  let ctx = prsr.into_ctx();
61
62  println!("{:?}", &ctx);
63
64  Ok(())
65}
examples/usage.rs (line 23)
19fn main() -> Result<(), Box<dyn std::error::Error>> {
20  let help_spec = arg::Builder::new()
21    .sopt('h')
22    .lopt("help")
23    .exit(true)
24    .help(&["Show this help."])
25    .build(|_spec, ctx: &mut MyContext, _args| {
26      ctx.do_help = true;
27    });
28  let version_spec = arg::Builder::new()
29    .sopt('V')
30    .lopt("version")
31    .exit(true)
32    .help(&["Output tool version and exit."])
33    .build(
34      |_spec: &arg::Spec<MyContext>,
35       ctx: &mut MyContext,
36       _args: &Vec<String>| ctx.do_version = true
37    );
38  let tophelp_spec = arg::Builder::new()
39    .sopt('t')
40    .lopt("tophelp")
41    .help(&["Show top help."])
42    .build(|_spec, ctx: &mut MyContext, _args| {
43      ctx.tophelp = true;
44    });
45  let bottomhelp_spec = arg::Builder::new()
46    .sopt('b')
47    .lopt("bottomhelp")
48    .help(&["Show bottom help."])
49    .build(|_spec, ctx: &mut MyContext, _args| {
50      ctx.bottomhelp = true;
51    });
52
53  let ctx = MyContext {
54    ..Default::default()
55  };
56  let mut prsr = arg::Parser::from_env(ctx);
57
58  prsr.add(help_spec)?;
59  prsr.add(version_spec)?;
60  prsr.add(tophelp_spec)?;
61  prsr.add(bottomhelp_spec)?;
62
63  prsr.parse()?;
64
65  if prsr.get_ctx().do_help == true {
66    prsr.usage(&mut std::io::stdout());
67    std::process::exit(0);
68  }
69
70  if prsr.get_ctx().do_version == true {
71    const VERSION: &'static str = env!("CARGO_PKG_VERSION");
72    println!("usage {}", VERSION);
73    std::process::exit(0);
74  }
75
76  let ctx = prsr.into_ctx();
77
78  println!("{:?}", &ctx);
79
80  usage_test(ctx)?;
81
82  Ok(())
83}
84
85
86fn usage_test(ctx: MyContext) -> Result<(), Box<dyn std::error::Error>> {
87  let help_spec = arg::Builder::new()
88    .sopt('h')
89    .lopt("help")
90    .exit(true)
91    .help(&["Show this help."])
92    .build(|_spec, ctx: &mut MyContext, _args| {
93      ctx.do_help = true;
94    });
95  let version_spec = arg::Builder::new()
96    .sopt('V')
97    .lopt("version")
98    .exit(true)
99    .help(&["Output tool version and exit."])
100    .build(
101      |_spec: &arg::Spec<MyContext>,
102       ctx: &mut MyContext,
103       _args: &Vec<String>| ctx.do_version = true
104    );
105  let file_spec = arg::Builder::new()
106    .sopt('f')
107    .lopt("file")
108    .help(&["Use data in FILE."])
109    .nargs(arg::Nargs::Count(1), &["FILE"])
110    .build(|_spec, ctx: &mut MyContext, args| {
111      ctx.fname = args[0].clone();
112    });
113  let param_spec = arg::Builder::new()
114    .sopt('p')
115    .lopt("param")
116    .help(&["Add a key/value parameter field. The key must be unique."])
117    .nargs(arg::Nargs::Count(2), &["KEY", "VALUE"])
118    .build(|_spec, ctx: &mut MyContext, args| {
119      ctx.params.insert(args[0].clone(), args[1].clone());
120    });
121  let cmd_spec = arg::Builder::new()
122    .name("command")
123    .required(true)
124    .nargs(arg::Nargs::Count(1), &["COMMAND"])
125    .help(&["The command to run."])
126    .build(|_spec, ctx: &mut MyContext, args| {
127      ctx.cmd = args[0].clone();
128    });
129  let subcmd_spec = arg::Builder::new()
130    .name("subcmd")
131    .nargs(arg::Nargs::Count(1), &["SUBCMD"])
132    .help(&["Command-specific sub-command."])
133    .build(|_spec, ctx: &mut MyContext, args| {
134      ctx.subcmd = args[0].clone();
135    });
136
137  let ctx2 = MyContext {
138    ..Default::default()
139  };
140  let mut prsr = arg::Parser::from_args("hello", &["--help"], ctx2);
141
142  if ctx.tophelp {
143    prsr.set_tophelp(&[
144      "\"You know,\" said Arthur, \"it's at times like this, when I'm \
145       trapped in a Vogon airlock with a man from Betelgeuse, and about to \
146       die of asphyxiation in deep space that I really wish I'd listened to \
147       what my mother told me when I was young.\"",
148      "\"Why, what did she tell you?\"",
149      "\"I don't know, I didn't listen.\""
150    ]);
151  }
152  if ctx.bottomhelp {
153    prsr.set_bottomhelp(&[
154      "\"So this is it,\" said Arthur, \"We are going to die.\"",
155      "\"Yes,\" said Ford, \"except... no! Wait a minute!\" He suddenly \
156       lunged across the chamber at something behind Arthur's line of \
157       vision. \"What's this switch?\" he cried.",
158      "\"What? Where?\" cried Arthur, twisting round.",
159      "\"No, I was only fooling,\" said Ford, \"we are going to die after \
160       all.\""
161    ]);
162  }
163
164  prsr.add(help_spec)?;
165  prsr.add(version_spec)?;
166  prsr.add(file_spec)?;
167  prsr.add(param_spec)?;
168  prsr.add(cmd_spec)?;
169  prsr.add(subcmd_spec)?;
170
171  prsr.parse()?;
172
173  if prsr.get_ctx().do_help == true {
174    prsr.usage(&mut std::io::stdout());
175    std::process::exit(0);
176  }
177
178  let ctx = prsr.into_ctx();
179
180  println!("{:?}", &ctx);
181
182  Ok(())
183}
examples/simple.rs (line 76)
72fn main() -> Result<(), Box<dyn std::error::Error>> {
73  let help_spec = arg::Builder::new()
74    .sopt('h')
75    .lopt("help")
76    .exit(true)
77    .help(&["Show this help."])
78    .build(help_proc);
79  let verbose_spec = arg::Builder::new()
80    .sopt('v')
81    .lopt("verbose")
82    .help(&["Increase level of verbosity.", "Be quiet by default."])
83    .build(verbose_proc);
84  let version_spec = arg::Builder::new()
85    .sopt('V')
86    .lopt("version")
87    .exit(true)
88    .help(&["Output tool version and exit."])
89    .build(
90      |_spec: &arg::Spec<MyContext>,
91       ctx: &mut MyContext,
92       _args: &Vec<String>| ctx.do_version = true
93    );
94  let file_spec = arg::Builder::new()
95    .sopt('f')
96    .lopt("file")
97    .help(&["Use data in FILE."])
98    .nargs(arg::Nargs::Count(1), &["FILE"])
99    .build(file_proc);
100  let param_spec = arg::Builder::new()
101    .sopt('p')
102    .lopt("param")
103    .help(&["Add a key/value parameter field. The key must be unique."])
104    .nargs(arg::Nargs::Count(2), &["KEY", "VALUE"])
105    .build(param_proc);
106  let cmd_spec = arg::Builder::new()
107    .name("command")
108    .required(true)
109    .nargs(arg::Nargs::Count(1), &["COMMAND"])
110    .help(&["The command to run."])
111    .build(cmd_proc);
112  let subcmd_spec = arg::Builder::new()
113    .name("subcmd")
114    .nargs(arg::Nargs::Count(1), &["SUBCMD"])
115    .help(&["Command-specific sub-command."])
116    .build(subcmd_proc);
117
118
119  let ctx = MyContext {
120    ..Default::default()
121  };
122  let mut prsr = arg::Parser::from_env(ctx);
123
124  prsr.add(help_spec)?;
125  prsr.add(verbose_spec)?;
126  prsr.add(version_spec)?;
127  prsr.add(file_spec)?;
128  prsr.add(param_spec)?;
129  prsr.add(cmd_spec)?;
130  prsr.add(subcmd_spec)?;
131
132  prsr.parse()?;
133
134  if prsr.get_ctx().do_help == true {
135    prsr.usage(&mut std::io::stdout());
136    std::process::exit(0);
137  }
138
139  let ctx = prsr.into_ctx();
140
141  println!("{:?}", &ctx);
142
143  Ok(())
144}
Source

pub fn required(&mut self, req: bool) -> &mut Self

Tell the parser that the argument must be processed. This is only useful for positional arguments.

Examples found in repository?
examples/simple.rs (line 108)
72fn main() -> Result<(), Box<dyn std::error::Error>> {
73  let help_spec = arg::Builder::new()
74    .sopt('h')
75    .lopt("help")
76    .exit(true)
77    .help(&["Show this help."])
78    .build(help_proc);
79  let verbose_spec = arg::Builder::new()
80    .sopt('v')
81    .lopt("verbose")
82    .help(&["Increase level of verbosity.", "Be quiet by default."])
83    .build(verbose_proc);
84  let version_spec = arg::Builder::new()
85    .sopt('V')
86    .lopt("version")
87    .exit(true)
88    .help(&["Output tool version and exit."])
89    .build(
90      |_spec: &arg::Spec<MyContext>,
91       ctx: &mut MyContext,
92       _args: &Vec<String>| ctx.do_version = true
93    );
94  let file_spec = arg::Builder::new()
95    .sopt('f')
96    .lopt("file")
97    .help(&["Use data in FILE."])
98    .nargs(arg::Nargs::Count(1), &["FILE"])
99    .build(file_proc);
100  let param_spec = arg::Builder::new()
101    .sopt('p')
102    .lopt("param")
103    .help(&["Add a key/value parameter field. The key must be unique."])
104    .nargs(arg::Nargs::Count(2), &["KEY", "VALUE"])
105    .build(param_proc);
106  let cmd_spec = arg::Builder::new()
107    .name("command")
108    .required(true)
109    .nargs(arg::Nargs::Count(1), &["COMMAND"])
110    .help(&["The command to run."])
111    .build(cmd_proc);
112  let subcmd_spec = arg::Builder::new()
113    .name("subcmd")
114    .nargs(arg::Nargs::Count(1), &["SUBCMD"])
115    .help(&["Command-specific sub-command."])
116    .build(subcmd_proc);
117
118
119  let ctx = MyContext {
120    ..Default::default()
121  };
122  let mut prsr = arg::Parser::from_env(ctx);
123
124  prsr.add(help_spec)?;
125  prsr.add(verbose_spec)?;
126  prsr.add(version_spec)?;
127  prsr.add(file_spec)?;
128  prsr.add(param_spec)?;
129  prsr.add(cmd_spec)?;
130  prsr.add(subcmd_spec)?;
131
132  prsr.parse()?;
133
134  if prsr.get_ctx().do_help == true {
135    prsr.usage(&mut std::io::stdout());
136    std::process::exit(0);
137  }
138
139  let ctx = prsr.into_ctx();
140
141  println!("{:?}", &ctx);
142
143  Ok(())
144}
More examples
Hide additional examples
examples/usage.rs (line 123)
86fn usage_test(ctx: MyContext) -> Result<(), Box<dyn std::error::Error>> {
87  let help_spec = arg::Builder::new()
88    .sopt('h')
89    .lopt("help")
90    .exit(true)
91    .help(&["Show this help."])
92    .build(|_spec, ctx: &mut MyContext, _args| {
93      ctx.do_help = true;
94    });
95  let version_spec = arg::Builder::new()
96    .sopt('V')
97    .lopt("version")
98    .exit(true)
99    .help(&["Output tool version and exit."])
100    .build(
101      |_spec: &arg::Spec<MyContext>,
102       ctx: &mut MyContext,
103       _args: &Vec<String>| ctx.do_version = true
104    );
105  let file_spec = arg::Builder::new()
106    .sopt('f')
107    .lopt("file")
108    .help(&["Use data in FILE."])
109    .nargs(arg::Nargs::Count(1), &["FILE"])
110    .build(|_spec, ctx: &mut MyContext, args| {
111      ctx.fname = args[0].clone();
112    });
113  let param_spec = arg::Builder::new()
114    .sopt('p')
115    .lopt("param")
116    .help(&["Add a key/value parameter field. The key must be unique."])
117    .nargs(arg::Nargs::Count(2), &["KEY", "VALUE"])
118    .build(|_spec, ctx: &mut MyContext, args| {
119      ctx.params.insert(args[0].clone(), args[1].clone());
120    });
121  let cmd_spec = arg::Builder::new()
122    .name("command")
123    .required(true)
124    .nargs(arg::Nargs::Count(1), &["COMMAND"])
125    .help(&["The command to run."])
126    .build(|_spec, ctx: &mut MyContext, args| {
127      ctx.cmd = args[0].clone();
128    });
129  let subcmd_spec = arg::Builder::new()
130    .name("subcmd")
131    .nargs(arg::Nargs::Count(1), &["SUBCMD"])
132    .help(&["Command-specific sub-command."])
133    .build(|_spec, ctx: &mut MyContext, args| {
134      ctx.subcmd = args[0].clone();
135    });
136
137  let ctx2 = MyContext {
138    ..Default::default()
139  };
140  let mut prsr = arg::Parser::from_args("hello", &["--help"], ctx2);
141
142  if ctx.tophelp {
143    prsr.set_tophelp(&[
144      "\"You know,\" said Arthur, \"it's at times like this, when I'm \
145       trapped in a Vogon airlock with a man from Betelgeuse, and about to \
146       die of asphyxiation in deep space that I really wish I'd listened to \
147       what my mother told me when I was young.\"",
148      "\"Why, what did she tell you?\"",
149      "\"I don't know, I didn't listen.\""
150    ]);
151  }
152  if ctx.bottomhelp {
153    prsr.set_bottomhelp(&[
154      "\"So this is it,\" said Arthur, \"We are going to die.\"",
155      "\"Yes,\" said Ford, \"except... no! Wait a minute!\" He suddenly \
156       lunged across the chamber at something behind Arthur's line of \
157       vision. \"What's this switch?\" he cried.",
158      "\"What? Where?\" cried Arthur, twisting round.",
159      "\"No, I was only fooling,\" said Ford, \"we are going to die after \
160       all.\""
161    ]);
162  }
163
164  prsr.add(help_spec)?;
165  prsr.add(version_spec)?;
166  prsr.add(file_spec)?;
167  prsr.add(param_spec)?;
168  prsr.add(cmd_spec)?;
169  prsr.add(subcmd_spec)?;
170
171  prsr.parse()?;
172
173  if prsr.get_ctx().do_help == true {
174    prsr.usage(&mut std::io::stdout());
175    std::process::exit(0);
176  }
177
178  let ctx = prsr.into_ctx();
179
180  println!("{:?}", &ctx);
181
182  Ok(())
183}
Source

pub fn hidden(&mut self, hidden: bool) -> &mut Self

Hidden arguments exist and work as usual, but they are not displayed in the help screen.

Examples found in repository?
examples/hidden.rs (line 35)
11fn main() -> Result<(), Box<dyn std::error::Error>> {
12  let help_spec = arg::Builder::new()
13    .sopt('h')
14    .lopt("help")
15    .exit(true)
16    .help(&["Show this help."])
17    .build(
18      |_spec: &arg::Spec<MyContext>,
19       ctx: &mut MyContext,
20       _args: &Vec<String>| ctx.do_help = true
21    );
22  let version_spec = arg::Builder::new()
23    .sopt('V')
24    .lopt("version")
25    .exit(true)
26    .help(&["Output tool version and exit."])
27    .build(
28      |_spec: &arg::Spec<MyContext>,
29       ctx: &mut MyContext,
30       _args: &Vec<String>| ctx.do_version = true
31    );
32  let secret_spec = arg::Builder::new()
33    .sopt('s')
34    .lopt("secret")
35    .hidden(true)
36    .help(&["A hidden option."])
37    .build(
38      |_spec: &arg::Spec<MyContext>,
39       ctx: &mut MyContext,
40       _args: &Vec<String>| ctx.do_secret = true
41    );
42
43
44  let ctx = MyContext {
45    ..Default::default()
46  };
47  let mut prsr = arg::Parser::from_env(ctx);
48
49  prsr.add(help_spec)?;
50  prsr.add(version_spec)?;
51  prsr.add(secret_spec)?;
52
53  prsr.parse()?;
54
55  if prsr.get_ctx().do_help == true {
56    prsr.usage(&mut std::io::stdout());
57    std::process::exit(0);
58  }
59
60  let ctx = prsr.into_ctx();
61
62  println!("{:?}", &ctx);
63
64  Ok(())
65}
Source

pub fn help<I, S>(&mut self, text: I) -> &mut Self
where I: IntoIterator<Item = S>, S: AsRef<str>,

Examples found in repository?
examples/conflict.rs (line 22)
17fn main() -> Result<(), Box<dyn std::error::Error>> {
18  let help_spec = arg::Builder::new()
19    .sopt('h')
20    .lopt("help")
21    .exit(true)
22    .help(&["Show this help."])
23    .build(help_proc);
24  let coll_spec = arg::Builder::new()
25    .sopt('h')
26    .lopt("hulp")
27    .exit(true)
28    .help(&["Show this help."])
29    .build(help_proc);
30
31
32  let ctx = MyContext {
33    ..Default::default()
34  };
35  let mut prsr = arg::Parser::from_env(ctx);
36
37  prsr.add(help_spec)?;
38  prsr.add(coll_spec)?;
39
40  prsr.parse()?;
41
42  //let ctx = prsr.into_ctx();
43  if prsr.get_ctx().do_help == true {
44    prsr.usage(&mut std::io::stdout());
45    std::process::exit(0);
46  }
47
48  println!("{:?}", prsr.get_ctx());
49
50  Ok(())
51}
More examples
Hide additional examples
examples/remaining.rs (line 42)
37fn main() -> Result<(), Box<dyn std::error::Error>> {
38  let help_spec = arg::Builder::new()
39    .sopt('h')
40    .lopt("help")
41    .exit(true)
42    .help(&["Show this help."])
43    .build(help_proc);
44  let exec_spec = arg::Builder::new()
45    .name("exec")
46    .nargs(arg::Nargs::Count(1), &["PRG"])
47    .help(&["The executable to run."])
48    .build(exec_proc);
49  let eargs_spec = arg::Builder::new()
50    .name("execargs")
51    .nargs(arg::Nargs::Remainder, &["PRGARG"])
52    .help(&["arguments to pass to the executable."])
53    .build(eargs_proc);
54
55  let ctx = MyContext {
56    ..Default::default()
57  };
58  let mut prsr = arg::Parser::from_env(ctx);
59
60  prsr.add(help_spec)?;
61  prsr.add(exec_spec)?;
62  prsr.add(eargs_spec)?;
63
64  prsr.parse()?;
65
66  if prsr.get_ctx().do_help == true {
67    prsr.usage(&mut std::io::stdout());
68    std::process::exit(0);
69  }
70
71  let ctx = prsr.into_ctx();
72
73  println!("{:?}", &ctx);
74
75  Ok(())
76}
examples/hidden.rs (line 16)
11fn main() -> Result<(), Box<dyn std::error::Error>> {
12  let help_spec = arg::Builder::new()
13    .sopt('h')
14    .lopt("help")
15    .exit(true)
16    .help(&["Show this help."])
17    .build(
18      |_spec: &arg::Spec<MyContext>,
19       ctx: &mut MyContext,
20       _args: &Vec<String>| ctx.do_help = true
21    );
22  let version_spec = arg::Builder::new()
23    .sopt('V')
24    .lopt("version")
25    .exit(true)
26    .help(&["Output tool version and exit."])
27    .build(
28      |_spec: &arg::Spec<MyContext>,
29       ctx: &mut MyContext,
30       _args: &Vec<String>| ctx.do_version = true
31    );
32  let secret_spec = arg::Builder::new()
33    .sopt('s')
34    .lopt("secret")
35    .hidden(true)
36    .help(&["A hidden option."])
37    .build(
38      |_spec: &arg::Spec<MyContext>,
39       ctx: &mut MyContext,
40       _args: &Vec<String>| ctx.do_secret = true
41    );
42
43
44  let ctx = MyContext {
45    ..Default::default()
46  };
47  let mut prsr = arg::Parser::from_env(ctx);
48
49  prsr.add(help_spec)?;
50  prsr.add(version_spec)?;
51  prsr.add(secret_spec)?;
52
53  prsr.parse()?;
54
55  if prsr.get_ctx().do_help == true {
56    prsr.usage(&mut std::io::stdout());
57    std::process::exit(0);
58  }
59
60  let ctx = prsr.into_ctx();
61
62  println!("{:?}", &ctx);
63
64  Ok(())
65}
examples/usage.rs (line 24)
19fn main() -> Result<(), Box<dyn std::error::Error>> {
20  let help_spec = arg::Builder::new()
21    .sopt('h')
22    .lopt("help")
23    .exit(true)
24    .help(&["Show this help."])
25    .build(|_spec, ctx: &mut MyContext, _args| {
26      ctx.do_help = true;
27    });
28  let version_spec = arg::Builder::new()
29    .sopt('V')
30    .lopt("version")
31    .exit(true)
32    .help(&["Output tool version and exit."])
33    .build(
34      |_spec: &arg::Spec<MyContext>,
35       ctx: &mut MyContext,
36       _args: &Vec<String>| ctx.do_version = true
37    );
38  let tophelp_spec = arg::Builder::new()
39    .sopt('t')
40    .lopt("tophelp")
41    .help(&["Show top help."])
42    .build(|_spec, ctx: &mut MyContext, _args| {
43      ctx.tophelp = true;
44    });
45  let bottomhelp_spec = arg::Builder::new()
46    .sopt('b')
47    .lopt("bottomhelp")
48    .help(&["Show bottom help."])
49    .build(|_spec, ctx: &mut MyContext, _args| {
50      ctx.bottomhelp = true;
51    });
52
53  let ctx = MyContext {
54    ..Default::default()
55  };
56  let mut prsr = arg::Parser::from_env(ctx);
57
58  prsr.add(help_spec)?;
59  prsr.add(version_spec)?;
60  prsr.add(tophelp_spec)?;
61  prsr.add(bottomhelp_spec)?;
62
63  prsr.parse()?;
64
65  if prsr.get_ctx().do_help == true {
66    prsr.usage(&mut std::io::stdout());
67    std::process::exit(0);
68  }
69
70  if prsr.get_ctx().do_version == true {
71    const VERSION: &'static str = env!("CARGO_PKG_VERSION");
72    println!("usage {}", VERSION);
73    std::process::exit(0);
74  }
75
76  let ctx = prsr.into_ctx();
77
78  println!("{:?}", &ctx);
79
80  usage_test(ctx)?;
81
82  Ok(())
83}
84
85
86fn usage_test(ctx: MyContext) -> Result<(), Box<dyn std::error::Error>> {
87  let help_spec = arg::Builder::new()
88    .sopt('h')
89    .lopt("help")
90    .exit(true)
91    .help(&["Show this help."])
92    .build(|_spec, ctx: &mut MyContext, _args| {
93      ctx.do_help = true;
94    });
95  let version_spec = arg::Builder::new()
96    .sopt('V')
97    .lopt("version")
98    .exit(true)
99    .help(&["Output tool version and exit."])
100    .build(
101      |_spec: &arg::Spec<MyContext>,
102       ctx: &mut MyContext,
103       _args: &Vec<String>| ctx.do_version = true
104    );
105  let file_spec = arg::Builder::new()
106    .sopt('f')
107    .lopt("file")
108    .help(&["Use data in FILE."])
109    .nargs(arg::Nargs::Count(1), &["FILE"])
110    .build(|_spec, ctx: &mut MyContext, args| {
111      ctx.fname = args[0].clone();
112    });
113  let param_spec = arg::Builder::new()
114    .sopt('p')
115    .lopt("param")
116    .help(&["Add a key/value parameter field. The key must be unique."])
117    .nargs(arg::Nargs::Count(2), &["KEY", "VALUE"])
118    .build(|_spec, ctx: &mut MyContext, args| {
119      ctx.params.insert(args[0].clone(), args[1].clone());
120    });
121  let cmd_spec = arg::Builder::new()
122    .name("command")
123    .required(true)
124    .nargs(arg::Nargs::Count(1), &["COMMAND"])
125    .help(&["The command to run."])
126    .build(|_spec, ctx: &mut MyContext, args| {
127      ctx.cmd = args[0].clone();
128    });
129  let subcmd_spec = arg::Builder::new()
130    .name("subcmd")
131    .nargs(arg::Nargs::Count(1), &["SUBCMD"])
132    .help(&["Command-specific sub-command."])
133    .build(|_spec, ctx: &mut MyContext, args| {
134      ctx.subcmd = args[0].clone();
135    });
136
137  let ctx2 = MyContext {
138    ..Default::default()
139  };
140  let mut prsr = arg::Parser::from_args("hello", &["--help"], ctx2);
141
142  if ctx.tophelp {
143    prsr.set_tophelp(&[
144      "\"You know,\" said Arthur, \"it's at times like this, when I'm \
145       trapped in a Vogon airlock with a man from Betelgeuse, and about to \
146       die of asphyxiation in deep space that I really wish I'd listened to \
147       what my mother told me when I was young.\"",
148      "\"Why, what did she tell you?\"",
149      "\"I don't know, I didn't listen.\""
150    ]);
151  }
152  if ctx.bottomhelp {
153    prsr.set_bottomhelp(&[
154      "\"So this is it,\" said Arthur, \"We are going to die.\"",
155      "\"Yes,\" said Ford, \"except... no! Wait a minute!\" He suddenly \
156       lunged across the chamber at something behind Arthur's line of \
157       vision. \"What's this switch?\" he cried.",
158      "\"What? Where?\" cried Arthur, twisting round.",
159      "\"No, I was only fooling,\" said Ford, \"we are going to die after \
160       all.\""
161    ]);
162  }
163
164  prsr.add(help_spec)?;
165  prsr.add(version_spec)?;
166  prsr.add(file_spec)?;
167  prsr.add(param_spec)?;
168  prsr.add(cmd_spec)?;
169  prsr.add(subcmd_spec)?;
170
171  prsr.parse()?;
172
173  if prsr.get_ctx().do_help == true {
174    prsr.usage(&mut std::io::stdout());
175    std::process::exit(0);
176  }
177
178  let ctx = prsr.into_ctx();
179
180  println!("{:?}", &ctx);
181
182  Ok(())
183}
examples/simple.rs (line 77)
72fn main() -> Result<(), Box<dyn std::error::Error>> {
73  let help_spec = arg::Builder::new()
74    .sopt('h')
75    .lopt("help")
76    .exit(true)
77    .help(&["Show this help."])
78    .build(help_proc);
79  let verbose_spec = arg::Builder::new()
80    .sopt('v')
81    .lopt("verbose")
82    .help(&["Increase level of verbosity.", "Be quiet by default."])
83    .build(verbose_proc);
84  let version_spec = arg::Builder::new()
85    .sopt('V')
86    .lopt("version")
87    .exit(true)
88    .help(&["Output tool version and exit."])
89    .build(
90      |_spec: &arg::Spec<MyContext>,
91       ctx: &mut MyContext,
92       _args: &Vec<String>| ctx.do_version = true
93    );
94  let file_spec = arg::Builder::new()
95    .sopt('f')
96    .lopt("file")
97    .help(&["Use data in FILE."])
98    .nargs(arg::Nargs::Count(1), &["FILE"])
99    .build(file_proc);
100  let param_spec = arg::Builder::new()
101    .sopt('p')
102    .lopt("param")
103    .help(&["Add a key/value parameter field. The key must be unique."])
104    .nargs(arg::Nargs::Count(2), &["KEY", "VALUE"])
105    .build(param_proc);
106  let cmd_spec = arg::Builder::new()
107    .name("command")
108    .required(true)
109    .nargs(arg::Nargs::Count(1), &["COMMAND"])
110    .help(&["The command to run."])
111    .build(cmd_proc);
112  let subcmd_spec = arg::Builder::new()
113    .name("subcmd")
114    .nargs(arg::Nargs::Count(1), &["SUBCMD"])
115    .help(&["Command-specific sub-command."])
116    .build(subcmd_proc);
117
118
119  let ctx = MyContext {
120    ..Default::default()
121  };
122  let mut prsr = arg::Parser::from_env(ctx);
123
124  prsr.add(help_spec)?;
125  prsr.add(verbose_spec)?;
126  prsr.add(version_spec)?;
127  prsr.add(file_spec)?;
128  prsr.add(param_spec)?;
129  prsr.add(cmd_spec)?;
130  prsr.add(subcmd_spec)?;
131
132  prsr.parse()?;
133
134  if prsr.get_ctx().do_help == true {
135    prsr.usage(&mut std::io::stdout());
136    std::process::exit(0);
137  }
138
139  let ctx = prsr.into_ctx();
140
141  println!("{:?}", &ctx);
142
143  Ok(())
144}
Source

pub fn build<C>( &self, proc: fn(spec: &Spec<C>, ctx: &mut C, args: &Vec<String>), ) -> Spec<C>

Examples found in repository?
examples/conflict.rs (line 23)
17fn main() -> Result<(), Box<dyn std::error::Error>> {
18  let help_spec = arg::Builder::new()
19    .sopt('h')
20    .lopt("help")
21    .exit(true)
22    .help(&["Show this help."])
23    .build(help_proc);
24  let coll_spec = arg::Builder::new()
25    .sopt('h')
26    .lopt("hulp")
27    .exit(true)
28    .help(&["Show this help."])
29    .build(help_proc);
30
31
32  let ctx = MyContext {
33    ..Default::default()
34  };
35  let mut prsr = arg::Parser::from_env(ctx);
36
37  prsr.add(help_spec)?;
38  prsr.add(coll_spec)?;
39
40  prsr.parse()?;
41
42  //let ctx = prsr.into_ctx();
43  if prsr.get_ctx().do_help == true {
44    prsr.usage(&mut std::io::stdout());
45    std::process::exit(0);
46  }
47
48  println!("{:?}", prsr.get_ctx());
49
50  Ok(())
51}
More examples
Hide additional examples
examples/remaining.rs (line 43)
37fn main() -> Result<(), Box<dyn std::error::Error>> {
38  let help_spec = arg::Builder::new()
39    .sopt('h')
40    .lopt("help")
41    .exit(true)
42    .help(&["Show this help."])
43    .build(help_proc);
44  let exec_spec = arg::Builder::new()
45    .name("exec")
46    .nargs(arg::Nargs::Count(1), &["PRG"])
47    .help(&["The executable to run."])
48    .build(exec_proc);
49  let eargs_spec = arg::Builder::new()
50    .name("execargs")
51    .nargs(arg::Nargs::Remainder, &["PRGARG"])
52    .help(&["arguments to pass to the executable."])
53    .build(eargs_proc);
54
55  let ctx = MyContext {
56    ..Default::default()
57  };
58  let mut prsr = arg::Parser::from_env(ctx);
59
60  prsr.add(help_spec)?;
61  prsr.add(exec_spec)?;
62  prsr.add(eargs_spec)?;
63
64  prsr.parse()?;
65
66  if prsr.get_ctx().do_help == true {
67    prsr.usage(&mut std::io::stdout());
68    std::process::exit(0);
69  }
70
71  let ctx = prsr.into_ctx();
72
73  println!("{:?}", &ctx);
74
75  Ok(())
76}
examples/hidden.rs (lines 17-21)
11fn main() -> Result<(), Box<dyn std::error::Error>> {
12  let help_spec = arg::Builder::new()
13    .sopt('h')
14    .lopt("help")
15    .exit(true)
16    .help(&["Show this help."])
17    .build(
18      |_spec: &arg::Spec<MyContext>,
19       ctx: &mut MyContext,
20       _args: &Vec<String>| ctx.do_help = true
21    );
22  let version_spec = arg::Builder::new()
23    .sopt('V')
24    .lopt("version")
25    .exit(true)
26    .help(&["Output tool version and exit."])
27    .build(
28      |_spec: &arg::Spec<MyContext>,
29       ctx: &mut MyContext,
30       _args: &Vec<String>| ctx.do_version = true
31    );
32  let secret_spec = arg::Builder::new()
33    .sopt('s')
34    .lopt("secret")
35    .hidden(true)
36    .help(&["A hidden option."])
37    .build(
38      |_spec: &arg::Spec<MyContext>,
39       ctx: &mut MyContext,
40       _args: &Vec<String>| ctx.do_secret = true
41    );
42
43
44  let ctx = MyContext {
45    ..Default::default()
46  };
47  let mut prsr = arg::Parser::from_env(ctx);
48
49  prsr.add(help_spec)?;
50  prsr.add(version_spec)?;
51  prsr.add(secret_spec)?;
52
53  prsr.parse()?;
54
55  if prsr.get_ctx().do_help == true {
56    prsr.usage(&mut std::io::stdout());
57    std::process::exit(0);
58  }
59
60  let ctx = prsr.into_ctx();
61
62  println!("{:?}", &ctx);
63
64  Ok(())
65}
examples/usage.rs (lines 25-27)
19fn main() -> Result<(), Box<dyn std::error::Error>> {
20  let help_spec = arg::Builder::new()
21    .sopt('h')
22    .lopt("help")
23    .exit(true)
24    .help(&["Show this help."])
25    .build(|_spec, ctx: &mut MyContext, _args| {
26      ctx.do_help = true;
27    });
28  let version_spec = arg::Builder::new()
29    .sopt('V')
30    .lopt("version")
31    .exit(true)
32    .help(&["Output tool version and exit."])
33    .build(
34      |_spec: &arg::Spec<MyContext>,
35       ctx: &mut MyContext,
36       _args: &Vec<String>| ctx.do_version = true
37    );
38  let tophelp_spec = arg::Builder::new()
39    .sopt('t')
40    .lopt("tophelp")
41    .help(&["Show top help."])
42    .build(|_spec, ctx: &mut MyContext, _args| {
43      ctx.tophelp = true;
44    });
45  let bottomhelp_spec = arg::Builder::new()
46    .sopt('b')
47    .lopt("bottomhelp")
48    .help(&["Show bottom help."])
49    .build(|_spec, ctx: &mut MyContext, _args| {
50      ctx.bottomhelp = true;
51    });
52
53  let ctx = MyContext {
54    ..Default::default()
55  };
56  let mut prsr = arg::Parser::from_env(ctx);
57
58  prsr.add(help_spec)?;
59  prsr.add(version_spec)?;
60  prsr.add(tophelp_spec)?;
61  prsr.add(bottomhelp_spec)?;
62
63  prsr.parse()?;
64
65  if prsr.get_ctx().do_help == true {
66    prsr.usage(&mut std::io::stdout());
67    std::process::exit(0);
68  }
69
70  if prsr.get_ctx().do_version == true {
71    const VERSION: &'static str = env!("CARGO_PKG_VERSION");
72    println!("usage {}", VERSION);
73    std::process::exit(0);
74  }
75
76  let ctx = prsr.into_ctx();
77
78  println!("{:?}", &ctx);
79
80  usage_test(ctx)?;
81
82  Ok(())
83}
84
85
86fn usage_test(ctx: MyContext) -> Result<(), Box<dyn std::error::Error>> {
87  let help_spec = arg::Builder::new()
88    .sopt('h')
89    .lopt("help")
90    .exit(true)
91    .help(&["Show this help."])
92    .build(|_spec, ctx: &mut MyContext, _args| {
93      ctx.do_help = true;
94    });
95  let version_spec = arg::Builder::new()
96    .sopt('V')
97    .lopt("version")
98    .exit(true)
99    .help(&["Output tool version and exit."])
100    .build(
101      |_spec: &arg::Spec<MyContext>,
102       ctx: &mut MyContext,
103       _args: &Vec<String>| ctx.do_version = true
104    );
105  let file_spec = arg::Builder::new()
106    .sopt('f')
107    .lopt("file")
108    .help(&["Use data in FILE."])
109    .nargs(arg::Nargs::Count(1), &["FILE"])
110    .build(|_spec, ctx: &mut MyContext, args| {
111      ctx.fname = args[0].clone();
112    });
113  let param_spec = arg::Builder::new()
114    .sopt('p')
115    .lopt("param")
116    .help(&["Add a key/value parameter field. The key must be unique."])
117    .nargs(arg::Nargs::Count(2), &["KEY", "VALUE"])
118    .build(|_spec, ctx: &mut MyContext, args| {
119      ctx.params.insert(args[0].clone(), args[1].clone());
120    });
121  let cmd_spec = arg::Builder::new()
122    .name("command")
123    .required(true)
124    .nargs(arg::Nargs::Count(1), &["COMMAND"])
125    .help(&["The command to run."])
126    .build(|_spec, ctx: &mut MyContext, args| {
127      ctx.cmd = args[0].clone();
128    });
129  let subcmd_spec = arg::Builder::new()
130    .name("subcmd")
131    .nargs(arg::Nargs::Count(1), &["SUBCMD"])
132    .help(&["Command-specific sub-command."])
133    .build(|_spec, ctx: &mut MyContext, args| {
134      ctx.subcmd = args[0].clone();
135    });
136
137  let ctx2 = MyContext {
138    ..Default::default()
139  };
140  let mut prsr = arg::Parser::from_args("hello", &["--help"], ctx2);
141
142  if ctx.tophelp {
143    prsr.set_tophelp(&[
144      "\"You know,\" said Arthur, \"it's at times like this, when I'm \
145       trapped in a Vogon airlock with a man from Betelgeuse, and about to \
146       die of asphyxiation in deep space that I really wish I'd listened to \
147       what my mother told me when I was young.\"",
148      "\"Why, what did she tell you?\"",
149      "\"I don't know, I didn't listen.\""
150    ]);
151  }
152  if ctx.bottomhelp {
153    prsr.set_bottomhelp(&[
154      "\"So this is it,\" said Arthur, \"We are going to die.\"",
155      "\"Yes,\" said Ford, \"except... no! Wait a minute!\" He suddenly \
156       lunged across the chamber at something behind Arthur's line of \
157       vision. \"What's this switch?\" he cried.",
158      "\"What? Where?\" cried Arthur, twisting round.",
159      "\"No, I was only fooling,\" said Ford, \"we are going to die after \
160       all.\""
161    ]);
162  }
163
164  prsr.add(help_spec)?;
165  prsr.add(version_spec)?;
166  prsr.add(file_spec)?;
167  prsr.add(param_spec)?;
168  prsr.add(cmd_spec)?;
169  prsr.add(subcmd_spec)?;
170
171  prsr.parse()?;
172
173  if prsr.get_ctx().do_help == true {
174    prsr.usage(&mut std::io::stdout());
175    std::process::exit(0);
176  }
177
178  let ctx = prsr.into_ctx();
179
180  println!("{:?}", &ctx);
181
182  Ok(())
183}
examples/simple.rs (line 78)
72fn main() -> Result<(), Box<dyn std::error::Error>> {
73  let help_spec = arg::Builder::new()
74    .sopt('h')
75    .lopt("help")
76    .exit(true)
77    .help(&["Show this help."])
78    .build(help_proc);
79  let verbose_spec = arg::Builder::new()
80    .sopt('v')
81    .lopt("verbose")
82    .help(&["Increase level of verbosity.", "Be quiet by default."])
83    .build(verbose_proc);
84  let version_spec = arg::Builder::new()
85    .sopt('V')
86    .lopt("version")
87    .exit(true)
88    .help(&["Output tool version and exit."])
89    .build(
90      |_spec: &arg::Spec<MyContext>,
91       ctx: &mut MyContext,
92       _args: &Vec<String>| ctx.do_version = true
93    );
94  let file_spec = arg::Builder::new()
95    .sopt('f')
96    .lopt("file")
97    .help(&["Use data in FILE."])
98    .nargs(arg::Nargs::Count(1), &["FILE"])
99    .build(file_proc);
100  let param_spec = arg::Builder::new()
101    .sopt('p')
102    .lopt("param")
103    .help(&["Add a key/value parameter field. The key must be unique."])
104    .nargs(arg::Nargs::Count(2), &["KEY", "VALUE"])
105    .build(param_proc);
106  let cmd_spec = arg::Builder::new()
107    .name("command")
108    .required(true)
109    .nargs(arg::Nargs::Count(1), &["COMMAND"])
110    .help(&["The command to run."])
111    .build(cmd_proc);
112  let subcmd_spec = arg::Builder::new()
113    .name("subcmd")
114    .nargs(arg::Nargs::Count(1), &["SUBCMD"])
115    .help(&["Command-specific sub-command."])
116    .build(subcmd_proc);
117
118
119  let ctx = MyContext {
120    ..Default::default()
121  };
122  let mut prsr = arg::Parser::from_env(ctx);
123
124  prsr.add(help_spec)?;
125  prsr.add(verbose_spec)?;
126  prsr.add(version_spec)?;
127  prsr.add(file_spec)?;
128  prsr.add(param_spec)?;
129  prsr.add(cmd_spec)?;
130  prsr.add(subcmd_spec)?;
131
132  prsr.parse()?;
133
134  if prsr.get_ctx().do_help == true {
135    prsr.usage(&mut std::io::stdout());
136    std::process::exit(0);
137  }
138
139  let ctx = prsr.into_ctx();
140
141  println!("{:?}", &ctx);
142
143  Ok(())
144}

Auto Trait Implementations§

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.