Example usage for javax.xml.datatype XMLGregorianCalendar toXMLFormat

List of usage examples for javax.xml.datatype XMLGregorianCalendar toXMLFormat

  1. HOME
  2. Java
  3. javax
  4. javax.xml.datatype.*
  5. XMLGregorianCalendar
  6. toXMLFormat

Introduction

In this page you can find the example usage for javax.xml.datatype XMLGregorianCalendar toXMLFormat.

Prototype

public abstract String toXMLFormat();

Source Link

Document

Return the lexical representation of this instance.

Usage

From source file:DatatypeAPIUsage.java

public static void main(String[] args) {
    try {//from  www  .j ava  2 s  .  co m
        DatatypeFactory df = DatatypeFactory.newInstance();
        // my work number in milliseconds:
        Duration myPhone = df.newDuration(9054133519l);
        Duration myLife = df.newDuration(true, 29, 2, 15, 13, 45, 0);
        int compareVal = myPhone.compare(myLife);
        switch (compareVal) {
        case DatatypeConstants.LESSER:
            System.out.println("There are fewer milliseconds in my phone number than my lifespan.");
            break;
        case DatatypeConstants.EQUAL:
            System.out.println("The same number of milliseconds are in my phone number and my lifespan.");
            break;
        case DatatypeConstants.GREATER:
            System.out.println("There are more milliseconds in my phone number than my lifespan.");
            break;
        case DatatypeConstants.INDETERMINATE:
            System.out.println("The comparison could not be carried out.");
        }

        // create a yearMonthDuration
        Duration ymDuration = df.newDurationYearMonth("P12Y10M");
        System.out.println("P12Y10M is of type: " + ymDuration.getXMLSchemaType());

        // create a dayTimeDuration (really this time)
        Duration dtDuration = df.newDurationDayTime("P10DT10H12M0S");
        System.out.println("P10DT10H12M0S is of type: " + dtDuration.getXMLSchemaType());

        // try to fool the factory!
        try {
            ymDuration = df.newDurationYearMonth("P12Y10M1D");
        } catch (IllegalArgumentException e) {
            System.out.println("'duration': P12Y10M1D is not 'yearMonthDuration'!!!");
        }

        XMLGregorianCalendar xgc = df.newXMLGregorianCalendar();
        xgc.setYear(1975);
        xgc.setMonth(DatatypeConstants.AUGUST);
        xgc.setDay(11);
        xgc.setHour(6);
        xgc.setMinute(44);
        xgc.setSecond(0);
        xgc.setMillisecond(0);
        xgc.setTimezone(5);
        xgc.add(myPhone);
        System.out.println("The approximate end of the number of milliseconds in my phone number was " + xgc);

        // adding a duration to XMLGregorianCalendar
        xgc.add(myLife);
        System.out.println("Adding the duration myLife to the above calendar:" + xgc);

        // create a new XMLGregorianCalendar using the string format of xgc.
        XMLGregorianCalendar xgcCopy = df.newXMLGregorianCalendar(xgc.toXMLFormat());

        // should be equal-if not what happened!!
        if (xgcCopy.compare(xgc) != DatatypeConstants.EQUAL) {
            System.out.println("oooops!");
        } else {
            System.out.println("Very good: " + xgc + " is equal to " + xgcCopy);
        }
    } catch (DatatypeConfigurationException dce) {
        System.err.println("error: Datatype error occurred - " + dce.getMessage());
        dce.printStackTrace(System.err);
    }
}

From source file:Main.java

/**
 * Format a date in xs:dateTime format.// w w w .ja va  2 s . com
 * 
 * @param date
 *            The date.
 * @return The xs:dateTime
 * @throws DatatypeConfigurationException
 *             For errors.
 */
public static String formatXmlDateTimeWithZone(Date date) throws DatatypeConfigurationException {
    GregorianCalendar gc = new GregorianCalendar();
    gc.setTime(date);
    DatatypeFactory datatypeFactory = DatatypeFactory.newInstance();
    XMLGregorianCalendar xmlGregorianCalendar = datatypeFactory.newXMLGregorianCalendar(gc);
    return xmlGregorianCalendar.toXMLFormat();
}

From source file:com.kcs.core.utilities.Utility.java

public static String getXmlDateFormatString(Date date) throws DatatypeConfigurationException {
    if (Utility.isNull(date)) {
        return StringUtil.BLANK;
    } else {//from w  w w. j a  v a2s  .  co m
        XMLGregorianCalendar xMLGregorianCalendar = getXMLGregorianCalendarDate(date);
        return xMLGregorianCalendar.toXMLFormat();
    }
}

From source file:com.evolveum.midpoint.prism.xml.XmlTypeConverter.java

public static String toXmlTextContent(Object val, QName elementName) {
    if (val == null) {
        // if no value is specified, do not create element
        return null;
    }/*www .  j a  v a2  s  .co  m*/
    Class type = XsdTypeMapper.getTypeFromClass(val.getClass());
    if (type == null) {
        throw new IllegalArgumentException(
                "No type mapping for conversion: " + val.getClass() + "(element " + elementName + ")");
    }
    if (type.equals(String.class)) {
        return (String) val;
    }
    if (type.equals(PolyString.class)) {
        return ((PolyString) val).getNorm();
    } else if (type.equals(char.class) || type.equals(Character.class)) {
        return ((Character) val).toString();
    } else if (type.equals(File.class)) {
        return ((File) val).getPath();
    } else if (type.equals(int.class) || type.equals(Integer.class)) {
        return ((Integer) val).toString();
    } else if (type.equals(long.class) || type.equals(Long.class)) {
        return ((Long) val).toString();
    } else if (type.equals(byte.class) || type.equals(Byte.class)) {
        return ((Byte) val).toString();
    } else if (type.equals(float.class) || type.equals(Float.class)) {
        return ((Float) val).toString();
    } else if (type.equals(double.class) || type.equals(Double.class)) {
        return ((Double) val).toString();
    } else if (type.equals(byte[].class)) {
        byte[] binaryData = (byte[]) val;
        return Base64.encodeBase64String(binaryData);
    } else if (type.equals(Boolean.class)) {
        Boolean bool = (Boolean) val;
        if (bool.booleanValue()) {
            return XsdTypeMapper.BOOLEAN_XML_VALUE_TRUE;
        } else {
            return XsdTypeMapper.BOOLEAN_XML_VALUE_FALSE;
        }
    } else if (type.equals(BigInteger.class)) {
        return ((BigInteger) val).toString();
    } else if (type.equals(BigDecimal.class)) {
        return ((BigDecimal) val).toString();
    } else if (type.equals(GregorianCalendar.class)) {
        XMLGregorianCalendar xmlCal = createXMLGregorianCalendar((GregorianCalendar) val);
        return xmlCal.toXMLFormat();
    } else if (XMLGregorianCalendar.class.isAssignableFrom(type)) {
        return ((XMLGregorianCalendar) val).toXMLFormat();
    } else if (Duration.class.isAssignableFrom(type)) {
        return ((Duration) val).toString();
    } else if (type.equals(ItemPath.class)) {
        XPathHolder xpath = new XPathHolder((ItemPath) val);
        return xpath.getXPath();
    } else {
        throw new IllegalArgumentException(
                "Unknown type for conversion: " + type + "(element " + elementName + ")");
    }
}

From source file:cz.cas.lib.proarc.common.export.mets.JhoveUtility.java

/**
 * Inserts dateCreated into Mix//from  w  ww .j a va2 s. c o  m
 *
 * @param mix
 * @param dateCreated
 */
public static void insertDateCreated(Mix mix, XMLGregorianCalendar dateCreated) {
    // inserts DateCreated if missing
    if ((mix.getImageCaptureMetadata() == null)
            || (mix.getImageCaptureMetadata().getGeneralCaptureInformation() == null)
            || (mix.getImageCaptureMetadata().getGeneralCaptureInformation().getDateTimeCreated() == null)) {
        TypeOfDateType dateTimeCreated = new TypeOfDateType();
        dateTimeCreated.setValue(dateCreated.toXMLFormat());
        if (mix.getImageCaptureMetadata() == null) {
            mix.setImageCaptureMetadata(new ImageCaptureMetadataType());
        }
        if (mix.getImageCaptureMetadata().getGeneralCaptureInformation() == null) {
            mix.getImageCaptureMetadata()
                    .setGeneralCaptureInformation(new ImageCaptureMetadataType.GeneralCaptureInformation());
        }
        mix.getImageCaptureMetadata().getGeneralCaptureInformation().setDateTimeCreated(dateTimeCreated);
    }
}

From source file:cz.cas.lib.proarc.common.export.mets.JhoveUtility.java

/**
 * Inserts changeHistory into Mix/*from   w w w .ja va 2s .c  o m*/
 *
 * @param mix
 * @param dateCreated
 * @param originalFileName
 */
public static void insertChangeHistory(Mix mix, XMLGregorianCalendar dateCreated, String originalFileName) {
    if (mix.getChangeHistory() == null) {
        mix.setChangeHistory(new ChangeHistoryType());
    }
    if (mix.getChangeHistory().getImageProcessing().size() == 0) {
        ImageProcessing imageProcessing = new ChangeHistoryType.ImageProcessing();
        TypeOfDateType dateTimeProcessed = new TypeOfDateType();
        dateTimeProcessed.setValue(dateCreated.toXMLFormat());
        imageProcessing.setDateTimeProcessed(dateTimeProcessed);
        StringType sourceData = new StringType();
        sourceData.setValue(originalFileName);
        imageProcessing.setSourceData(sourceData);
        mix.getChangeHistory().getImageProcessing().add(imageProcessing);
    }
}

From source file:org.energyos.espi.datacustodian.web.api.ExportServiceTests.java

private String getXMLTime(int millis) throws DatatypeConfigurationException {
    DatatypeFactory datatypeFactory = DatatypeFactory.newInstance();
    GregorianCalendar cal = getGregorianCalendar(millis);
    XMLGregorianCalendar xmlGregorianCalendar = datatypeFactory.newXMLGregorianCalendar(cal);
    xmlGregorianCalendar.setFractionalSecond(null);
    return xmlGregorianCalendar.toXMLFormat();
}

From source file:ejava.projects.edmv.xml.EDmvParserTest.java

public void testMonthFormat() throws Exception {
    log.info("*** testMonthFormat ***");
    XMLGregorianCalendar cal1 = DatatypeFactory.newInstance().newXMLGregorianCalendar();
    cal1.setMonth(GregorianCalendar.MARCH);
    String xml = cal1.toXMLFormat();
    log.debug("MAR=" + xml);

    XMLGregorianCalendar cal = DatatypeFactory.newInstance().newXMLGregorianCalendar(xml);
    assertNotNull("calendar was null", cal);
    log.info("month=" + cal.getMonth());
    assertEquals("unexpected month", GregorianCalendar.MARCH, cal.getMonth());
}

From source file:ejava.projects.edmv.xml.EDmvParserTest.java

public void testMonthParse() throws Exception {
    log.info("*** testCalendar ***");
    DatatypeFactory dataFactory = DatatypeFactory.newInstance();
    log.info("DataTypeFactory=" + dataFactory);
    XMLGregorianCalendar cal = dataFactory.newXMLGregorianCalendar();
    log.info("XMLGregorianCalendar=" + cal.getClass());

    cal.setMonth(GregorianCalendar.MARCH);
    String xml = cal.toXMLFormat();
    log.debug("cal=" + xml);
    dataFactory.newXMLGregorianCalendar(xml);

    cal.setTimezone(0);//  w  w  w .j  a v  a 2s.c  om

    String format = "--01";
    try {
        XMLGregorianCalendar xCal = dataFactory.newXMLGregorianCalendar(format);
        log.info("successfully parsed:" + format + ", xCal=" + xCal.toXMLFormat());
        format = "--01--";
        xCal = dataFactory.newXMLGregorianCalendar(format);
        log.info("successfully parsed:" + format + ", xCal=" + xCal.toXMLFormat());
    } catch (Exception ex) {
        log.error("failed to parse:" + format);
        fail("failed to parse:" + format);
    }
}

From source file:ejava.projects.edmv.xml.EDmvBindingTest.java

public void testCalendar() throws Exception {
    log.info("*** testCalendar ***");
    DatatypeFactory dataFactory = DatatypeFactory.newInstance();
    log.info("DataTypeFactory=" + dataFactory);
    XMLGregorianCalendar cal = dataFactory.newXMLGregorianCalendar();
    log.info("XMLGregorianCalendar=" + cal.getClass());
    cal.setMonth(GregorianCalendar.MARCH);
    String xml = cal.toXMLFormat();
    log.debug("cal=" + xml);
    dataFactory.newXMLGregorianCalendar(xml);

    cal.setTimezone(0);//w w w  .  j  a va 2 s. c  o m

    Calendar jCal = Calendar.getInstance();
    jCal.clear();
    jCal.set(Calendar.MONTH, Calendar.MARCH);
    DateFormat df = DateFormat.getDateInstance();
    String dfString = df.format(jCal.getTime());
    log.debug("calendar=" + dfString);

    String format = "--01";
    try {
        XMLGregorianCalendar xCal = dataFactory.newXMLGregorianCalendar(format);
        log.info("successfully parsed:" + format + ", xCal=" + xCal.toXMLFormat());
        format = "--01--";
        xCal = dataFactory.newXMLGregorianCalendar(format);
        log.info("successfully parsed:" + format + ", xCal=" + xCal.toXMLFormat());
    } catch (Exception ex) {
        log.error("failed to parse:" + format);
        fail("failed to parse:" + format);
    }
}