}

    @Override
    protected DateTime fromConvertedColumns(Object[] convertedColumns) {

        LocalDateTime datePart = (LocalDateTime) convertedColumns[0];
        DateTimeZoneWithOffset offset = (DateTimeZoneWithOffset) convertedColumns[1];

        DateTime result;

        if (datePart == null) {
            result = null;
        } else {
            result = datePart.toDateTime(offset.getStandardDateTimeZone());
        }
        
        // Handling DST rollover
        if (result != null && offset.getOffsetDateTimeZone() != null &&
        		offset.getStandardDateTimeZone().getOffset(result) > offset.getOffsetDateTimeZone().getOffset(result)) {
        	return result.withLaterOffsetAtOverlap();
        }

        return result;
    }

    @Override
    protected Object[] toConvertedColumns(DateTime value) {
        return new Object[] { value.toLocalDateTime(), new DateTimeZoneWithOffset(value.getZone(), value.getZone().isFixed() ? null : DateTimeZone.forOffsetMillis(value.getZone().getOffset(value))) };
    }

	private static final ColumnMapper<?, ?>[] COLUMN_MAPPERS = new ColumnMapper<?, ?>[] { new StringColumnCurrencyUnitMapper(), new LongLongColumnMapper<Long>() };

    private static final String[] PROPERTY_NAMES = new String[]{ "currencyUnit", "amountMajor" };
	
	@Override
	protected ColumnMapper<?, ?>[] getColumnMappers() {
		return COLUMN_MAPPERS;
	}

    @Override
    protected BigMoney fromConvertedColumns(Object[] convertedColumns) {

        CurrencyUnit currencyUnitPart = (CurrencyUnit) convertedColumns[0];
        Long amountMajorPart = (Long) convertedColumns[1];

        BigMoney theMoney = BigMoney.ofMajor(currencyUnitPart, amountMajorPart);
        if (theMoney.getScale() < currencyUnitPart.getDecimalPlaces()) {
        	theMoney = theMoney.withCurrencyScale();
        }

        return theMoney;
    }

    @Override
    protected Object[] toConvertedColumns(BigMoney value) {

        return new Object[] { value.getCurrencyUnit(), value.getAmountMajorLong() };
    }
    
    @Override
	public String[] getPropertyNames() {
		return PROPERTY_NAMES;
	}
}

		performValidTypesConfiguration(next);
//		}
//		if (ValidTypesConfigured.class.isAssignableFrom(getColumnMapper().getClass())) {			
//		ValidTypesConfigured<Unit<?>> next = (ValidTypesConfigured<Unit<?>>)getColumnMapper();
//		performValidTypesConfiguration(next);
//		}
//		if (UnitConfigured.class.isAssignableFrom(this.getClass())) {
//		UnitConfigured unitConfigured = (UnitConfigured)this;			
//		performUnitConfiguration(unitConfigured);
//		}
	}
	
	private void performValidTypesConfiguration(ValidTypesConfigured<Unit<?>> next) {
		
        String validTypesString = null;
        if (getParameterValues() != null) {
        	validTypesString = getParameterValues().getProperty("validTypes");
        }
		if (validTypesString != null) {
			String[] validTypes = validTypesString.split(",");
			List<Class<Unit<?>>> units = new ArrayList<>();
			for (String nextType : validTypes) {
				
				
				try {
					@SuppressWarnings("unchecked")
					Class<Unit<?>> nextClass = (Class<Unit<?>>)(ClassLoaderUtils.classForName(nextType));
					units.add(nextClass);
				} catch (ClassNotFoundException e) {
					throw new IllegalStateException("Cannot find specified class " + nextType, e);
				}
				
			}
			next.setValidTypes(units);
		}
	}

	}
	
	private void performValidTypesConfiguration(ValidTypesConfigured<Unit<?>> next) {
		
        String validTypesString = null;
        if (getParameterValues() != null) {
        	validTypesString = getParameterValues().getProperty("validTypes");
        }
		if (validTypesString != null) {
			String[] validTypes = validTypesString.split(",");
			List<Class<Unit<?>>> units = new ArrayList<>();
			for (String nextType : validTypes) {
				
				
				try {
					@SuppressWarnings("unchecked")
					Class<Unit<?>> nextClass = (Class<Unit<?>>)(ClassLoaderUtils.classForName(nextType));
					units.add(nextClass);
				} catch (ClassNotFoundException e) {
					throw new IllegalStateException("Cannot find specified class " + nextType, e);
				}
				
			}
			next.setValidTypes(units);
		}
	}

public abstract class AbstractSingleColumnMoneyUserType<T, J, C extends ColumnMapper<T, J>> extends AbstractSingleColumnUserType<T, J, C> implements ParameterizedType, IntegratorConfiguredType {

	private static final long serialVersionUID = 8244061728586173961L;

	private Properties parameterValues;

    private CurrencyUnit currencyUnit;
    
    @Override
    public void setParameterValues(Properties parameters) {
    	this.parameterValues = new ConcurrentHashMapBackedProperties(parameters);
    }
    
    protected Properties getParameterValues() {
    	return parameterValues;
    }
    
    @Override
	public void applyConfiguration(SessionFactory sessionFactory) {

    	CurrencyUnitConfigured columnMapper = (CurrencyUnitConfigured) getColumnMapper();
    	if (currencyUnit == null) {

    		String currencyString = null;
			if (parameterValues != null) {
				currencyString = parameterValues.getProperty("currencyCode");
			}
			if (currencyString == null) {
				currencyString = ConfigurationHelper.getProperty("currencyCode");
			}
			if (currencyString != null) {

				currencyUnit = CurrencyUnit.of(currencyString);

	private static final ColumnMapper<?, ?>[] COLUMN_MAPPERS = new ColumnMapper<?, ?>[] { new StringColumnCurrencyUnitMapper(), new LongLongColumnMapper<Long>() };

    private static final String[] PROPERTY_NAMES = new String[]{ "currencyUnit", "amountMinor" };
	
	@Override
	protected ColumnMapper<?, ?>[] getColumnMappers() {
		return COLUMN_MAPPERS;
	}

    @Override
    protected BigMoney fromConvertedColumns(Object[] convertedColumns) {

        CurrencyUnit currencyUnitPart = (CurrencyUnit) convertedColumns[0];
        Long amountMinorPart = (Long) convertedColumns[1];
        BigMoney money = BigMoney.ofMinor(currencyUnitPart, amountMinorPart);

        return money;
    }

    @Override
    protected Object[] toConvertedColumns(BigMoney value) {

        return new Object[] { value.getCurrencyUnit(), value.getAmountMinorLong() };
    }
    
    @Override
	public String[] getPropertyNames() {
		return PROPERTY_NAMES;
	}
}

	private static final ColumnMapper<?, ?>[] COLUMN_MAPPERS = new ColumnMapper<?, ?>[] { new StringColumnCurrencyUnitMapper(), new LongLongColumnMapper<Long>() };

    private static final String[] PROPERTY_NAMES = new String[]{ "currencyUnit", "amountMajor" };
	
	@Override
	protected ColumnMapper<?, ?>[] getColumnMappers() {
		return COLUMN_MAPPERS;
	}

    @Override
    protected Money fromConvertedColumns(Object[] convertedColumns) {

        CurrencyUnit currencyUnitPart = (CurrencyUnit) convertedColumns[0];
        Long amountMajorPart = (Long) convertedColumns[1];
        Money money = Money.ofMajor(currencyUnitPart, amountMajorPart);

        return money;
    }

    @Override
    protected Object[] toConvertedColumns(Money value) {

        return new Object[] { value.getCurrencyUnit(), value.getAmountMajorLong() };
    }
    
    @Override
	public String[] getPropertyNames() {
		return PROPERTY_NAMES;
	}
}

	private static final ColumnMapper<?, ?>[] COLUMN_MAPPERS = new ColumnMapper<?, ?>[] { new StringColumnCurrencyUnitMapper(), new LongLongColumnMapper<Long>() };

    private static final String[] PROPERTY_NAMES = new String[]{ "currencyUnit", "amountMinor" };
	
	@Override
	protected ColumnMapper<?, ?>[] getColumnMappers() {
		return COLUMN_MAPPERS;
	}

    @Override
    protected Money fromConvertedColumns(Object[] convertedColumns) {

        CurrencyUnit currencyUnitPart = (CurrencyUnit) convertedColumns[0];
        Long amountMinorPart = (Long) convertedColumns[1];
        Money money = Money.ofMinor(currencyUnitPart, amountMinorPart);

        return money;
    }

    @Override
    protected Object[] toConvertedColumns(Money value) {

        return new Object[] { value.getCurrencyUnit(), value.getAmountMinorLong() };
    }
    
    @Override
	public String[] getPropertyNames() {
		return PROPERTY_NAMES;
	}
}

	private static final ColumnMapper<?, ?>[] COLUMN_MAPPERS = new ColumnMapper<?, ?>[] { new StringColumnCurrencyUnitMapper(), new BigDecimalBigDecimalColumnMapper() };

    private static final String[] PROPERTY_NAMES = new String[]{ "currencyUnit", "amount" };
	
	@Override
	protected ColumnMapper<?, ?>[] getColumnMappers() {
		return COLUMN_MAPPERS;
	}

    @Override
    protected BigMoney fromConvertedColumns(Object[] convertedColumns) {

        CurrencyUnit currencyUnitPart = (CurrencyUnit) convertedColumns[0];
        BigDecimal amountPart = (BigDecimal) convertedColumns[1];
        BigMoney money = BigMoney.of(currencyUnitPart, amountPart);

        return money;
    }

    @Override
    protected Object[] toConvertedColumns(BigMoney value) {

        return new Object[] { value.getCurrencyUnit(), value.getAmount() };
    }
    
    @Override
	public String[] getPropertyNames() {
		return PROPERTY_NAMES;
	}
}

	private static final ColumnMapper<?, ?>[] COLUMN_MAPPERS = new ColumnMapper<?, ?>[] { new StringColumnCurrencyUnitMapper(), new BigDecimalBigDecimalColumnMapper() };

    private static final String[] PROPERTY_NAMES = new String[]{ "currencyUnit", "amount" };
	
	@Override
	protected ColumnMapper<?, ?>[] getColumnMappers() {
		return COLUMN_MAPPERS;
	}

    @Override
    protected Money fromConvertedColumns(Object[] convertedColumns) {

        CurrencyUnit currencyUnitPart = (CurrencyUnit) convertedColumns[0];
        BigDecimal amountPart = (BigDecimal) convertedColumns[1];
        Money money = Money.of(currencyUnitPart, amountPart);

        return money;
    }

    @Override
    protected Object[] toConvertedColumns(Money value) {

        return new Object[] { value.getCurrencyUnit(), value.getAmount() };
    }
    
    @Override
	public String[] getPropertyNames() {
		return PROPERTY_NAMES;
	}
}

    	return value.getNumber().numberValue(BigDecimal.class);
    }

	@Override
	public FastMoney fromNonNullString(String s) {
		
		int separator = s.indexOf(' ');
		
		String currency = s.substring(0, separator);
		String value = s.substring(separator + 1);
		
		return FastMoney.of(Long.parseLong(value), Monetary.getCurrency(currency));
	}

	@Override
	public String toNonNullString(MonetaryAmount value) {
		return value.toString();
	}
	
	@Override
    public void setCurrencyUnit(CurrencyUnit currencyUnit) {
        this.currencyUnit = currencyUnit;
    }
}

    	return value.getNumber().numberValue(BigDecimal.class);
    }

	@Override
	public Money fromNonNullString(String s) {
		
		int separator = s.indexOf(' ');
		
		String currency = s.substring(0, separator);
		String value = s.substring(separator + 1);
		
		return Money.of(Long.parseLong(value), Monetary.getCurrency(currency));
	}

	@Override
	public String toNonNullString(MonetaryAmount value) {
		return value.toString();
	}
	
	@Override
    public void setCurrencyUnit(CurrencyUnit currencyUnit) {
        this.currencyUnit = currencyUnit;
    }
}

    	return FastMoney.of(minorVal, currencyUnit);
    }

    @Override
    public Long toNonNullValue(MonetaryAmount value) {
    	if (!currencyUnit.equals(value.getCurrency())) {
    		throw new IllegalStateException("Expected currency " + currencyUnit.getCurrencyCode() + " but was " + value.getCurrency());
    	}
		BigDecimal val = value.getNumber().numberValue(BigDecimal.class);
    	
    	return val.movePointRight(currencyUnit.getDefaultFractionDigits()).longValue();
    }

	@Override
	public FastMoney fromNonNullString(String s) {

public class PersistentFastMoneyMajorAmountAndCurrency extends AbstractMultiColumnUserType<MonetaryAmount> {

	private static final long serialVersionUID = -3990523657883978202L;

	private static final ColumnMapper<?, ?>[] COLUMN_MAPPERS = new ColumnMapper<?, ?>[] { new StringColumnCurrencyUnitMapper(), new LongLongColumnMapper<Long>() };

    private static final String[] PROPERTY_NAMES = new String[]{ "currencyUnit", "amountMajor" };
	
	@Override
	protected ColumnMapper<?, ?>[] getColumnMappers() {
		return COLUMN_MAPPERS;
	}

    @Override
    protected FastMoney fromConvertedColumns(Object[] convertedColumns) {

public class PersistentFastMoneyMinorAmountAndCurrency extends AbstractMultiColumnUserType<MonetaryAmount> {

    private static final long serialVersionUID = -3990523657883978202L;

    private static final ColumnMapper<?, ?>[] COLUMN_MAPPERS = new ColumnMapper<?, ?>[] {
            new StringColumnCurrencyUnitMapper(), new LongLongColumnMapper<Long>() };

    private static final String[] PROPERTY_NAMES = new String[] { "currencyUnit", "amountMinor" };

    @Override
    protected ColumnMapper<?, ?>[] getColumnMappers() {
        return COLUMN_MAPPERS;
    }

    @Override
    protected FastMoney fromConvertedColumns(Object[] convertedColumns) {

public class PersistentBigMoneyMajorAmountAndCurrency extends AbstractMultiColumnUserType<BigMoney> {

	private static final long serialVersionUID = -3990523657883978202L;

	private static final ColumnMapper<?, ?>[] COLUMN_MAPPERS = new ColumnMapper<?, ?>[] { new StringColumnCurrencyUnitMapper(), new LongLongColumnMapper<Long>() };

    private static final String[] PROPERTY_NAMES = new String[]{ "currencyUnit", "amountMajor" };
	
	@Override
	protected ColumnMapper<?, ?>[] getColumnMappers() {
		return COLUMN_MAPPERS;
	}

    @Override
    protected BigMoney fromConvertedColumns(Object[] convertedColumns) {

public class PersistentBigMoneyMajorAmountAndCurrencyAsInteger extends AbstractMultiColumnUserType<BigMoney> {

	private static final long serialVersionUID = -3990523657883978202L;

	private static final ColumnMapper<?, ?>[] COLUMN_MAPPERS = new ColumnMapper<?, ?>[] { new IntegerColumnCurrencyUnitMapper(), new LongLongColumnMapper<Long>() };

    private static final String[] PROPERTY_NAMES = new String[]{ "currencyUnit", "amountMajor" };
	
	@Override
	protected ColumnMapper<?, ?>[] getColumnMappers() {
		return COLUMN_MAPPERS;
	}

    @Override
    protected BigMoney fromConvertedColumns(Object[] convertedColumns) {

public class PersistentBigMoneyMinorAmountAndCurrency extends AbstractMultiColumnUserType<BigMoney> {

	private static final long serialVersionUID = -3990523657883978202L;

	private static final ColumnMapper<?, ?>[] COLUMN_MAPPERS = new ColumnMapper<?, ?>[] { new StringColumnCurrencyUnitMapper(), new LongLongColumnMapper<Long>() };

    private static final String[] PROPERTY_NAMES = new String[]{ "currencyUnit", "amountMinor" };
	
	@Override
	protected ColumnMapper<?, ?>[] getColumnMappers() {
		return COLUMN_MAPPERS;
	}

    @Override
    protected BigMoney fromConvertedColumns(Object[] convertedColumns) {

public class PersistentBigMoneyMinorAmountAndCurrencyAsInteger extends AbstractMultiColumnUserType<BigMoney> {

	private static final long serialVersionUID = -3990523657883978202L;

	private static final ColumnMapper<?, ?>[] COLUMN_MAPPERS = new ColumnMapper<?, ?>[] { new IntegerColumnCurrencyUnitMapper(), new LongLongColumnMapper<Long>() };

    private static final String[] PROPERTY_NAMES = new String[]{ "currencyUnit", "amountMinor" };
	
	@Override
	protected ColumnMapper<?, ?>[] getColumnMappers() {
		return COLUMN_MAPPERS;
	}

    @Override
    protected BigMoney fromConvertedColumns(Object[] convertedColumns) {

public class PersistentFastMoneyAmountAndCurrency extends AbstractMultiColumnUserType<MonetaryAmount> {

	private static final long serialVersionUID = 3735995469031558183L;

	private static final ColumnMapper<?, ?>[] COLUMN_MAPPERS = new ColumnMapper<?, ?>[] { new StringColumnCurrencyUnitMapper(), new BigDecimalBigDecimalColumnMapper() };

    private static final String[] PROPERTY_NAMES = new String[]{ "currencyUnit", "amount" };
	
	@Override
	protected ColumnMapper<?, ?>[] getColumnMappers() {
		return COLUMN_MAPPERS;
	}

    @Override
    protected FastMoney fromConvertedColumns(Object[] convertedColumns) {

        return FastMoney.of(majorVal, currencyUnitPart);
    }

    @Override
    protected Object[] toConvertedColumns(MonetaryAmount value) {

        BigDecimal minorVal = value.getNumber().numberValue(BigDecimal.class);
        minorVal = minorVal.movePointRight(value.getCurrency().getDefaultFractionDigits());

        return new Object[] { value.getCurrency(), minorVal.longValue() };
    }

    @Override
    public String[] getPropertyNames() {
        return PROPERTY_NAMES;
    }
}

    public TimeOfDay fromNonNullValue(Time value) {

        DateTime dateTime = new DateTime(value.getTime());
        LocalTime localTime = dateTime.toLocalTime();

        final TimeOfDay timeOfDay = new TimeOfDay(localTime.getHourOfDay(), localTime.getMinuteOfHour(), localTime.getSecondOfMinute(), localTime.getMillisOfSecond(), localTime.getChronology());
        return timeOfDay;
    }

    @Override
    public String toNonNullString(TimeOfDay value) {
        return value.toString();
    }

    @Override
    public Time toNonNullValue(TimeOfDay value) {

	private static final ColumnMapper<?, ?>[] COLUMN_MAPPERS = new ColumnMapper<?, ?>[] { new IntegerColumnCurrencyUnitMapper(), new LongLongColumnMapper<Long>() };

    private static final String[] PROPERTY_NAMES = new String[]{ "currencyUnit", "amountMajor" };
	
	@Override
	protected ColumnMapper<?, ?>[] getColumnMappers() {
		return COLUMN_MAPPERS;
	}

    @Override
    protected Money fromConvertedColumns(Object[] convertedColumns) {

        CurrencyUnit currencyUnitPart = (CurrencyUnit) convertedColumns[0];
        Long amountMajorPart = (Long) convertedColumns[1];
        Money money = Money.ofMajor(currencyUnitPart, amountMajorPart);

	private static final ColumnMapper<?, ?>[] COLUMN_MAPPERS = new ColumnMapper<?, ?>[] { new IntegerColumnCurrencyUnitMapper(), new BigDecimalBigDecimalColumnMapper() };

    private static final String[] PROPERTY_NAMES = new String[]{ "currencyUnit", "amount" };
	
	@Override
	protected ColumnMapper<?, ?>[] getColumnMappers() {
		return COLUMN_MAPPERS;
	}

    @Override
    protected Money fromConvertedColumns(Object[] convertedColumns) {

        CurrencyUnit currencyUnitPart = (CurrencyUnit) convertedColumns[0];
        BigDecimal amountPart = (BigDecimal) convertedColumns[1];
        Money money = Money.of(currencyUnitPart, amountPart);

public class PersistentBigMoneyAmountAndCurrency extends AbstractMultiColumnUserType<BigMoney> {

	private static final long serialVersionUID = 3735995469031558183L;

	private static final ColumnMapper<?, ?>[] COLUMN_MAPPERS = new ColumnMapper<?, ?>[] { new StringColumnCurrencyUnitMapper(), new BigDecimalBigDecimalColumnMapper() };

    private static final String[] PROPERTY_NAMES = new String[]{ "currencyUnit", "amount" };
	
	@Override
	protected ColumnMapper<?, ?>[] getColumnMappers() {
		return COLUMN_MAPPERS;
	}

    @Override
    protected BigMoney fromConvertedColumns(Object[] convertedColumns) {

public class PersistentBigMoneyAmountAndCurrencyAsInteger extends AbstractMultiColumnUserType<BigMoney> {

	private static final long serialVersionUID = 3735995469031558183L;

	private static final ColumnMapper<?, ?>[] COLUMN_MAPPERS = new ColumnMapper<?, ?>[] { new IntegerColumnCurrencyUnitMapper(), new BigDecimalBigDecimalColumnMapper() };

    private static final String[] PROPERTY_NAMES = new String[]{ "currencyUnit", "amount" };
	
	@Override
	protected ColumnMapper<?, ?>[] getColumnMappers() {
		return COLUMN_MAPPERS;
	}

    @Override
    protected BigMoney fromConvertedColumns(Object[] convertedColumns) {

	private static final ColumnMapper<?, ?>[] COLUMN_MAPPERS = new ColumnMapper<?, ?>[] { new IntegerColumnCurrencyUnitMapper(), new LongLongColumnMapper<Long>() };

    private static final String[] PROPERTY_NAMES = new String[]{ "currencyUnit", "amountMinor" };
	
	@Override
	protected ColumnMapper<?, ?>[] getColumnMappers() {
		return COLUMN_MAPPERS;
	}

    @Override
    protected Money fromConvertedColumns(Object[] convertedColumns) {

        CurrencyUnit currencyUnitPart = (CurrencyUnit) convertedColumns[0];
        Long amountMinorPart = (Long) convertedColumns[1];

        return FastMoney.of(val, currencyUnit);
    }

    @Override
    public Long toNonNullValue(MonetaryAmount value) {
    	if (!currencyUnit.equals(value.getCurrency())) {
    		throw new IllegalStateException("Expected currency " + currencyUnit.getCurrencyCode() + " but was " + value.getCurrency());
    	}
        return MonetaryQueries.extractMajorPart().queryFrom(value).longValue();
    }

	@Override
	public FastMoney fromNonNullString(String s) {

        return FastMoney.of(val, currencyUnit);
    }

    @Override
    public BigDecimal toNonNullValue(MonetaryAmount value) {
    	if (!currencyUnit.equals(value.getCurrency())) {
    		throw new IllegalStateException("Expected currency " + currencyUnit.getCurrencyCode() + " but was " + value.getCurrency());
    	}
    	return value.getNumber().numberValue(BigDecimal.class);
    }

	@Override
	public FastMoney fromNonNullString(String s) {

    public Timestamp toNonNullValue(OffsetDateTime value) {
        
        final Timestamp timestamp = new Timestamp((value.toEpochSecond() * MILLIS_IN_SECOND));
        timestamp.setNanos(value.getNano());
        return timestamp;
    }
    
    @Override
    public void setJavaZone(ZoneId javaZone) {
        this.javaZone = javaZone;
    }
        
	@Override
	public ZoneId parseJavaZone(String zoneString) {
		return ZoneId.of(zoneString);
	}
}

    public Time toNonNullValue(LocalTime value) {

    	DateTime zonedValue = new LocalDateTime(
    			1970,1,1,value.getHourOfDay(), value.getMinuteOfHour(), value.getSecondOfMinute(), value.getMillisOfSecond(), value.getChronology()
    	).toDateTime();

        final Time time = new Time(zonedValue.getMillis());
        return time;
    }
}

    public Timestamp toNonNullValue(LocalTime value) {

    	DateTime zonedValue = new LocalDateTime(
    			1970,1,1,value.getHourOfDay(), value.getMinuteOfHour(), value.getSecondOfMinute(), value.getMillisOfSecond(), value.getChronology()
    	).toDateTime();

        final Timestamp timestamp = new Timestamp(zonedValue.getMillis());
        return timestamp;
    }
}

public class PersistentBigMoneyMajorAmountAndCurrency extends AbstractMultiColumnUserType<BigMoney> {

	private static final long serialVersionUID = -3990523657883978202L;

	private static final ColumnMapper<?, ?>[] COLUMN_MAPPERS = new ColumnMapper<?, ?>[] { new StringColumnCurrencyUnitMapper(), new LongLongColumnMapper<Long>() };

    private static final String[] PROPERTY_NAMES = new String[]{ "currencyUnit", "amountMajor" };

public class PersistentBigMoneyMajorAmountAndCurrencyAsInteger extends AbstractMultiColumnUserType<BigMoney> {

	private static final long serialVersionUID = -3990523657883978202L;

	private static final ColumnMapper<?, ?>[] COLUMN_MAPPERS = new ColumnMapper<?, ?>[] { new IntegerColumnCurrencyUnitMapper(), new LongLongColumnMapper<Long>() };

    private static final String[] PROPERTY_NAMES = new String[]{ "currencyUnit", "amountMajor" };

public class PersistentMoneyMajorAmountAndCurrency extends AbstractMultiColumnUserType<Money> {

	private static final long serialVersionUID = -3990523657883978202L;

	private static final ColumnMapper<?, ?>[] COLUMN_MAPPERS = new ColumnMapper<?, ?>[] { new StringColumnCurrencyUnitMapper(), new LongLongColumnMapper<Long>() };

    private static final String[] PROPERTY_NAMES = new String[]{ "currencyUnit", "amountMajor" };

public class PersistentMoneyMajorAmountAndCurrencyAsInteger extends AbstractMultiColumnUserType<Money> {

	private static final long serialVersionUID = -3990523657883978202L;

	private static final ColumnMapper<?, ?>[] COLUMN_MAPPERS = new ColumnMapper<?, ?>[] { new IntegerColumnCurrencyUnitMapper(), new LongLongColumnMapper<Long>() };

    private static final String[] PROPERTY_NAMES = new String[]{ "currencyUnit", "amountMajor" };

public class PersistentFastMoneyMajorAmountAndCurrency extends AbstractMultiColumnUserType<MonetaryAmount> {

	private static final long serialVersionUID = -3990523657883978202L;

	private static final ColumnMapper<?, ?>[] COLUMN_MAPPERS = new ColumnMapper<?, ?>[] { new StringColumnCurrencyUnitMapper(), new LongLongColumnMapper<Long>() };

    private static final String[] PROPERTY_NAMES = new String[]{ "currencyUnit", "amountMajor" };

        FastMoney money = FastMoney.of(amountMajorPart, currencyUnitPart);

        return money;
    }

    @Override
    protected Object[] toConvertedColumns(MonetaryAmount value) {

        return new Object[] { value.getCurrency(), MonetaryQueries.extractMajorPart().queryFrom(value).longValue() };
    }
    
    @Override
	public String[] getPropertyNames() {
		return PROPERTY_NAMES;
	}
}

    private static final ColumnMapper<?, ?>[] COLUMN_MAPPERS = new ColumnMapper<?, ?>[] { new DateColumnLocalDateMapper(), new StringColumnDateTimeZoneWithOffsetMapper() };

    private static final String[] PROPERTY_NAMES = new String[] { "date", "offset" };

    @Override
    protected ColumnMapper<?, ?>[] getColumnMappers() {
        return COLUMN_MAPPERS;
    }

    @Override
    public String[] getPropertyNames() {
        return ArrayUtils.copyOf(PROPERTY_NAMES);
    }
}

        FastMoney money = FastMoney.of(amountPart, currencyUnitPart);

        return money;
    }

    @Override
    protected Object[] toConvertedColumns(MonetaryAmount value) {

        return new Object[] { value.getCurrency(), value.getNumber().numberValue(BigDecimal.class) };
    }
    
    @Override
	public String[] getPropertyNames() {
		return PROPERTY_NAMES;
	}
}

public class PersistentBigMoneyMajorAmountAndCurrency extends AbstractMultiColumnUserType<BigMoney> {

	private static final long serialVersionUID = -3990523657883978202L;

	private static final ColumnMapper<?, ?>[] COLUMN_MAPPERS = new ColumnMapper<?, ?>[] { new StringColumnCurrencyUnitMapper(), new LongLongColumnMapper<Long>() };

    private static final String[] PROPERTY_NAMES = new String[]{ "currencyUnit", "amountMajor" };

public class PersistentBigMoneyMajorAmountAndCurrencyAsInteger extends AbstractMultiColumnUserType<BigMoney> {

	private static final long serialVersionUID = -3990523657883978202L;

	private static final ColumnMapper<?, ?>[] COLUMN_MAPPERS = new ColumnMapper<?, ?>[] { new IntegerColumnCurrencyUnitMapper(), new LongLongColumnMapper<Long>() };

    private static final String[] PROPERTY_NAMES = new String[]{ "currencyUnit", "amountMajor" };

public class PersistentBigMoneyMinorAmountAndCurrency extends AbstractMultiColumnUserType<BigMoney> {

	private static final long serialVersionUID = -3990523657883978202L;

	private static final ColumnMapper<?, ?>[] COLUMN_MAPPERS = new ColumnMapper<?, ?>[] { new StringColumnCurrencyUnitMapper(), new LongLongColumnMapper<Long>() };

    private static final String[] PROPERTY_NAMES = new String[]{ "currencyUnit", "amountMinor" };

public class PersistentBigMoneyMinorAmountAndCurrencyAsInteger extends AbstractMultiColumnUserType<BigMoney> {

	private static final long serialVersionUID = -3990523657883978202L;

	private static final ColumnMapper<?, ?>[] COLUMN_MAPPERS = new ColumnMapper<?, ?>[] { new IntegerColumnCurrencyUnitMapper(), new LongLongColumnMapper<Long>() };

    private static final String[] PROPERTY_NAMES = new String[]{ "currencyUnit", "amountMinor" };

		if (identifier instanceof PGobject) {
			PGobject pg = (PGobject) identifier;
			jsonText = pg.getValue();
		} else if (identifier instanceof String) { // some PostgreSQL Dialects /
													// Versions return String
													// not PGObject
			jsonText = (String) identifier;
		} else {
			throw new IllegalArgumentException("PersistentJsonObjectAsPostgreSQLJson type expected PGobject, received "
					+ identifier.getClass().getName() + " with value of '" + identifier + "'");
		}

	private static boolean HAS_POSTGRES_DRIVER;
    
	static {
		
		try {
		Class.forName("org.postgresql.util.PGobject");
		HAS_POSTGRES_DRIVER = true;
		} catch (ClassNotFoundException e) {
			HAS_POSTGRES_DRIVER = false;
		}
	}
	
    @Override
    public Object doNullSafeGet(ResultSet rs, String[] names, SharedSessionContractImplementor session, Object owner) throws HibernateException, SQLException, IllegalArgumentException, IllegalAccessException, InvocationTargetException {

        return BigMoney.of(value).getAmount();
    }

	@Override
	public BigMoney fromNonNullString(String s) {
		return BigMoney.parse(s);
	}

	@Override
	public String toNonNullString(BigMoney value) {
		return value.toString();
	}
	
	@Override
    public void setCurrencyUnit(CurrencyUnit currencyUnit) {
        this.currencyUnit = currencyUnit;
    }
}

		String value = s.substring(separator + 1);
		
		return Money.of(Long.parseLong(value), Monetary.getCurrency(currency));
	}

	@Override
	public String toNonNullString(MonetaryAmount value) {
		return value.toString();
	}
	
	@Override
    public void setCurrencyUnit(CurrencyUnit currencyUnit) {
        this.currencyUnit = currencyUnit;
    }
}

    }

    @Override
    public Long toNonNullValue(BigMoney value) {
    	if (!currencyUnit.equals(value.getCurrencyUnit())) {
    		throw new IllegalStateException("Expected currency " + currencyUnit.getCurrencyCode() + " but was " + value.getCurrencyUnit());
    	}
        return value.toBigMoney().getAmountMajorLong();

    public String toNonNullValue(LocalTime value) {
        if (value.getMillisOfSecond() == 0) {
            if (value.getSecondOfMinute() == 0) {
                return Formatter.LOCAL_TIME_NOSECONDS_PRINTER.print(value);
            }
            return Formatter.LOCAL_TIME_NOMILLIS_PRINTER.print(value);
        } else {
            return value.toString();

    public Time toNonNullValue(LocalTime value) {

    	DateTime zonedValue = new LocalDateTime(
    			1970,1,1,value.getHourOfDay(), value.getMinuteOfHour(), value.getSecondOfMinute(), value.getMillisOfSecond(), value.getChronology()
    	).toDateTime();

        final Time time = new Time(zonedValue.getMillis());

    public Time toNonNullValue(TimeOfDay value) {

    	DateTime zonedValue = new LocalDateTime(
    			1970,1,1,value.getHourOfDay(), value.getMinuteOfHour(), value.getSecondOfMinute(), value.getMillisOfSecond(), value.getChronology()
    	).toDateTime();

        final Time time = new Time(zonedValue.getMillis());

    private static final ColumnMapper<?, ?>[] COLUMN_MAPPERS = new ColumnMapper<?, ?>[] { new TimestampColumnLocalDateTimeMapper(), new StringColumnDateTimeZoneWithOffsetMapper() };

    private static final String[] PROPERTY_NAMES = new String[]{ "datetime", "offset" };

    @Override
    protected ColumnMapper<?, ?>[] getColumnMappers() {

	}
	
	@Override
	public void applyConfiguration(SessionFactory sessionFactory) {
		super.applyConfiguration(sessionFactory);
		doApplyConfiguration();
    }
    
	private <Z> void doApplyConfiguration() {

//		if (ValidTypesConfigured.class.isAssignableFrom(this.getClass())) {
		ValidTypesConfigured<Unit<?>> next = (ValidTypesConfigured<Unit<?>>)this;			
		performValidTypesConfiguration(next);

	}

    @Override
    public void doNullSafeSet(PreparedStatement preparedStatement, Object value, int index, SharedSessionContractImplementor session) throws SQLException, IllegalArgumentException, IllegalAccessException, InvocationTargetException {

    	if (value == null) {
			preparedStatement.setNull(index, getType().sqlType());
		} else {

public class DateColumnLocalDateMapper extends AbstractDateColumnMapper<LocalDate> {

    private static final long serialVersionUID = 6734385103313158326L;

    public static final DateTimeFormatter LOCAL_DATE_FORMATTER = new DateTimeFormatterBuilder().appendPattern("yyyy-MM-dd").toFormatter();

    public DateColumnLocalDateMapper() {
    }

    @Override
    public LocalDate fromNonNullString(String s) {
        return new LocalDate(s);

public class StringColumnMonthDayMapper extends AbstractStringColumnMapper<MonthDay> {

    private static final long serialVersionUID = 982411452349850753L;

    @Override
    public MonthDay fromNonNullValue(String s) {
        return MonthDay.parse(s);
    }

    @Override
    public String toNonNullValue(MonthDay value) {
        return value.toString();
    }
}

public class StringColumnYearMonthMapper extends AbstractStringColumnMapper<YearMonth> {

    private static final long serialVersionUID = 982411452349850753L;

    @Override
    public YearMonth fromNonNullValue(String s) {
        return YearMonth.parse(s);
    }

    @Override
    public String toNonNullValue(YearMonth value) {
        return value.toString();
    }
}

public class TimeColumnLocalTimeMapper extends AbstractTimeColumnMapper<LocalTime> {

    private static final long serialVersionUID = 6734385103313158326L;

    public static final DateTimeFormatter LOCAL_TIME_FORMATTER = new DateTimeFormatterBuilder().appendPattern("HH:mm:ss").toFormatter();

    public TimeColumnLocalTimeMapper() {
    }

    @Override
    public LocalTime fromNonNullString(String s) {
        return new LocalTime(s);

        final SimpleDateFormat sdf = DATETIME_FORMAT.get();
        sdf.setTimeZone(gmtZone);
        
        Calendar now = Calendar.getInstance(gmtZone);
        now.clear();
        now.setTime(value);
        
        final String tsString;
        
        long milliseconds = now.get(Calendar.MILLISECOND);
        if (milliseconds == 0) {

public class PersistentDate extends AbstractVersionableUserType<java.util.Date, Timestamp, TimestampColumnDateMapper> implements ParameterizedType, IntegratorConfiguredType {

    private static final long serialVersionUID = -6656619988954550389L;

    @Override
    public int compare(Object o1, Object o2) {
        return ((java.util.Date) o1).compareTo((java.util.Date) o2);
    }
}

    public OffsetDateTime fromNonNullValue(Timestamp value) {

        ZoneId currentJavaZone = javaZone == null ? getDefaultZoneId() : javaZone;

        ZonedDateTime zonedDateTime = value.toInstant().with(ChronoField.NANO_OF_SECOND, value.getNanos()).atZone(currentJavaZone);
        OffsetDateTime dateTime = zonedDateTime.toOffsetDateTime();

		} catch (JsonParseException e) {
			throw new HibernateException("Problem parsing retrieved JSON String: " + jsonText, e);
		} catch (JsonMappingException e) {
			throw new HibernateException("Problem mapping retrieved JSON String: " + jsonText, e);
		} catch (IOException e) {
			throw new HibernateException("Problem reading JSON String: " + jsonText, e);
		}

		return FastMoney.of(Long.parseLong(value), Monetary.getCurrency(currency));
	}

	@Override
	public String toNonNullString(MonetaryAmount value) {
		return value.toString();
	}
	
	@Override
    public void setCurrencyUnit(CurrencyUnit currencyUnit) {
        this.currencyUnit = currencyUnit;
    }
}

        .appendLiteral('T').appendHourOfDay(2)
        .appendLiteral(':').appendMinuteOfHour(2)
        .appendLiteral(':').appendSecondOfMinute(2)
        .appendOptional(new DateTimeFormatterBuilder().appendLiteral('.').appendFractionOfSecond(3, 9).toParser())
        .appendTimeZoneOffset("Z", true, 2, 4).toFormatter();

    public Time toNonNullValue(LocalTime value) {

    	DateTime zonedValue = new LocalDateTime(
    			1970,1,1,value.getHourOfDay(), value.getMinuteOfHour(), value.getSecondOfMinute(), value.getMillisOfSecond(), value.getChronology()
    	).toDateTime();

        final Time time = new Time(zonedValue.getMillis());

    public Time toNonNullValue(TimeOfDay value) {

    	DateTime zonedValue = new LocalDateTime(
    			1970,1,1,value.getHourOfDay(), value.getMinuteOfHour(), value.getSecondOfMinute(), value.getMillisOfSecond(), value.getChronology()
    	).toDateTime();

        final Time time = new Time(zonedValue.getMillis());

				new PersistentMoneyAmount(),
				new PersistentCurrencyUnit()
			};
			
		} else {
			userTypes = new UserType[]{};
		}
	}
	
	/**
	 * {@inheritDoc}
	 */
	@Override
	protected CompositeUserType[] getCompositeUserTypes() {
		return COMPOSITE_USER_TYPES;
	}

	/**
	 * {@inheritDoc}
	 */
	@Override
	protected UserType[] getUserTypes() {
		return userTypes;
	}	
}

        return FastMoney.of(val, currencyUnit);
    }

    @Override
    public Long toNonNullValue(MonetaryAmount value) {
    	if (!currencyUnit.equals(value.getCurrency())) {
    		throw new IllegalStateException("Expected currency " + currencyUnit.getCurrencyCode() + " but was " + value.getCurrency());
    	}

	private static final ColumnMapper<?, ?>[] COLUMN_MAPPERS = new ColumnMapper<?, ?>[] { new StringColumnCurrencyUnitMapper(), new LongLongColumnMapper<Long>() };

    private static final String[] PROPERTY_NAMES = new String[]{ "currencyUnit", "amountMajor" };
	
	@Override
	protected ColumnMapper<?, ?>[] getColumnMappers() {
		return COLUMN_MAPPERS;
	}

    @Override
    protected BigMoney fromConvertedColumns(Object[] convertedColumns) {

	private static final ColumnMapper<?, ?>[] COLUMN_MAPPERS = new ColumnMapper<?, ?>[] { new IntegerColumnCurrencyUnitMapper(), new LongLongColumnMapper<Long>() };

    private static final String[] PROPERTY_NAMES = new String[]{ "currencyUnit", "amountMajor" };
	
	@Override
	protected ColumnMapper<?, ?>[] getColumnMappers() {
		return COLUMN_MAPPERS;
	}

    @Override
    protected BigMoney fromConvertedColumns(Object[] convertedColumns) {

	private static final ColumnMapper<?, ?>[] COLUMN_MAPPERS = new ColumnMapper<?, ?>[] { new StringColumnCurrencyUnitMapper(), new LongLongColumnMapper<Long>() };

    private static final String[] PROPERTY_NAMES = new String[]{ "currencyUnit", "amountMinor" };
	
	@Override
	protected ColumnMapper<?, ?>[] getColumnMappers() {
		return COLUMN_MAPPERS;
	}

    @Override
    protected BigMoney fromConvertedColumns(Object[] convertedColumns) {

	private static final ColumnMapper<?, ?>[] COLUMN_MAPPERS = new ColumnMapper<?, ?>[] { new IntegerColumnCurrencyUnitMapper(), new LongLongColumnMapper<Long>() };

    private static final String[] PROPERTY_NAMES = new String[]{ "currencyUnit", "amountMinor" };
	
	@Override
	protected ColumnMapper<?, ?>[] getColumnMappers() {
		return COLUMN_MAPPERS;
	}

    @Override
    protected BigMoney fromConvertedColumns(Object[] convertedColumns) {

        return MonetaryQueries.extractMajorPart().queryFrom(value).longValue();
    }

	@Override
	public Money fromNonNullString(String s) {
		
		int separator = s.indexOf(' ');
		
		String currency = s.substring(0, separator);
		String value = s.substring(separator + 1);

    public BigDecimal toNonNullValue(Money value) {
    	if (!currencyUnit.equals(value.getCurrencyUnit())) {
    		throw new IllegalStateException("Expected currency " + currencyUnit.getCurrencyCode() + " but was " + value.getCurrencyUnit());
    	}
        return value.getAmount();

    	return new Object[] { value.toLocalDate(), new DateTimeZoneWithOffset(value.getZone(), value.getZone().isFixed() ? null : DateTimeZone.forOffsetMillis(value.getZone().getOffset(value))) };
    }
}

    public BigDecimal toNonNullValue(Money value) {
    	if (!currencyUnit.equals(value.getCurrencyUnit())) {
    		throw new IllegalStateException("Expected currency " + currencyUnit.getCurrencyCode() + " but was " + value.getCurrencyUnit());
    	}
        return value.getAmount();

    private static final String[] PROPERTY_NAMES = new String[]{ "currencyUnit", "amountMajor" };
	
	@Override
	protected ColumnMapper<?, ?>[] getColumnMappers() {
		return COLUMN_MAPPERS;
	}

    @Override
    protected BigMoney fromConvertedColumns(Object[] convertedColumns) {

        CurrencyUnit currencyUnitPart = (CurrencyUnit) convertedColumns[0];
        Long amountMajorPart = (Long) convertedColumns[1];

    private static final String[] PROPERTY_NAMES = new String[]{ "currencyUnit", "amountMajor" };
	
	@Override
	protected ColumnMapper<?, ?>[] getColumnMappers() {
		return COLUMN_MAPPERS;
	}

    @Override
    protected Money fromConvertedColumns(Object[] convertedColumns) {

        CurrencyUnit currencyUnitPart = (CurrencyUnit) convertedColumns[0];
        Long amountMajorPart = (Long) convertedColumns[1];

    public BigDecimal toNonNullValue(MonetaryAmount value) {
    	if (!currencyUnit.equals(value.getCurrency())) {
    		throw new IllegalStateException("Expected currency " + currencyUnit.getCurrencyCode() + " but was " + value.getCurrency());
    	}

    private static final String[] PROPERTY_NAMES = new String[]{ "currencyUnit", "amountMajor" };
	
	@Override
	protected ColumnMapper<?, ?>[] getColumnMappers() {
		return COLUMN_MAPPERS;
	}

    @Override
    protected FastMoney fromConvertedColumns(Object[] convertedColumns) {

        CurrencyUnit currencyUnitPart = (CurrencyUnit) convertedColumns[0];
        Long amountMajorPart = (Long) convertedColumns[1];

    private static final String[] PROPERTY_NAMES = new String[]{ "currencyUnit", "amount" };
	
	@Override
	protected ColumnMapper<?, ?>[] getColumnMappers() {
		return COLUMN_MAPPERS;
	}

    @Override
    protected Money fromConvertedColumns(Object[] convertedColumns) {

        CurrencyUnit currencyUnitPart = (CurrencyUnit) convertedColumns[0];

        return new Object[] { value.toLocalDateTime(), value.getZone() };
    }
    
    @Override
    protected ColumnMapper<?, ?>[] getColumnMappers() {
        return COLUMN_MAPPERS;
    }

    @Override
    public String[] getPropertyNames() {
        return ArrayUtils.copyOf(PROPERTY_NAMES);
    }
}

        final Timestamp timestamp = new Timestamp((value.toEpochSecond() * MILLIS_IN_SECOND));
        timestamp.setNanos(value.getNano());
        return timestamp;
    }
    
    @Override
    public void setJavaZone(ZoneId javaZone) {
        this.javaZone = javaZone;
    }
        
	@Override
	public ZoneId parseJavaZone(String zoneString) {

    public BigDecimal toNonNullValue(BigMoney value) {
    	if (!currencyUnit.equals(value.getCurrencyUnit())) {
    		throw new IllegalStateException("Expected currency " + currencyUnit.getCurrencyCode() + " but was " + value.getCurrencyUnit());
    	}
        return BigMoney.of(value).getAmount();

    private static final String[] PROPERTY_NAMES = new String[] { "date", "offset" };

    @Override
    protected ColumnMapper<?, ?>[] getColumnMappers() {
        return COLUMN_MAPPERS;
    }

    @Override
    public String[] getPropertyNames() {
        return ArrayUtils.copyOf(PROPERTY_NAMES);
    }

	private static SystemOfUnitsService SYSTEM_OF_UNITS_SERVICE = ServiceProvider.current().getSystemOfUnitsService();
    
    private final Map<String, Unit<?>> unitsMap = new HashMap<String, Unit<?>>();

	private List<Class<Unit<?>>> validTypes;

	public FastMoney fromNonNullString(String s) {
		
		int separator = s.indexOf(' ');
		
		String currency = s.substring(0, separator);
		String value = s.substring(separator + 1);
		
		return FastMoney.of(Long.parseLong(value), Monetary.getCurrency(currency));

public class PersistentOffsetTimeAsLongAndStringOffset extends AbstractMultiColumnUserType<OffsetTime> {

    private static final long serialVersionUID = 1364221029392346011L;

    private static final ColumnMapper<?, ?>[] COLUMN_MAPPERS = new ColumnMapper<?, ?>[] { new LongColumnLocalTimeMapper(), new StringColumnZoneOffsetMapper() };

public class PersistentBigMoneyAmountAndCurrency extends AbstractMultiColumnUserType<BigMoney> {

	private static final long serialVersionUID = 3735995469031558183L;

	private static final ColumnMapper<?, ?>[] COLUMN_MAPPERS = new ColumnMapper<?, ?>[] { new StringColumnCurrencyUnitMapper(), new BigDecimalBigDecimalColumnMapper() };

public class PersistentMoneyAmountAndCurrency extends AbstractMultiColumnUserType<Money> {

	private static final long serialVersionUID = 3735995469031558183L;

	private static final ColumnMapper<?, ?>[] COLUMN_MAPPERS = new ColumnMapper<?, ?>[] { new StringColumnCurrencyUnitMapper(), new BigDecimalBigDecimalColumnMapper() };

	public FastMoney fromNonNullString(String s) {
		
		int separator = s.indexOf(' ');
		
		String currency = s.substring(0, separator);
		String value = s.substring(separator + 1);

    private final Map<String, Unit<?>> unitsMap = new HashMap<String, Unit<?>>();

	private List<Class<Unit<?>>> validTypes;
    		
    public StringColumnUnitMapper() {

        return LocalTime.fromMillisOfDay(value / 1000000L);
    }

    @Override
    public String toNonNullString(LocalTime value) {
        return value.toString();
    }

    @Override
    public Long toNonNullValue(LocalTime value) {
        return Long.valueOf(value.getMillisOfDay() * 1000000L);

    protected Object[] toConvertedColumns(BigMoney value) {

        return new Object[] { value.getCurrencyUnit(), value.getAmount() };
    }
    
    @Override
	public String[] getPropertyNames() {
		return PROPERTY_NAMES;
	}
}

    protected Object[] toConvertedColumns(BigMoney value) {

        return new Object[] { value.getCurrencyUnit(), value.getAmountMajorLong() };
    }
    
    @Override
	public String[] getPropertyNames() {
		return PROPERTY_NAMES;
	}
}

    protected Object[] toConvertedColumns(BigMoney value) {

        return new Object[] { value.getCurrencyUnit(), value.getAmountMinorLong() };
    }
    
    @Override
	public String[] getPropertyNames() {
		return PROPERTY_NAMES;
	}
}

    public Long toNonNullValue(Q value) {
    	if (!unit.getClass().isAssignableFrom(value.getUnit().getClass())) {
    		throw new IllegalStateException("Expected unit " + unit + " but was " + value.getUnit());

    private static final Map<String, Unit<?>> unitsMap = new HashMap<String, Unit<?>>();
    
	private List<Class<Unit<?>>> validTypes;

	}

	@Override
	public Object doNullSafeGet(ResultSet rs, String[] names, SharedSessionContractImplementor session, Object owner) throws HibernateException, SQLException, IllegalArgumentException, IllegalAccessException, InvocationTargetException {

		Object identifier = getType().get(rs, names[0], session);

        if (datePart != null && offset.getOffsetDateTimeZone() != null &&
        		offset.getStandardDateTimeZone().getOffset(result) > offset.getOffsetDateTimeZone().getOffset(result)) {
        	return new DateMidnight(datePart.getYear(), datePart.getMonthOfYear(), datePart.getDayOfMonth(), offset.getOffsetDateTimeZone());

    }

    @Override
    public String toNonNullString(LocalDate value) {
        return value.toString();
    }

    @Override
    public Date toNonNullValue(LocalDate value) {

        return Date.valueOf(LOCAL_DATE_FORMATTER.print((LocalDate) value));

        return (value == null ? new Duration(null) : Duration.millis(1000L * value.intValue()));
    }

    @Override
    public String toNonNullString(Duration value) {
        return value.toString();
    }

    @Override
    public Integer toNonNullValue(Duration value) {
        long longValue = value.getStandardSeconds();

	public static final DateTimeFormatter DATETIME_FORMATTER = new DateTimeFormatterBuilder().appendPattern("yyyy-MM-dd'T'HH:mm:ss").appendOptional(new DateTimeFormatterBuilder().appendLiteral('.').appendFraction(ChronoField.NANO_OF_SECOND, 1, 9, false).toFormatter()).toFormatter();

	public TimeColumnOffsetTimeMapper(ZoneOffset javaZone) {
		this.javaZone = javaZone;
	}
    
    @Override
    public OffsetTime fromNonNullString(String s) {
        return OffsetTime.parse(s);
    }

    @Override
    public OffsetTime fromNonNullValue(Time value) {

	public String toNonNullString(Q value) {
    	if (!unit.getClass().isAssignableFrom(value.getUnit().getClass())) {
    		throw new IllegalStateException("Expected unit " + unit + " but was " + value.getUnit());

    public static final DateTimeFormatter LOCAL_TIME_FORMATTER = new DateTimeFormatterBuilder().appendHourOfDay(2).appendLiteral(':').appendMinuteOfHour(2).appendLiteral(':').appendSecondOfMinute(2)
    .appendOptional(new DateTimeFormatterBuilder().appendLiteral('.').appendFractionOfSecond(3, 9).toParser()).toFormatter();

public class LongColumnMoneyMajorMapper extends AbstractLongColumnMapper<Money> implements CurrencyUnitConfigured {

    private static final long serialVersionUID = 4205713919952452881L;
	
    private CurrencyUnit currencyUnit;

    @Override
    public Money fromNonNullValue(Long val) {
        return Money.ofMajor(currencyUnit, val);

public class DateColumnLocalDateMapper extends AbstractDateColumnMapper<LocalDate> {

    private static final long serialVersionUID = 6734385103313158326L;

    public static final DateTimeFormatter LOCAL_DATE_FORMATTER = new DateTimeFormatterBuilder().appendPattern("yyyy-MM-dd").toFormatter();

    public DateColumnLocalDateMapper() {

        return LocalTime.fromMillisOfDay(value);
    }

    @Override
    public String toNonNullString(LocalTime value) {
        return value.toString();
    }

    @Override
    public Integer toNonNullValue(LocalTime value) {

        return (value == null ? new Duration(null) : Duration.millis(value));
    }

    @Override
    public String toNonNullString(Duration value) {
        return value.toString();
    }

    @Override
    public Long toNonNullValue(Duration value) {

    private static final ColumnMapper<?, ?>[] COLUMN_MAPPERS = new ColumnMapper<?, ?>[] { new StringColumnLocalDateTimeMapper(), new StringColumnDateTimeZoneWithOffsetMapper() };

    private static final BigDecimal NANOS_IN_SECOND = BigDecimal.valueOf(1_000_000_000L);
    
    @Override
    public Duration fromNonNullString(String s) {
        return Duration.parse(s);
    }

    @Override
    public Duration fromNonNullValue(BigDecimal value) {

public class BigDecimalColumnMoneyMapper extends AbstractBigDecimalColumnMapper<Money> implements CurrencyUnitConfigured {

    private static final long serialVersionUID = 4205713919952452881L;
	
    private CurrencyUnit currencyUnit;

    @Override
    public Money fromNonNullValue(BigDecimal val) {
        return Money.of(currencyUnit, val);

        return OffsetDateTime.of(datePart, offset);
    }


    @Override
    protected ColumnMapper<?, ?>[] getColumnMappers() {
        return COLUMN_MAPPERS;
    }

    @Override
    protected Object[] toConvertedColumns(OffsetDateTime value) {

public class UserTypeJodaMoneyHibernateIntegrator extends AbstractUserTypeHibernateIntegrator implements Integrator {

	private static UserType[] userTypes;
	private static final CompositeUserType[] COMPOSITE_USER_TYPES = new CompositeUserType[]{};

	static {
		
		boolean found = false;

    protected BigMoney fromConvertedColumns(Object[] convertedColumns) {

        CurrencyUnit currencyUnitPart = (CurrencyUnit) convertedColumns[0];
        BigDecimal amountPart = (BigDecimal) convertedColumns[1];

    protected BigMoney fromConvertedColumns(Object[] convertedColumns) {

        CurrencyUnit currencyUnitPart = (CurrencyUnit) convertedColumns[0];
        Long amountMajorPart = (Long) convertedColumns[1];

    protected BigMoney fromConvertedColumns(Object[] convertedColumns) {

        CurrencyUnit currencyUnitPart = (CurrencyUnit) convertedColumns[0];
        Long amountMinorPart = (Long) convertedColumns[1];

public class LongColumnFastMoneyMajorMapper extends AbstractLongColumnMapper<MonetaryAmount> implements CurrencyUnitConfigured {

    private static final long serialVersionUID = 4205713919952452881L;
	
    private CurrencyUnit currencyUnit;

    @Override
    public FastMoney fromNonNullValue(Long val) {

public class LongColumnMoneyMajorMapper extends AbstractLongColumnMapper<MonetaryAmount> implements CurrencyUnitConfigured {

    private static final long serialVersionUID = 4205713919952452881L;
	
    private CurrencyUnit currencyUnit;

    @Override
    public Money fromNonNullValue(Long val) {

public class LongColumnQuantityMapper<Q extends Quantity<Q>> extends AbstractLongColumnMapper<Q> implements UnitConfigured<Q> {

    private static final long serialVersionUID = 4205713919952452881L;
	
    private Unit<Q> unit;
    
	@Override
    public Q fromNonNullValue(Long val) {

		Object identifier = getType().get(rs, names[0], session);
		
		if (rs.wasNull()) {
			return null;
		}

public class IntegerColumnDurationMapper extends AbstractIntegerColumnMapper<Duration> {

    private static final long serialVersionUID = 8408450977695192938L;

    @Override
    public Duration fromNonNullString(String s) {
        return new Duration(s);

public class LongColumnInstantMapper extends AbstractVersionableLongColumnMapper<Instant> {

    private static final long serialVersionUID = 8408450977695192938L;

    @Override
    public Instant fromNonNullString(String s) {
        return new Instant(s);

public class LongColumnLocalTimeMapper extends AbstractLongColumnMapper<LocalTime> {

    private static final long serialVersionUID = 8408450977695192938L;

    @Override
    public LocalTime fromNonNullString(String s) {
        return new LocalTime(s);

public class LongColumnMoneyMajorMapper extends AbstractLongColumnMapper<Money> implements CurrencyUnitConfigured {

    private static final long serialVersionUID = 4205713919952452881L;
	
    private CurrencyUnit currencyUnit;

    @Override
    public Money fromNonNullValue(Long val) {
        return Money.ofMajor(currencyUnit, val);

public class StringColumnCurrencyUnitMapper extends AbstractStringColumnMapper<CurrencyUnit> {

    private static final long serialVersionUID = 4205713919952452881L;

    @Override
    public CurrencyUnit fromNonNullValue(String s) {
        return CurrencyUnit.of(s);

			Class.forName("org.joda.time.DateTime", false, ClassLoaderUtils.getClassLoader());
			found = true;
		} catch (ClassNotFoundException e) {
		}

		try {
			Class.forName("org.joda.time.DateTime");

        DateTimeZone zone = (DateTimeZone) convertedColumns[1];

        DateTime result;

        if (datePart == null) {
            result = null;
        } else {
            result = datePart.toDateTime(zone);

                    zone = ZoneOffset.of(id);
                }
            } catch (RuntimeException ex) {
                zone = null;
            }
            if (zone == null) {
                zone = ZoneOffset.ofTotalSeconds(java.util.TimeZone.getDefault().getOffset(System.currentTimeMillis()) / MILLIS_IN_SECOND);

                    zone = ZoneId.of(id);
                }
            } catch (RuntimeException ex) {
                zone = null;
            }
            if (zone == null) {
                zone = ZoneId.of(java.util.TimeZone.getDefault().getID());

	private static final ColumnMapper<?, ?>[] COLUMN_MAPPERS = new ColumnMapper<?, ?>[] { new StringColumnCurrencyUnitMapper(), new LongLongColumnMapper<Long>() };

    private static final String[] PROPERTY_NAMES = new String[]{ "currencyUnit", "amountMajor" };

	private static final ColumnMapper<?, ?>[] COLUMN_MAPPERS = new ColumnMapper<?, ?>[] { new IntegerColumnCurrencyUnitMapper(), new LongLongColumnMapper<Long>() };

    private static final String[] PROPERTY_NAMES = new String[]{ "currencyUnit", "amountMajor" };

			return OBJECT_WRITER.writeValueAsString(map);
		} catch (JsonProcessingException e) {
			throw new HibernateException("Cannot serialize JSON object: " + e.getMessage(), e);
		}
	}

	@SuppressWarnings("unchecked")

    private static final BigDecimal NANOS_IN_SECOND = BigDecimal.valueOf(1_000_000_000L);
    
    @Override
    public Duration fromNonNullString(String s) {
        return Duration.parse(s);
    }

    @Override
    public Duration fromNonNullValue(BigDecimal value) {

	}
    
    @Override
    public MonthDay fromNonNullString(String s) {
        return MonthDay.parse(s);
    }

    @Override
    public MonthDay fromNonNullValue(Date value) {

	}
    
    @Override
    public LocalTime fromNonNullString(String s) {
        return LocalTime.parse(s);
    }

    @Override
    public LocalTime fromNonNullValue(Time value) {

        return value.toLocalTime();
    }

    @Override
    public String toNonNullString(LocalTime value) {
        return value.toString();
    }

    @Override
    public Time toNonNullValue(LocalTime value) {

        ZoneOffset zone = null;
        try {
            try {
                String id = System.getProperty("user.timezone");
                if (id != null) {
                    zone = ZoneOffset.of(id);

	            preparedStatement.setObject(index, jsonObject);
			} catch (JsonProcessingException e) {
				throw new HibernateException("Problem writing JSON String: " + e.getMessage(), e);
			}
		}
    }

public class LongColumnBigMoneyMajorMapper extends AbstractLongColumnMapper<BigMoney> implements CurrencyUnitConfigured {

    private static final long serialVersionUID = 4205713919952452881L;
	
    private CurrencyUnit currencyUnit;

    @Override
    public BigMoney fromNonNullValue(Long value) {

		return value.toString();
	}
	
	@Override
    public void setUnit(Unit<Q> unit) {
        this.unit = unit;
    }
}

			return OBJECT_WRITER.writeValueAsString(map);
		} catch (JsonProcessingException e) {
			throw new HibernateException("Cannot serialize JSON object: " + e.getMessage(), e);
		}
	}

    @Override
    public Instant fromNonNullString(String s) {
        return Instant.parse(s);
    }

    @Override
    public Instant fromNonNullValue(BigInteger value) {

    @Override
    public LocalTime fromNonNullString(String s) {
        return LocalTime.parse(s);
    }

    @Override
    public LocalTime fromNonNullValue(Integer value) {

        return new Object[] { value.toLocalDateTime(), value.getOffset() };
    }

    @Override
    public String[] getPropertyNames() {
        return PROPERTY_NAMES;
    }
}

                    zone = ZoneOffset.of(id);
                }
            } catch (RuntimeException ex) {
                zone = null;
            }
            if (zone == null) {
                zone = ZoneOffset.ofTotalSeconds(java.util.TimeZone.getDefault().getOffset(System.currentTimeMillis()) / MILLIS_IN_SECOND);

    @Override
    public Instant fromNonNullString(String s) {
        return new Instant(s);
    }

    @Override
    public Instant fromNonNullValue(BigInteger value) {

    @Override
    public LocalTime fromNonNullString(String s) {
        return new LocalTime(s);
    }

    @Override
    public LocalTime fromNonNullValue(Integer value) {

    @Override
    public TimeOfDay fromNonNullString(String s) {
        return new TimeOfDay(s);
    }

    @Override
    public TimeOfDay fromNonNullValue(Integer value) {

    public LocalTime fromNonNullValue(Time value) {

        DateTime dateTime = new DateTime(value.getTime());
        LocalTime localTime = dateTime.toLocalTime();

    public TimeOfDay fromNonNullValue(Time value) {

        DateTime dateTime = new DateTime(value.getTime());
        LocalTime localTime = dateTime.toLocalTime();

    private static final ColumnMapper<?, ?>[] COLUMN_MAPPERS = new ColumnMapper<?, ?>[] { new TimestampColumnLocalDateTimeMapper(), new StringColumnDateTimeZoneMapper() };

    private static final String[] PROPERTY_NAMES = new String[]{ "datetime", "offset" };

    @Override
    protected DateTime fromConvertedColumns(Object[] convertedColumns) {

public class BigIntegerColumnDurationMapper extends AbstractBigIntegerColumnMapper<Duration> {

    private static final long serialVersionUID = 8408450977695192938L;

    @Override
    public Duration fromNonNullString(String s) {
        return new Duration(s);

        return Duration.millis(value.divide(BigInteger.valueOf(1000000L)).longValue());
    }

    @Override
    public String toNonNullString(Duration value) {
        return value.toString();
    }

    @Override
    public BigInteger toNonNullValue(Duration value) {

public class BigIntegerColumnInstantMapper extends AbstractVersionableBigIntegerColumnMapper<Instant> {

    private static final long serialVersionUID = 8408450977695192938L;

    @Override
    public Instant fromNonNullString(String s) {
        return new Instant(s);

        return new Instant(value.divide(BigInteger.valueOf(1000000L)).longValue());
    }

    @Override
    public String toNonNullString(Instant value) {
        return value.toString();
    }

    @Override
    public BigInteger toNonNullValue(Instant value) {

        return LocalTime.fromMillisOfDay(value);
    }

    @Override
    public String toNonNullString(LocalTime value) {
        return value.toString();
    }

    @Override
    public Integer toNonNullValue(LocalTime value) {

        return TimeOfDay.fromMillisOfDay(value);
    }

    @Override
    public String toNonNullString(TimeOfDay value) {
        return value.toString();
    }

    @Override
    public Integer toNonNullValue(TimeOfDay value) {

        return new Duration(s);
    }

    @Override
    public String toNonNullValue(Duration value) {
        return value.toString();
    }
}

public class PersistentDurationAsNanosBigInteger extends AbstractSingleColumnUserType<Duration, Long, LongColumnDurationMapper> {

    private static final long serialVersionUID = -2339112412473925328L;
}

    	return MonthDay.parse(value.toString(), LOCAL_DATE_FORMATTER);
    }

    @Override
    public String toNonNullString(MonthDay value) {
        return value.toString();
    }

    @Override
    public Date toNonNullValue(MonthDay value) {

public class BigDecimalColumnBigMoneyMapper extends AbstractBigDecimalColumnMapper<BigMoney> implements CurrencyUnitConfigured {

    private static final long serialVersionUID = 4205713919952452881L;
	
    private CurrencyUnit currencyUnit;

    @Override
    public BigMoney fromNonNullValue(BigDecimal val) {

public class BigDecimalColumnFastMoneyMapper extends AbstractBigDecimalColumnMapper<MonetaryAmount> implements CurrencyUnitConfigured {

    private static final long serialVersionUID = 4205713919952452881L;
	
    private CurrencyUnit currencyUnit;

    @Override
    public FastMoney fromNonNullValue(BigDecimal val) {

    private static final ColumnMapper<?, ?>[] COLUMN_MAPPERS = new ColumnMapper<?, ?>[] { new DateColumnLocalDateMapper(), new StringColumnDateTimeZoneWithOffsetMapper() };

    private static final String[] PROPERTY_NAMES = new String[] { "date", "offset" };

    private static final String[] PROPERTY_NAMES = new String[] { "date", "offset" };

    @Override
    protected ColumnMapper<?, ?>[] getColumnMappers() {
        return COLUMN_MAPPERS;
    }

    @Override

public class PersistentDurationAsMillisLong extends AbstractSingleColumnUserType<Duration, Long, LongColumnDurationMapper> {

    private static final long serialVersionUID = 5223443949599090296L;

}

public class PersistentDurationAsSecondsInteger extends AbstractSingleColumnUserType<Duration, Integer, IntegerColumnDurationMapper> {

    private static final long serialVersionUID = 5954125836252428928L;
}

public class PersistentMonthDayAsString extends AbstractSingleColumnUserType<MonthDay, String, StringColumnMonthDayMapper> {

    private static final long serialVersionUID = 5686457807800307458L;
}

public class PersistentYearMonthAsString extends AbstractSingleColumnUserType<YearMonth, String, StringColumnYearMonthMapper> {

    private static final long serialVersionUID = 2203287045641899191L;
}

    public static final DateTimeFormatter LOCAL_TIME_FORMATTER = new DateTimeFormatterBuilder().appendHourOfDay(2).appendLiteral(':').appendMinuteOfHour(2).appendLiteral(':').appendSecondOfMinute(2)

    }

    @Override
    public String toNonNullString(OffsetTime value) {
        return value.toString();
    }

    @Override
    public Time toNonNullValue(OffsetTime value) {

    public static final DateTimeFormatter LOCAL_DATETIME_PRINTER = new DateTimeFormatterBuilder().appendPattern("0001-01-01 HH:mm:ss").appendFraction(ChronoField.NANO_OF_SECOND, 0, 9, true).toFormatter();

    public static final DateTimeFormatter LOCAL_DATETIME_PARSER = new DateTimeFormatterBuilder().appendPattern("yyyy-MM-dd HH:mm:ss").appendFraction(ChronoField.NANO_OF_SECOND, 0, 9, true).toFormatter();

    private static final ColumnMapper<?, ?>[] COLUMN_MAPPERS = new ColumnMapper<?, ?>[] { new StringColumnLocalDateTimeMapper(), new StringColumnZoneOffsetMapper() };

    private static final String[] PROPERTY_NAMES = new String[]{ "datetime", "offset" };

    	if (!currencyUnit.equals(value.getCurrencyUnit())) {
    		throw new IllegalStateException("Expected currency " + currencyUnit.getCurrencyCode() + " but was " + value.getCurrencyUnit());

public class PersistentCurrencyUnit extends AbstractSingleColumnUserType<CurrencyUnit, String, StringColumnCurrencyUnitMapper> {

	private static final long serialVersionUID = 5653012946771904484L;
}

public class BigDecimalColumnFastMoneyMapper extends AbstractBigDecimalColumnMapper<MonetaryAmount> implements CurrencyUnitConfigured {

    private static final long serialVersionUID = 4205713919952452881L;
	
    private CurrencyUnit currencyUnit;

    @Override
    public FastMoney fromNonNullValue(BigDecimal val) {

public class LongColumnFastMoneyMajorMapper extends AbstractLongColumnMapper<MonetaryAmount> implements CurrencyUnitConfigured {

    private static final long serialVersionUID = 4205713919952452881L;
	
    private CurrencyUnit currencyUnit;

    @Override
    public FastMoney fromNonNullValue(Long val) {

	public Object doNullSafeGet(ResultSet rs, String[] names, SharedSessionContractImplementor session, Object owner) throws HibernateException, SQLException, IllegalArgumentException, IllegalAccessException, InvocationTargetException {

    public static final DateTimeFormatter LOCAL_DATE_FORMATTER = new DateTimeFormatterBuilder().appendPattern("yyyy-MM-dd").toFormatter();

    public DateColumnLocalDateMapper() {

    private static final DateTimeFormatter DATE_TIME_PARSER = new DateTimeFormatterBuilder()
        .append(ISODateTimeFormat.date())
        .appendLiteral('T')
        .append(ISODateTimeFormat.hourMinuteSecondFraction())

    }

    @Override
    public String[] getPropertyNames() {
        return ArrayUtils.copyOf(PROPERTY_NAMES);
    }
}

public class PersistentInstantAsNanosBigInteger extends AbstractVersionableUserType<Instant, BigInteger, BigIntegerColumnInstantMapper> {

    private static final long serialVersionUID = -1319869221068626293L;

public class LongColumnMoneyMajorMapper extends AbstractLongColumnMapper<Money> implements CurrencyUnitConfigured {

    private static final long serialVersionUID = 4205713919952452881L;
	
    private CurrencyUnit currencyUnit;

    @Override
    public Money fromNonNullValue(Long val) {

        return new Object[] { value.getCurrency(), MonetaryQueries.extractMajorPart().queryFrom(value).longValue() };
    }
    
    @Override
	public String[] getPropertyNames() {
		return PROPERTY_NAMES;
	}
}

    public StringColumnUnitMapper() {
    	for (Unit<?> next : SYSTEM_OF_UNITS_SERVICE.getSystemOfUnits().getUnits()) {