001 /*
002 * Copyright 2016 UnboundID Corp.
003 * All Rights Reserved.
004 */
005 /*
006 * Copyright (C) 2016 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 java.util.Date;
026
027 import com.unboundid.util.NotMutable;
028 import com.unboundid.util.StaticUtils;
029 import com.unboundid.util.ThreadSafety;
030 import com.unboundid.util.ThreadSafetyLevel;
031
032 import static com.unboundid.util.args.ArgsMessages.*;
033
034
035
036 /**
037 * This class provides an implementation of an argument value validator that
038 * ensures that values must be timestamps (parsable by the
039 * {@link TimestampArgument} class) within a specified time range.
040 */
041 @NotMutable()
042 @ThreadSafety(level=ThreadSafetyLevel.COMPLETELY_THREADSAFE)
043 public final class TimestampRangeArgumentValueValidator
044 extends ArgumentValueValidator
045 {
046 // The most recent timestamp value that will be accepted.
047 private final Date mostRecentAllowedDate;
048
049 // The oldest timestamp value that will be accepted.
050 private final Date oldestAllowedDate;
051
052
053
054 /**
055 * Creates a new validator that will ensure that timestamp values are within
056 * the specified time range.
057 *
058 * @param oldestAllowedDate The oldest timestamp that will be accepted
059 * by this validator. It may be {@code null}
060 * if any timestamp older than the provided
061 * {@code mostRecentAllowedDate} will be
062 * permitted.
063 * @param mostRecentAllowedDate The most recent timestamp that will be
064 * accepted by this validator. It may be
065 * {@code null} if any timestamp more recent
066 * than the provided {@code oldestAllowedDate}
067 * will be permitted.
068 */
069 public TimestampRangeArgumentValueValidator(final Date oldestAllowedDate,
070 final Date mostRecentAllowedDate)
071 {
072 if (oldestAllowedDate == null)
073 {
074 this.oldestAllowedDate = null;
075 }
076 else
077 {
078 this.oldestAllowedDate = oldestAllowedDate;
079 }
080
081 if (mostRecentAllowedDate == null)
082 {
083 this.mostRecentAllowedDate = null;
084 }
085 else
086 {
087 this.mostRecentAllowedDate = mostRecentAllowedDate;
088 }
089 }
090
091
092
093 /**
094 * Retrieves the oldest allowed date value that will be permitted by this
095 * validator.
096 *
097 * @return The oldest allowed date value that will be permitted by this
098 * validator, or {@code null} if any timestamp older than the
099 * most recent allowed date will be permitted.
100 */
101 public Date getOldestAllowedDate()
102 {
103 return oldestAllowedDate;
104 }
105
106
107
108 /**
109 * Retrieves the most recent allowed date value that will be permitted by this
110 * validator.
111 *
112 * @return The most recent allowed date value that will be permitted by this
113 * validator, or {@code null} if any timestamp newer than the oldest
114 * allowed date will be permitted.
115 */
116 public Date getMostRecentAllowedDate()
117 {
118 return mostRecentAllowedDate;
119 }
120
121
122
123 /**
124 * {@inheritDoc}
125 */
126 @Override()
127 public void validateArgumentValue(final Argument argument,
128 final String valueString)
129 throws ArgumentException
130 {
131 // Ensure that the value can be parsed as a valid timestamp.
132 final Date parsedDate;
133 try
134 {
135 parsedDate = TimestampArgument.parseTimestamp(valueString);
136 }
137 catch (final Exception e)
138 {
139 throw new ArgumentException(
140 ERR_TIMESTAMP_VALUE_NOT_TIMESTAMP.get(valueString,
141 argument.getIdentifierString()),
142 e);
143 }
144
145 final long parsedTime = parsedDate.getTime();
146 if ((oldestAllowedDate != null) &&
147 (parsedTime < oldestAllowedDate.getTime()))
148 {
149 throw new ArgumentException(ERR_TIMESTAMP_RANGE_VALIDATOR_TOO_OLD.get(
150 valueString, argument.getIdentifierString(),
151 StaticUtils.encodeGeneralizedTime(oldestAllowedDate)));
152 }
153
154 if ((mostRecentAllowedDate != null) &&
155 (parsedTime > mostRecentAllowedDate.getTime()))
156 {
157 throw new ArgumentException(ERR_TIMESTAMP_RANGE_VALIDATOR_TOO_NEW.get(
158 valueString, argument.getIdentifierString(),
159 StaticUtils.encodeGeneralizedTime(mostRecentAllowedDate)));
160 }
161 }
162
163
164
165 /**
166 * Retrieves a string representation of this argument value validator.
167 *
168 * @return A string representation of this argument value validator.
169 */
170 @Override()
171 public String toString()
172 {
173 final StringBuilder buffer = new StringBuilder();
174 toString(buffer);
175 return buffer.toString();
176 }
177
178
179
180 /**
181 * Appends a string representation of this argument value validator to the
182 * provided buffer.
183 *
184 * @param buffer The buffer to which the string representation should be
185 * appended.
186 */
187 public void toString(final StringBuilder buffer)
188 {
189 buffer.append("TimestampRangeArgumentValueValidator(");
190
191 if (oldestAllowedDate != null)
192 {
193 buffer.append("oldestAllowedDate='");
194 buffer.append(StaticUtils.encodeGeneralizedTime(oldestAllowedDate));
195 buffer.append('\'');
196
197 if (mostRecentAllowedDate != null)
198 {
199 buffer.append(", mostRecentAllowedDate='");
200 buffer.append(StaticUtils.encodeGeneralizedTime(mostRecentAllowedDate));
201 buffer.append('\'');
202 }
203 }
204 else if (mostRecentAllowedDate != null)
205 {
206 buffer.append("mostRecentAllowedDate='");
207 buffer.append(StaticUtils.encodeGeneralizedTime(mostRecentAllowedDate));
208 buffer.append('\'');
209 }
210
211 buffer.append(')');
212 }
213 }