1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16 package org.jadira.usertype.spi.shared;
17
18 import java.io.Serializable;
19 import java.sql.PreparedStatement;
20 import java.sql.ResultSet;
21 import java.sql.SQLException;
22 import java.util.Map;
23
24 import org.hibernate.HibernateException;
25 import org.hibernate.MappingException;
26 import org.hibernate.engine.jdbc.Size;
27 import org.hibernate.engine.spi.Mapping;
28 import org.hibernate.engine.spi.SessionFactoryImplementor;
29 import org.hibernate.engine.spi.SharedSessionContractImplementor;
30 import org.hibernate.type.ForeignKeyDirection;
31 import org.hibernate.type.SingleColumnType;
32 import org.hibernate.type.Type;
33
34 public class ColumnMapperSingleColumnTypeAdapter<T,J> implements SingleColumnType<T> {
35
36 private static final long serialVersionUID = -8396126842631394890L;
37
38 private ColumnMapper<T, J> columnMapper;
39
40 public ColumnMapperSingleColumnTypeAdapter(ColumnMapper<T, J> columnMapper) {
41 this.columnMapper = columnMapper;
42 }
43
44 @Override
45 public boolean isAssociationType() {
46 return columnMapper.getHibernateType().isAssociationType();
47 }
48
49 @Override
50 public boolean isCollectionType() {
51 return columnMapper.getHibernateType().isCollectionType();
52 }
53
54 @Override
55 public boolean isEntityType() {
56 return columnMapper.getHibernateType().isEntityType();
57 }
58
59 @Override
60 public boolean isAnyType() {
61 return columnMapper.getHibernateType().isAnyType();
62 }
63
64 @Override
65 public boolean isComponentType() {
66 return columnMapper.getHibernateType().isComponentType();
67 }
68
69 @Override
70 public int getColumnSpan(Mapping mapping) throws MappingException {
71 return columnMapper.getHibernateType().getColumnSpan(mapping);
72 }
73
74 @Override
75 public int[] sqlTypes(Mapping mapping) throws MappingException {
76 return new int[] { columnMapper.getSqlType() };
77 }
78
79 @Override
80 public Size[] dictatedSizes(Mapping mapping) throws MappingException {
81 return columnMapper.getHibernateType().dictatedSizes(mapping);
82 }
83
84 @Override
85 public Size[] defaultSizes(Mapping mapping) throws MappingException {
86 return columnMapper.getHibernateType().defaultSizes(mapping);
87 }
88
89 @SuppressWarnings("rawtypes")
90 @Override
91 public Class getReturnedClass() {
92 return columnMapper.returnedClass();
93 }
94
95 @Override
96 public boolean isSame(Object x, Object y) throws HibernateException {
97 return columnMapper.getHibernateType().isSame(x, y);
98 }
99
100 @Override
101 public boolean isEqual(Object x, Object y) throws HibernateException {
102 return columnMapper.getHibernateType().isEqual(x, y);
103 }
104
105 @Override
106 public boolean isEqual(Object x, Object y, SessionFactoryImplementor factory)
107 throws HibernateException {
108 return columnMapper.getHibernateType().isEqual(x, y, factory);
109 }
110
111 @Override
112 public int getHashCode(Object x) throws HibernateException {
113 return columnMapper.getHibernateType().getHashCode(x);
114 }
115
116 @Override
117 public int getHashCode(Object x, SessionFactoryImplementor factory)
118 throws HibernateException {
119 return columnMapper.getHibernateType().getHashCode(x, factory);
120 }
121
122 @Override
123 public int compare(Object x, Object y) {
124 return columnMapper.getHibernateType().compare(x, y);
125 }
126
127 @Override
128 public boolean isDirty(Object old, Object current,
129 SharedSessionContractImplementor session) throws HibernateException {
130 return columnMapper.getHibernateType().isDirty(old, current, session);
131 }
132
133 @Override
134 public boolean isDirty(Object oldState, Object currentState,
135 boolean[] checkable, SharedSessionContractImplementor session)
136 throws HibernateException {
137 return columnMapper.getHibernateType().isDirty(oldState, currentState, checkable, session);
138 }
139
140 @Override
141 public boolean isModified(Object dbState, Object currentState,
142 boolean[] checkable, SharedSessionContractImplementor session)
143 throws HibernateException {
144 return columnMapper.getHibernateType().isModified(dbState, currentState, checkable, session);
145 }
146
147
148 @Override
149 public Object nullSafeGet(ResultSet rs, String[] names,
150 SharedSessionContractImplementor session, Object owner)
151 throws HibernateException, SQLException {
152
153 @SuppressWarnings("unchecked") final J hibernateValue = (J)(columnMapper.getHibernateType().nullSafeGet(rs, names, session, owner));
154 if (hibernateValue == null) {
155 return null;
156 }
157 return columnMapper.fromNonNullValue(hibernateValue);
158 }
159
160 @Override
161 public Object nullSafeGet(ResultSet rs, String name,
162 SharedSessionContractImplementor session, Object owner)
163 throws HibernateException, SQLException {
164
165 @SuppressWarnings("unchecked") final J hibernateValue = (J) columnMapper.getHibernateType().nullSafeGet(rs, name, session, owner);
166 if (hibernateValue == null) {
167 return null;
168 }
169 return columnMapper.fromNonNullValue(hibernateValue);
170 }
171
172 @SuppressWarnings("unchecked")
173 @Override
174 public void nullSafeSet(PreparedStatement st, Object value, int index,
175 boolean[] settable, SharedSessionContractImplementor session)
176 throws HibernateException, SQLException {
177
178 final Object param = value == null ? null : columnMapper.fromNonNullValue((J) value);
179 columnMapper.getHibernateType().nullSafeSet(st, param, index, settable, session);
180 }
181
182 @SuppressWarnings("unchecked")
183 @Override
184 public void nullSafeSet(PreparedStatement st, Object value, int index,
185 SharedSessionContractImplementor session) throws HibernateException, SQLException {
186
187 final Object param = value == null ? null : columnMapper.toNonNullValue((T) value);
188 columnMapper.getHibernateType().nullSafeSet(st, param, index, session);
189 }
190
191 @Override
192 public String toLoggableString(Object value,
193 SessionFactoryImplementor factory) throws HibernateException {
194 return columnMapper.getHibernateType().toLoggableString(value, factory);
195 }
196
197 @Override
198 public String getName() {
199 return columnMapper.returnedClass().getSimpleName();
200 }
201
202 @Override
203 public Object deepCopy(Object value, SessionFactoryImplementor factory)
204 throws HibernateException {
205 return columnMapper.getHibernateType().deepCopy(value, factory);
206 }
207
208 @Override
209 public boolean isMutable() {
210 return columnMapper.getHibernateType().isMutable();
211 }
212
213 @Override
214 public Serializable disassemble(Object value, SharedSessionContractImplementor session,
215 Object owner) throws HibernateException {
216 return columnMapper.getHibernateType().disassemble(value, session, owner);
217 }
218
219 @Override
220 public Object assemble(Serializable cached, SharedSessionContractImplementor session,
221 Object owner) throws HibernateException {
222 return columnMapper.getHibernateType().assemble(cached, session, owner);
223 }
224
225 @Override
226 public void beforeAssemble(Serializable cached, SharedSessionContractImplementor session) {
227 columnMapper.getHibernateType().beforeAssemble(cached, session);
228 }
229
230 @Override
231 public Object hydrate(ResultSet rs, String[] names,
232 SharedSessionContractImplementor session, Object owner)
233 throws HibernateException, SQLException {
234 return columnMapper.getHibernateType().hydrate(rs, names, session, owner);
235 }
236
237 @Override
238 public Object resolve(Object value, SharedSessionContractImplementor session, Object owner)
239 throws HibernateException {
240 return columnMapper.getHibernateType().resolve(value, session, owner);
241 }
242
243 @Override
244 public Object semiResolve(Object value, SharedSessionContractImplementor session,
245 Object owner) throws HibernateException {
246 return columnMapper.getHibernateType().semiResolve(value, session, owner);
247 }
248
249 @Override
250 public Type getSemiResolvedType(SessionFactoryImplementor factory) {
251 return this;
252 }
253
254 @Override
255 public Object replace(Object original, Object target,
256 SharedSessionContractImplementor session, Object owner, @SuppressWarnings("rawtypes") Map copyCache)
257 throws HibernateException {
258 return columnMapper.getHibernateType().replace(original, target, session, owner, copyCache);
259 }
260
261 @Override
262 public Object replace(Object original, Object target,
263 SharedSessionContractImplementor session, Object owner, @SuppressWarnings("rawtypes") Map copyCache,
264 ForeignKeyDirection foreignKeyDirection) throws HibernateException {
265 return columnMapper.getHibernateType().replace(original, target, session, owner, copyCache, foreignKeyDirection);
266 }
267
268 @Override
269 public boolean[] toColumnNullness(Object value, Mapping mapping) {
270 return columnMapper.getHibernateType().toColumnNullness(value, mapping);
271 }
272
273 @Override
274 public int sqlType() {
275 return columnMapper.getSqlType();
276 }
277
278 @SuppressWarnings("unchecked")
279 @Override
280 public String toString(Object value) throws HibernateException {
281 if (value == null) {
282 return null;
283 }
284 return columnMapper.toNonNullString((T) value);
285 }
286
287 @Override
288 public T fromStringValue(String xml) throws HibernateException {
289 if (xml == null) {
290 return null;
291 }
292 return columnMapper.fromNonNullString(xml);
293 }
294
295 @Override
296 public T nullSafeGet(ResultSet rs, String name,
297 SharedSessionContractImplementor session) throws HibernateException, SQLException {
298
299 @SuppressWarnings("unchecked") final J hibernateValue = (J) columnMapper.getHibernateType().nullSafeGet(rs, name, session);
300 if (hibernateValue == null) {
301 return null;
302 }
303 return columnMapper.fromNonNullValue(hibernateValue);
304 }
305
306 @Override
307 public Object get(ResultSet rs, String name, SharedSessionContractImplementor session)
308 throws HibernateException, SQLException {
309
310 @SuppressWarnings("unchecked") final J hibernateValue = (J)(columnMapper.getHibernateType().get(rs, name, session));
311 if (hibernateValue == null) {
312 return null;
313 }
314 return columnMapper.fromNonNullValue(hibernateValue);
315 }
316
317 @SuppressWarnings("unchecked")
318 @Override
319 public void set(PreparedStatement st, Object value, int index,
320 SharedSessionContractImplementor session) throws HibernateException, SQLException {
321
322 final Object param = value == null ? null : columnMapper.toNonNullValue((T) value);
323 columnMapper.getHibernateType().nullSafeSet(st, param, index, session); }
324 }