org.hibernate.type.CustomType.java Source code

Java tutorial

Introduction

Here is the source code for org.hibernate.type.CustomType.java

Source

/*
 * Hibernate, Relational Persistence for Idiomatic Java
 *
 * License: GNU Lesser General Public License (LGPL), version 2.1 or later.
 * See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>.
 */
package org.hibernate.type;

import java.io.Serializable;
import java.sql.CallableStatement;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Arrays;
import java.util.Comparator;
import java.util.Map;

import org.hibernate.HibernateException;
import org.hibernate.MappingException;
import org.hibernate.dialect.Dialect;
import org.hibernate.engine.jdbc.Size;
import org.hibernate.engine.spi.Mapping;
import org.hibernate.engine.spi.SessionFactoryImplementor;
import org.hibernate.engine.spi.SharedSessionContractImplementor;
import org.hibernate.internal.util.collections.ArrayHelper;
import org.hibernate.usertype.EnhancedUserType;
import org.hibernate.usertype.LoggableUserType;
import org.hibernate.usertype.Sized;
import org.hibernate.usertype.UserType;
import org.hibernate.usertype.UserVersionType;

/**
 * Adapts {@link UserType} to the generic {@link Type} interface, in order
 * to isolate user code from changes in the internal Type contracts.
 *
 * @author Gavin King
 * @author Steve Ebersole
 */
public class CustomType extends AbstractType implements IdentifierType, DiscriminatorType, VersionType, BasicType,
        StringRepresentableType, ProcedureParameterNamedBinder, ProcedureParameterExtractionAware {

    private final UserType userType;
    private final String name;
    private final int[] types;
    private final Size[] dictatedSizes;
    private final Size[] defaultSizes;
    private final boolean customLogging;
    private final String[] registrationKeys;

    public CustomType(UserType userType) throws MappingException {
        this(userType, ArrayHelper.EMPTY_STRING_ARRAY);
    }

    public CustomType(UserType userType, String[] registrationKeys) throws MappingException {
        this.userType = userType;
        this.name = userType.getClass().getName();
        this.types = userType.sqlTypes();
        this.dictatedSizes = Sized.class.isInstance(userType) ? ((Sized) userType).dictatedSizes()
                : new Size[types.length];
        this.defaultSizes = Sized.class.isInstance(userType) ? ((Sized) userType).defaultSizes()
                : new Size[types.length];
        this.customLogging = LoggableUserType.class.isInstance(userType);
        this.registrationKeys = registrationKeys;
    }

    public UserType getUserType() {
        return userType;
    }

    @Override
    public String[] getRegistrationKeys() {
        return registrationKeys;
    }

    @Override
    public int[] sqlTypes(Mapping pi) {
        return types;
    }

    @Override
    public Size[] dictatedSizes(Mapping mapping) throws MappingException {
        return dictatedSizes;
    }

    @Override
    public Size[] defaultSizes(Mapping mapping) throws MappingException {
        return defaultSizes;
    }

    @Override
    public int getColumnSpan(Mapping session) {
        return types.length;
    }

    @Override
    public Class getReturnedClass() {
        return getUserType().returnedClass();
    }

    @Override
    public boolean isEqual(Object x, Object y) throws HibernateException {
        return getUserType().equals(x, y);
    }

    @Override
    public int getHashCode(Object x) {
        return getUserType().hashCode(x);
    }

    @Override
    public Object nullSafeGet(ResultSet rs, String[] names, SharedSessionContractImplementor session, Object owner)
            throws SQLException {
        return getUserType().nullSafeGet(rs, names, session, owner);
    }

    @Override
    public Object nullSafeGet(ResultSet rs, String columnName, SharedSessionContractImplementor session,
            Object owner) throws SQLException {
        return nullSafeGet(rs, new String[] { columnName }, session, owner);
    }

    @Override
    public Object assemble(Serializable cached, SharedSessionContractImplementor session, Object owner) {
        return getUserType().assemble(cached, owner);
    }

    @Override
    public Serializable disassemble(Object value, SharedSessionContractImplementor session, Object owner) {
        return getUserType().disassemble(value);
    }

    @Override
    public Object replace(Object original, Object target, SharedSessionContractImplementor session, Object owner,
            Map copyCache) throws HibernateException {
        return getUserType().replace(original, target, owner);
    }

    @Override
    public void nullSafeSet(PreparedStatement st, Object value, int index, boolean[] settable,
            SharedSessionContractImplementor session) throws SQLException {
        if (settable[0]) {
            getUserType().nullSafeSet(st, value, index, session);
        }
    }

    @Override
    public void nullSafeSet(PreparedStatement st, Object value, int index, SharedSessionContractImplementor session)
            throws SQLException {
        getUserType().nullSafeSet(st, value, index, session);
    }

    @SuppressWarnings({ "UnusedDeclaration" })
    public String toXMLString(Object value, SessionFactoryImplementor factory) {
        return toString(value);
    }

    @SuppressWarnings({ "UnusedDeclaration" })
    public Object fromXMLString(String xml, Mapping factory) {
        return fromStringValue(xml);
    }

    @Override
    public String getName() {
        return name;
    }

    @Override
    public Object deepCopy(Object value, SessionFactoryImplementor factory) throws HibernateException {
        return getUserType().deepCopy(value);
    }

    @Override
    public boolean isMutable() {
        return getUserType().isMutable();
    }

    @Override
    public Object stringToObject(String xml) {
        return fromStringValue(xml);
    }

    @Override
    public String objectToSQLString(Object value, Dialect dialect) throws Exception {
        return ((EnhancedUserType) getUserType()).objectToSQLString(value);
    }

    @Override
    public Comparator getComparator() {
        return (Comparator) getUserType();
    }

    @Override
    public Object next(Object current, SharedSessionContractImplementor session) {
        return ((UserVersionType) getUserType()).next(current, session);
    }

    @Override
    public Object seed(SharedSessionContractImplementor session) {
        return ((UserVersionType) getUserType()).seed(session);
    }

    @Override
    public String toLoggableString(Object value, SessionFactoryImplementor factory) throws HibernateException {
        if (value == null) {
            return "null";
        } else if (customLogging) {
            return ((LoggableUserType) getUserType()).toLoggableString(value, factory);
        } else {
            return toXMLString(value, factory);
        }
    }

    @Override
    public boolean[] toColumnNullness(Object value, Mapping mapping) {
        boolean[] result = new boolean[getColumnSpan(mapping)];
        if (value != null) {
            Arrays.fill(result, true);
        }
        return result;
    }

    @Override
    public boolean isDirty(Object old, Object current, boolean[] checkable,
            SharedSessionContractImplementor session) throws HibernateException {
        return checkable[0] && isDirty(old, current, session);
    }

    @Override
    @SuppressWarnings("unchecked")
    public String toString(Object value) throws HibernateException {
        if (StringRepresentableType.class.isInstance(getUserType())) {
            return ((StringRepresentableType) getUserType()).toString(value);
        }
        if (value == null) {
            return null;
        }
        if (EnhancedUserType.class.isInstance(getUserType())) {
            //noinspection deprecation
            return ((EnhancedUserType) getUserType()).toXMLString(value);
        }
        return value.toString();
    }

    @Override
    public Object fromStringValue(String string) throws HibernateException {
        if (StringRepresentableType.class.isInstance(getUserType())) {
            return ((StringRepresentableType) getUserType()).fromStringValue(string);
        }
        if (EnhancedUserType.class.isInstance(getUserType())) {
            //noinspection deprecation
            return ((EnhancedUserType) getUserType()).fromXMLString(string);
        }
        throw new HibernateException(
                String.format("Could not process #fromStringValue, UserType class [%s] did not implement %s or %s",
                        name, StringRepresentableType.class.getName(), EnhancedUserType.class.getName()));
    }

    @Override
    public boolean canDoSetting() {
        if (ProcedureParameterNamedBinder.class.isInstance(getUserType())) {
            return ((ProcedureParameterNamedBinder) getUserType()).canDoSetting();
        }
        return false;
    }

    @Override
    public void nullSafeSet(CallableStatement statement, Object value, String name,
            SharedSessionContractImplementor session) throws SQLException {
        if (canDoSetting()) {
            ((ProcedureParameterNamedBinder) getUserType()).nullSafeSet(statement, value, name, session);
        } else {
            throw new UnsupportedOperationException(
                    "Type [" + getUserType() + "] does support parameter binding by name");
        }
    }

    @Override
    public boolean canDoExtraction() {
        if (ProcedureParameterExtractionAware.class.isInstance(getUserType())) {
            return ((ProcedureParameterExtractionAware) getUserType()).canDoExtraction();
        }
        return false;
    }

    @Override
    public Object extract(CallableStatement statement, int startIndex, SharedSessionContractImplementor session)
            throws SQLException {
        if (canDoExtraction()) {
            return ((ProcedureParameterExtractionAware) getUserType()).extract(statement, startIndex, session);
        } else {
            throw new UnsupportedOperationException(
                    "Type [" + getUserType() + "] does support parameter value extraction");
        }
    }

    @Override
    public Object extract(CallableStatement statement, String[] paramNames,
            SharedSessionContractImplementor session) throws SQLException {
        if (canDoExtraction()) {
            return ((ProcedureParameterExtractionAware) getUserType()).extract(statement, paramNames, session);
        } else {
            throw new UnsupportedOperationException(
                    "Type [" + getUserType() + "] does support parameter value extraction");
        }
    }

    @Override
    public int hashCode() {
        return getUserType().hashCode();
    }

    @Override
    public boolean equals(Object obj) {
        return (obj instanceof CustomType) && getUserType().equals(((CustomType) obj).getUserType());
    }
}