Workspace/Siman-Common/src/org/splat/dal/bo/kernel/GenericEnumType.java

   1 package org.splat.dal.bo.kernel;
   2
   3 /**
   4  *
   5  * @author    Daniel Brunier-Coulin
   6  * @copyright OPEN CASCADE 2012
   7  */
   8 import java.io.Serializable;
   9 import java.sql.PreparedStatement;
  10 import java.sql.ResultSet;
  11 import java.sql.SQLException;
  12 import java.sql.Types;
  13 import java.util.Properties;
  14
  15 import org.hibernate.HibernateException;
  16 import org.hibernate.usertype.EnhancedUserType;
  17 import org.hibernate.usertype.ParameterizedType;
  18 import org.splat.common.Constants;
  19
  20 /**
  21  * Base class for persistent enumerations. <BR>
  22  * Parameter enumClassName defines the enumeration implementation class in <BR>
  23  * hibernate mapping like this:<BR>
  24  * <code>
  25  * &lt;typedef name="ProgressState" class="<i>org.splat.dal.bo.kernel.GenericEnumType</i>"&gt;<BR>
  26  * &nbsp;&nbsp;&lt;param name="<i>enumClassName</i>"&gt;org.splat.dal.bo.som.ProgressState&lt;/param&gt;<BR>
  27  * &lt;/typedef&gt;<BR>
  28  * </code>
  29  */
  30 public class GenericEnumType implements EnhancedUserType, ParameterizedType {
  31
  32         /**
  33          * Enumeration implementation class.
  34          */
  35         @SuppressWarnings(Constants.UNCHECKED)
  36         private transient Class<Enum> _enumClass;
  37
  38         /**
  39          * {@inheritDoc}
  40          *
  41          * @see org.hibernate.usertype.ParameterizedType#setParameterValues(java.util.Properties)
  42          */
  43         @SuppressWarnings(Constants.UNCHECKED)
  44         public void setParameterValues(final Properties parameters) {
  45                 String enumClassName = parameters.getProperty("enumClassName");
  46                 try {
  47                         _enumClass = (Class<Enum>) Class.forName(enumClassName);
  48                 } catch (ClassNotFoundException cnfe) {
  49                         throw new HibernateException("Enum class not found", cnfe);
  50                 }
  51         }
  52
  53         /**
  54          * {@inheritDoc}
  55          *
  56          * @see org.hibernate.usertype.UserType#assemble(java.io.Serializable, java.lang.Object)
  57          */
  58         public Object assemble(final Serializable cached, final Object owner)
  59                         throws HibernateException {
  60                 return cached;
  61         }
  62
  63         /**
  64          * {@inheritDoc}
  65          *
  66          * @see org.hibernate.usertype.UserType#deepCopy(java.lang.Object)
  67          */
  68         public Object deepCopy(final Object value) throws HibernateException {
  69                 return value;
  70         }
  71
  72         /**
  73          * {@inheritDoc}
  74          *
  75          * @see org.hibernate.usertype.UserType#disassemble(java.lang.Object)
  76          */
  77         @SuppressWarnings(Constants.UNCHECKED)
  78         public Serializable disassemble(final Object value)
  79                         throws HibernateException {
  80                 return (Enum) value;
  81         }
  82
  83         /**
  84          * {@inheritDoc}
  85          *
  86          * @see org.hibernate.usertype.UserType#equals(java.lang.Object, java.lang.Object)
  87          */
  88         public boolean equals(final Object x, final Object y)
  89                         throws HibernateException {
  90                 return x.equals(y);
  91         }
  92
  93         /**
  94          * {@inheritDoc}
  95          *
  96          * @see org.hibernate.usertype.UserType#hashCode(java.lang.Object)
  97          */
  98         public int hashCode(final Object x) throws HibernateException {
  99                 return x.hashCode();
 100         }
 101
 102         /**
 103          * {@inheritDoc}
 104          *
 105          * @see org.hibernate.usertype.UserType#isMutable()
 106          */
 107         public boolean isMutable() {
 108                 return false;
 109         }
 110
 111         /**
 112          * {@inheritDoc}
 113          *
 114          * @see org.hibernate.usertype.UserType#nullSafeGet(java.sql.ResultSet, java.lang.String[], java.lang.Object)
 115          */
 116         @SuppressWarnings(Constants.UNCHECKED)
 117         public Object nullSafeGet(final ResultSet rs, final String[] names,
 118                         final Object owner) throws HibernateException, SQLException {
 119                 Object res = null;
 120                 if (!rs.wasNull()) {
 121                         String name = rs.getString(names[0]);
 122                         res = Enum.valueOf(_enumClass, name);
 123                 }
 124                 return res;
 125         }
 126
 127         /**
 128          * {@inheritDoc}
 129          *
 130          * @see org.hibernate.usertype.UserType#nullSafeSet(java.sql.PreparedStatement, java.lang.Object, int)
 131          */
 132         @SuppressWarnings(Constants.UNCHECKED)
 133         public void nullSafeSet(final PreparedStatement st, final Object value,
 134                         final int index) throws HibernateException, SQLException {
 135                 if (value == null) {
 136                         st.setNull(index, Types.VARCHAR);
 137                 } else {
 138                         st.setString(index, ((Enum) value).name());
 139                 }
 140         }
 141
 142         /**
 143          * {@inheritDoc}
 144          *
 145          * @see org.hibernate.usertype.UserType#replace(java.lang.Object, java.lang.Object, java.lang.Object)
 146          */
 147         public Object replace(final Object original, final Object target,
 148                         final Object owner) throws HibernateException {
 149                 return original;
 150         }
 151
 152         /**
 153          * {@inheritDoc}
 154          *
 155          * @see org.hibernate.usertype.UserType#returnedClass()
 156          */
 157         @SuppressWarnings(Constants.UNCHECKED)
 158         public Class returnedClass() {
 159                 return _enumClass;
 160         }
 161
 162         /**
 163          * {@inheritDoc}
 164          *
 165          * @see org.hibernate.usertype.UserType#sqlTypes()
 166          */
 167         public int[] sqlTypes() {
 168                 return new int[] { Types.VARCHAR };
 169         }
 170
 171         /**
 172          * {@inheritDoc}
 173          *
 174          * @see org.hibernate.usertype.EnhancedUserType#fromXMLString(java.lang.String)
 175          */
 176         @SuppressWarnings(Constants.UNCHECKED)
 177         public Object fromXMLString(final String xmlValue) {
 178                 return Enum.valueOf(_enumClass, xmlValue);
 179         }
 180
 181         /**
 182          * {@inheritDoc}
 183          *
 184          * @see org.hibernate.usertype.EnhancedUserType#objectToSQLString(java.lang.Object)
 185          */
 186         @SuppressWarnings(Constants.UNCHECKED)
 187         public String objectToSQLString(final Object value) {
 188                 return '\'' + ((Enum) value).name() + '\'';
 189         }
 190
 191         /**
 192          * {@inheritDoc}
 193          *
 194          * @see org.hibernate.usertype.EnhancedUserType#toXMLString(java.lang.Object)
 195          */
 196         @SuppressWarnings(Constants.UNCHECKED)
 197         public String toXMLString(final Object value) {
 198                 return ((Enum) value).name();
 199         }
 200 }