public void setDate(int parameterIndex, java.sql.Date inputValue, java.util.Calendar inputCalendar) //throws SQLException { String dateString; /* * Convert string to YYYYMMDD format that dBase needs. */ if (inputValue == (java.sql.Date)null) { setString(parameterIndex, (String)null); } else if (inputValue.toString().trim().length() < 8) { setString(parameterIndex, (String)null); } else { dateString = inputValue.toString().trim(); /* * Convert date string to the standard YYYYMMDD format */ dateString = UtilString.dateValue(dateString); setString(parameterIndex, dateString); } }
/* * <p>Returns the length of the duration in milli-seconds.</p> * * <p>If the seconds field carries more digits than milli-second order, * those will be simply discarded (or in other words, rounded to zero.) * For example, for any Calendar value <code>x</code>,</p> * <pre> * <code>new Duration("PT10.00099S").getTimeInMills(x) == 10000</code>. * <code>new Duration("-PT10.00099S").getTimeInMills(x) == -10000</code>. * </pre> * * <p/> * Note that this method uses the {@link #addTo(Calendar)} method, * which may work incorrectly with <code>Duration</code> objects with * very large values in its fields. See the {@link #addTo(Calendar)} * method for details. * * @param startInstant * The length of a month/year varies. The <code>startInstant</code> is * used to disambiguate this variance. Specifically, this method * returns the difference between <code>startInstant</code> and * <code>startInstant+duration</code> * * @return milliseconds between <code>startInstant</code> and * <code>startInstant</code> plus this <code>Duration</code> * * @throws NullPointerException if <code>startInstant</code> parameter * is null. * */ public long getTimeInMillis(java.util.Calendar startInstant) { java.util.Calendar cal = (java.util.Calendar)startInstant.clone(); addTo(cal); return(getCalendarTimeInMillis(cal) - getCalendarTimeInMillis(startInstant)); }
public void setTimestamp(java.io.RandomAccessFile ff) //throws tinySQLException { try { java.util.Calendar cal = java.util.Calendar.getInstance(); cal.setTime(new java.util.Date()); int dd = cal.get(java.util.Calendar.DAY_OF_MONTH); int mm = cal.get(java.util.Calendar.MONTH) + 1; int yy = cal.get(java.util.Calendar.YEAR); yy = yy % 100; // Y2K problem: only 2 digits ff.seek(DATE_INDEX); ff.write(yy); ff.write(mm); ff.write(dd); } catch (Exception e) { throw new TinySQLException(e.getMessage()); } }
/** * Convert a Date object to a DOS date/time field. * * <p>Stolen from InfoZip's <code>fileio.c</code></p> * @param t number of milliseconds since the epoch * @return the date as a byte array */ public static byte[] toDosTime(long t) { java.util.Calendar c = java.util.Calendar.getInstance(); c.setTimeInMillis(t); int year = c.get(java.util.Calendar.YEAR); if (year < 1980) { return(copy(DOS_TIME_MIN)); // stop callers from changing the array } int month = c.get(java.util.Calendar.MONTH) + 1; long value = ((year - 1980) << 25) | (month << 21) | (c.get(java.util.Calendar.DAY_OF_MONTH) << 16) | (c.get(java.util.Calendar.HOUR_OF_DAY) << 11) | (c.get(java.util.Calendar.MINUTE) << 5) | (c.get(java.util.Calendar.SECOND) >> 1); return(ZipLong.getBytes(value)); }
/** * Converts DOS time to Java time (number of milliseconds since * epoch). */ public static long dosToJavaTime(long dosTime) { java.util.Calendar cal = java.util.Calendar.getInstance(); // CheckStyle:MagicNumberCheck OFF - no point /* Basties Note: why so many method calls? * cal.set(java.util.Calendar.YEAR, (int) ((dosTime >> 25) & 0x7f) + 1980); * cal.set(java.util.Calendar.MONTH, (int) ((dosTime >> 21) & 0x0f) - 1); * cal.set(java.util.Calendar.DATE, (int) (dosTime >> 16) & 0x1f); * cal.set(java.util.Calendar.HOUR_OF_DAY, (int) (dosTime >> 11) & 0x1f); * cal.set(java.util.Calendar.MINUTE, (int) (dosTime >> 5) & 0x3f); * cal.set(java.util.Calendar.SECOND, (int) (dosTime << 1) & 0x3e); */ cal.set((int)(((dosTime >> 25) & 0x7f) + 1980), (int)(((dosTime >> 21) & 0x0f) - 1), (int)((dosTime >> 16) & 0x1f), (int)((dosTime >> 11) & 0x1f), (int)((dosTime >> 5) & 0x3f), (int)((dosTime << 1) & 0x3e)); // CheckStyle:MagicNumberCheck ON return(cal.getTime().getTime()); }
public void setTimestamp(int parameterIndex, java.sql.Timestamp inputValue, java.util.Calendar inputCalendar) //throws SQLException { setString(parameterIndex, inputValue.toString()); }
/* * <p>Calls the {@link Calendar#getTimeInMillis} method. * Prior to JDK1.4, this method was protected and therefore * cannot be invoked directly.</p> * * <p>TODO: In future, this should be replaced by <code>cal.getTimeInMillis()</code>.</p> * * @param cal <code>Calendar</code> to get time in milliseconds. * * @return Milliseconds of <code>cal</code>. */ private static long getCalendarTimeInMillis(java.util.Calendar cal) { return(cal.getTime().getTime()); }
/* * <p>Converts the years and months fields into the days field * by using a specific time instant as the reference point.</p> * * <p>For example, duration of one month normalizes to 31 days * given the start time instance "July 8th 2003, 17:40:32".</p> * * <p>Formally, the computation is done as follows:</p> * <ol> * <li>the given Calendar object is cloned</li> * <li>the years, months and days fields will be added to the {@link Calendar} object * by using the {@link Calendar#add(int,int)} method</li> * <li>the difference between the two Calendars in computed in milliseconds and converted to days, * if a remainder occurs due to Daylight Savings Time, it is discarded</li> * <li>the computed days, along with the hours, minutes and seconds * fields of this duration object is used to construct a new * Duration object.</li> * </ol> * * <p>Note that since the Calendar class uses <code>int</code> to * hold the value of year and month, this method may produce * an unexpected result if this duration object holds * a very large value in the years or months fields.</p> * * @param startTimeInstant <code>Calendar</code> reference point. * * @return <code>Duration</code> of years and months of this <code>Duration</code> as days. * * @throws NullPointerException If the startTimeInstant parameter is null. */ public abstract Duration normalizeWith(java.util.Calendar startTimeInstant);
/* * Adds this duration to a {@link Calendar} object. * * <p> * Calls {@link java.util.Calendar#add(int,int)} in the * order of YEARS, MONTHS, DAYS, HOURS, MINUTES, SECONDS, and MILLISECONDS * if those fields are present. Because the {@link Calendar} class * uses int to hold values, there are cases where this method * won't work correctly (for example if values of fields * exceed the range of int.) * </p> * * <p> * Also, since this duration class is a Gregorian duration, this * method will not work correctly if the given {@link Calendar} * object is based on some other calendar systems. * </p> * * <p> * Any fractional parts of this <code>Duration</code> object * beyond milliseconds will be simply ignored. For example, if * this duration is "P1.23456S", then 1 is added to SECONDS, * 234 is added to MILLISECONDS, and the rest will be unused. * </p> * * <p/> * Note that because {@link Calendar#add(int, int)} is using * <tt>int</tt>, <code>Duration</code> with values beyond the * range of <tt>int</tt> in its fields * will cause overflow/underflow to the given {@link Calendar}. * {@link XMLGregorianCalendar#add(Duration)} provides the same * basic operation as this method while avoiding * the overflow/underflow issues. * * @param calendar * A calendar object whose value will be modified. * @throws NullPointerException * if the calendar parameter is null. */ public abstract void addTo(java.util.Calendar calendar);