dateattribute.java

sunxacml源码

        int defaultedTimeZone;

        if (simpleParser == null)
            initParsers();

        // If string ends with Z, it's in GMT. Chop off the Z and
        // add +0000 to make the time zone explicit, then parse it
        // with the timezone parser.
        if (value.endsWith("Z")) {
            value = value.substring(0, value.length()-1) + "+0000";
            dateValue = strictParse(zoneParser, value);
            timeZone = 0;
            defaultedTimeZone = 0;
        } else {
            // If string ends with :XX, it must have a time zone
            // or be invalid. Strip off the possible time zone and
            // make sure what's left is a valid simple date. If so,
            // reformat the time zone by stripping out the colon
            // and parse the whole thing with the timezone parser.
            int len = value.length();
            
            if ((len > 6) && (value.charAt(len-3) == ':')) {
                Date gmtValue = strictParse(zoneParser,
                                            value.substring(0,len-6) +
                                            "+0000");
                value = value.substring(0, len-3) +
                    value.substring(len-2, len);
                dateValue = strictParse(zoneParser, value);
                timeZone =
                    (int) (gmtValue.getTime() - dateValue.getTime());
                timeZone = timeZone / 60000;
                defaultedTimeZone = timeZone;
            } else {
                // No funny business. This must be a simple date.
                dateValue = strictParse(simpleParser, value);
                timeZone = TZ_UNSPECIFIED;
                Date gmtValue = strictParse(zoneParser, value + "+0000");
                defaultedTimeZone =
                    (int) (gmtValue.getTime() - dateValue.getTime());
                defaultedTimeZone = defaultedTimeZone / 60000;
            }
        }

        // If parsing went OK, create a new DateAttribute object and
        // return it.
        DateAttribute attr = new DateAttribute(dateValue, timeZone,
                                               defaultedTimeZone);
        return attr;
    }

    /**
     * Parse a String using a DateFormat parser, requiring that
     * the entire String be consumed by the parser. On success,
     * return a Date. On failure, throw a ParseException.
     * <p>
     * Synchronize on the parser object when using it, since we
     * assume they're the shared static objects in this class.
     */
    private static Date strictParse(DateFormat parser, String str)
        throws ParseException {
        ParsePosition pos = new ParsePosition(0);
        Date ret;
        synchronized (parser) {
            ret = parser.parse(str, pos);
        }
        if (pos.getIndex() != str.length())
            throw new ParseException("", 0);
        return ret;
    }

    /**
     * Initialize the parser objects.
     */
    private static void initParsers() {
        // If simpleParser is already set, we're done.
        if (simpleParser != null)
            return;

        // Make sure that identifierURI is not null
        if (earlyException != null)
            throw earlyException;

        // Synchronize on identifierURI while initializing parsers
        // so we don't end up using a half-way initialized parser
        synchronized (identifierURI) {
            // This simple parser has no time zone
            simpleParser = new SimpleDateFormat("yyyy-MM-dd");
            simpleParser.setLenient(false);

            // This parser has a four digit offset to GMT with sign
            zoneParser = new SimpleDateFormat("yyyy-MM-ddZ");
            zoneParser.setLenient(false);
        }
    }

    /**
     * Gets the date represented by this object. The return value is
     * a <code>Date</code> object representing the
     * instant at which the specified date began (midnight)
     * in the time zone.
     * <p>
     * <b>NOTE:</b> The <code>Date</code> object is cloned before it
     * is returned to avoid unauthorized changes.
     *
     * @return a <code>Date</code> object representing the instant
     *         at which the date began
     */
    public Date getValue() {
        return (Date) value.clone();
    }

    /**
     * Gets the specified time zone of this object (or
     * TZ_UNSPECIFIED if unspecified).
     *
     * @return the offset to GMT in minutes (positive or negative)
     */
    public int getTimeZone() {
        return timeZone;
    }

    /**
     * Gets the time zone actually used for this object (if it was
     * originally unspecified, the default time zone used).
     *
     * @return the offset to GMT in minutes (positive or negative)
     */
    public int getDefaultedTimeZone() {
        return defaultedTimeZone;
    }

    /**
     * Returns true if the input is an instance of this class and if its
     * value equals the value contained in this class.
     * <p>
     * Two <code>DateAttribute</code>s are equal if and only if the
     * instant on which the date began is equal. This means that they
     * must have the same time zone.
     *
     * @param o the object to compare
     *
     * @return true if this object and the input represent the same value
     */
    public boolean equals(Object o) {
        if (! (o instanceof DateAttribute))
            return false;

        DateAttribute other = (DateAttribute)o;

        return value.equals(other.value);
    }

    /**
     * Returns the hashcode value used to index and compare this object with
     * others of the same type.
     *
     * @return the object's hashcode value
     */
    public int hashCode() {
        // Only the value field is considered by the equals method, so only
        // that field should be considered by this method.
        return value.hashCode();
    }

    /**
     * Converts to a String representation.
     *
     * @return the String representation
     */
    public String toString() {
        StringBuffer sb = new StringBuffer();

        sb.append("DateAttribute: [\n");
        sb.append("  Date: " + value + " local time");
        sb.append("  TimeZone: " + timeZone);
        sb.append("  Defaulted TimeZone: " + defaultedTimeZone);
        sb.append("]");

        return sb.toString();
    }

    /**
     * Encodes the value in a form suitable for including in XML data like
     * a request or an obligation. This must return a value that could in
     * turn be used by the factory to create a new instance with the same
     * value.
     *
     * @return a <code>String</code> form of the value
     */
    public String encode() {
        if (encodedValue != null)
            return encodedValue;

        if (timeZone == TZ_UNSPECIFIED) {
            // If no time zone was specified, format Date value in
            // local time with no time zone string.
            initParsers();
            synchronized (simpleParser) {
                encodedValue = simpleParser.format(value);
            }
        } else {
            // If a time zone was specified, don't use SimpleParser
            // because it can only format dates in the local (default)
            // time zone. And the offset between that time zone and the
            // time zone we need to display can vary in complicated ways.

            // Instead, do it ourselves using our formatDateWithTZ method.
            encodedValue = formatDateWithTZ();
        }
        return encodedValue;
    }

    /**
     * Encodes the value of this object as an xsi:date.
     * Only for use when the time zone is specified.
     *
     * @return a <code>String</code> form of the value
     */
    private String formatDateWithTZ() {
        if (gmtCalendar == null) {
            TimeZone gmtTimeZone = TimeZone.getTimeZone("GMT");

            // Locale doesn't make much difference here. We don't use
            // any of the strings in the Locale and we don't do anything
            // that depends on week count conventions. We use the US
            // locale because it's always around and it ensures that we
            // will always get a Gregorian calendar, which is necessary
            // for compliance with ISO 8501.
            gmtCalendar = Calendar.getInstance(gmtTimeZone, Locale.US);
        }

        // "YYYY-MM-DD+hh:mm".length() = 16
        // Length may be longer if years < -999 or > 9999
        StringBuffer buf = new StringBuffer(16);

        synchronized (gmtCalendar) {
            // Start with the GMT instant when the date started in the
            // specified time zone (would be 7:00 PM the preceding day
            // if the specified time zone was +0500).
            gmtCalendar.setTime(value);
            // Bump by the timeZone (so we get the right date/time that
            // that we want to format)
            gmtCalendar.add(Calendar.MINUTE, timeZone);

            // Now, assemble the string
            int year = gmtCalendar.get(Calendar.YEAR);
            buf.append(zeroPadInt(year, 4));
            buf.append('-');
            // JANUARY is 0
            int month = gmtCalendar.get(Calendar.MONTH) + 1;
            buf.append(zeroPadInt(month, 2));
            buf.append('-');
            int dom = gmtCalendar.get(Calendar.DAY_OF_MONTH);
            buf.append(zeroPadInt(dom, 2));
        }

        int tzNoSign = timeZone;
        if (timeZone < 0) {
            tzNoSign = -tzNoSign;
            buf.append('-');
        } else
            buf.append('+');
        int tzHours = tzNoSign / 60;
        buf.append(zeroPadInt(tzHours, 2));
        buf.append(':');
        int tzMinutes = tzNoSign % 60;
        buf.append(zeroPadInt(tzMinutes, 2));

        return buf.toString();
    }

    /**
     * Takes a String representation of an integer (an optional
     * sign followed by digits) and pads it with zeros on the left
     * until it has at least the specified number of digits.
     * Note that this function will work for an integer of
     * any size: int, long, etc.
     *
     * @param unpadded the unpadded <code>String</code>
     *                 (must have length of at least one)
     * @param minDigits the minimum number of digits desired
     * @return the padded <code>String</code>
     */
    static String zeroPadIntString(String unpadded, int minDigits) {
        int len = unpadded.length();

        // Get the sign character (or 0 if none)
        char sign = unpadded.charAt(0);
        if ((sign != '-') && (sign != '+'))
            sign = 0;

        // The number of characters required is the number of digits,
        // plus one for the sign if present.
        int minChars = minDigits;
        if (sign != 0)
            minChars++;

        // If we already have that many characters, we're done.
        if (len >= minChars)
            return unpadded;

        // Otherwise, create the buffer
        StringBuffer buf = new StringBuffer();

        // Copy in the sign first, if present
        if (sign != 0) {
            buf.append(sign);
        }

        // Add the zeros
        int zerosNeeded = minChars - len;
        while (zerosNeeded-- != 0)
            buf.append('0');

        // Copy the rest of the unpadded string
        if (sign != 0) {
            // Skip sign
            buf.append(unpadded.substring(1, len));
        } else {
            buf.append(unpadded);
        }

        return buf.toString();
    }

    /**
     * Converts an integer to a base 10 string and pads it with
     * zeros on the left until it has at least the specified
     * number of digits. Note that the length of the resulting
     * string will be greater than minDigits if the number is
     * negative since the string will start with a minus sign.
     *
     * @param intValue the integer to convert
     * @param minDigits the minimum number of digits desired
     * @return the padded <code>String</code>
     */
    static String zeroPadInt(int intValue, int minDigits) {
        return zeroPadIntString(Integer.toString(intValue), minDigits);
    }
}