001    /*
002     * Copyright 2010-2015 UnboundID Corp.
003     * All Rights Reserved.
004     */
005    /*
006     * Copyright (C) 2010-2015 UnboundID Corp.
007     *
008     * This program is free software; you can redistribute it and/or modify
009     * it under the terms of the GNU General Public License (GPLv2 only)
010     * or the terms of the GNU Lesser General Public License (LGPLv2.1 only)
011     * as published by the Free Software Foundation.
012     *
013     * This program is distributed in the hope that it will be useful,
014     * but WITHOUT ANY WARRANTY; without even the implied warranty of
015     * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
016     * GNU General Public License for more details.
017     *
018     * You should have received a copy of the GNU General Public License
019     * along with this program; if not, see <http://www.gnu.org/licenses>.
020     */
021    package com.unboundid.util.args;
022    
023    
024    
025    import com.unboundid.util.Mutable;
026    import com.unboundid.util.StaticUtils;
027    import com.unboundid.util.ThreadSafety;
028    import com.unboundid.util.ThreadSafetyLevel;
029    
030    import static com.unboundid.util.args.ArgsMessages.*;
031    
032    
033    
034    /**
035     * Creates a new argument that is intended to represent Boolean states based on
036     * the value provided for this argument.  This is similar to the
037     * {@link BooleanArgument} argument type, except that the Boolean value for this
038     * argument must be explicitly specified, whereas the Boolean value for the
039     * {@code BooleanArgument} class is inferred based on whether the argument
040     * was present.
041     * <BR><BR>
042     * Arguments of this type must always have exactly one value.  Values of "true",
043     * "t", "yes", "y", "on", and "1" will be interpreted as representing a Boolean
044     * value of {@code true}, and values of "false", "f", "no", "n", "off", and "0"
045     * will be interpreted as representing a Boolean value of {@code false}.  No
046     * other values will be allowed.
047     */
048    @Mutable()
049    @ThreadSafety(level=ThreadSafetyLevel.NOT_THREADSAFE)
050    public final class BooleanValueArgument
051           extends Argument
052    {
053      /**
054       * The serial version UID for this serializable class.
055       */
056      private static final long serialVersionUID = -3903872574065550222L;
057    
058    
059    
060      // The default value for this argument.
061      private final Boolean defaultValue;
062    
063      // The provided value for this argument.
064      private Boolean value;
065    
066    
067    
068      /**
069       * Creates a new Boolean value argument with no default value.
070       *
071       * @param  shortIdentifier   The short identifier for this argument.  It may
072       *                           not be {@code null} if the long identifier is
073       *                           {@code null}.
074       * @param  longIdentifier    The long identifier for this argument.  It may
075       *                           not be {@code null} if the short identifier is
076       *                           {@code null}.
077       * @param  isRequired        Indicates whether this argument is required to
078       *                           be provided.
079       * @param  valuePlaceholder  A placeholder to display in usage information to
080       *                           indicate that a value must be provided.  It must
081       *                           not be {@code null}.
082       * @param  description       A human-readable description for this argument.
083       *                           It must not be {@code null}.
084       *
085       * @throws  ArgumentException  If there is a problem with the definition of
086       *                             this argument.
087       */
088      public BooleanValueArgument(final Character shortIdentifier,
089                                  final String longIdentifier,
090                                  final boolean isRequired,
091                                  final String valuePlaceholder,
092                                  final String description)
093             throws ArgumentException
094      {
095        this(shortIdentifier, longIdentifier, isRequired, valuePlaceholder,
096             description, null);
097      }
098    
099    
100    
101      /**
102       * Creates a new Boolean value argument with the specified default value.
103       *
104       * @param  shortIdentifier   The short identifier for this argument.  It may
105       *                           not be {@code null} if the long identifier is
106       *                           {@code null}.
107       * @param  longIdentifier    The long identifier for this argument.  It may
108       *                           not be {@code null} if the short identifier is
109       *                           {@code null}.
110       * @param  isRequired        Indicates whether this argument is required to
111       *                           be provided.
112       * @param  valuePlaceholder  A placeholder to display in usage information to
113       *                           indicate that a value must be provided.  It must
114       *                           not be {@code null}.
115       * @param  description       A human-readable description for this argument.
116       *                           It must not be {@code null}.
117       * @param  defaultValue      The default value that will be used for this
118       *                           argument if no values are provided.  It may be
119       *                           {@code null} if there should not be a default
120       *                           value.
121       *
122       * @throws  ArgumentException  If there is a problem with the definition of
123       *                             this argument.
124       */
125      public BooleanValueArgument(final Character shortIdentifier,
126                                  final String longIdentifier,
127                                  final boolean isRequired,
128                                  final String valuePlaceholder,
129                                  final String description,
130                                  final Boolean defaultValue)
131             throws ArgumentException
132      {
133        super(shortIdentifier, longIdentifier, isRequired, 1, valuePlaceholder,
134             description);
135    
136        if (valuePlaceholder == null)
137        {
138          throw new ArgumentException(
139               ERR_ARG_MUST_TAKE_VALUE.get(getIdentifierString()));
140        }
141    
142        this.defaultValue = defaultValue;
143    
144        value = null;
145      }
146    
147    
148    
149      /**
150       * Creates a new Boolean value argument that is a "clean" copy of the provided
151       * source argument.
152       *
153       * @param  source  The source argument to use for this argument.
154       */
155      private BooleanValueArgument(final BooleanValueArgument source)
156      {
157        super(source);
158    
159        defaultValue = source.defaultValue;
160        value        = null;
161      }
162    
163    
164    
165      /**
166       * {@inheritDoc}
167       */
168      @Override()
169      protected boolean hasDefaultValue()
170      {
171        return (defaultValue != null);
172      }
173    
174    
175    
176      /**
177       * Retrieves the default value for this argument, if defined.
178       *
179       * @return  The default value for this argument, or {@code null} if none is
180       *          defined.
181       */
182      public Boolean getDefaultValue()
183      {
184        return defaultValue;
185      }
186    
187    
188    
189      /**
190       * Retrieves the value for this argument, if one was provided.
191       *
192       * @return  The value for this argument.  If no value was provided but a
193       *          default value was defined, then the default value will be
194       *          returned.  If no value was provided and no default value was
195       *          defined, then {@code null} will be returned.
196       */
197      public Boolean getValue()
198      {
199        if (value == null)
200        {
201          return defaultValue;
202        }
203        else
204        {
205          return value;
206        }
207      }
208    
209    
210    
211      /**
212       * {@inheritDoc}
213       */
214      @Override()
215      protected void addValue(final String valueString)
216                throws ArgumentException
217      {
218        if (value != null)
219        {
220          throw new ArgumentException(
221               ERR_ARG_MAX_OCCURRENCES_EXCEEDED.get(getIdentifierString()));
222        }
223    
224        final String lowerStr = StaticUtils.toLowerCase(valueString);
225        if (lowerStr.equals("true") || lowerStr.equals("t") ||
226            lowerStr.equals("yes") || lowerStr.equals("y") ||
227            lowerStr.equals("on") || lowerStr.equals("1"))
228        {
229          value = Boolean.TRUE;
230        }
231        else if (lowerStr.equals("false") || lowerStr.equals("f") ||
232                 lowerStr.equals("no") || lowerStr.equals("n") ||
233                 lowerStr.equals("off") || lowerStr.equals("0"))
234        {
235          value = Boolean.FALSE;
236        }
237        else
238        {
239          throw new ArgumentException(ERR_ARG_VALUE_NOT_ALLOWED.get(
240               valueString, getIdentifierString()));
241        }
242      }
243    
244    
245    
246      /**
247       * {@inheritDoc}
248       */
249      @Override()
250      public String getDataTypeName()
251      {
252        return INFO_BOOLEAN_VALUE_TYPE_NAME.get();
253      }
254    
255    
256    
257      /**
258       * {@inheritDoc}
259       */
260      @Override()
261      public String getValueConstraints()
262      {
263        return INFO_BOOLEAN_VALUE_CONSTRAINTS.get();
264      }
265    
266    
267    
268      /**
269       * {@inheritDoc}
270       */
271      @Override()
272      public BooleanValueArgument getCleanCopy()
273      {
274        return new BooleanValueArgument(this);
275      }
276    
277    
278    
279      /**
280       * {@inheritDoc}
281       */
282      @Override()
283      public void toString(final StringBuilder buffer)
284      {
285        buffer.append("BooleanValueArgument(");
286        appendBasicToStringInfo(buffer);
287    
288        if (defaultValue != null)
289        {
290          buffer.append(", defaultValue=");
291          buffer.append(defaultValue);
292        }
293    
294        buffer.append(')');
295      }
296    }