mirror of
https://github.com/DSpace/DSpace.git
synced 2025-10-10 19:43:10 +00:00
[DS-317] Add Support for Embargo function
git-svn-id: http://scm.dspace.org/svn/repo/dspace/trunk@4277 9c30dcfa-912a-0410-8fc2-9e0234be79fd
This commit is contained in:
Richard Rodgers
@@ -18,7 +18,8 @@
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* - Neither the name of the DSpace Foundation nor the names of its
|
||||
* - Neither the name of the Hewlett-Packard Company nor the name of the
|
||||
* Massachusetts Institute of Technology nor the names of their
|
||||
* contributors may be used to endorse or promote products derived from
|
||||
* this software without specific prior written permission.
|
||||
*
|
||||
@@ -38,17 +39,17 @@
|
||||
package org.dspace.content;
|
||||
|
||||
import java.text.DateFormatSymbols;
|
||||
import java.text.DateFormat;
|
||||
import java.text.SimpleDateFormat;
|
||||
import java.text.ParseException;
|
||||
import java.util.Calendar;
|
||||
import java.util.Date;
|
||||
import java.util.GregorianCalendar;
|
||||
import java.util.Locale;
|
||||
import java.util.TimeZone;
|
||||
import java.util.regex.Matcher;
|
||||
import java.util.regex.Pattern;
|
||||
|
||||
import org.apache.log4j.Logger;
|
||||
|
||||
// FIXME: No tests
|
||||
// FIXME: Not very robust - assumes dates will always be valid
|
||||
|
||||
/**
|
||||
@@ -60,154 +61,175 @@ import org.apache.log4j.Logger;
|
||||
* <code>YYYY-MM-DDThh:mm:ss</code>
|
||||
* <P>
|
||||
* There are four levels of granularity, depending on how much date information
|
||||
* is available.
|
||||
* is available: year, month, day, time.
|
||||
* <P>
|
||||
* Examples: <code>1994-05-03T15:30:24</code>,<code>1995-10-04</code>,
|
||||
* <code>2001-10</code>,<code>1975</code>
|
||||
*
|
||||
*
|
||||
* The main() method is a simple test program: run it with an optional
|
||||
* first argument that is a date string to decode, and it prints the
|
||||
* results of all the accessor methods.
|
||||
*
|
||||
* @author Robert Tansley
|
||||
* @author Larry Stone
|
||||
* @version $Revision$
|
||||
*/
|
||||
public class DCDate
|
||||
{
|
||||
/** Logger */
|
||||
private static Logger cat = Logger.getLogger(DCDate.class);
|
||||
private static Logger log = Logger.getLogger(DCDate.class);
|
||||
|
||||
/** The year, or -1 if none */
|
||||
private int year;
|
||||
// UTC timezone
|
||||
private static final TimeZone utcZone = TimeZone.getTimeZone("UTC");
|
||||
|
||||
/** The month, or -1 if none */
|
||||
private int month;
|
||||
// Full ISO 8601 is e.g. "2009-07-16T13:59:21Z"
|
||||
private static final SimpleDateFormat fullIso = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss'Z'");
|
||||
static { fullIso.setTimeZone(utcZone); }
|
||||
|
||||
/** The day, or -1 if none */
|
||||
private int day;
|
||||
// without Z
|
||||
private static final SimpleDateFormat fullIso2 = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss");
|
||||
static { fullIso2.setTimeZone(utcZone); }
|
||||
|
||||
/** Hours, -1 if none */
|
||||
private int hours;
|
||||
// without seconds
|
||||
private static final SimpleDateFormat fullIso3 = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm");
|
||||
static { fullIso3.setTimeZone(utcZone); }
|
||||
|
||||
/** Minutes, -1 if none */
|
||||
private int minutes;
|
||||
// Date-only ISO 8601 is e.g. "2009-07-16"
|
||||
private static final SimpleDateFormat dateIso = new SimpleDateFormat("yyyy-MM-dd");
|
||||
static { dateIso.setTimeZone(utcZone); }
|
||||
|
||||
/** seconds, -1 if none */
|
||||
private int seconds;
|
||||
// Year-Month-only ISO 8601 is e.g. "2009-07"
|
||||
private static final SimpleDateFormat yearMonthIso = new SimpleDateFormat("yyyy-MM");
|
||||
static { yearMonthIso.setTimeZone(utcZone); }
|
||||
|
||||
/**
|
||||
* Calendar object for timezone conversion. Only used if the date has a time
|
||||
* component.
|
||||
*/
|
||||
private GregorianCalendar localGC;
|
||||
// just year, "2009"
|
||||
private static final SimpleDateFormat yearIso = new SimpleDateFormat("yyyy");
|
||||
static { yearIso.setTimeZone(utcZone); }
|
||||
|
||||
// components of time in UTC
|
||||
private GregorianCalendar calendar = null;
|
||||
|
||||
// components of time in local zone, if needed
|
||||
private GregorianCalendar localCalendar = null;
|
||||
|
||||
private enum DateGran { YEAR, MONTH, DAY, TIME };
|
||||
DateGran granularity = null;
|
||||
|
||||
/**
|
||||
* DateFormatSymbols for locale monthsname
|
||||
*/
|
||||
private static DateFormatSymbols dfs = null;
|
||||
|
||||
*/
|
||||
private static DateFormatSymbols dfs = null;
|
||||
|
||||
/**
|
||||
* note the session locale
|
||||
*/
|
||||
private static Locale langMonth = null;
|
||||
|
||||
|
||||
private final Pattern fullDateTimePattern = Pattern.compile("(\\d*)-(\\d{2})-(\\d{2})T(\\d{2}):(\\d{2}):(\\d{2})Z");
|
||||
private final Pattern datePattern = Pattern.compile("(\\d*)-(\\d{2})-(\\d{2})");
|
||||
private final Pattern yearMonthPattern = Pattern.compile("(\\d*)-(\\d{2})");
|
||||
private static Locale langMonth = null;
|
||||
|
||||
|
||||
/**
|
||||
* Construct a clean date
|
||||
*/
|
||||
public DCDate()
|
||||
{
|
||||
// Set all fields to unknown
|
||||
year = month = day = hours = minutes = seconds = -1;
|
||||
localGC = null;
|
||||
super();
|
||||
}
|
||||
|
||||
/**
|
||||
* Construct a date object from a Java <code>Date</code> object.
|
||||
*
|
||||
* @param date
|
||||
* the Java <code>Date</code> object.
|
||||
*/
|
||||
public DCDate(Date date)
|
||||
{
|
||||
super();
|
||||
setTime(date);
|
||||
if (!(calendar.get(Calendar.HOUR_OF_DAY) == 0 &&
|
||||
calendar.get(Calendar.MINUTE) == 0 &&
|
||||
calendar.get(Calendar.SECOND) == 0))
|
||||
granularity = DateGran.TIME;
|
||||
|
||||
// if date is 1-jan, assume it's because this was set for year
|
||||
else if (calendar.get(Calendar.DAY_OF_MONTH) == 1 && calendar.get(Calendar.MONTH) == 0)
|
||||
granularity = DateGran.YEAR;
|
||||
|
||||
// otherwise day
|
||||
else
|
||||
granularity = DateGran.DAY;
|
||||
}
|
||||
|
||||
/**
|
||||
* Construct a date from a Dublin Core value
|
||||
*
|
||||
*
|
||||
* @param fromDC
|
||||
* the date string, in ISO 8601 (no timezone, always use UTC/GMT)
|
||||
*/
|
||||
public DCDate(String fromDC)
|
||||
{
|
||||
// Set all fields to unknown
|
||||
year = month = day = hours = minutes = seconds = -1;
|
||||
localGC = null;
|
||||
super();
|
||||
|
||||
// An empty date is OK
|
||||
if ((fromDC == null) || fromDC.equals(""))
|
||||
{
|
||||
return;
|
||||
}
|
||||
// default granularity
|
||||
granularity = DateGran.TIME;
|
||||
Date date = tryParse(fullIso, fromDC);
|
||||
if (date == null)
|
||||
date = tryParse(fullIso2, fromDC);
|
||||
if (date == null)
|
||||
date = tryParse(fullIso3, fromDC);
|
||||
if (date == null)
|
||||
{
|
||||
date = tryParse(dateIso, fromDC);
|
||||
granularity = DateGran.DAY;
|
||||
}
|
||||
if (date == null)
|
||||
{
|
||||
date = tryParse(yearMonthIso, fromDC);
|
||||
granularity = DateGran.MONTH;
|
||||
}
|
||||
if (date == null)
|
||||
{
|
||||
date = tryParse(yearIso, fromDC);
|
||||
granularity = DateGran.YEAR;
|
||||
}
|
||||
|
||||
if (date == null)
|
||||
log.warn("Mangled date: " + fromDC + " ..failed all attempts to parse as date.");
|
||||
else
|
||||
setTime(date);
|
||||
}
|
||||
|
||||
// Attempt to parse, swallowing errors; return null for failure.
|
||||
private synchronized Date tryParse(SimpleDateFormat sdf, String source)
|
||||
{
|
||||
try
|
||||
{
|
||||
|
||||
Matcher fullDateTimeMatcher = fullDateTimePattern.matcher(fromDC);
|
||||
Matcher dateMatcher = datePattern.matcher(fromDC);
|
||||
Matcher yearMonthMatcher = yearMonthPattern.matcher(fromDC);
|
||||
|
||||
if (fullDateTimeMatcher.matches())
|
||||
{
|
||||
year = Integer.parseInt(fullDateTimeMatcher.group(1));
|
||||
month = Integer.parseInt(fullDateTimeMatcher.group(2));
|
||||
day = Integer.parseInt(fullDateTimeMatcher.group(3));
|
||||
|
||||
hours = Integer.parseInt(fullDateTimeMatcher.group(4));
|
||||
minutes = Integer.parseInt(fullDateTimeMatcher.group(5));
|
||||
seconds = Integer.parseInt(fullDateTimeMatcher.group(6));
|
||||
|
||||
}
|
||||
else if (dateMatcher.matches())
|
||||
{
|
||||
year = Integer.parseInt(dateMatcher.group(1));
|
||||
month = Integer.parseInt(dateMatcher.group(2));
|
||||
day = Integer.parseInt(dateMatcher.group(3));
|
||||
}
|
||||
else if (yearMonthMatcher.matches())
|
||||
{
|
||||
year = Integer.parseInt(yearMonthMatcher.group(1));
|
||||
month = Integer.parseInt(yearMonthMatcher.group(2));
|
||||
}
|
||||
else
|
||||
{ // only the year
|
||||
year = Integer.parseInt(fromDC);
|
||||
}
|
||||
return sdf.parse(source);
|
||||
}
|
||||
catch (NumberFormatException e)
|
||||
catch (ParseException pe)
|
||||
{
|
||||
// Mangled date
|
||||
cat.warn("Mangled date: " + fromDC + " Exception: " + e);
|
||||
year = month = day = hours = minutes = seconds = -1;
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Construct a date object from a Java <code>Date</code> object.
|
||||
*
|
||||
* Set the time components to reflect the absolute time in this Date.
|
||||
*
|
||||
* @param date
|
||||
* the Java <code>Date</code> object.
|
||||
*/
|
||||
public DCDate(Date date)
|
||||
private void setTime(Date date)
|
||||
{
|
||||
Calendar calendar = Calendar.getInstance();
|
||||
|
||||
calendar = new GregorianCalendar(utcZone);
|
||||
calendar.setTime(date);
|
||||
|
||||
// Set all fields
|
||||
setDateLocal(calendar.get(Calendar.YEAR),
|
||||
|
||||
// Uses 1 to 12 implementation below instead of Java's
|
||||
// 0 to 11 convention
|
||||
calendar.get(Calendar.MONTH) + 1, calendar
|
||||
.get(Calendar.DAY_OF_MONTH), calendar
|
||||
.get(Calendar.HOUR_OF_DAY), calendar
|
||||
.get(Calendar.MINUTE), calendar.get(Calendar.SECOND));
|
||||
}
|
||||
|
||||
/**
|
||||
* Get a date representing the current instant in time.
|
||||
*
|
||||
*
|
||||
* @return a DSpaceDate object representing the current instant.
|
||||
*/
|
||||
public static DCDate getCurrent()
|
||||
@@ -217,105 +239,46 @@ public class DCDate
|
||||
|
||||
/**
|
||||
* Get the date as a string to put back in the Dublin Core
|
||||
*
|
||||
*
|
||||
* @return The date as a string.
|
||||
*/
|
||||
public String toString()
|
||||
{
|
||||
StringBuffer sb = new StringBuffer();
|
||||
if (calendar == null)
|
||||
return "null";
|
||||
return toStringInternal();
|
||||
}
|
||||
|
||||
if (year > 0)
|
||||
{
|
||||
sb.append(year);
|
||||
}
|
||||
|
||||
if (month > 0)
|
||||
{
|
||||
sb.append('-').append(fleshOut(month));
|
||||
}
|
||||
|
||||
if (day > 0)
|
||||
{
|
||||
sb.append('-').append(fleshOut(day));
|
||||
}
|
||||
|
||||
if (hours >= 0)
|
||||
{
|
||||
sb.append("T").append(fleshOut(hours)).append(':').append(
|
||||
fleshOut(minutes)).append(':').append(fleshOut(seconds))
|
||||
.append("Z");
|
||||
}
|
||||
|
||||
return (sb.toString());
|
||||
private synchronized String toStringInternal()
|
||||
{
|
||||
if (granularity == DateGran.YEAR)
|
||||
return yearIso.format(calendar.getTime());
|
||||
else if (granularity == DateGran.MONTH)
|
||||
return yearMonthIso.format(calendar.getTime());
|
||||
else if (granularity == DateGran.DAY)
|
||||
return dateIso.format(calendar.getTime());
|
||||
else
|
||||
return fullIso.format(calendar.getTime());
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the date as a Java Date object
|
||||
*
|
||||
*
|
||||
* @return a Date object
|
||||
*/
|
||||
public Date toDate()
|
||||
{
|
||||
int tmpmonth;
|
||||
int tmpday;
|
||||
int tmphours;
|
||||
int tmpmin;
|
||||
int tmpsec;
|
||||
|
||||
if (month < 0) {
|
||||
// Month is unknown and set to -1
|
||||
// but GregorianCalendar will interpret this as a rollback
|
||||
// to December of the previous year
|
||||
tmpmonth = 0;
|
||||
}
|
||||
else {
|
||||
// Month is known, but GC calendar is 0 - 11, not 1 - 12
|
||||
// so we'll do subtraction here
|
||||
tmpmonth = month - 1;
|
||||
}
|
||||
|
||||
if (day < 0) {
|
||||
tmpday = 1;
|
||||
}
|
||||
else {
|
||||
tmpday = day;
|
||||
}
|
||||
|
||||
if (hours < 0) {
|
||||
tmphours = 0;
|
||||
}
|
||||
else {
|
||||
tmphours = hours;
|
||||
}
|
||||
|
||||
if (minutes < 0) {
|
||||
tmpmin = 0;
|
||||
}
|
||||
else {
|
||||
tmpmin = minutes;
|
||||
}
|
||||
|
||||
if (seconds < 0) {
|
||||
tmpsec = 0;
|
||||
}
|
||||
else {
|
||||
tmpsec = seconds;
|
||||
}
|
||||
|
||||
GregorianCalendar utcGC = new GregorianCalendar(TimeZone
|
||||
.getTimeZone("UTC"));
|
||||
|
||||
utcGC.set(year, tmpmonth, tmpday, tmphours, tmpmin, tmpsec);
|
||||
|
||||
return utcGC.getTime();
|
||||
|
||||
if (calendar == null)
|
||||
return null;
|
||||
else
|
||||
return calendar.getTime();
|
||||
}
|
||||
|
||||
/**
|
||||
* Set the date. The date passed in is assumed to be in the current time
|
||||
* zone, and is adjusting to fit the current time zone. Unknown values
|
||||
* should be given as -1.
|
||||
*
|
||||
*
|
||||
* @param yyyy
|
||||
* the year
|
||||
* @param mm
|
||||
@@ -331,248 +294,191 @@ public class DCDate
|
||||
*/
|
||||
public void setDateLocal(int yyyy, int mm, int dd, int hh, int mn, int ss)
|
||||
{
|
||||
year = month = day = hours = minutes = seconds = -1;
|
||||
// default values
|
||||
int lyear = 0;
|
||||
int lhours = 0;
|
||||
int lminutes = 0;
|
||||
int lseconds = 0;
|
||||
int lmonth = 1;
|
||||
int lday = 1;
|
||||
|
||||
if (yyyy > 0)
|
||||
{
|
||||
year = yyyy;
|
||||
lyear = yyyy;
|
||||
granularity = DateGran.YEAR;
|
||||
}
|
||||
else
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
if (mm > 0)
|
||||
{
|
||||
month = mm;
|
||||
lmonth = mm;
|
||||
granularity = DateGran.MONTH;
|
||||
}
|
||||
else
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
if (dd > 0)
|
||||
{
|
||||
day = dd;
|
||||
lday = dd;
|
||||
granularity = DateGran.DAY;
|
||||
}
|
||||
else
|
||||
if (hh >= 0)
|
||||
{
|
||||
return;
|
||||
lhours = hh;
|
||||
granularity = DateGran.TIME;
|
||||
}
|
||||
|
||||
if (hh == -1)
|
||||
if (mn >= 0)
|
||||
{
|
||||
return;
|
||||
lminutes = mn;
|
||||
granularity = DateGran.TIME;
|
||||
}
|
||||
if (ss >= 0)
|
||||
{
|
||||
lseconds = ss;
|
||||
granularity = DateGran.TIME;
|
||||
}
|
||||
|
||||
// We have a time, so we need to do a timezone adjustment
|
||||
localGC = new GregorianCalendar(year, month - 1, day, hh, mn, ss);
|
||||
|
||||
// Adjust to UTC
|
||||
GregorianCalendar utcGC = new GregorianCalendar(TimeZone
|
||||
.getTimeZone("UTC"));
|
||||
|
||||
utcGC.setTime(localGC.getTime());
|
||||
|
||||
year = utcGC.get(Calendar.YEAR);
|
||||
|
||||
// Notation
|
||||
month = utcGC.get(Calendar.MONTH) + 1;
|
||||
day = utcGC.get(Calendar.DAY_OF_MONTH);
|
||||
hours = utcGC.get(Calendar.HOUR_OF_DAY);
|
||||
minutes = utcGC.get(Calendar.MINUTE);
|
||||
seconds = utcGC.get(Calendar.SECOND);
|
||||
// do the timezone adjustment: get Date and put it in UTC zone.
|
||||
GregorianCalendar localGC = new GregorianCalendar(lyear, lmonth - 1, lday,
|
||||
lhours, lminutes, lseconds);
|
||||
setTime(localGC.getTime());
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the date as an array of ints, adjusted for the current timezone
|
||||
*
|
||||
* @return the date an an array: ( year, month, day, hour, minute, seconds) -
|
||||
* unset fields are given a value of -1.
|
||||
*/
|
||||
private int[] getDateLocal()
|
||||
// get cached calendar in local timezone
|
||||
private GregorianCalendar getLocalCalendar()
|
||||
{
|
||||
// Handle simple date cases first - no timezone adjustment
|
||||
if (hours == -1)
|
||||
if (localCalendar == null)
|
||||
{
|
||||
return new int[] { year, month, day, -1, -1, -1 };
|
||||
if (calendar == null)
|
||||
return null;
|
||||
localCalendar = new GregorianCalendar();
|
||||
localCalendar.setTime(calendar.getTime());
|
||||
}
|
||||
|
||||
// We have a full time, adjust to current timezone
|
||||
if (localGC == null)
|
||||
{
|
||||
GregorianCalendar utcGC = new GregorianCalendar(TimeZone
|
||||
.getTimeZone("UTC"));
|
||||
|
||||
utcGC.set(year, month - 1, day, hours, minutes, seconds);
|
||||
localGC = new GregorianCalendar();
|
||||
localGC.setTime(utcGC.getTime());
|
||||
}
|
||||
|
||||
return new int[] { localGC.get(Calendar.YEAR),
|
||||
localGC.get(Calendar.MONTH) + 1,
|
||||
localGC.get(Calendar.DAY_OF_MONTH),
|
||||
localGC.get(Calendar.HOUR_OF_DAY),
|
||||
localGC.get(Calendar.MINUTE), localGC.get(Calendar.SECOND) };
|
||||
return localCalendar;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the year, adjusting for current time zone.
|
||||
*
|
||||
*
|
||||
* @return the year
|
||||
*/
|
||||
public int getYear()
|
||||
{
|
||||
return (getDateLocal())[0];
|
||||
return getLocalCalendar() == null ? -1 : localCalendar.get(Calendar.YEAR);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Get the month, adjusting for current time zone.
|
||||
*
|
||||
*
|
||||
* @return the month
|
||||
*/
|
||||
public int getMonth()
|
||||
{
|
||||
return (getDateLocal())[1];
|
||||
return getLocalCalendar() == null ? -1 : localCalendar.get(Calendar.MONTH) + 1;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the day, adjusting for current time zone.
|
||||
*
|
||||
*
|
||||
* @return the day
|
||||
*/
|
||||
public int getDay()
|
||||
{
|
||||
return (getDateLocal())[2];
|
||||
return getLocalCalendar() == null ? -1 : localCalendar.get(Calendar.DAY_OF_MONTH);
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the hour, adjusting for current time zone.
|
||||
*
|
||||
*
|
||||
* @return the hour
|
||||
*/
|
||||
public int getHour()
|
||||
{
|
||||
return (getDateLocal())[3];
|
||||
return getLocalCalendar() == null ? -1 : localCalendar.get(Calendar.HOUR_OF_DAY);
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the minute, adjusting for current time zone.
|
||||
*
|
||||
*
|
||||
* @return the minute
|
||||
*/
|
||||
public int getMinute()
|
||||
{
|
||||
return (getDateLocal())[4];
|
||||
return getLocalCalendar() == null ? -1 : localCalendar.get(Calendar.MINUTE);
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the second, adjusting for current time zone.
|
||||
*
|
||||
*
|
||||
* @return the second
|
||||
*/
|
||||
public int getSecond()
|
||||
{
|
||||
return (getDateLocal())[5];
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the date as an array of ints in GMT
|
||||
*
|
||||
* @return the date an an array: ( year, month, day, hour, minute, seconds) -
|
||||
* unset fields are given a value of -1.
|
||||
*/
|
||||
private int[] getDateGMT()
|
||||
{
|
||||
return new int[] { year, month, day, hours, minutes, seconds };
|
||||
return getLocalCalendar() == null ? -1 : localCalendar.get(Calendar.SECOND);
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the year in GMT.
|
||||
*
|
||||
*
|
||||
* @return the year
|
||||
*/
|
||||
public int getYearGMT()
|
||||
{
|
||||
return (getDateGMT())[0];
|
||||
return calendar == null ? -1 : calendar.get(Calendar.YEAR);
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the month in GMT.
|
||||
*
|
||||
*
|
||||
* @return the month
|
||||
*/
|
||||
public int getMonthGMT()
|
||||
{
|
||||
return (getDateGMT())[1];
|
||||
return calendar == null ? -1 : calendar.get(Calendar.MONTH) + 1;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the day in GMT.
|
||||
*
|
||||
*
|
||||
* @return the day
|
||||
*/
|
||||
public int getDayGMT()
|
||||
{
|
||||
return (getDateGMT())[2];
|
||||
return calendar == null ? -1 : calendar.get(Calendar.DAY_OF_MONTH);
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the hour in GMT.
|
||||
*
|
||||
*
|
||||
* @return the hour
|
||||
*/
|
||||
public int getHourGMT()
|
||||
{
|
||||
return (getDateGMT())[3];
|
||||
return calendar == null ? -1 : calendar.get(Calendar.HOUR_OF_DAY);
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the minute in GMT.
|
||||
*
|
||||
*
|
||||
* @return the minute
|
||||
*/
|
||||
public int getMinuteGMT()
|
||||
{
|
||||
return (getDateGMT())[4];
|
||||
return calendar == null ? -1 : calendar.get(Calendar.MINUTE);
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the second in GMT.
|
||||
*
|
||||
*
|
||||
* @return the second
|
||||
*/
|
||||
public int getSecondGMT()
|
||||
{
|
||||
return (getDateGMT())[5];
|
||||
}
|
||||
|
||||
/**
|
||||
* Flesh out a number to two digits
|
||||
*
|
||||
* @param n
|
||||
* the number
|
||||
* @return the number as a two-digit string
|
||||
*/
|
||||
private String fleshOut(int n)
|
||||
{
|
||||
if (n < 10)
|
||||
{
|
||||
return "0" + n;
|
||||
}
|
||||
else
|
||||
{
|
||||
return String.valueOf(n);
|
||||
}
|
||||
return calendar == null ? -1 : calendar.get(Calendar.SECOND);
|
||||
}
|
||||
|
||||
/**
|
||||
* Get a month's name for a month between 1 and 12. Any invalid month value
|
||||
* (e.g. 0 or -1) will return a value of "Unspecified".
|
||||
*
|
||||
*
|
||||
* @param m
|
||||
* the month number
|
||||
*
|
||||
*
|
||||
* @return the month name.
|
||||
*/
|
||||
public static String getMonthName(int m, Locale locale)
|
||||
@@ -580,16 +486,74 @@ public class DCDate
|
||||
if ((m > 0) && (m < 13))
|
||||
{
|
||||
if (dfs == null || !langMonth.equals(locale))
|
||||
{
|
||||
dfs = new DateFormatSymbols(locale);
|
||||
langMonth = locale;
|
||||
}
|
||||
{
|
||||
dfs = new DateFormatSymbols(locale);
|
||||
langMonth = locale;
|
||||
}
|
||||
return dfs.getMonths()[m-1];
|
||||
}
|
||||
else
|
||||
{
|
||||
return "Unspecified";
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
/**
|
||||
* Simple test program
|
||||
* Usage: java org.dspace.content.DCdate [DCDate | -l yyyy [mm [dd ..]]] ]
|
||||
* (-l form tests local time parsing)
|
||||
* Default is to use current time.
|
||||
*/
|
||||
public static void main(String args[])
|
||||
throws Exception
|
||||
{
|
||||
DCDate d;
|
||||
|
||||
// if there's an arg, parse it for the date, otherwise use now
|
||||
if (args.length > 0)
|
||||
{
|
||||
if (args[0].equals("-l"))
|
||||
{
|
||||
int val[] = { -1, -1, -1, -1, -1, -1 };
|
||||
for (int i = 1; i < 7 && i < args.length; ++i)
|
||||
val[i-1] = Integer.parseInt(args[i]);
|
||||
d = new DCDate();
|
||||
d.setDateLocal(val[0], val[1], val[2], val[3], val[4], val[5]);
|
||||
}
|
||||
else
|
||||
d = new DCDate(args[0]);
|
||||
}
|
||||
else
|
||||
d = DCDate.getCurrent();
|
||||
|
||||
// display results:
|
||||
System.out.println("toString() = \""+d.toString()+"\"");
|
||||
System.out.println("toDate().toString() = \""+d.toDate().toString()+"\"");
|
||||
|
||||
System.out.println("By component:");
|
||||
System.out.println("granularity = "+d.granularity);
|
||||
System.out.println("getYear(), = "+d.getYear());
|
||||
System.out.println("getMonth(), = "+d.getMonth());
|
||||
System.out.println("getDay(), = "+d.getDay());
|
||||
System.out.println("getHour(), = "+d.getHour());
|
||||
System.out.println("getMinute(), = "+d.getMinute());
|
||||
System.out.println("getSecond()); = "+d.getSecond());
|
||||
System.out.println("By GMT component:");
|
||||
System.out.println("getYearGMT(), = "+d.getYearGMT());
|
||||
System.out.println("getMonthGMT(), = "+d.getMonthGMT());
|
||||
System.out.println("getDayGMT(), = "+d.getDayGMT());
|
||||
System.out.println("getHourGMT(), = "+d.getHourGMT());
|
||||
System.out.println("getMinuteGMT(), = "+d.getMinuteGMT());
|
||||
System.out.println("getSecondGMT()); = "+d.getSecondGMT());
|
||||
|
||||
// convert it the hard way:
|
||||
DCDate hw = new DCDate();
|
||||
hw.setDateLocal(d.getYear(),d.getMonth(),d.getDay(),
|
||||
d.getHour(),d.getMinute(),d.getSecond());
|
||||
System.out.println("hardway.toString() = \""+hw.toString()+"\"");
|
||||
|
||||
// month str
|
||||
System.out.println("Month Name = \""+DCDate.getMonthName(d.getMonth(), Locale.getDefault())+"\"");
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user