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
|
use crate::Pickable;
use std::marker::PhantomData;
/// Represents a constraint definition for a parameter selection.
///
/// This structure describes the constraints that a command-line parameter (Picker parameter item)
/// should satisfy, including its full name list (with aliases), short name form, and whether it is
/// positional.
///
/// # Field Descriptions
///
/// - `full`: Full name or alias list. For example, `["config", "cfg"]` means the parameter can be
/// matched with either `--config` or `--cfg`. Must contain at least one non-empty string.
///
/// - `short`: Short name (single character). For example, `Some('c')` means it can be passed using
/// the `-c` form. If set to `None`, the short name form is not supported.
///
/// - `positional`: Whether the parameter is positional (i.e., an argument without a flag).
/// - `true`: The parameter is positional; it is matched by its position in the command line rather
/// than by a `--name` or `-n` flag.
/// - `false`: The parameter is a named (flag-based) parameter.
///
/// - `_type`: PhantomData to hold the type parameter.
#[derive(Default, Clone, Copy)]
pub struct PickerFlag<'a, Type>
where
Type: Default + Pickable,
{
/// Full name, may include variant names (aliases), e.g., `["config", "cfg"]`.
pub full: &'a [&'a str],
/// Short name, e.g., `'c'`.
pub short: Option<char>,
/// Whether the parameter is positional (no flag, matched by position).
pub positional: bool,
/// PhantomData to hold the type parameter.
pub internal_type: PhantomData<Type>,
}
impl<'a, Type> PickerFlag<'a, Type>
where
Type: Default + Pickable,
{
/// Creates a new `PickerFlag` with the provided parameters.
pub fn new(full: &'a [&'a str], short: Option<char>, positional: bool) -> Self {
Self {
full,
short,
positional,
internal_type: PhantomData,
}
}
/// Returns the full name list (including aliases).
pub fn full(&self) -> &'a [&'a str] {
self.full
}
/// Returns the short name, if any.
pub fn short(&self) -> Option<char> {
self.short
}
/// Returns whether the parameter is positional.
///
/// If `full` is empty or `short` is `None`, the parameter is considered positional
/// regardless of the stored value.
pub fn is_positional(&self) -> bool {
if self.full.is_empty() && self.short.is_none() {
true
} else {
self.positional
}
}
/// Sets the full name list.
pub fn set_full(&mut self, full: &'a [&'a str]) {
self.full = full;
}
/// Sets the short name.
pub fn set_short(&mut self, short: Option<char>) {
self.short = short;
}
/// Sets whether the parameter is positional.
pub fn set_positional(&mut self, positional: bool) {
self.positional = positional;
}
/// Sets the full name list and returns self.
pub fn with_full(mut self, full: &'a [&'a str]) -> Self {
self.full = full;
self
}
/// Clears the full name list (sets it to an empty slice) and returns self.
pub fn without_full(mut self) -> Self {
self.full = &[];
self
}
/// Sets the short name to the given character and returns self.
pub fn with_short(mut self, short: char) -> Self {
self.short = Some(short);
self
}
/// Clears the short name (sets it to None) and returns self.
pub fn without_short(mut self) -> Self {
self.short = None;
self
}
/// Sets whether the parameter is positional and returns self.
pub fn with_positional(mut self, positional: bool) -> Self {
self.positional = positional;
self
}
}
|
