Examples with SqlDateConverter jodd.typeconverter.impl.SqlDateConverter used on opensource projects

Example 1 with SqlDateConverter

use of jodd.typeconverter.impl.SqlDateConverter in project jodd by oblac.

the class TypeConverterManagerBean method registerDefaults.

/**
	 * Registers default set of converters.
	 */
@SuppressWarnings({ "UnnecessaryFullyQualifiedName" })
public void registerDefaults() {
    register(String.class, new StringConverter());
    register(String[].class, new StringArrayConverter(this));
    IntegerConverter integerConverter = new IntegerConverter();
    register(Integer.class, integerConverter);
    register(int.class, integerConverter);
    register(MutableInteger.class, new MutableIntegerConverter(this));
    ShortConverter shortConverter = new ShortConverter();
    register(Short.class, shortConverter);
    register(short.class, shortConverter);
    register(MutableShort.class, new MutableShortConverter(this));
    LongConverter longConverter = new LongConverter();
    register(Long.class, longConverter);
    register(long.class, longConverter);
    register(MutableLong.class, new MutableLongConverter(this));
    ByteConverter byteConverter = new ByteConverter();
    register(Byte.class, byteConverter);
    register(byte.class, byteConverter);
    register(MutableByte.class, new MutableByteConverter(this));
    FloatConverter floatConverter = new FloatConverter();
    register(Float.class, floatConverter);
    register(float.class, floatConverter);
    register(MutableFloat.class, new MutableFloatConverter(this));
    DoubleConverter doubleConverter = new DoubleConverter();
    register(Double.class, doubleConverter);
    register(double.class, doubleConverter);
    register(MutableDouble.class, new MutableDoubleConverter(this));
    BooleanConverter booleanConverter = new BooleanConverter();
    register(Boolean.class, booleanConverter);
    register(boolean.class, booleanConverter);
    CharacterConverter characterConverter = new CharacterConverter();
    register(Character.class, characterConverter);
    register(char.class, characterConverter);
    register(byte[].class, new ByteArrayConverter(this));
    register(short[].class, new ShortArrayConverter(this));
    register(int[].class, new IntegerArrayConverter(this));
    register(long[].class, new LongArrayConverter(this));
    register(float[].class, new FloatArrayConverter(this));
    register(double[].class, new DoubleArrayConverter(this));
    register(boolean[].class, new BooleanArrayConverter(this));
    register(char[].class, new CharacterArrayConverter(this));
    // we don't really need these, but converters will be cached and not created every time
    register(Integer[].class, new ArrayConverter<Integer>(this, Integer.class) {

        @Override
        protected Integer[] createArray(int length) {
            return new Integer[length];
        }
    });
    register(Long[].class, new ArrayConverter<Long>(this, Long.class) {

        @Override
        protected Long[] createArray(int length) {
            return new Long[length];
        }
    });
    register(Byte[].class, new ArrayConverter<Byte>(this, Byte.class) {

        @Override
        protected Byte[] createArray(int length) {
            return new Byte[length];
        }
    });
    register(Short[].class, new ArrayConverter<Short>(this, Short.class) {

        @Override
        protected Short[] createArray(int length) {
            return new Short[length];
        }
    });
    register(Float[].class, new ArrayConverter<Float>(this, Float.class) {

        @Override
        protected Float[] createArray(int length) {
            return new Float[length];
        }
    });
    register(Double[].class, new ArrayConverter<Double>(this, Double.class) {

        @Override
        protected Double[] createArray(int length) {
            return new Double[length];
        }
    });
    register(Boolean[].class, new ArrayConverter<Boolean>(this, Boolean.class) {

        @Override
        protected Boolean[] createArray(int length) {
            return new Boolean[length];
        }
    });
    register(Character[].class, new ArrayConverter<Character>(this, Character.class) {

        @Override
        protected Character[] createArray(int length) {
            return new Character[length];
        }
    });
    register(MutableInteger[].class, new ArrayConverter<>(this, MutableInteger.class));
    register(MutableLong[].class, new ArrayConverter<>(this, MutableLong.class));
    register(MutableByte[].class, new ArrayConverter<>(this, MutableByte.class));
    register(MutableShort[].class, new ArrayConverter<>(this, MutableShort.class));
    register(MutableFloat[].class, new ArrayConverter<>(this, MutableFloat.class));
    register(MutableDouble[].class, new ArrayConverter<>(this, MutableDouble.class));
    register(BigDecimal.class, new BigDecimalConverter());
    register(BigInteger.class, new BigIntegerConverter());
    register(BigDecimal[].class, new ArrayConverter<>(this, BigDecimal.class));
    register(BigInteger[].class, new ArrayConverter<>(this, BigInteger.class));
    register(java.util.Date.class, new DateConverter());
    register(java.sql.Date.class, new SqlDateConverter());
    register(Time.class, new SqlTimeConverter());
    register(Timestamp.class, new SqlTimestampConverter());
    register(Calendar.class, new CalendarConverter());
    register(GregorianCalendar.class, new CalendarConverter());
    register(JDateTime.class, new JDateTimeConverter());
    register(File.class, new FileConverter());
    register(Class.class, new ClassConverter());
    register(Class[].class, new ClassArrayConverter(this));
    register(URI.class, new URIConverter());
    register(URL.class, new URLConverter());
    register(Locale.class, new LocaleConverter());
    register(TimeZone.class, new TimeZoneConverter());
}

Example 2 with SqlDateConverter

use of jodd.typeconverter.impl.SqlDateConverter in project jodd by oblac.

the class JDateTimeConverterTest method testLoadFromStoreTo.

@Test
public void testLoadFromStoreTo() {
    Calendar c = Calendar.getInstance();
    c.set(2001, 0, 1, 2, 3, 4);
    c.set(Calendar.MILLISECOND, 500);
    JDateTime jdt = Convert.toJDateTime(c);
    assertEquals("2001-01-01 02:03:04.500", jdt.toString());
    Calendar c1 = Convert.toCalendar(jdt);
    assertEquals(2001, c1.get(Calendar.YEAR));
    assertEquals(0, c1.get(Calendar.MONTH));
    assertEquals(1, c1.get(Calendar.DAY_OF_MONTH));
    assertEquals(2, c1.get(Calendar.HOUR_OF_DAY));
    assertEquals(3, c1.get(Calendar.MINUTE));
    assertEquals(4, c1.get(Calendar.SECOND));
    assertEquals(500, c1.get(Calendar.MILLISECOND));
    GregorianCalendar gc = new GregorianCalendar(2002, 5, 2, 3, 4, 5);
    gc.set(GregorianCalendar.MILLISECOND, 600);
    jdt = Convert.toJDateTime(gc);
    assertEquals("2002-06-02 03:04:05.600", jdt.toString());
    GregorianCalendar gc1 = (GregorianCalendar) Convert.toCalendar(jdt);
    assertEquals(2002, gc1.get(GregorianCalendar.YEAR));
    assertEquals(5, gc1.get(GregorianCalendar.MONTH));
    assertEquals(2, gc1.get(GregorianCalendar.DAY_OF_MONTH));
    assertEquals(3, gc1.get(GregorianCalendar.HOUR_OF_DAY));
    assertEquals(4, gc1.get(GregorianCalendar.MINUTE));
    assertEquals(5, gc1.get(GregorianCalendar.SECOND));
    assertEquals(600, gc1.get(GregorianCalendar.MILLISECOND));
    Date d = new Date(101, 2, 3, 4, 5, 6);
    jdt = Convert.toJDateTime(d);
    assertEquals("2001-03-03 04:05:06.000", jdt.toString());
    Date d2 = Convert.toDate(jdt);
    assertEquals(101, d2.getYear());
    assertEquals(2, d2.getMonth());
    assertEquals(3, d2.getDate());
    assertEquals(4, d2.getHours());
    assertEquals(5, d2.getMinutes());
    assertEquals(6, d2.getSeconds());
    JDateTime gt_new = new JDateTime(2003, 6, 5, 4, 3, 2, 100);
    jdt.setJulianDate(gt_new.getJulianDate());
    assertEquals("2003-06-05 04:03:02.100", jdt.toString());
    JDateTime gt2 = jdt.clone();
    assertEquals(2003, gt2.getYear());
    assertEquals(6, gt2.getMonth());
    assertEquals(5, gt2.getDay());
    assertEquals(4, gt2.getHour());
    assertEquals(3, gt2.getMinute());
    assertEquals(2, gt2.getSecond());
    assertEquals(100, gt2.getMillisecond());
    java.sql.Date sd = new java.sql.Date(123, 4, 5);
    jdt = Convert.toJDateTime(sd);
    assertEquals("2023-05-05 00:00:00.000", jdt.toString());
    java.sql.Date sd2 = new java.sql.Date(1, 2, 3);
    SqlDateConverter sqlDateConverter = new SqlDateConverter();
    sd2 = sqlDateConverter.convert(jdt);
    assertEquals(123, sd2.getYear());
    assertEquals(4, sd2.getMonth());
    assertEquals(5, sd2.getDate());
    Timestamp st = new Timestamp(123, 4, 5, 6, 7, 8, 500000000);
    jdt = Convert.toJDateTime(st);
    assertEquals("2023-05-05 06:07:08.500", jdt.toString());
    SqlTimestampConverter sqlTimestampConverter = new SqlTimestampConverter();
    Timestamp st2 = sqlTimestampConverter.convert(jdt);
    assertEquals(123, st2.getYear());
    assertEquals(4, st2.getMonth());
    assertEquals(5, st2.getDate());
    assertEquals(6, st2.getHours());
    assertEquals(7, st2.getMinutes());
    assertEquals(8, st2.getSeconds());
    assertEquals(500, st2.getNanos() / 1000000);
}