Update documentation for enhanced clarity
[cli-helper.git] / src / main / java / eu / svjatoslav / commons / cli_helper / parameter_parser / Option.java
1 /*
2  * Svjatoslav Commons - shared library of common functionality. Author: Svjatoslav Agejenko.
3  * This project is released under Creative Commons Zero (CC0) license.
4  */
5 package eu.svjatoslav.commons.cli_helper.parameter_parser;
6
7 import java.util.ArrayList;
8 import java.util.List;
9
10 import static eu.svjatoslav.commons.cli_helper.parameter_parser.ParameterCount.NONE;
11 import static java.lang.String.join;
12 import static java.util.Collections.addAll;
13 import static java.util.stream.Collectors.joining;
14
15 public abstract class Option<T, I extends Option> {
16
17     /**
18      * Purpose of this option, like: input image path, compression level, etc...
19      *
20      * Note: for describing option type there is {@link #describeFormat()}.
21      */
22     public final String description;
23
24     /**
25      * List of arguments for this parameter.
26      */
27     public final List<String> parameters = new ArrayList<>();
28     final ParameterCount parameterCount;
29
30     /**
31      * List of aliases for this option.
32      */
33     private final List<String> aliases = new ArrayList<>();
34
35     /**
36      * Indicates that at least one parameter is mandatory for this option.
37      */
38     protected boolean mandatory;
39
40     /**
41      * If this parameter was present in the commandline, then this boolean will
42      * be set to <code>true</code>.
43      */
44     private boolean isPresent;
45
46     public Option(final boolean mandatory,
47                   final ParameterCount parameterCount, final String description,
48                   final String... aliases2) {
49
50         this.mandatory = mandatory;
51         this.description = description;
52         this.parameterCount = parameterCount;
53
54         // save aliases
55         addAll(aliases, aliases2);
56     }
57
58     public Option(final String description, final ParameterCount parameterCount) {
59         this.description = description;
60         this.parameterCount = parameterCount;
61     }
62
63     @SuppressWarnings("unchecked")
64     public I addAliases(final String... aliasArray) {
65
66         // save aliases
67         addAll(aliases, aliasArray);
68
69         return (I) this;
70     }
71
72     /**
73      * @param parameterString parameter to add
74      * @return <code>true</code> if no errors were found. <code>false</code>
75      * otherwise.
76      */
77     public boolean addParameter(final String parameterString) {
78         // check if arguments are allowed for this parameter
79         if (parameterCount.equals(NONE)) {
80             System.out
81                     .println("Error! No parameters are allowed for option(s): "
82                             + getAliasesAsString());
83             return false;
84         }
85
86         // check if multiple arguments are allowed
87         if ((!parameters.isEmpty())
88                 && (parameterCount.equals(ParameterCount.ONE))) {
89             System.out
90                     .println("Error! Only single parameter is allowed for argument(s): "
91                             + getAliasesAsString());
92             return false;
93         }
94
95         if (isValid(parameterString)) {
96             parameters.add(parameterString);
97             return true;
98         } else {
99             System.out.println("Error! Invalid parameter type for \"" + parameterString
100                     + "\". It shall be " + describeFormat() + ".");
101             return false;
102         }
103     }
104
105     /**
106      * @return Single line parameter type description. For example: "file", "date", "integer", "regular expression", etc..
107      * <p>
108      * Note: for argument purpose description there is {@link #description}
109      */
110     public abstract String describeFormat();
111
112     /**
113      * @return aliases for this parameter as string.
114      */
115     public String getAliasesAsString() {
116         return join(", ", aliases);
117     }
118
119     /**
120      * @return help for this option.
121      */
122     public String getHelp() {
123         final StringBuilder result = new StringBuilder();
124
125         // first line
126         result.append(getAliasesAsString());
127         if (!NONE.equals(parameterCount)) {
128             result
129                     .append(" (")
130                     .append(isMandatory() ? "mandatory, " : "")
131                     .append(describeFormat())
132                     .append(")");
133
134             if (parameterCount.equals(ParameterCount.ONE_OR_MORE))
135                 result.append("...");
136         }
137         result.append("\n");
138
139         // second line
140         result.append("    " + description + "\n");
141
142         return result.toString();
143     }
144
145     public abstract T getValue();
146
147     public boolean isMandatory() {
148         return mandatory;
149     }
150
151     /**
152      * @return the parameterSpecified
153      */
154     public boolean isPresent() {
155         return isPresent;
156     }
157
158     /**
159      * @param present the parameterSpecified to set
160      */
161     protected void setPresent(final boolean present) {
162         this.isPresent = present;
163     }
164
165     /**
166      * @param alias alias to check against
167      * @return <code>true</code> if given alias is registered for this
168      * parameter.
169      */
170     public boolean matchesAlias(final String alias) {
171         return aliases.contains(alias);
172
173     }
174
175     /**
176      * Notifies this option that no more parameters will follow.
177      * This gives option chance to verify if this is ok.
178      *
179      * @return <code>true</code> if no errors were found. <code>false</code>
180      * otherwise.
181      */
182     public boolean noMoreArguments() {
183
184         if ((!parameterCount.equals(NONE))
185                 && (parameters.isEmpty())) {
186
187             System.out.println("Error! " + getAliasesAsString()
188                     + " require at least one parameter.");
189
190             return false;
191         }
192         return true;
193     }
194
195     @SuppressWarnings("unchecked")
196     public I setMandatory() {
197         mandatory = true;
198         return (I) this;
199     }
200
201     /**
202      * @param value value to validate
203      * @return <code>true</code> if value is correct, <code>false</code>
204      * otherwise.
205      */
206     public abstract boolean isValid(String value);
207
208 }