private void performDatabaseZoneConfiguration(DatabaseZoneConfigured next) {
		
        String databaseZone = null;
        if (getParameterValues() != null) {
        	databaseZone = getParameterValues().getProperty("databaseZone");
        }
		if (databaseZone == null) {
			databaseZone = ConfigurationHelper.getProperty("databaseZone");
		}
		
        if (databaseZone != null) {
            if ("jvm".equals(databaseZone)) {
                next.setDatabaseZone(null);
            } else {
            	next.setDatabaseZone(next.parseZone(databaseZone));
            }
        }
	}
	
	private <Z> void performJavaZoneConfiguration(JavaZoneConfigured<Z> next) {
		
		String javaZone = null;
        if (getParameterValues() != null) {
        	javaZone = getParameterValues().getProperty("javaZone");
        }
		if (javaZone == null) {
			javaZone = ConfigurationHelper.getProperty("javaZone");
		}
		
        if (javaZone != null) {
            if ("jvm".equals(javaZone)) {
                next.setJavaZone(null);
            } else {
            	next.setJavaZone(next.parseJavaZone(javaZone));
            }
        }
	}	
}

		}
    }
		
	@SuppressWarnings("unused")
	private void performJdbc42Configuration(Jdbc42Configured next) {
        
        Boolean jdbc42Apis = null;
        if (getParameterValues() != null) {
            String apisString = getParameterValues().getProperty("jdbc42Apis");
            if (apisString != null) {
                jdbc42Apis = Boolean.parseBoolean(apisString);
            }
        }
        if (jdbc42Apis == null) {
            jdbc42Apis = ConfigurationHelper.getUse42Api();
        }
        if (jdbc42Apis == null) {
            jdbc42Apis = Boolean.FALSE;
        }
        
        next.setUseJdbc42Apis(jdbc42Apis);
    }
	
	@Override
	protected SharedSessionContractImplementor doWrapSession(SharedSessionContractImplementor session) {
		SharedSessionContractImplementor mySession = session;

							javaTypeDescriptor.unwrap(value, Date.class, options), cal);	
				}
			}
		};
	}
	
	public <X> ValueExtractor<X> getExtractor(
			final JavaTypeDescriptor<X> javaTypeDescriptor) {
		return new BasicExtractor<X>(javaTypeDescriptor, (SqlTypeDescriptor) this) {
			@Override
			protected X doExtract(ResultSet rs, String name,
					WrapperOptions options) throws SQLException {
				if (cal == null) {
					return javaTypeDescriptor.wrap(rs.getDate(name), options);

							javaTypeDescriptor.unwrap(value, Date.class, options), cal);	
				}
			}

			@Override
			protected void doBind(CallableStatement st, X value, String name, WrapperOptions options)
					throws SQLException {
				if (cal == null) {
					st.setDate(name,

					return javaTypeDescriptor.wrap(statement.getDate(index, cal), options);	
				}
			}

			protected X doExtract(CallableStatement statement, String name, WrapperOptions options) throws SQLException {
				if (cal == null) {
					return javaTypeDescriptor.wrap(statement.getDate(name), options);

            return super.createNativeEntityManagerFactory();
        } finally {

            if (this.transactionManager != null) {
                configurationTransactionManagerHolder.set(null);
            }
        }
    }

    /**
     * Associate a transaction manager with this session
     * @param transactionManager The {@link JtaTransactionManager}
     */
    public void setTransactionManager(JtaTransactionManager transactionManager) {
        this.transactionManager = transactionManager;
    }
}

    @Override
    public T nullSafeGet(ResultSet resultSet, String[] strings, SharedSessionContractImplementor session, Object object) throws SQLException {

    	beforeNullSafeOperation(session);
    	
    	final SharedSessionContractImplementor mySession = doWrapSession(session);
    	
    	try {

public class HibernateEntityManagerFactoryBean extends LocalContainerEntityManagerFactoryBean {

    private JtaTransactionManager transactionManager;

    private static final ThreadLocal<JtaTransactionManager> configurationTransactionManagerHolder = new ThreadLocal<JtaTransactionManager>();

    static JtaTransactionManager getConfigurationTransactionManager() {
        return configurationTransactionManagerHolder.get();
    }

    @Override
    protected EntityManagerFactory createNativeEntityManagerFactory() throws PersistenceException {

    @Override
    public void nullSafeSet(PreparedStatement preparedStatement, Object value, int index, SharedSessionContractImplementor session) throws SQLException {

    	beforeNullSafeOperation(session);
    	
    	final SharedSessionContractImplementor mySession = doWrapSession(session);
    	
    	try {
	        final Object[] valuesToSet = new Object[getColumnMappers().length];

                throw new IllegalStateException("Could not access setRollbackOnly() on UOWManager: " + e.getMessage(),
                        e);
            } catch (InvocationTargetException e) {
                throw new IllegalStateException("Could not invoke setRollbackOnly() on UOWManager: " + e.getMessage(),
                        e);
            }
        }

        @Override
        public Transaction getTransaction() {

		}
		if (WrapsSession.class.isAssignableFrom(this.getClass())) {
			mySession = ((WrapsSession)this).wrapSession(mySession);
		}
		return mySession;
	}
}

		super.setParameterValues(parameters);
	}

    @SuppressWarnings("unchecked")
    @Override
    public Class<T> returnedClass() {
        return (Class<T>) TypeHelper.getTypeArguments(AbstractKnownClassHeuristicUserType.class, getClass()).get(0);

	private void registerType(Configuration configuration, CompositeUserType type) {
		String className = type.returnedClass().getName();
		configuration.registerTypeOverride(type, new String[] {className});
	}
	
	private void registerType(Configuration configuration, UserType type) {

	private void registerType(MetadataImplementor mi, CompositeUserType type) {
		String className = type.returnedClass().getName();
		mi.getTypeResolver().registerTypeOverride(type, new String[] {className});
	}

			String jdbc42Apis = configuration.getProperty(JDBC42_API_KEY);
			
			configureDefaultProperties(sessionFactory, javaZone, databaseZone, seed, currencyCode, jdbc42Apis);
		
			if (isEnabled != null && Boolean.valueOf(isEnabled)) {
				autoRegisterUsertypes(configuration);

    @Override
    public void nullSafeSet(PreparedStatement preparedStatement, Object value, int index, SharedSessionContractImplementor session) throws SQLException {

    	beforeNullSafeOperation(session);
    	
    	try {
    		doNullSafeSet(preparedStatement, value, index, session);

			SharedSessionContractImplementor session, Object owner)
			throws HibernateException, SQLException {

		@SuppressWarnings("unchecked") final J hibernateValue = (J) columnMapper.getHibernateType().nullSafeGet(rs, name, session, owner);

	@SuppressWarnings("unchecked")
	@Override
    public void nullSafeSet(PreparedStatement preparedStatement, Object value, int index, SharedSessionContractImplementor session) throws SQLException {

    	beforeNullSafeOperation(session);

    public Map<K, V> nullSafeGet(ResultSet resultSet, String[] strings, SharedSessionContractImplementor session, Object object) throws SQLException {
        
    	beforeNullSafeOperation(session);

	        performJdbc42Configuration(next);
	    }
		
		for (int i = 0; i < getColumnMappers().length; i++) {
			
		    if (JavaVersion.isJava8OrLater() &&

		@SuppressWarnings("unchecked") final J hibernateValue = (J)(columnMapper.getHibernateType().nullSafeGet(rs, names, session, owner));
		if (hibernateValue == null) {
			return null;
		}
		return columnMapper.fromNonNullValue(hibernateValue);
	}

	@Override
	public Object nullSafeGet(ResultSet rs, String name,

			protected X doExtract(CallableStatement statement, int index, WrapperOptions options) throws SQLException {
				if (cal == null) {
					return javaTypeDescriptor.wrap(statement.getDate(index), options);

			protected X doExtract(CallableStatement statement, int index, WrapperOptions options) throws SQLException {
				if (cal == null) {
					return javaTypeDescriptor.wrap(statement.getTimestamp(index), options);

			protected X doExtract(CallableStatement statement, int index, WrapperOptions options) throws SQLException {
				if (cal == null) {
					return javaTypeDescriptor.wrap(statement.getTime(index), options);

				: new Timestamp(value.getTime());
		// TODO : use JDBC date literal escape syntax? -> {d 'date-string'} in
		// yyyy-mm-dd hh:mm:ss[.f...] format
		return StringType.INSTANCE.objectToSQLString(ts.toString(), dialect);
	}

			super.load(reader);
			this.properties.putAll(this);
		}
		finally{
			super.clear();
		}
	}

	@Override
	public void load(InputStream inStream) throws IOException {

			} catch (IllegalArgumentException e) {
				throw new HibernateException(
						"Exception during nullSafeGet of type '" 
							+ identifierType.getName() + "'", e);
			} catch (IllegalAccessException e) {

							+ identifierType.getName() + "'", e);
			} catch (IllegalAccessException e) {
				throw new HibernateException(

		} catch (IllegalArgumentException e) {
			throw new HibernateException(
					"Exception during nullSafeSet of type '" 
							+ identifierType.getName() + "'", e);
		} catch (IllegalAccessException e) {

			final boolean use42Api = use42Api(configuration.getProperty(JDBC42_API_KEY), sessionFactory);
			ConfigurationHelper.setUse42Api(sessionFactory, use42Api);
			
			// doIntegrate(configuration, sessionFactory, serviceRegistry);
		} finally {
			ConfigurationHelper.setCurrentSessionFactory(null);
		}
	}

	public boolean isDirty(Object oldState, Object currentState,
			boolean[] checkable, SharedSessionContractImplementor session)
			throws HibernateException {
		return columnMapper.getHibernateType().isDirty(oldState, currentState, checkable, session);

		return columnMapper.fromNonNullValue(hibernateValue);
	}

	@SuppressWarnings("unchecked")
	@Override
	public void nullSafeSet(PreparedStatement st, Object value, int index,

			SharedSessionContractImplementor session, Object owner, @SuppressWarnings("rawtypes") Map copyCache)
			throws HibernateException {
		return columnMapper.getHibernateType().replace(original, target, session, owner, copyCache);

			protected X doExtract(ResultSet rs, String name,
					WrapperOptions options) throws SQLException {
				if (cal == null) {
					return javaTypeDescriptor.wrap(rs.getDate(name), options);

				java.sql.Date.class.getName()
		};
	}

	public String objectToSQLString(Date value, Dialect dialect) throws Exception {
		final java.sql.Date jdbcDate = java.sql.Date.class.isInstance( value )

public abstract class AbstractBigDecimalColumnMapper<T> extends AbstractColumnMapper<T, BigDecimal> {

    private static final long serialVersionUID = 1702998875351962961L;

    @Override
    public final int getSqlType() {
        return Types.NUMERIC;

public abstract class AbstractIntegerColumnMapper<T> extends AbstractColumnMapper<T, Integer> {

    private static final long serialVersionUID = 6892220362704239520L;

    @Override
    public final int getSqlType() {
        return Types.INTEGER;

        return super.disassemble(value);
    }

    @Override
    public Object assemble(Serializable cached, SharedSessionContractImplementor session, Object owner) throws HibernateException {
        return super.assemble(cached, owner);

		configuration.registerTypeOverride(type, new String[] {className});
	}
	
	private void registerType(MetadataImplementor mi, CompositeUserType type) {

		@SuppressWarnings("unchecked") final J hibernateValue = (J)(columnMapper.getHibernateType().nullSafeGet(rs, names, session, owner));
		if (hibernateValue == null) {
			return null;
		}
		return columnMapper.fromNonNullValue(hibernateValue);
	}

	@Override

			protected X doExtract(CallableStatement statement, int index, WrapperOptions options) throws SQLException {
				if (cal == null) {
					return javaTypeDescriptor.wrap(statement.getDate(index), options);

	}

	@Override
	public String[] getRegistrationKeys() {
		return new String[] {
				getName(),

	public Object computeIfPresent(Object key,
			BiFunction<? super Object, ? super Object, ? extends Object> remappingFunction) {
		return properties.computeIfPresent(key, remappingFunction);

                    + e.getMessage(), e);
        } catch (IllegalAccessException e) {
            throw new IllegalStateException("Unexpected exception accessing WebSphereUowTransactionManager: "

                throw new IllegalStateException("Could not access setRollbackOnly() on UOWManager: " + e.getMessage(),
                        e);
            } catch (InvocationTargetException e) {
                throw new IllegalStateException("Could not invoke setRollbackOnly() on UOWManager: " + e.getMessage(),

			getEntityManager().remove(entity);
		}
		// Case of unattached entity, first it is necessary to perform
		// a merge, before doing the remove
		else {
			entity = getEntityManager().merge(entity);
			getEntityManager().remove(entity);

			} catch (IllegalArgumentException e) {
				throw new HibernateException(
						"Exception during nullSafeGet of type '" 
							+ identifierType.getName() + "'", e);
			} catch (IllegalAccessException e) {

		            Jdbc42Configured.class.isAssignableFrom(getColumnMappers()[i].getClass())) {
		        Jdbc42Configured next = (Jdbc42Configured)this;
		        performJdbc42Configuration(next);
		    }
		}

		@SuppressWarnings("unchecked") final J hibernateValue = (J)(columnMapper.getHibernateType().nullSafeGet(rs, names, session, owner));
		if (hibernateValue == null) {
			return null;
		}
		return columnMapper.fromNonNullValue(hibernateValue);
	}

	@Override

		bw.newLine();
		for (Map.Entry<Object, Object> entry : properties.entrySet()) {