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