001 package sale;
002
003 /**
004 * This class is an implementation of the {@link Time Time} interface.
005 *
006 * <p>The time is represented in the form of a simple date. The format is "dd.mm.yy".</p>
007 *
008 * <p><strong>Note:</strong> This is a very simple implementation and it is <b>not</b> Y2K safe!</p>
009 *
010 * @author Sven Matznick
011 * @version 2.0 15/06/1999
012 * @since v2.0
013 *
014 * @deprecated As this class is not Y2K safe, it is of no use any more. Use CalendarTime instead.
015 */
016 public class Date extends Object implements Time {
017
018 /**
019 * ID for serialization.
020 */
021 private static final long serialVersionUID = 3597919751511519481L;
022
023 /**
024 * The current date.
025 *
026 * @serial
027 */
028 private String m_sDate;
029
030 /**
031 * The default interval for Dates.
032 *
033 * @serial
034 */
035 private String m_sDefaultInterval = new String("1");
036
037 /**
038 * Is this a special year?
039 *
040 * @serial
041 */
042 private boolean m_fSpecialYear = true;
043
044 /**
045 * Creates a new date with standard starting time "01.01.00".
046 */
047 public Date() {
048 this("01.01.00");
049 }
050
051 /**
052 * Creates a new date with the given starting time.
053 *
054 * @param sNewDate a String representing the date to be set, format: dd.mm.yy (day.month.year)
055 *
056 * @exception IllegalArgumentException if the given String has an invalid format
057 */
058 public Date(String sNewDate) throws IllegalArgumentException {
059 super();
060 setTime(sNewDate);
061 }
062
063 /**
064 * Set the given date.
065 *
066 * @override Never
067 *
068 * @param oTime a String representing the date to be set, format: dd.mm.yy (day.month.year)
069 *
070 * @exception IllegalArgumentException if the given String has an invalid format
071 */
072 public void setTime(Object oTime) throws IllegalArgumentException {
073 validate(oTime);
074 m_sDate = (String)oTime;
075 long lHelp = Long.parseLong(m_sDate.substring(6, 8));
076 if (lHelp % 4 == 0) {
077 m_fSpecialYear = true;
078 } else {
079 m_fSpecialYear = false;
080 }
081 }
082
083 /**
084 * Get the current date.
085 *
086 * @override Never
087 *
088 * @return a String representing the current date
089 */
090 public Object getTime() {
091 return (m_sDate);
092 }
093
094 /**
095 * Increment the time by the given time interval.
096 *
097 * @override Never
098 *
099 * @param oInterval the interval to increment time. Must be a String that gives the number of days by which
100 * to increment.
101 *
102 * @exception IllegalArgumentException if the given interval is no String or cannot be transformed into a
103 * long value.
104 */
105 public void goAhead(Object oInterval) throws IllegalArgumentException {
106 if (!(oInterval instanceof String)) {
107 throw new IllegalArgumentException("Parameter has to be of type String.");
108 }
109 long lInterval = Long.parseLong((String)oInterval); // transform String to long
110 long lDay = Long.parseLong(m_sDate.substring(0, 2));
111 long lMonth = Long.parseLong(m_sDate.substring(3, 5)); //months count from 0
112 long lYear = Long.parseLong(m_sDate.substring(6, 8));
113
114 lDay += lInterval; // increase days
115
116 // now correct overflown days
117 while ((((lMonth == 1) || (lMonth == 3) || (lMonth == 5) || (lMonth == 7) || (lMonth == 8) ||
118 (lMonth == 10) || (lMonth == 12)) && (lDay > 31)) || (((lMonth == 4) || (lMonth == 6) ||
119 (lMonth == 9) || (lMonth == 11)) && (lDay > 30)) ||
120 ((lMonth == 2) && ((lDay > 28) && (!m_fSpecialYear))) ||
121 ((lMonth == 2) && ((lDay > 29) && (m_fSpecialYear)))) { // still more days than this month has ?
122
123 if (((lMonth == 1) || (lMonth == 3) || (lMonth == 5) || (lMonth == 7) || (lMonth == 8) ||
124 (lMonth == 10) || (lMonth == 12)) && (lDay > 31)) { // 31 day month ?
125 lDay -= 31; // okay, decrease
126 lMonth++; // next month
127 }
128
129 if (((lMonth == 4) || (lMonth == 6) || (lMonth == 9) || (lMonth == 11)) && (lDay > 30)) { // 30 day month ?
130 lDay -= 30; // okay, decrease
131 lMonth++; // next month
132 }
133
134 if ((lMonth == 2) && (lDay > 28)) { // february ?
135 if (!m_fSpecialYear) {
136 lDay -= 28; // okay, descrease
137 lMonth++; // next month
138 } else {
139 if (lDay > 29) {
140 lDay -= 29;
141 lMonth++; // next month
142 }
143 }
144 }
145
146 if (lMonth > 12) { // more than 12 month ?
147 long i = 0;
148 while (lMonth > 12) {
149 lMonth -= 12;
150 i++; // how many years will pass ?
151 }
152 lYear += i; ; // increase years
153 if (lYear > 99) {
154 lYear = 0;
155 } // y2k bug ? no ! well, yes, but we don't care.
156 if (lYear % 4 == 0) {
157 m_fSpecialYear = true;
158 } else {
159 m_fSpecialYear = false;
160 }
161 }
162 }
163
164 // Build new String representation:
165 String sHelp = "";
166 if (lDay < 10) {
167 sHelp = "0" + Long.toString(lDay) + ".";
168 } else {
169 sHelp = Long.toString(lDay) + ".";
170 }
171 if (lMonth < 10) {
172 sHelp = sHelp + "0" + Long.toString(lMonth) + ".";
173 } else {
174 sHelp = sHelp + Long.toString(lMonth) + ".";
175 }
176 if (lYear < 10) {
177 sHelp = sHelp + "0" + Long.toString(lYear);
178 } else {
179 sHelp = sHelp + Long.toString(lYear);
180 }
181
182 m_sDate = new String(sHelp); // set new time
183 }
184
185 /**
186 * Get the default time interval.
187 *
188 * @override Never
189 *
190 * @return a String describing the default time step in days (standard: "1").
191 */
192 public Object getDefaultInterval() {
193 return (m_sDefaultInterval);
194 }
195
196 /**
197 * Create and return a time stamp.
198 *
199 * @override Never
200 *
201 * @param lStampNumber the number of the stamp
202 *
203 * @return a fresh time stamp.
204 */
205 public Comparable<String> getTimeStamp(long lStampNumber) {
206 java.util.StringTokenizer stDate = new java.util.StringTokenizer(m_sDate, ".");
207
208 String sReturn = ("000000000" +
209 Long.toString(lStampNumber)).substring(Long.toString(lStampNumber).length());
210 //number of stamp in this intervall
211
212 sReturn = stDate.nextToken() + sReturn; //day
213 sReturn = stDate.nextToken() + sReturn; //month
214 sReturn = stDate.nextToken() + sReturn; //year
215
216 return sReturn;
217 }
218
219 /**
220 * Returns the current date.
221 *
222 * @override Sometimes
223 *
224 * @return a String describing the current date
225 */
226 public String toString() {
227 return m_sDate;
228 }
229
230 /**
231 * Validate a given String, i.e. check it represents a date.
232 *
233 * @override Never
234 */
235 private void validate(Object oToValidate) throws IllegalArgumentException {
236 if (!(oToValidate instanceof String)) {
237 throw new IllegalArgumentException("Parameter has to be of type String.");
238 }
239 if (!(((String)oToValidate).length() == 8)) {
240 throw new IllegalArgumentException("Parameter has to consist of 8 chars: dd.mm.yy");
241 }
242 java.util.StringTokenizer stToValidate = new java.util.StringTokenizer((String)oToValidate, ".");
243
244 String sDay = stToValidate.nextToken();
245 if (sDay.length() != 2) {
246 throw new IllegalArgumentException("Parameter has to consist of 8 chars: dd.mm.yy");
247 }
248
249 String sMonth = stToValidate.nextToken();
250 if (sMonth.length() != 2) {
251 throw new IllegalArgumentException("Parameter has to consist of 8 chars: dd.mm.yy");
252 }
253
254 String sYear = stToValidate.nextToken();
255 if (sYear.length() != 2) {
256 throw new IllegalArgumentException("Parameter has to consist of 8 chars: dd.mm.yy");
257 }
258
259 long lDay = Long.parseLong(sDay); // throws IllegalArgumentException if neccessary
260 long lMonth = Long.parseLong(sMonth); // throws IllegalArgumentException if neccessary
261 long lYear = Long.parseLong(sYear); // throws IllegalArgumentException if neccessary
262
263 if ((lMonth > 12) || (lMonth < 1)) {
264 throw new IllegalArgumentException("Month has to be between 1 and 12");
265 }
266 switch ((int)lMonth) {
267 case 1:
268 case 3:
269 case 5:
270 case 7:
271 case 8:
272 case 10:
273 case 12:
274 if ((lDay > 31) || (lDay < 1)) {
275 throw new IllegalArgumentException("Day has to be between 1 and 31");
276 }
277 break;
278 case 4:
279 case 6:
280 case 9:
281 case 11:
282 if ((lDay > 30) || (lDay < 1)) {
283 throw new IllegalArgumentException("Day has to be between 1 and 30");
284 }
285 break;
286 default: // case 2
287 if (lYear % 4 == 0 && (lDay > 29 || lDay < 1)) {
288 throw new IllegalArgumentException("Day has to be between 1 and 29");
289 }
290 if (lYear % 4 != 0 && (lDay > 28 || lDay < 1)) {
291 throw new IllegalArgumentException("Day has to be between 1 and 28");
292 }
293 }
294 }
295
296 /** Convert the date to a {@link java.util.Date} object.
297 * <B>Note:</B> As the entire sale.Date class is not Y2K compliant, this method also is not.
298 *
299 * @return The converted date.
300 * @since v2.0 (06/07/2000)
301 */
302 public java.util.Date getDateValue() {
303 try {
304 java.util.StringTokenizer stToValidate = new java.util.StringTokenizer(m_sDate, ".");
305
306 String sDay = stToValidate.nextToken();
307 String sMonth = stToValidate.nextToken();
308 String sYear = stToValidate.nextToken();
309
310 long lDay = Long.parseLong(sDay); // throws IllegalArgumentException if neccessary
311 long lMonth = Long.parseLong(sMonth) - 1; // throws IllegalArgumentException if neccessary
312 long lYear = Long.parseLong(sYear); // throws IllegalArgumentException if neccessary
313
314 java.util.Calendar c = java.util.Calendar.getInstance();
315 c.clear();
316 c.set((int)lYear + 1900, (int)lMonth, (int)lDay);
317
318 return c.getTime();
319 }
320 catch (IllegalArgumentException iae) {
321 return null;
322 }
323 }
324 }