src.com.ibm.as400.access.DateTimeConverter Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of jt400 Show documentation
Show all versions of jt400 Show documentation
The Open Source version of the IBM Toolbox for Java
///////////////////////////////////////////////////////////////////////////////
//
// JTOpen (IBM Toolbox for Java - OSS version)
//
// Filename: DateTimeConverter.java
//
// The source code contained herein is licensed under the IBM Public License
// Version 1.0, which has been approved by the Open Source Initiative.
// Copyright (C) 1997-2004 International Business Machines Corporation and
// others. All rights reserved.
//
///////////////////////////////////////////////////////////////////////////////
// 2008-05-21 @A1 Changes for *CURRENT when returning Date objects. Adjust the
// AS400 system time to the local client time.
///////////////////////////////////////////////////////////////////////////////
package com.ibm.as400.access;
import java.beans.PropertyVetoException;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.util.Calendar;
import java.util.Date;
import java.util.Hashtable; //@CAA
import java.util.TimeZone; //@A1A
/**
A utility for converting date/time values.
The system API QWCCVTDT is used to convert a date and time value
from one format to another format.
@see AS400Date
@see AS400Time
@see AS400Timestamp
**/
public class DateTimeConverter
{
private AS400 system_;
private ProgramCall program_;
private AS400Text text10_;
private Calendar calendar_;
//private Calendar calendarGMT_;
private DateTime17Format format17_;
//private DateTime16Format format16_;
private TimeZone systemTimeZone_; // the time zone for the IBM i server
/**
* Constructs a DateTimeConverter object.
* @param system The system.
**/
public DateTimeConverter(AS400 system)
{
if (system == null)
throw new NullPointerException("system");
system_ = system;
program_ = new ProgramCall(system_);
text10_ = new AS400Text(10, system_.getCcsid(), system_);
///format17_ = new DateTime17Format(system_);
//format16_ = new DateTime16Format(system_);
}
/**
* Converts date and time values from the input format to the requested output format.
* The system API QWCCVTDT (Convert Date and Time Format) is called to perform the conversion.
* This method effectively just re-arranges the time format and returns it.
* The input and output values are relative to the same time zone.
* Therefore, no adjustments are made based on time-zone.
*
* @param data The date and time value to be converted.
* @param inFormat The input date and time format.
* Possible values are:
- *CURRENT
- *DTS
- *JOB
- *SYSVAL
- *YMD
- *YYMD
- *MDY
- *MDYY
- *DMY
- *DMYY
- *JUL
- *LONGJUL
* @param outFormat The output date and time format.
* Possible values are:
- *DTS
- *JOB
- *SYSVAL
- *YMD
- *YYMD
- *MDY
- *MDYY
- *DMY
- *DMYY
- *JUL
- *LONGJUL
- *DOS
* @return The converted date and time value, left-justified in the array.
* Refer to the specification for the QWCCVTDT API to determine how many of the
* returned bytes are meaningful.
*
* @exception AS400SecurityException If a security or authority error
* occurs.
* @exception ErrorCompletingRequestException If an error occurs before
* the request is completed.
* @exception InterruptedException If this thread is interrupted.
* @exception IOException If an error occurs while communicating with
* the system.
* @exception ObjectDoesNotExistException If the object does not exist on the system.
**/
public byte[] convert(byte[] data, String inFormat, String outFormat)
throws AS400SecurityException,
ErrorCompletingRequestException,
InterruptedException,
IOException,
ObjectDoesNotExistException
{
return convert(data, inFormat, outFormat, null);
}
private byte[] convert(byte[] data, String inFormat, String outFormat, String timezone)
throws AS400SecurityException,
ErrorCompletingRequestException,
InterruptedException,
IOException,
ObjectDoesNotExistException
{
if (data == null) throw new NullPointerException("data");
if (inFormat == null) throw new NullPointerException("inFormat");
if (outFormat == null) throw new NullPointerException("outFormat");
// Set up the parameters.
// Design note: We don't need to use the optional parms, since we're not converting between different time zones.
ProgramParameter[] parmList;
if (timezone == null) {
parmList = new ProgramParameter[5];
setRequiredParameters(parmList, data, inFormat, outFormat);
}
else {
parmList = new ProgramParameter[10];
setRequiredParameters(parmList, data, inFormat, outFormat);
setOptionalParameters(parmList, timezone);
}
// Set the program name and parameter list
try
{
program_.setProgram("/QSYS.LIB/QWCCVTDT.PGM", parmList);
}
catch(PropertyVetoException pve) {} // Quiet the compiler
program_.suggestThreadsafe(); //@A2A
// Run the program
if (!program_.run())
{
// Note that there was an error
Trace.log(Trace.ERROR, "DateTimeConverter call to QWCCVTDT failed.");
// Show the messages
AS400Message[] messageList = program_.getMessageList();
for (int i=0; iQWCCVTDT (Convert Date and Time Format) is called to perform the conversion.
* @param data The date and time value to be converted.
* The value is assumed to be relative to the IBM i system's time zone.
* @param inFormat The format of the date and time value being provided.
* Possible values are:
- *CURRENT
- *DTS
- *JOB
- *SYSVAL
- *YMD
- *YYMD
- *MDY
- *MDYY
- *DMY
- *DMYY
- *JUL
- *LONGJUL
* Note: When *CURRENT is specified, the data parameter is disregarded.
* @return The converted date and time.
* @exception AS400SecurityException If a security or authority error
* occurs.
* @exception ErrorCompletingRequestException If an error occurs before
* the request is completed.
* @exception InterruptedException If this thread is interrupted.
* @exception IOException If an error occurs while communicating with
* the system.
* @exception ObjectDoesNotExistException If the object does not exist on the system.
**/
public Date convert(byte[] data, String inFormat)
throws AS400SecurityException,
ErrorCompletingRequestException,
InterruptedException,
IOException,
ObjectDoesNotExistException
{
if (data == null) throw new NullPointerException("data");
if (inFormat == null) throw new NullPointerException("inFormat");
// Use output format *YYMD which gives us a full Date: YYYYMMDD.
byte[] converted = convert(data, inFormat, "*YYMD", null); // call QWCCVTDT
Record rec = getFormat17().getNewRecord(converted);
if (Trace.traceOn_)
{
Trace.log(Trace.DIAGNOSTIC, "DateTimeConverter record parsed from bytes: "+rec.toString());
}
Calendar calendar = getCalendar();
calendar.set(Integer.parseInt(((String)rec.getField("year")).trim()),
Integer.parseInt(((String)rec.getField("month")).trim())-1,
Integer.parseInt(((String)rec.getField("day")).trim()),
Integer.parseInt(((String)rec.getField("hour")).trim()),
Integer.parseInt(((String)rec.getField("minute")).trim()),
Integer.parseInt(((String)rec.getField("second")).trim()));
calendar.set(Calendar.MILLISECOND, Integer.parseInt(((String)rec.getField("millisecond")).trim()));
return calendar.getTime();
}
// For testing and/or future enhancement:
// /**
// * Returns a converted Date object, relative to the GMT time zone.
// * The system API QWCCVTDT (Convert Date and Time Format) is called to perform the conversion.
// * @param data The date and time value to be converted.
// * The value is assumed to be relative to the IBM i system's time zone.
// * @param inFormat The format of the date and time value being provided.
// * Possible values are:
//
// - *CURRENT
//
- *DTS
//
- *JOB
//
- *SYSVAL
//
- *YMD
//
- *YYMD
//
- *MDY
//
- *MDYY
//
- *DMY
//
- *DMYY
//
- *JUL
//
- *LONGJUL
//
// * Note: When *CURRENT is specified, the data parameter is disregarded.
// * @return The converted date and time.
// * @exception AS400SecurityException If a security or authority error
// * occurs.
// * @exception ErrorCompletingRequestException If an error occurs before
// * the request is completed.
// * @exception InterruptedException If this thread is interrupted.
// * @exception IOException If an error occurs while communicating with
// * the system.
// * @exception ObjectDoesNotExistException If the object does not exist on the system.
// **/
// public Date convertGMT(byte[] data, String inFormat)
// throws AS400SecurityException,
// ErrorCompletingRequestException,
// InterruptedException,
// IOException,
// ObjectDoesNotExistException
// {
// if (data == null) throw new NullPointerException("data");
// if (inFormat == null) throw new NullPointerException("inFormat");
//
// // Use output format *YYMD which gives us a full Date: YYYYMMDD.
// byte[] converted = convert(data, inFormat, "*YYMD", "*UTC"); // call QWCCVTDT
// Record rec = getFormat17().getNewRecord(converted);
//
// if (Trace.traceOn_)
// {
// Trace.log(Trace.DIAGNOSTIC, "DateTimeConverter record parsed from bytes: "+rec.toString());
// }
//
// Calendar calendar = getCalendarGMT();
// calendar.set(Integer.parseInt(((String)rec.getField("year")).trim()),
// Integer.parseInt(((String)rec.getField("month")).trim())-1,
// Integer.parseInt(((String)rec.getField("day")).trim()),
// Integer.parseInt(((String)rec.getField("hour")).trim()),
// Integer.parseInt(((String)rec.getField("minute")).trim()),
// Integer.parseInt(((String)rec.getField("second")).trim()));
// calendar.set(Calendar.MILLISECOND, Integer.parseInt(((String)rec.getField("millisecond")).trim()));
//
// return calendar.getTime();
// }
/**
* Returns the converted date and time in a byte array.
* @param date The Date object to be converted.
* @param outFormat The format of the returned date and time value.
* Possible values are:
- *DTS
- *JOB
- *SYSVAL
- *YMD
- *YYMD
- *MDY
- *MDYY
- *DMY
- *DMYY
- *JUL
- *LONGJUL
* @return The converted date and time value, left-justified in the array.
* The context of the value is the IBM i system's time zone.
* Refer to the specification for the QWCCVTDT API to determine how many of the
* returned bytes are meaningful.
*
* @exception AS400SecurityException If a security or authority error
* occurs.
* @exception ErrorCompletingRequestException If an error occurs before
* the request is completed.
* @exception InterruptedException If this thread is interrupted.
* @exception IOException If an error occurs while communicating with
* the system.
* @exception ObjectDoesNotExistException If the object does not exist on the system.
**/
public byte[] convert(Date date, String outFormat)
throws AS400SecurityException,
ErrorCompletingRequestException,
InterruptedException,
IOException,
ObjectDoesNotExistException
{
if (date == null) throw new NullPointerException("date");
if (outFormat == null) throw new NullPointerException("outFormat");
byte[] data = dateToBytes(date);
return convert(data, "*YYMD", outFormat, null);
}
// For testing and/or future enhancement:
// /**
// * Returns the converted date and time in a byte array, relative to the GMT time zone.
// * @param date The Date object to be converted.
// * @param outFormat The format of the returned date and time value.
// * Possible values are:
//
// - *DTS
//
- *JOB
//
- *SYSVAL
//
- *YMD
//
- *YYMD
//
- *MDY
//
- *MDYY
//
- *DMY
//
- *DMYY
//
- *JUL
//
- *LONGJUL
//
// * @return The converted date and time value, left-justified in the array.
// * The context of the value is the GMT time zone.
// * Refer to the specification for the QWCCVTDT API to determine how many of the
// * returned bytes are meaningful.
// *
// * @exception AS400SecurityException If a security or authority error
// * occurs.
// * @exception ErrorCompletingRequestException If an error occurs before
// * the request is completed.
// * @exception InterruptedException If this thread is interrupted.
// * @exception IOException If an error occurs while communicating with
// * the system.
// * @exception ObjectDoesNotExistException If the object does not exist on the system.
// **/
// public byte[] convertGMT(Date date, String outFormat)
// throws AS400SecurityException,
// ErrorCompletingRequestException,
// InterruptedException,
// IOException,
// ObjectDoesNotExistException
// {
// if (date == null) throw new NullPointerException("date");
// if (outFormat == null) throw new NullPointerException("outFormat");
//
// byte[] data = dateToBytes(date);
// return convert(data, "*YYMD", outFormat, "*UTC"); // "*UTC" == GMT timezone
// }
// Converts a Date value to an IBM i byte sequence in *YYMD format.
private byte[] dateToBytes(Date date)
throws AS400SecurityException,
ErrorCompletingRequestException,
InterruptedException,
IOException,
ObjectDoesNotExistException
{
Calendar calendar = getCalendar();
calendar.setTime(date);
// Start with *YYMD for conversion. Seems like a good format to use.
Record rec = getFormat17().getNewRecord();
rec.setField("year", Integer.toString(calendar.get(Calendar.YEAR)));
// Need to pad each number with 0s if necessary, so it will fill the format
int month = calendar.get(Calendar.MONTH)+1;
String monthStr = (month < 10 ? "0" : "") + month;
rec.setField("month", monthStr);
int day = calendar.get(Calendar.DAY_OF_MONTH);
String dayStr = (day < 10 ? "0" : "") + day;
rec.setField("day", dayStr);
int hour = calendar.get(Calendar.HOUR_OF_DAY);
String hourStr = (hour < 10 ? "0" : "") + hour;
rec.setField("hour", hourStr);
int minute = calendar.get(Calendar.MINUTE);
String minuteStr = (minute < 10 ? "0" : "") + minute;
rec.setField("minute", minuteStr);
int second = calendar.get(Calendar.SECOND);
String secondStr = (second < 10 ? "0" : "") + second;
rec.setField("second", secondStr);
int ms = calendar.get(Calendar.MILLISECOND);
String msStr = (ms < 100 ? "0" : "") + (ms < 10 ? "0" : "") + ms;
rec.setField("millisecond", msStr);
if (Trace.traceOn_)
{
Trace.log(Trace.DIAGNOSTIC, "DateTimeConverter record parsed from Date: "+rec.toString());
}
return rec.getContents();
}
// Utility method.
// Returns a Calendar object for the current system, set to the IBM i system's time zone.
private final Calendar getCalendar()
throws AS400SecurityException,
ErrorCompletingRequestException,
InterruptedException,
IOException,
ObjectDoesNotExistException
{
if (calendar_ == null) {
// Create a Calendar object, based in the system's time zone.
calendar_ = AS400Calendar.getGregorianInstance(getSystemTimeZone());
}
else calendar_.clear();
return calendar_;
}
// For testing and/or future enhancement:
// // Utility method.
// // Returns a Calendar object set to the GMT time zone.
// private final Calendar getCalendarGMT()
// {
// if (calendarGMT_ == null) {
// // Create a Calendar object, based in the GMT time zone.
// calendarGMT_ = AS400Calendar.getGregorianInstance(TimeZone.getTimeZone("GMT-0"));
// }
// else calendarGMT_.clear();
// return calendarGMT_;
// }
// Utility method.
private synchronized DateTime17Format getFormat17()
{
if (format17_ == null) {
format17_ = new DateTime17Format(system_);
}
return format17_;
}
/**
* Returns a TimeZone object to represent the time zone for the system.
* The TimeZone object will have the correct UTC offset for the system.
* @return A TimeZone object representing the system's configured time zone setting.
* @exception AS400SecurityException If a security or authority error
* occurs.
* @exception ErrorCompletingRequestException If an error occurs before
* the request is completed.
* @exception InterruptedException If this thread is interrupted.
* @exception IOException If an error occurs while communicating with
* the system.
* @exception ObjectDoesNotExistException If the API used to retrieve the information does not exist on the system.
**/
final TimeZone getSystemTimeZone()
throws AS400SecurityException,
ErrorCompletingRequestException,
InterruptedException,
IOException,
ObjectDoesNotExistException
{
if (systemTimeZone_ == null) {
systemTimeZone_ = timeZoneForSystem(system_);
}
return systemTimeZone_;
}
//
// These are the values shipped with the system.
// See http://publib.boulder.ibm.com/infocenter/iseries/v7r1m0/index.jsp?topic=/rzati/rzatitimezone.htm
// @CAA
static String iTimeZoneTojavaTimeZoneMapping[][] = {
{"Q0000UTC","UTC"},
{"Q0000GMT","GMT"},
{"Q0000GMT2","Europe/London"},
{"Q000GMT3","Europe/London"},
{"QN0100UTCS","GMT-1"},
{"QN0200UTCS","GMT-2"},
{"QN0300UTCS","GMT-3"},
{"QN0300UTC2","America/Sao_Paulo"},
{"QN0330NST","America/St_Johns"},
{"QN0330NST2","America/St_Johns"},
{"QN0330NST3","America/St_Johns"},
{"QN0330NST4","America/St_Johns"},
{"QN0400UTCS","GMT-4"},
{"QN0400AST","Atlantic/Bermuda"},
{"QN0400AST2","Atlantic/Bermuda"},
{"QN0400CLT","America/Santiago"},
{"QN0400UTC2","America/Caracas"},
{"QN0500UTCS","GMT-5"},
{"QN0500EST","America/New_York"},
{"QN0500EST2","GMT-5"},
{"QN0500EST3","America/New_York"},
{"QN0600UTCS","GMT-6"},
{"QN0600CST","America/Chicago"},
{"QN0600CST2","America/Chicago"},
{"QN0600CST3","America/Mexico_City"},
{"QN0600S","America/Chicago"},
{"QN0700UTCS","GMT-7"},
{"QN0700MST","America/Denver"},
{"QN0700MST2","America/Phoenix"},
{"QN0700MST3","America/Denver"},
{"QN0700MST4","America/Mazatlan"},
{"QN0700T","America/Denver"},
{"QN0800UTCS","GMT-8"},
{"QN0800PST","America/Los_Angeles"},
{"QN0800PST2","America/Los_Angeles"},
{"QN0800PST3","America/Tijuana"},
{"QN0800U","America/Los_Angeles"},
{"QN0900UTCS","GMT-9"},
{"QN0900AST","America/Anchorage"},
{"QN0900AST2","America/Anchorage"},
{"QN1000UTCS","GMT-10"},
{"QN1000HAST","America/Adak"},
{"QN1000HAS2","America/Adak"},
{"QN1000HST","Pacific/Honolulu"},
{"QN1100UTCS","GMT-11"},
{"QN1200UTCS","GMT-12"},
{"QP1245UTCS","Pacific/Chatham"},
{"QP1245UTC2","Pacific/Chatham"},
{"QP1200UTCS","GMT+12"},
{"QP1200NZST","Pacific/Auckland"},
{"QP1200NZS2","Pacific/Auckland"},
{"QP1200NZS3","Pacific/Auckland"},
{"QP1100UTCS","GMT+11"},
{"QP1000UTCS","GMT+10"},
{"QP1000AEST","Australia/Sydney"},
{"QP1000AES2","Australia/Sydney"},
{"QP0930ACST","Australia/Adelaide"},
{"QP0930ACS2","Australia/Adelaide"},
{"QP0900UTCS","GMT+9"},
{"QP0900JST","Asia/Tokyo"},
{"QP0900KST","Asia/Seoul"},
{"QP0900WIT","Asia/Jayapura"},
{"QP0800UTCS","GMT+8"},
{"QP0800AWST","Australia/Perth"},
{"QP0800AWS2","Australia/Perth"},
{"QP0800AWS3","Australia/Perth"},
{"QP0800BST","Asia/Shanghai"},
{"QP0800JIST","Asia/Hong_Kong"},
{"QP0800WITA","Asia/Ujung_Pandang"},
{"QP0700UTCS","GMT+7"},
{"QP0700WIB","Asia/Jakarta"},
{"QP0600UTCS","GMT+6"},
{"QP0600UTC2","Asia/Almaty"},
{"QP0600UTC3","Asia/Almaty"},
{"QP0530IST","Asia/Calcutta"},
{"QP0500UTCS","GMT+5"},
{"QP0500UTC2","Asia/Aqtobe"},
{"QP0500UTC3","Asia/Aqtobe"},
{"QP0400UTCS","GMT+4"},
{"QP0400UTC2","Asia/Aqtau"},
{"QP0400UTC3","Asia/Aqtau"},
{"QP0300MSK","Europe/Moscow"},
{"QP0300UTCS","GMT+3"},
{"QP0200UTCS","GMT+2"},
{"QP0200EET","Europe/Tallinn"},
{"QP0200EET2","GMT+2"},
{"QP0200EET3","Europe/Tallinn"},
{"QP0200SAST","Africa/Johannesburg"},
{"QP0100UTCS","GMT+1"},
{"QP0100CET","Europe/Zurich"},
{"QP0100CET2","Europe/Zurich"},
{"QP0100CET3","Europe/Zurich"},
{"QP0100CET4","Europe/Zurich"},
};
static Hashtable iTimeZoneToJavaTimeZoneHash = null;
/**
* Returns the name of the java timezone corresponding to the IBM i timezone.
*/
static String iTimeZoneToJavaTimeZone(String iTimeZone) {
iTimeZone = iTimeZone.toUpperCase();
synchronized(iTimeZoneTojavaTimeZoneMapping) {
if (iTimeZoneToJavaTimeZoneHash == null) {
iTimeZoneToJavaTimeZoneHash = new Hashtable();
for (int i = 0; i < iTimeZoneTojavaTimeZoneMapping.length; i++) {
iTimeZoneToJavaTimeZoneHash.put(iTimeZoneTojavaTimeZoneMapping[i][0],iTimeZoneTojavaTimeZoneMapping[i][1]);
}
}
}
return (String) iTimeZoneToJavaTimeZoneHash.get(iTimeZone);
}
/**
* Returns a TimeZone object to represent the time zone for the specified system.
* The TimeZone object will have the correct UTC offset for the system.
* @param system The IBM i system.
* @return A TimeZone object representing the time zone for the system.
* @exception AS400SecurityException If a security or authority error
* occurs.
* @exception ErrorCompletingRequestException If an error occurs before
* the request is completed.
* @exception InterruptedException If this thread is interrupted.
* @exception IOException If an error occurs while communicating with
* the system.
* @exception ObjectDoesNotExistException If the API used to retrieve the information does not exist on the system.
* @see AS400#getTimeZone()
**/
public static TimeZone timeZoneForSystem(AS400 system)
throws AS400SecurityException,
ErrorCompletingRequestException,
InterruptedException,
IOException,
ObjectDoesNotExistException
{
// Using the UTC offset does not properly account for the use of daylight savings time. We use
// the QTIMZON value to adjust for those areas that use daylight savings time.
//
try {
SystemValue sv = new SystemValue(system, "QTIMZON");
String iTimeZone = ((String)sv.getValue()).trim(); // returns a value such as "-0500" @7XC
String javaTimeZoneName = iTimeZoneToJavaTimeZone(iTimeZone);
if (javaTimeZoneName != null) {
return TimeZone.getTimeZone(javaTimeZoneName);
}
} catch (Exception e) {
// Log the exception and continue
Trace.log(Trace.ERROR, e);
}
// If the new method does not work, fall back to the old method of getting the timezone.
// To obtain a standard ID for the time zone, simply concatenate "GMT" and the QUTCOFFSET value.
String utcOffset = null;
try
{
SystemValue sv = new SystemValue(system, "QUTCOFFSET");
utcOffset = (String)sv.getValue(); // returns a value such as "-0500"
if (utcOffset == null || utcOffset.length() == 0)
{
if (Trace.traceOn_) {
Trace.log(Trace.DIAGNOSTIC, "QUTCOFFSET is not set. Assuming server is in the same time zone as client application.");
}
return TimeZone.getDefault();
}
else return TimeZone.getTimeZone("GMT" + utcOffset);
}
catch (RequestNotSupportedException e) // this won't happen
{ // ... but if it does happen, trace it and rethrow as a runtime exception
Trace.log(Trace.ERROR, e);
throw new InternalErrorException(InternalErrorException.UNEXPECTED_EXCEPTION, e);
}
catch (RuntimeException e)
{
// Note: We've observed the following error during testing:
// java.lang.NullPointerException at java.util.TimeZone.parseCustomTimeZone()
if (Trace.traceOn_) {
Trace.log(Trace.WARNING, "["+e.toString()+"] Unable to determine time zone of system. " +
"QUTCOFFSET value is " + utcOffset + ". " +
"Assuming server is in the same time zone as client application.");
}
return TimeZone.getDefault();
}
}
// Utility method, for use by other Toolbox classes.
// Trims-down a QWCCVTDT-generated EBCDIC date string, for use in a CL command parameter.
// Depending on the specified format, this method strips extra leading and trailing digits that aren't expected by CL commands.
static final String formatDateForCommandParameter(byte[] dateBytes, String dateFormat)
throws UnsupportedEncodingException
{
int expectedLength = 0;
String outVal = null;
// Convert EBCDIC characters to a Unicode String.
final String dateString = CharConverter.byteArrayToString(37, dateBytes);
if (dateFormat.equals("*DTS")) expectedLength = 8;
else if (dateFormat.equals("*YYMD") ||
dateFormat.equals("*MDYY") ||
dateFormat.equals("*DMYY") ||
dateFormat.equals("*LONGJUL"))
{
expectedLength = 17; // for details, refer to the API spec for QWCCVTDT
}
else if (dateFormat.equals("*MDY") ||
dateFormat.equals("*YMD") ||
dateFormat.equals("*DMY"))
{
// For these formats, CL commands expect 6 digits, with no leading "century guard digit".
outVal = dateString.substring(1,7);
}
else if (dateFormat.equals("*JUL"))
{
// For *JUL, CL commands expect 5 digits, with no leading "century guard digit".
outVal = dateString.substring(1,6);
}
else
{
expectedLength = 16; // for details, refer to the API spec for QWCCVTDT
}
if (outVal != null) return outVal;
else
{
if (dateString.length() == expectedLength) return dateString; // no truncation needed
else return dateString.substring(0,expectedLength); // truncate extra trailing digits
}
}
/**
* Specifies the 17-byte character date and time value format returned
* on the QWCCVTDT API.
**/
private static class DateTime17Format extends RecordFormat
{
private static final long serialVersionUID = 1L;
DateTime17Format(AS400 system)
{
int ccsid = system.getCcsid();
AS400Text text2 = new AS400Text(2, ccsid, system);
addFieldDescription(new CharacterFieldDescription(new AS400Text(4, ccsid, system), "year"));
addFieldDescription(new CharacterFieldDescription(text2, "month"));
addFieldDescription(new CharacterFieldDescription(text2, "day"));
addFieldDescription(new CharacterFieldDescription(text2, "hour"));
addFieldDescription(new CharacterFieldDescription(text2, "minute"));
addFieldDescription(new CharacterFieldDescription(text2, "second"));
addFieldDescription(new CharacterFieldDescription(new AS400Text(3, ccsid, system), "millisecond"));
}
}
// /**
// * Specifies the 16-byte character date and time value format returned
// * on the QWCCVTDT API.
//**/
//private static class DateTime16Format extends RecordFormat
//{
// DateTime16Format(AS400 system)
// {
// int ccsid = system.getCcsid();
// AS400Text text2 = new AS400Text(2, ccsid, system);
// addFieldDescription(new CharacterFieldDescription(new AS400Text(1, ccsid, system), "century"));
// addFieldDescription(new CharacterFieldDescription(text2, "year"));
// addFieldDescription(new CharacterFieldDescription(text2, "month"));
// addFieldDescription(new CharacterFieldDescription(text2, "day"));
// addFieldDescription(new CharacterFieldDescription(text2, "hour"));
// addFieldDescription(new CharacterFieldDescription(text2, "minute"));
// addFieldDescription(new CharacterFieldDescription(text2, "second"));
// addFieldDescription(new CharacterFieldDescription(new AS400Text(3, ccsid, system), "millisecond"));
// }
//}
}