datetime (P2J - Progress 4GL to Java Conversion and Runtime)

java.lang.Object
- com.goldencode.p2j.util.LazyUndoable
- - com.goldencode.p2j.util.BaseDataType
  - - com.goldencode.p2j.util.date
    - - com.goldencode.p2j.util.datetime

All Implemented Interfaces:: Undoable, java.io.Externalizable, java.io.Serializable, java.lang.Comparable

Direct Known Subclasses:: datetimetz

public class datetime
extends date

A class that represents a Progress 4GL compatible datetime object whose data is mutable. All Progress language features related to date data types are supported including all function that can be accessed via the date aware operators and built-in Progress date-related functions.

This class extends the date class so all methods should work directly. If they don't they will be overridden. Also should the following static implementations:

 +        operator (datetime, integer)              plusMillis(datetime, NumberType) 
 -        operator (datetime, integer)              minusMillis(datetime, NumberType)
 -        operator (datetime, datetime)             differenceNum(datetime, datetime)
 string   function (default format)                 date.toString()
                   (user-defined format)            toString(String) 
                   (export format)                  toStringExport()
 now      function                                  now()
 datetime function (date)                           datetime(date)
 datetime function (date, integer)                  datetime(date, NumberType)
 datetime function (integer m, d, y, h, mm, s, ms)  datetime(NumberType, NumberType, NumberType, NumberType, NumberType, NumberType, NumberType)
 datetime function (string parameter)               datetime(String)
                   [literal]                        fromLiteral(String)

Default data type display formats: DATETIME 99/99/9999 HH:MM:SS.SSS

Author:: OM
See Also:: Serialized Form

Nested Class Summary
- Nested classes/interfaces inherited from class com.goldencode.p2j.util.BaseDataType
  BaseDataType.Type, BaseDataType.WrapperHandler

Field Summary

Fields
Modifier and Type	Field and Description
`static byte`	`AMPM` Represents the AM/PM string component of
`private static java.lang.String`	`defaultFormat` The default format string.
`private static java.util.regex.Pattern`	`DT_PATTERN` The pattern to parse ISO 8601 formats.
`private static java.lang.String`	`DT_PATTERN_STRING` The pattern format for ISO 8601 dates.
`static byte`	`HOURS` Represents the hours component of the string formatted datetime(-tz).
`protected static java.time.format.DateTimeFormatter`	`ISO_LOCAL_DATE_TIME` The specific ISO-8601 datetime format used by 4GL.
`static java.time.format.DateTimeFormatter`	`ISO_LOCAL_TIME` The specific ISO-8601 time format used by 4GL.
`static byte`	`MILLIS` Represents the milliseconds component of the string formatted datetime(-tz).
`static byte`	`MINUTES` Represents the minutes component of the string formatted datetime(-tz).
`static byte`	`SECONDS` Represents the seconds component of the string formatted datetime(-tz).
`private int`	`time` The milliseconds since midnight.
`static byte`	`TZ_HOURS` Represents the hours time zone component of the string formatted datetime(-tz).
`static byte`	`TZ_MINS` Represents the minutes time zone component of the string formatted datetime(-tz).

Fields inherited from class com.goldencode.p2j.util.date
DAY, DEFAULT_DATE_FORMAT, DEFAULT_DATE_WINDOWING_YEAR, DEFAULT_DATETIME_FORMAT, INVALID_DATE, INVALID_TZ, ISO_LOCAL_DATE, JULIAN_EPOCH_OFFSET, MAX_VALID_TZ, MILLIS_PER_DAY, MIN_VALID_TZ, MONTH, OCX_EPOCH_OFFSET, ORDER_MDY, ORDER_YMD, RAW_EPOCH, YEAR

Constructor Summary

Constructors
Constructor and Description
`datetime()` Default constructor which creates an unknown instance.
`datetime(BaseDataType value)` This is a special c'tor which should be used only when converting the value returned by a function or method with polymorphic return type into the expected type (i.e.
`datetime(BaseDataType d, BaseDataType time)` Constructs an instance with the exact same state as the passed instance and having the specified time.
`datetime(character spec)` Creates a new instance from the given date and time specification.
`datetime(date d)` Constructs an instance with the exact same state as the passed instance.
`datetime(java.util.Date d)` Creates an instance from a `java.util.Date` instance.
`datetime(date d, double time)` Constructs an instance with the exact same state as the passed instance and having the specified time.
`datetime(date d, NumberType time)` Constructs an instance with the exact same state as the passed instance and having the specified time.
`datetime(java.util.Date d, java.util.TimeZone zone)` Creates an instance from a `java.util.Date` instance.
`datetime(double month, double day, double year)` Construct a datetime instance using explicit values for each discrete component of the date and with a time value of 0.
`datetime(double month, double day, double year, double hours, double minutes)` Construct a datetime instance using explicit values for each discrete component.
`datetime(double month, double day, double year, double hours, double minutes, double seconds)` Construct a datetime instance using explicit values for each discrete component.
`datetime(double month, double day, double year, double hours, double minutes, double seconds, double millis)` Construct a datetime instance using explicit values for each discrete component.
`datetime(NumberType month, NumberType day, NumberType year)` Construct a datetime instance using explicit values for each discrete component of the date and with a time value of 0.
`datetime(NumberType month, NumberType day, NumberType year, NumberType hours, NumberType minutes)` Construct a datetime instance using explicit values for each discrete component.
`datetime(NumberType month, NumberType day, NumberType year, NumberType hours, NumberType minutes, NumberType seconds)` Construct a datetime instance using explicit values for each discrete component.
`datetime(NumberType month, NumberType day, NumberType year, NumberType hours, NumberType minutes, NumberType seconds, NumberType millis)` Construct a datetime instance using explicit values for each discrete component.
`datetime(java.lang.String spec)` Creates a new instance from the given date and time specification.
`datetime(java.lang.String spec, java.lang.String format, int windowingYear)` Converts a string to a datetime using a specified format and an optional windowing year for date part.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`void`	`assign(BaseDataType value)` Sets the state (data and unknown value) of this instance based on the state of the passed instance.
`void`	`assign(date value)` Sets the state of this instance based on the state of the passed instance.
`int`	`compareTo(java.lang.Object obj)` Compares this instance with the specified instance and returns a -1 if this instance is less than the specified, 0 if the two instances are equal and 1 if this instance is greater than the specified instance.
`java.util.Date`	`dateValue()` Returns the current instance as an instance of the `Date` class which will accurately represent the UTC time that corresponds to the current date in the timezone stored in this instance or in the default timezone if the stored timezone is `null`.
`java.util.Date`	`dateValue(java.util.TimeZone override)` Returns the current instance as an instance of the `Date` class which will accurately represent the UTC time that corresponds to the current date in the timezone passed as a parameter or in the default timezone if the passed timezone is `null`.
`void`	`deepAssign(datetime value)` Sets the state (data and unknown value) and configuration (time-zone) of this instance based on the state of the passed instance.
`java.lang.String`	`defaultFormatString()` Return the default display format string for this type.
`static int64`	`differenceNum(datetime op1, datetime op2)` Returns the number of milliseconds difference between the datetimes of two instances.
`datetime`	`duplicate()` Does the same as standard `clone()` method but returns an instance of `BaseDataType` and doesn't throw the `CloneNotSupportedException`.
`boolean`	`equals(java.lang.Object o)` An equality test which handles the most common cases with the least amount of overhead.
`void`	`fromIso(java.lang.String val)` Parses this ISO 8601 value as a datetime.
`static datetime`	`fromLiteral(java.lang.String str)` Check if the `str` is a Progress datetime-tz literal (in ISO8601 format string representation), parse it and return the `datetimetz` object.
`protected void`	`generateParsingError(int errCode)` Generate a parsing error.
`protected long`	`getAbsoluteTimeOffset()` Returns the absolute time in milliseconds since Java 'Epoch' or 0 if this is unknown.
`int`	`getHours()` Extract the hours time-element from this datetime.
`int64`	`getHoursNum()` Extract the hours time-element from this datetime.
`java.lang.String`	`getIsoDate()` Obtains the text form of this date instance in ISO 8601 standard format.
`int`	`getMilliseconds()` Extract the milliseconds time-element from this datetime.
`int64`	`getMillisecondsNum()` Extract the milliseconds time-element from this datetime.
`int`	`getMinutes()` Extract the minutes time-element from this datetime.
`int64`	`getMinutesNum()` Extract the minutes time-element from this datetime.
`int`	`getSeconds()` Extract the seconds time-element from this datetime.
`int64`	`getSecondsNum()` Extract the seconds time-element from this datetime.
`int`	`getSize()` Obtain the length (in bytes) of this BDT will use when serialized.
`int`	`getTime()` Obtain the millis from midnight.
`int64`	`getTimeNum()` Obtain the millis since midnight for this instance.
`BaseDataType.Type`	`getType()` Get the type
`int`	`getTzHours()` Obtains the hours of timezone offset.
`int64`	`getTzHoursNum()` Obtains the hours of timezone offset.
`int`	`getTzMinutes()` Obtains the minutes of timezone offset.
`int64`	`getTzMinutesNum()` Obtains the minutes of timezone offset.
`int`	`hashCode()` Hash code implementation which is consistent with `BaseDataType.equals(java.lang.Object)`.
`static datetime`	`init(java.lang.String literal)` Parse the INITIAL string of a datetime var definition.
`BaseDataType`	`instantiateDefault()` Creates a new instance of the same type that represents the default initialized value.
`protected void`	`instantiateFromDateTime(date d, long time)` Worker to set the date (in the superclass) and the time (in this class) given all the basic inputs.
`protected void`	`instantiateFromStringWorker(java.lang.String spec, java.lang.String dateFormat, int windowingYear)` Parses the given date and time specification and assigns the values into the instance.
`BaseDataType`	`instantiateUnknown()` Creates a new instance of the same type that represents the `unknown value`.
`static datetime`	`instantiateUnknownDatetime()` Deprecated.
`static integer`	`millisecondsSinceMidnight()` Returns the time in milliseconds (MTIME, similar to TIME, which returns seconds since midnight).
`static integer`	`millisecondsSinceMidnight(character dt)` Returns the time in milliseconds (MTIME, similar to TIME, which returns seconds since midnight).
`static integer`	`millisecondsSinceMidnight(datetime dt)` Returns the time in milliseconds (MTIME, similar to TIME, which returns seconds since midnight).
`private static int`	`millisSinceMidnight(java.util.Calendar cal)` Extract the portion of the calendar representing the number of milliseconds since midnight.
`static <T extends datetime> T`	`minusMillis(T dt, long millis)` TODO: perhaps this should be moved to DateOps Subtracts `milliseconds` to the datetime of the left operand and returns a new instance representing that datetime.
`static <T extends datetime> T`	`minusMillis(T dt, NumberType millis)` TODO: perhaps this should be moved to DateOps Subtracts `milliseconds` to the datetime of the left operand and returns a new instance representing that datetime.
`static datetime`	`now()` Creates an instance that represents current date and time using the default timezone.
`static datetime`	`parseInitial(java.lang.String text)` Parses the literal encountered in a INITIAL option.
`static date`	`parseLiteral(java.lang.String val)` Parses this ISO 8601 value as a datetime.
`static <T extends datetime> T`	`plusMillis(T dt, long millis)` TODO: perhaps this should be moved to DateOps Adds `milliseconds` to the datetime of the left operand and returns a new instance representing that datetime.
`static <T extends datetime> T`	`plusMillis(T dt, NumberType millis)` TODO: perhaps this should be moved to DateOps Adds `milliseconds` to the datetime of the left operand and returns a new instance representing that datetime.
`void`	`readExternal(java.io.ObjectInput in)` Replacement for the default object reading method.
`protected void`	`resetTime()` Reset the time for this instance.
`void`	`setTime(long millis)` Sets the milliseconds since midnight.
`void`	`setTime(long hours, long mins, long secs, long millis)` Sets the internal time.
`void`	`setTime(NumberType millis)` Sets the millis from midnight.
`void`	`setTime(NumberType hours, NumberType mins, NumberType secs, NumberType millis)` Sets the internal time.
`protected void`	`setTimeZoneOffset(long offset)` Set the offset in minutes from UTC for this instance and adjust to localtime.
`datetime`	`toLocalDatetime()` Return an object equal to this expressed in local time (current timezone offset).
`java.lang.String`	`toString(java.lang.String fmt)` Create a string representation of this date using a Progress 4GL style date format string such as 99/99/99 HH:MM:SS.SSS or 99-99-9999 HH:MM:SS.SSS.
`java.lang.String`	`toStringExport()` Obtains the text form of this date instance in ISO 8601 standard format.
`java.lang.String`	`toStringMessage()` Creates a string representation of the instance data using the Progress 4GL 'export' format.
`java.lang.String`	`toStringSQL()` Creates a SQL compatible string representation of the instance data (the format is "YYYY-MM-DD HH:MM:SS.zzz").
`void`	`writeExternal(java.io.ObjectOutput out)` Replacement for the default object writing method.

Methods inherited from class com.goldencode.p2j.util.date
assign, calendarToLocalMillis, cleanFormattedDate, createDate, dateToLocalMillis, day, decimalValue, decrement, deepAssign, difference, differenceNum, doubleValue, elapsed, elapsed, elapsed, getDateComponentOrder, getDateOrder, getDateOrderNative, getDay, getDayNum, getDefaultOffset, getDefaultOffset, getDefaultTimeZone, getDefaultTimeZoneOffset, getDisplayTimeZone, getDynamicFormat, getMonth, getMonthNum, getOffsetForSpec, getOffsetForSpec, getTimeSource, getTimeZone, getWeekday, getWeekdayNum, getWindowingYear, getYear, getYearMonthDay, getYearNum, getYearOffset, getZoneCalendar, getZoneFromOffset, increment, initFormat, instantiateDate, instantiateUnknownDate, integerValue, intValue, inY2KWindow, isoDate, isUnknown, julianDayToMillis, longValue, main, maximum, maximum, millisToJulianDay, minimum, minimum, minusDays, minusDays, minusDays, month, neutralMillisToCalendar, neutralMillisToDate, parseIso8601, plusDays, plusDays, plusDays, secondsSinceMidnight, secondsSinceMidnight, setDateComponentOrder, setDateOrder, setDateOrder, setDayNumber, setDayNumber, setDayNumber, setDisplayTimeZone, setDisplayTimeZone, setSessionTimeZone, setTimeSource, setTimeSource, setTimeZone, setUnknown, setWindowingYear, setYearOffset, specToOffset, today, toString, toYearString, utc, validate, weekday, windowing, windowingImpl, withDynamicFormat, year

Methods inherited from class com.goldencode.p2j.util.BaseDataType
assign, assign, calcFormatLength, createProxy, createProxy, deepCopy, elementsOfType, fallback, formatLength, fromTypeName, generateDefault, generateUnknown, getAssigner, getTypeName, incompatibleTypesOnConversion, initialize, initializeDefaultExtent, instantiateDefaultExtent, invalidInitializer, isAllKnown, isAllKnown, isAssignDirect, isIncompatibleTypesOnConversion, isProxy, isUnknownValue, maximum, minimum, notUnknownValue, sameType, val, variable

Methods inherited from class com.goldencode.p2j.util.LazyUndoable
changed, checkUndoable, checkUndoable, checkUndoable, getTransLevel, isGlobal, isUndoable, markUndoable, popBlock, rollback, setGlobal

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

- Field Detail
  - HOURS
```
public static final byte HOURS
```
    Represents the hours component of the string formatted datetime(-tz).
    
    See Also:
    
    Constant Field Values
  - MINUTES
```
public static final byte MINUTES
```
    Represents the minutes component of the string formatted datetime(-tz).
    
    See Also:
    
    Constant Field Values
  - SECONDS
```
public static final byte SECONDS
```
    Represents the seconds component of the string formatted datetime(-tz).
    
    See Also:
    
    Constant Field Values
  - MILLIS
```
public static final byte MILLIS
```
    Represents the milliseconds component of the string formatted datetime(-tz).
    
    See Also:
    
    Constant Field Values
  - AMPM
```
public static final byte AMPM
```
    Represents the AM/PM string component of
    
    See Also:
    
    Constant Field Values
  - TZ_HOURS
```
public static final byte TZ_HOURS
```
    Represents the hours time zone component of the string formatted datetime(-tz).
    
    See Also:
    
    Constant Field Values
  - TZ_MINS
```
public static final byte TZ_MINS
```
    Represents the minutes time zone component of the string formatted datetime(-tz).
    
    See Also:
    
    Constant Field Values
  - ISO_LOCAL_TIME
```
public static final java.time.format.DateTimeFormatter ISO_LOCAL_TIME
```
    The specific ISO-8601 time format used by 4GL.
  - ISO_LOCAL_DATE_TIME
```
protected static final java.time.format.DateTimeFormatter ISO_LOCAL_DATE_TIME
```
    The specific ISO-8601 datetime format used by 4GL.
  - defaultFormat
```
private static final java.lang.String defaultFormat
```
    The default format string.
    
    See Also:
    
    Constant Field Values
  - DT_PATTERN_STRING
```
private static final java.lang.String DT_PATTERN_STRING
```
    The pattern format for ISO 8601 dates.
    
    See Also:
    
    Constant Field Values
  - DT_PATTERN
```
private static final java.util.regex.Pattern DT_PATTERN
```
    The pattern to parse ISO 8601 formats.
  - time
```
private int time
```
    The milliseconds since midnight.
- Constructor Detail
  - datetime
```
public datetime()
```
    Default constructor which creates an unknown instance.
  - datetime
```
public datetime(BaseDataType value)
```
    This is a special c'tor which should be used only when converting the value returned by a function or method with polymorphic return type into the expected type (i.e. DYNAMIC-FUNCTION()). In such cases, the 4GL does some automatic type conversion (see assign(BaseDataType)).
    
    Parameters:
    
    value - The value to be used for this instance.
  - datetime
```
public datetime(java.util.Date d)
```
    Creates an instance from a java.util.Date instance.
    WARNING: this will only work if the calendar in which this datetime was constructed is the GregorianCalendar AND if the timezone in which this object was created is the same as the current default for this JVM instance. If this is not correct then you must use the datetime(Date,TimeZone) version.
    
    Parameters:
    
    d - The Date instance from which to pattern the instance.
  - datetime
```
public datetime(java.util.Date d,
                java.util.TimeZone zone)
```
    Creates an instance from a java.util.Date instance.
    
    Parameters:
    
    d - The Date instance from which to pattern the instance.
    
    zone - The TimeZone for the calendar to be used for d.
  - datetime
```
public datetime(date d)
```
    Constructs an instance with the exact same state as the passed instance. This can be used both as a copy constructor as well as an implementation of the DATETIME() built-in function when called with a date subclass.
    
    Parameters:
    
    d - The instance from which to copy state.
  - datetime
```
public datetime(BaseDataType d,
                BaseDataType time)
```
    Constructs an instance with the exact same state as the passed instance and having the specified time. This is an implementation of the DATETIME() built-in function.
    The time value (positive or negative) is added to the date and the resulting value will be used to determine the date and time based on the default timezone. In other words, the date value can change in either direction by an arbitrary magnitude. This is how it is done in the 4GL.
    
    Parameters:
    
    d - The date from which to copy.
    
    time - The milliseconds since midnight.
  - datetime
```
public datetime(date d,
                NumberType time)
```
    Constructs an instance with the exact same state as the passed instance and having the specified time. This is an implementation of the DATETIME() built-in function.
    The time value (positive or negative) is added to the date and the resulting value will be used to determine the date and time based on the default timezone. In other words, the date value can change in either direction by an arbitrary magnitude. This is how it is done in the 4GL.
    
    Parameters:
    
    d - The date from which to copy.
    
    time - The milliseconds since midnight.
  - datetime
```
public datetime(date d,
                double time)
```
    Constructs an instance with the exact same state as the passed instance and having the specified time. This is an implementation of the DATETIME() built-in function.
    The time value (positive or negative) is added to the date and the resulting value will be used to determine the date and time based on the default timezone. In other words, the date value can change in either direction by an arbitrary magnitude. This is how it is done in the 4GL.
    
    Parameters:
    
    d - The date from which to copy.
    
    time - The milliseconds since midnight.
  - datetime
```
public datetime(double month,
                double day,
                double year,
                double hours,
                double minutes,
                double seconds,
                double millis)
```
    Construct a datetime instance using explicit values for each discrete component. This is a variant of the DATETIME() built-in function.
    
    Parameters:
    
    month - The month number from 1 to 12 inclusive.
    
    day - The day of the month from 1 to the maximum days in that month, inclusive
    
    year - The Progress 4GL year which may be a negative number which represents the BC era or a positive AD era year. The value must be between -32768 and 32767 and it cannot be 0 since the year 0 is invalid in Progress. The value will be windowed into the right century if it is 2 digits. It will be used unchanged if it is 3 or more digits.
    
    hours - The hour of the day from 0 to 23 inclusive.
    
    minutes - The minute of the hour from 0 to 59 inclusive.
    
    seconds - The seconds of the minute from 0 to 62 inclusive. This accounts for leap seconds. Please note that Progress documents 61 as the limit. It turns out that 62 is the real limit.
    
    millis - The milliseconds of the second from 0 to 999 inclusive.
  - datetime
```
public datetime(double month,
                double day,
                double year,
                double hours,
                double minutes,
                double seconds)
```
    Construct a datetime instance using explicit values for each discrete component. This is a variant of the DATETIME() built-in function.
    
    Parameters:
    
    month - The month number from 1 to 12 inclusive.
    
    day - The day of the month from 1 to the maximum days in that month, inclusive
    
    year - The Progress 4GL year which may be a negative number which represents the BC era or a positive AD era year. The value must be between -32768 and 32767 and it cannot be 0 since the year 0 is invalid in Progress. The value will be windowed into the right century if it is 2 digits. It will be used unchanged if it is 3 or more digits.
    
    hours - The hour of the day from 0 to 23 inclusive.
    
    minutes - The minute of the hour from 0 to 59 inclusive.
    
    seconds - The seconds of the minute from 0 to 62 inclusive. This accounts for leap seconds. Please note that Progress documents 61 as the limit. It turns out that 62 is the real limit.
  - datetime
```
public datetime(double month,
                double day,
                double year,
                double hours,
                double minutes)
```
    Construct a datetime instance using explicit values for each discrete component. This is a variant of the DATETIME() built-in function.
    
    Parameters:
    
    month - The month number from 1 to 12 inclusive.
    
    day - The day of the month from 1 to the maximum days in that month, inclusive
    
    year - The Progress 4GL year which may be a negative number which represents the BC era or a positive AD era year. The value must be between -32768 and 32767 and it cannot be 0 since the year 0 is invalid in Progress. The value will be windowed into the right century if it is 2 digits. It will be used unchanged if it is 3 or more digits.
    
    hours - The hour of the day from 0 to 23 inclusive.
    
    minutes - The minute of the hour from 0 to 59 inclusive.
  - datetime
```
public datetime(double month,
                double day,
                double year)
```
    Construct a datetime instance using explicit values for each discrete component of the date and with a time value of 0.
    
    Parameters:
    
    month - The month number from 1 to 12 inclusive.
    
    day - The day of the month from 1 to the maximum days in that month, inclusive
    
    year - The Progress 4GL year which may be a negative number which represents the BC era or a positive AD era year. The value must be between -32768 and 32767 and it cannot be 0 since the year 0 is invalid in Progress. The value will be windowed into the right century if it is 2 digits. It will be used unchanged if it is 3 or more digits.
  - datetime
```
public datetime(NumberType month,
                NumberType day,
                NumberType year,
                NumberType hours,
                NumberType minutes,
                NumberType seconds,
                NumberType millis)
```
    Construct a datetime instance using explicit values for each discrete component. This is a variant of the DATETIME() built-in function. Any component that is unknown will result in the instance being unknown.
    
    Parameters:
    
    month - The month number from 1 to 12 inclusive.
    
    day - The day of the month from 1 to the maximum days in that month, inclusive
    
    year - The Progress 4GL year which may be a negative number which represents the BC era or a positive AD era year. The value must be between -32768 and 32767 and it cannot be 0 since the year 0 is invalid in Progress. The value will be windowed into the right century if it is 2 digits. It will be used unchanged if it is 3 or more digits.
    
    hours - The hour of the day from 0 to 23 inclusive.
    
    minutes - The minute of the hour from 0 to 59 inclusive.
    
    seconds - The seconds of the minute from 0 to 62 inclusive. This accounts for leap seconds. Please note that Progress documents 61 as the limit. It turns out that 62 is the real limit.
    
    millis - The milliseconds of the second from 0 to 999 inclusive.
  - datetime
```
public datetime(NumberType month,
                NumberType day,
                NumberType year,
                NumberType hours,
                NumberType minutes,
                NumberType seconds)
```
    Construct a datetime instance using explicit values for each discrete component. This is a variant of the DATETIME() built-in function. Any component that is unknown will result in the instance being unknown.
    
    Parameters:
    
    month - The month number from 1 to 12 inclusive.
    
    day - The day of the month from 1 to the maximum days in that month, inclusive
    
    year - The Progress 4GL year which may be a negative number which represents the BC era or a positive AD era year. The value must be between -32768 and 32767 and it cannot be 0 since the year 0 is invalid in Progress. The value will be windowed into the right century if it is 2 digits. It will be used unchanged if it is 3 or more digits.
    
    hours - The hour of the day from 0 to 23 inclusive.
    
    minutes - The minute of the hour from 0 to 59 inclusive.
    
    seconds - The seconds of the minute from 0 to 62 inclusive. This accounts for leap seconds. Please note that Progress documents 61 as the limit. It turns out that 62 is the real limit.
  - datetime
```
public datetime(NumberType month,
                NumberType day,
                NumberType year,
                NumberType hours,
                NumberType minutes)
```
    Construct a datetime instance using explicit values for each discrete component. This is a variant of the DATETIME() built-in function. Any component that is unknown will result in the instance being unknown.
    
    Parameters:
    
    month - The month number from 1 to 12 inclusive.
    
    day - The day of the month from 1 to the maximum days in that month, inclusive
    
    year - The Progress 4GL year which may be a negative number which represents the BC era or a positive AD era year. The value must be between -32768 and 32767 and it cannot be 0 since the year 0 is invalid in Progress. The value will be windowed into the right century if it is 2 digits. It will be used unchanged if it is 3 or more digits.
    
    hours - The hour of the day from 0 to 23 inclusive.
    
    minutes - The minute of the hour from 0 to 59 inclusive.
  - datetime
```
public datetime(NumberType month,
                NumberType day,
                NumberType year)
```
    Construct a datetime instance using explicit values for each discrete component of the date and with a time value of 0. Any unknown input will result in an instance that is unknown.
    
    Parameters:
    
    month - The month number from 1 to 12 inclusive.
    
    day - The day of the month from 1 to the maximum days in that month, inclusive
    
    year - The Progress 4GL year which may be a negative number which represents the BC era or a positive AD era year. The value must be between -32768 and 32767 and it cannot be 0 since the year 0 is invalid in Progress. The value will be windowed into the right century if it is 2 digits. It will be used unchanged if it is 3 or more digits.
  - datetime
```
public datetime(java.lang.String spec)
         throws ErrorConditionException
```
    Creates a new instance from the given date and time specification. This is one form of the DATETIME built-in function. This is also the form of the constructor that is used to handle initializer expressions (literals).
    The specification must match the following format rules:
    1. Date value (this is not optional). The string cannot start with whitespace. The first input is a date value that has at least a month and day specified or a month, day and year. The values are parsed in order as specified in SESSION:DATE-FORMAT. Zero padding is allowed but not required.
    2. Date and time delimiter (not optional). Whitespace or a letter T (upper or lowercase) which is followed by whitespace. If the letter T is used, it cannot be preceded by whitespace. No other characters are allowed.
    3. Time value (optional). If not specified, it is set to 0. It is specified in HH:MM:SS.sss format, however right side components can be left off (so HH, HH:MM, HH:MM:SS and HH:MM:SS.sss are all valid forms). Zero padding is allowed but not required, so hours can be H or HH, minutes M or MM, seconds S or SS and milliseconds can be s, ss or sss. Delimiters can only be there if the following component is included.
    4. Whitespace (optional).
    5. Timezone specification (optional). This is in the form of a sign (+ or -) then the hours (1 or 2 digits) a colon delimiter and then minites (1 or 2 digits). Zero padding is allowed but not required. The minutes can be left off but if so, then the delimiter must also be left off. If specified, the instance will be set using the timezone specified EVEN THOUGH THE TIMEZONE OFFSET IS NOT STORED (since this is not a datetimetz).
    6. Whitespace (optional).
    Parameters:
    
    spec - The date and time specification.
    
    Throws:
    
    ErrorConditionException
  - datetime
```
public datetime(java.lang.String spec,
                java.lang.String format,
                int windowingYear)
         throws ErrorConditionException
```
    Converts a string to a datetime using a specified format and an optional windowing year for date part. The purpose of this constructor is to be used with PL/Java as there is no way to access P2J SESSION's attributes on SQL server side.
    
    Parameters:
    
    spec - The date and time specification.
    
    format - The format string used for date conversion.
    
    windowingYear - The start of the 100 year window used for conversion when year is in 2-digits.
    
    Throws:
    
    ErrorConditionException
    
    See Also:
    
    datetime(String)
  - datetime
```
public datetime(character spec)
         throws ErrorConditionException
```
    Creates a new instance from the given date and time specification. This is one form of the DATETIME built-in function. If the input is unknown the instance will be unknown.
    The specification must match the following format rules:
    1. Date value (this is not optional). The string cannot start with whitespace. The first input is a date value that has at least a month and day specified or a month, day and year. The values are parsed in order as specified in SESSION:DATE-FORMAT. Zero padding is allowed but not required.
    2. Date and time delimiter (not optional). Whitespace or a letter T (upper or lowercase) which is followed by whitespace. If the letter T is used, it cannot be preceded by whitespace. No other characters are allowed.
    3. Time value (optional). If not specified, it is set to 0. It is specified in HH:MM:SS.sss format, however right side components can be left off (so HH, HH:MM, HH:MM:SS and HH:MM:SS.sss are all valid forms). Zero padding is allowed but not required, so hours can be H or HH, minutes M or MM, seconds S or SS and milliseconds can be s, ss or sss. Delimiters can only be there if the following component is included.
    4. Whitespace (optional).
    5. Timezone specification (optional). This is in the form of a sign (+ or -) then the hours (1 or 2 digits) a colon delimiter and then minutes (1 or 2 digits). Zero padding is allowed but not required. The minutes can be left off but if so, then the delimiter must also be left off. If specified, the instance will be set using the timezone specified EVEN THOUGH THE TIMEZONE OFFSET IS NOT STORED (since this is not a datetime-tz).
    6. Whitespace (optional).
    Parameters:
    
    spec - The date and time specification.
    
    Throws:
    
    ErrorConditionException
- Method Detail
  - parseLiteral
```
public static date parseLiteral(java.lang.String val)
```
    Parses this ISO 8601 value as a datetime.
    This API relies on instantiateFromStringWorker(java.lang.String, java.lang.String, int) to parse the literal.
    
    Parameters:
    
    val - The date to parse.
    
    Returns:
    
    The date value.
  - now
```
public static datetime now()
```
    Creates an instance that represents current date and time using the default timezone. This is the equivalent of the NOW built-in function.
  - init
```
public static datetime init(java.lang.String literal)
```
    Parse the INITIAL string of a datetime var definition.
    
    Parameters:
    
    literal - The datetime literal, which will always have the date part in 'mdy' format.
    
    Returns:
    
    The datetime instance initialized with this literal.
  - fromLiteral
```
public static datetime fromLiteral(java.lang.String str)
```
    Check if the str is a Progress datetime-tz literal (in ISO8601 format string representation), parse it and return the datetimetz object. The recognized formats are:
```
    YYYY-MM-ddTHH:mm[:S[S].s[s[s[...]]]]
 
```
    where the date-separator can be either 't' or 'T'. The hours and minutes are mandatory in 2 digits and seconds can be represented as 1 or 2 digits. The seconds parts can be tenths of seconds (one digit), hundredths (2 digits) and milliseconds (3 digits after '.'). If more digits appear after '.' they are ignored. Normally the timezone should be present, otherwise P2J parser wouldn't classified it as a datetime-tz literal.
    Parameters:
    
    str - The text to be parsed.
    
    Returns:
    
    a datetime-tz object whose string literal representation was given as argument on success or null if the passed argument does not fit the known pattern.
  - getType
```
public BaseDataType.Type getType()
```
    Get the type
    
    Overrides:
    
    getType in class date
    
    Returns:
    
    type
  - differenceNum
```
public static int64 differenceNum(datetime op1,
                                  datetime op2)
```
    Returns the number of milliseconds difference between the datetimes of two instances.
    
    Parameters:
    
    op1 - The left operand.
    
    op2 - The right operand (instance to subtract from the left operand).
    
    Returns:
    
    The difference in days between the two datetimes or unknown value if any input is unknown value.
  - getTimeNum
```
public int64 getTimeNum()
```
    Obtain the millis since midnight for this instance. This is an implementation of the TIME() built-in function.
    
    Returns:
    
    The milliseconds since midnight.
  - getTime
```
public int getTime()
```
    Obtain the millis from midnight.
    
    Returns:
    
    milliseconds passed from midnight.
  - setTime
```
public void setTime(NumberType millis)
```
    Sets the millis from midnight.
    
    Parameters:
    
    millis - Milliseconds passed from midnight.
  - setTime
```
public void setTime(long millis)
```
    Sets the milliseconds since midnight. If millis is negative a previous day is computed. If millis > date.MILLIS_PER_DAY, the extra milliseconds are combined in days in the future.
    
    Parameters:
    
    millis - Milliseconds since midnight.
  - getHours
```
public int getHours()
```
    Extract the hours time-element from this datetime.
    
    Returns:
    
    The hour of this datetime object.
  - getHoursNum
```
public int64 getHoursNum()
```
    Extract the hours time-element from this datetime.
    
    Returns:
    
    the hour of this datetime object or unknown value if this is an unknown object.
  - getMinutes
```
public int getMinutes()
```
    Extract the minutes time-element from this datetime.
    
    Returns:
    
    the minute of this datetime object
  - getMinutesNum
```
public int64 getMinutesNum()
```
    Extract the minutes time-element from this datetime.
    
    Returns:
    
    the minute of this datetime object or unknown value if this is an unknown object.
  - getSeconds
```
public int getSeconds()
```
    Extract the seconds time-element from this datetime.
    
    Returns:
    
    the second of this datetime object
  - getSecondsNum
```
public int64 getSecondsNum()
```
    Extract the seconds time-element from this datetime.
    
    Returns:
    
    the second of this datetime object or unknown value if this is an unknown object.
  - getMilliseconds
```
public int getMilliseconds()
```
    Extract the milliseconds time-element from this datetime.
    
    Returns:
    
    the millisecond of this datetime object
  - getMillisecondsNum
```
public int64 getMillisecondsNum()
```
    Extract the milliseconds time-element from this datetime.
    
    Returns:
    
    the millisecond of this datetime object or unknown value if this is an unknown object.
  - getTzMinutes
```
public int getTzMinutes()
```
    Obtains the minutes of timezone offset. This is only used for displaying when forced by using a format that contains timezone specifiers.
    
    Returns:
    
    The minutes of timezone of the session.
  - getTzHours
```
public int getTzHours()
```
    Obtains the hours of timezone offset. This is only used for displaying when forced by using a format that contains timezone specifiers.
    
    Returns:
    
    The hours of timezone of the session.
  - getTzMinutesNum
```
public int64 getTzMinutesNum()
```
    Obtains the minutes of timezone offset.
    
    Returns:
    
    The minutes of timezone offset or unknown value if this datetime-tz is unknown.
  - getTzHoursNum
```
public int64 getTzHoursNum()
```
    Obtains the hours of timezone offset.
    
    Returns:
    
    The hours of timezone offset or unknown value if this datetime-tz is unknown.
  - setTime
```
public void setTime(NumberType hours,
                    NumberType mins,
                    NumberType secs,
                    NumberType millis)
```
    Sets the internal time. This method will validate the parameters and raise an error if they are incorrect.Any input that is unknown will cause this instance to be unknown.
    
    Parameters:
    
    hours - The hour of the day from 0 to 23 inclusive.
    
    mins - The minute of the hour from 0 to 59 inclusive.
    
    secs - The seconds of the minute from 0 to 62 inclusive. This accounts for leap seconds. Please note that Progress documents 61 as the limit. It turns out that 62 is the real limit.
    
    millis - The milliseconds of the second from 0 to 999 inclusive.
  - setTime
```
public void setTime(long hours,
                    long mins,
                    long secs,
                    long millis)
```
    Sets the internal time. This method will validate the parameters and raise an error if they are incorrect.
    
    Parameters:
    
    hours - The hour of the day from 0 to 23 inclusive.
    
    mins - The minute of the hour from 0 to 59 inclusive.
    
    secs - The seconds of the minute from 0 to 62 inclusive. This accounts for leap seconds. Please note that Progress documents 61 as the limit. It turns out that 62 is the real limit.
    
    millis - The milliseconds of the second from 0 to 999 inclusive.
  - plusMillis
```
public static <T extends datetime> T plusMillis(T dt,
                                                long millis)
```
    TODO: perhaps this should be moved to DateOps Adds milliseconds to the datetime of the left operand and returns a new instance representing that datetime.
    
    Parameters:
    
    dt - The left operand.
    
    millis - The right operand (the number of milliseconds to add. Note that this can be a negative number to effectively subtract instead of add.
    
    Returns:
    
    The date which is millis different from the left operand or unknown value if dt is unknown value.
  - plusMillis
```
public static <T extends datetime> T plusMillis(T dt,
                                                NumberType millis)
```
    TODO: perhaps this should be moved to DateOps Adds milliseconds to the datetime of the left operand and returns a new instance representing that datetime.
    
    Parameters:
    
    dt - The left operand.
    
    millis - The right operand (the number of milliseconds to add. Note that this can be a negative number to effectively subtract instead of add.
    
    Returns:
    
    The date which is millis different from the left operand or unknown value if any input is unknown value.
  - minusMillis
```
public static <T extends datetime> T minusMillis(T dt,
                                                 long millis)
```
    TODO: perhaps this should be moved to DateOps Subtracts milliseconds to the datetime of the left operand and returns a new instance representing that datetime.
    
    Parameters:
    
    dt - The left operand.
    
    millis - The right operand (the number of milliseconds to subtract. Note that this can be a negative number to effectively add instead of subtract.
    
    Returns:
    
    The date which is millis different from the left operand or unknown value if dt is unknown value.
  - minusMillis
```
public static <T extends datetime> T minusMillis(T dt,
                                                 NumberType millis)
```
    TODO: perhaps this should be moved to DateOps Subtracts milliseconds to the datetime of the left operand and returns a new instance representing that datetime.
    
    Parameters:
    
    dt - The left operand.
    
    millis - The right operand (the number of milliseconds to subtract. Note that this can be a negative number to effectively add instead of subtract.
    
    Returns:
    
    The date which is millis different from the left operand or unknown value if any input is unknown value.
  - millisecondsSinceMidnight
```
public static integer millisecondsSinceMidnight()
```
    Returns the time in milliseconds (MTIME, similar to TIME, which returns seconds since midnight).
    
    Returns:
    
    the time in milliseconds.
  - millisecondsSinceMidnight
```
public static integer millisecondsSinceMidnight(datetime dt)
```
    Returns the time in milliseconds (MTIME, similar to TIME, which returns seconds since midnight).
    
    Parameters:
    
    dt - the datetime or datetime-tz to evaluate.
    
    Returns:
    
    the time in milliseconds.
  - millisecondsSinceMidnight
```
public static integer millisecondsSinceMidnight(character dt)
```
    Returns the time in milliseconds (MTIME, similar to TIME, which returns seconds since midnight).
    
    Parameters:
    
    dt - the datetime or datetime-tz to evaluate.
    
    Returns:
    
    the time in milliseconds.
  - instantiateUnknownDatetime
```
@Deprecated
public static datetime instantiateUnknownDatetime()
```
    Deprecated.
    
    Creates a new datetime instance that represents the unknown value.
    This method is deprecated. Use the default constructor instead.
    
    Returns:
    
    An instance that represents the unknown value.
  - instantiateUnknown
```
public BaseDataType instantiateUnknown()
```
    Creates a new instance of the same type that represents the unknown value.
    
    Overrides:
    
    instantiateUnknown in class date
    
    Returns:
    
    An instance that represents the unknown value.
  - instantiateDefault
```
public BaseDataType instantiateDefault()
```
    Creates a new instance of the same type that represents the default initialized value.
    
    Overrides:
    
    instantiateDefault in class date
    
    Returns:
    
    An instance that represents the default value.
  - defaultFormatString
```
public java.lang.String defaultFormatString()
```
    Return the default display format string for this type.
    
    Overrides:
    
    defaultFormatString in class date
    
    Returns:
    
    The default format string.
  - getSize
```
public int getSize()
```
    Obtain the length (in bytes) of this BDT will use when serialized.
    
    Overrides:
    
    getSize in class date
    
    Returns:
    
    the length of this BDT will use when serialized.
  - assign
```
public void assign(BaseDataType value)
```
    Sets the state (data and unknown value) of this instance based on the state of the passed instance.
    If the value is not of type datetime, the following automatic type conversion will occur:
    1. if the value is a date/datetime/datetimetz value, the current value is used
    2. if the value is unknown, sets the instance to unknown
    3. if the value is of type logical, the value is converted to integer (1 / 0) and then evaluate for the new value
    4. if the value is a non-unknown numeric value, including recid, this uses the number as the julian day
    5. if the value is a non-unknown character value, it attempts to parse this as a properly formatted date
    6. otherwise it will recordOrThrowError number 5729.
    This conversion is meant to handle the cases of built-in functions and methods in the 4GL which have polymorphic return types (e.g. DYNAMIC-FUNCTION()).
    Overrides:
    
    assign in class date
    
    Parameters:
    
    value - The instance from which to copy state.
  - assign
```
public void assign(date value)
```
    Sets the state of this instance based on the state of the passed instance. If time information is not available (value is a date) 00:00 is assumed. Extra information available in datetimetz (time-zone offset) is ignored.
    
    Overrides:
    
    assign in class date
    
    Parameters:
    
    value - The instance from which to copy state.
  - deepAssign
```
public void deepAssign(datetime value)
```
    Sets the state (data and unknown value) and configuration (time-zone) of this instance based on the state of the passed instance.
    
    Parameters:
    
    value - The instance from which to copy state.
  - compareTo
```
public int compareTo(java.lang.Object obj)
```
    Compares this instance with the specified instance and returns a -1 if this instance is less than the specified, 0 if the two instances are equal and 1 if this instance is greater than the specified instance. This is the implementation of the Comparable interface.
    The algorithm will fail to give meaningful results in the case where one tries to sort against other objects that do not represent compatible values.
    
    Specified by:
    
    compareTo in interface java.lang.Comparable
    
    Overrides:
    
    compareTo in class date
    
    Parameters:
    
    obj - The date instance to compare against.
    
    Returns:
    
    -1, 0 or 1 depending on if this instance is less than, equal to or greater (respectively) than the specified instance obj.
  - equals
```
public boolean equals(java.lang.Object o)
```
    An equality test which handles the most common cases with the least amount of overhead. The superclass implementation is invoked otherwise.
    This implementation is consistent with hashCode().
    
    Overrides:
    
    equals in class date
    
    Parameters:
    
    o - The instance to compare against.
    
    Returns:
    
    true if the objects compare equivalently; false if they do not, or if the parameter is not a BaseDataType instance.
    
    See Also:
    
    BaseDataType.equals(java.lang.Object)
  - hashCode
```
public int hashCode()
```
    Hash code implementation which is consistent with BaseDataType.equals(java.lang.Object).
    
    Overrides:
    
    hashCode in class date
    
    Returns:
    
    Hash code value for this object instance.
  - duplicate
```
public datetime duplicate()
```
    Does the same as standard clone() method but returns an instance of BaseDataType and doesn't throw the CloneNotSupportedException.
    
    Overrides:
    
    duplicate in class date
    
    Returns:
    
    A clone of this instance.
  - dateValue
```
public java.util.Date dateValue()
```
    Returns the current instance as an instance of the Date class which will accurately represent the UTC time that corresponds to the current date in the timezone stored in this instance or in the default timezone if the stored timezone is null.
    WARNING: since the J2SE Date class implicitly encodes locale-specific time information along with date information, the Date object returned by this method is sensitive to the environment in which it is interpreted downstream. It is imperative therefore, when using the returned Date in downstream code, that the timezone of such code (e.g., a date formatter or Calendar instance) matches the timezone stored in this date instance (if the stored timezone is null, the JVM's default timezone should be used in downstream code). Otherwise, the discrepancy in timezones (including any Daylight Savings offset) may cause downstream code to interpret the date information in the returned object incorrectly, typically as one day earlier than expected.
    
    Overrides:
    
    dateValue in class date
    
    Returns:
    
    The date converted to be specific to the stored timezone or to the default timezone if the stored timezone is null.
  - dateValue
```
public java.util.Date dateValue(java.util.TimeZone override)
```
    Returns the current instance as an instance of the Date class which will accurately represent the UTC time that corresponds to the current date in the timezone passed as a parameter or in the default timezone if the passed timezone is null.
    WARNING: since the J2SE Date class implicitly encodes locale-specific time information along with date information, the Date object returned by this method is sensitive to the environment in which it is interpreted downstream. It is imperative therefore, when using the returned Date in downstream code, that the timezone of such code (e.g., a date formatter or Calendar instance) matches the the override parameter to this method (if override is null, the JVM's default timezone should be used in downstream code). Otherwise, the discrepancy in timezones (including any Daylight Savings offset) may cause downstream code to interpret the date information in the returned object incorrectly, typically as one day earlier than expected.
    
    Overrides:
    
    dateValue in class date
    
    Parameters:
    
    override - The timezone to use for interpreting this date or null if the default JVM timezone should be used.
    
    Returns:
    
    The date converted to be specific to the passed timezone.
  - toStringSQL
```
public java.lang.String toStringSQL()
```
    Creates a SQL compatible string representation of the instance data (the format is "YYYY-MM-DD HH:MM:SS.zzz").
    The year component is treated differently since it can have a sign (negative indicates BC era) and if the date is within the Y2K window it is truncated to fit.
    
    Overrides:
    
    toStringSQL in class date
    
    Returns:
    
    The formatted string or the 'failure' string if the date is too large to fit in the specified format.
  - toStringMessage
```
public java.lang.String toStringMessage()
```
    Creates a string representation of the instance data using the Progress 4GL 'export' format. This format is unusual in that it does not have a fixed width for the year but in fact it ensures that all years are formatted to at least 3 digits (with leading zeros) up to a maximum of 6 digits (for the year -32768 which is the widest possible Progress year) as necessary. The months and days are always formatted as '99'. Another 'quirk' of this format is that if the year is within the Y2K window, it is formatted as a 2 digit year. The separators are always '/' characters. The time part uses the standard format of 2 digits per components separated by ":", except for milliseconds which have three digits and are separated by ".".
    This implementation creates the given string based on the order of date components (e.g. MDY, YMD...) defined for this context.
    
    Overrides:
    
    toStringMessage in class date
    
    Returns:
    
    The 'message' formatted string.
  - toStringExport
```
public java.lang.String toStringExport()
```
    Obtains the text form of this date instance in ISO 8601 standard format.
    
    Overrides:
    
    toStringExport in class date
    
    Returns:
    
    A string that is the ISO representation of this date ("YYYY-MM-DDTHH:MM:SS.SSS+HH:MM") or "?" if unknown.
  - toString
```
public java.lang.String toString(java.lang.String fmt)
```
    Create a string representation of this date using a Progress 4GL style date format string such as 99/99/99 HH:MM:SS.SSS or 99-99-9999 HH:MM:SS.SSS. The '/', '-', '.' and ':' are valid separators. All 7 components of the date must be represented in the format string and the number of digits in each component is used to pad on the left with zeros as well as to detect when values are too large to fit in the requested format. In such cases the resulting string has all '9' characters of the format string replaced with the '?'. For example, a failure with a format string of '99/99/99' will result in a '??/??/??'.
    There are 2 (and only 2) cases where separator characters are not needed: '999999' and '99999999'. Any other format string without separator characters will cause an error to occur.
    The year component is treated differently since it can have a sign (negative indicates BC era) and if the date is within the Y2K window it is truncated to fit inside a 9 (if possible without losing data) or 99 format (but not a 999 format).
    This implementation creates the given string based on the order of date components (e.g. MDY, YMD...) defined for this context.
    
    Overrides:
    
    toString in class date
    
    Parameters:
    
    fmt - The Progress style format string to use or null to use the default obtained using defaultFormatString().
    
    Returns:
    
    The formatted string or the 'failure' string if the date is too large to fit in the specified format.
  - readExternal
```
public void readExternal(java.io.ObjectInput in)
                  throws java.io.IOException,
                         java.lang.ClassNotFoundException
```
    Replacement for the default object reading method. The latest state is read from the input source.
    
    Specified by:
    
    readExternal in interface java.io.Externalizable
    
    Overrides:
    
    readExternal in class date
    
    Parameters:
    
    in - The input source from which fields will be restored.
    
    Throws:
    
    java.io.IOException - In case of I/O errors.
    
    java.lang.ClassNotFoundException - If payload can't be instantiated.
  - writeExternal
```
public void writeExternal(java.io.ObjectOutput out)
                   throws java.io.IOException
```
    Replacement for the default object writing method. The latest state is written to the output destination.
    
    Specified by:
    
    writeExternal in interface java.io.Externalizable
    
    Overrides:
    
    writeExternal in class date
    
    Parameters:
    
    out - The output destination to which fields will be saved.
    
    Throws:
    
    java.io.IOException - In case of I/O errors.
  - toLocalDatetime
```
public datetime toLocalDatetime()
```
    Return an object equal to this expressed in local time (current timezone offset).
    
    Overrides:
    
    toLocalDatetime in class date
    
    Returns:
    
    a copy of this object (it's already in local time)
  - getIsoDate
```
public java.lang.String getIsoDate()
```
    Obtains the text form of this date instance in ISO 8601 standard format.
    
    Overrides:
    
    getIsoDate in class date
    
    Returns:
    
    A string that is the ISO representation of this date ("YYYY-MM-DDTHH:MM:SS.SSS") or "?" if unknown.
  - resetTime
```
protected void resetTime()
```
    Reset the time for this instance.
  - fromIso
```
public void fromIso(java.lang.String val)
```
    Parses this ISO 8601 value as a datetime.
    
    Overrides:
    
    fromIso in class date
    
    Parameters:
    
    val - The date to parse.
    
    Throws:
    
    java.time.format.DateTimeParseException - If the format is not ISO 8601 compliant.
  - parseInitial
```
public static datetime parseInitial(java.lang.String text)
```
    Parses the literal encountered in a INITIAL option. Does the best effort to parse the text of the literal taking into account the current session settings (like the date format and the windowing year and the moment when the method is invoked. The main purpose of this method is to select the proper date format and then create the proper datetime object with respective values.
    now is also supported, in which case the current timestamp is returned.
    
    Parameters:
    
    text - The text of the literal to be parsed.
    
    Returns:
    
    A datetime representing the respective value, taking into account the current session settings (like the date format and the windowing year).
  - getAbsoluteTimeOffset
```
protected long getAbsoluteTimeOffset()
```
    Returns the absolute time in milliseconds since Java 'Epoch' or 0 if this is unknown.
    
    Overrides:
    
    getAbsoluteTimeOffset in class date
    
    Returns:
    
    The absolute time in milliseconds since the Java epoch.
  - instantiateFromDateTime
```
protected void instantiateFromDateTime(date d,
                                       long time)
```
    Worker to set the date (in the superclass) and the time (in this class) given all the basic inputs.
    
    Parameters:
    
    d - The date instance to copy from.
    
    time - Milliseconds since midnight.
  - generateParsingError
```
protected void generateParsingError(int errCode)
```
    Generate a parsing error. The object is left in unknown state after setting the error code and associated message. The routine automatically generates the error message based on the error code provided.
    
    Parameters:
    
    errCode - The code of error to be raised.
  - instantiateFromStringWorker
```
protected void instantiateFromStringWorker(java.lang.String spec,
                                           java.lang.String dateFormat,
                                           int windowingYear)
```
    Parses the given date and time specification and assigns the values into the instance. The result will be a date and time value that is "local" to the default timezone. If a different timezone is specified in the input, then the date and time values that are specified will be translated into values "local" to the default timezone, before assignment.
    The special string "NOW" is honored as the specification. This is equivalent to the built-in function now.
    When the specification is of a datetime literal, it must match the following format rules:
    1. Date value (this is not optional). The string cannot start with whitespace. The first input is a date value that has at least a month and day specified or a month, day and year. The values are parsed in order as specified in SESSION:DATE-FORMAT. Zero padding is allowed but not required.
    2. Date and time delimiter (not optional). Whitespace or a letter T (upper or lowercase) which is followed by whitespace. If the letter T is used, it cannot be preceded by whitespace. No other characters are allowed.
    3. Time value (optional). If not specified, it is set to 0. It is specified in HH:MM:SS.sss format, however right side components can be left off (so HH, HH:MM, HH:MM:SS and HH:MM:SS.sss are all valid forms). Zero padding is allowed but not required, so hours can be H or HH, minutes M or MM, seconds S or SS and milliseconds can be s, ss or sss. Delimiters can only be there if the following component is included.
    4. Whitespace (optional).
    5. Timezone specification (optional). This is in the form of a sign (+ or -) then the hours (1 or 2 digits) a colon delimiter and then minutes (1 or 2 digits). Zero padding is allowed but not required. The minutes can be left off but if so, then the delimiter must also be left off. If specified, the instance will be set using the timezone specified EVEN THOUGH THE TIMEZONE OFFSET IS NOT STORED (since this is not a datetimetz).
    6. Whitespace (optional).
    If the spec string is empty or if it matches '?' (with no leading or trailing spaces), an unknown datetime object is instantiated.
    Overrides:
    
    instantiateFromStringWorker in class date
    
    Parameters:
    
    spec - The date and time specification.
    
    dateFormat - The date format used for parsing. If it is null the default is used.
    
    windowingYear - The windowing year used for 2 digits years. If it is negative the default is used.
  - setTimeZoneOffset
```
protected void setTimeZoneOffset(long offset)
```
    Set the offset in minutes from UTC for this instance and adjust to localtime. This should only called from instantiateFromStringWorker().
    
    Parameters:
    
    offset - The offset, must be between -840 and 840 inclusive.
  - millisSinceMidnight
```
private static int millisSinceMidnight(java.util.Calendar cal)
```
    Extract the portion of the calendar representing the number of milliseconds since midnight.
    
    Parameters:
    
    cal - The calendar instance to query.
    
    Returns:
    
    The milliseconds since midnight.

Class datetime

Nested Class Summary

Nested classes/interfaces inherited from class com.goldencode.p2j.util.BaseDataType

Field Summary

Fields inherited from class com.goldencode.p2j.util.date

Constructor Summary

Method Summary

Methods inherited from class com.goldencode.p2j.util.date

Methods inherited from class com.goldencode.p2j.util.BaseDataType

Methods inherited from class com.goldencode.p2j.util.LazyUndoable

Methods inherited from class java.lang.Object

Field Detail

HOURS

MINUTES

SECONDS

MILLIS

AMPM

TZ_HOURS

TZ_MINS

ISO_LOCAL_TIME

ISO_LOCAL_DATE_TIME

defaultFormat

DT_PATTERN_STRING

DT_PATTERN

time

Constructor Detail

datetime

datetime

datetime

datetime

datetime

datetime

datetime

datetime

datetime

datetime

datetime

datetime

datetime

datetime

datetime

datetime

datetime

datetime

datetime

Method Detail

parseLiteral

now

init

fromLiteral

getType

differenceNum

getTimeNum

getTime

setTime

setTime

getHours

getHoursNum

getMinutes

getMinutesNum

getSeconds

getSecondsNum

getMilliseconds

getMillisecondsNum

getTzMinutes

getTzHours

getTzMinutesNum

getTzHoursNum

setTime

setTime

plusMillis

plusMillis

minusMillis

minusMillis

millisecondsSinceMidnight

millisecondsSinceMidnight

millisecondsSinceMidnight

instantiateUnknownDatetime

instantiateUnknown

instantiateDefault