Coverage Report

Coverage Report - org.melati.poem.BasePoemType

Classes in this File

Line Coverage

Branch Coverage

Complexity

BasePoemType

94%

94/100

86%

52/60

2.143

 /*
  * $Source$
  * $Revision$
  *
  * Copyright (C) 2000 William Chesters
  *
  * Part of Melati (http://melati.org), a framework for the rapid
  * development of clean, maintainable web applications.
  *
  * Melati is free software; Permission is granted to copy, distribute
  * and/or modify this software under the terms either:
  *
  * a) the GNU General Public License as published by the Free Software
  *    Foundation; either version 2 of the License, or (at your option)
  *    any later version,
  *
  *    or
  *
  * b) any version of the Melati Software License, as published
  *    at http://melati.org
  *
  * You should have received a copy of the GNU General Public License and
  * the Melati Software License along with this program;
  * if not, write to the Free Software Foundation, Inc.,
  * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA to obtain the
  * GNU General Public License and visit http://melati.org to obtain the
  * Melati Software License.
  *
  * Feel free to contact the Developers of Melati (http://melati.org),
  * if you would like to work out a different arrangement than the options
  * outlined here.  It is our intention to allow Melati to be used by as
  * wide an audience as possible.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * Contact details for copyright holder:
  *
  *     William Chesters <williamc At paneris.org>
  *     http://paneris.org/~williamc
  *     Obrechtstraat 114, 2517VX Den Haag, The Netherlands
  */
 
 package org.melati.poem;
 
 import java.sql.PreparedStatement;
 import java.sql.ResultSet;
 import java.sql.SQLException;
 import java.util.Enumeration;
 
 import org.melati.poem.dbms.Dbms;
 import org.melati.poem.util.ConsEnumeration;
 
 /**
  * Base class of all fundamental types.
  */
 public abstract class BasePoemType<T> implements SQLPoemType<T>, Cloneable {
   private int sqlTypeCode;
   protected boolean nullable;
 
   private Comparable<T> low = null, limit = null;
 
   BasePoemType(int sqlTypeCode, boolean nullable) {
     this.sqlTypeCode = sqlTypeCode;
     this.nullable = nullable;
   }
 
   /**
    * Set the limits, if applicable.
    * @param low included lower limit
    * @param limit excluded upper limit
    */
   public void setRawRange(Comparable<T> low, Comparable<T> limit) {
     this.low = low;
     this.limit = limit;
   }
 
   protected Comparable<T> getLowRaw() {
     return low;
   }
 
   protected Comparable<T> getLimitRaw() {
     return limit;
   }
 
   protected abstract void _assertValidRaw(Object raw)
       throws ValidationPoemException;
 
   @SuppressWarnings("unchecked")
   private void assertRawInRange(Object raw) {
     // Range check.  Since we can't do this with multiple inheritance, we
     // provide it as a facility even in types for which it is meaningless.
 
     T asComparable;
     try {
       // Note that in java5 this will not throw until 
       // the cast object is accessed
       asComparable = (T)raw;
 
       if ((low != null && low.compareTo(asComparable) > 0) ||
           (limit != null && limit.compareTo(asComparable) <= 0))
       throw new ValidationPoemException(
             this, raw, new OutsideRangePoemException(low, limit, raw));
     } catch (ClassCastException e) {
       throw new NotComparablePoemException(raw, this);
     }
   }
 
   /**
    * {@inheritDoc}
    * @see org.melati.poem.PoemType#assertValidRaw(java.lang.Object)
    */
   public final void assertValidRaw(Object raw)
       throws ValidationPoemException {
     if (raw == null) {
       if (!nullable)
         throw new NullTypeMismatchPoemException(this);
     }
     else {
       if (low != null || limit != null)
         assertRawInRange(raw);
       _assertValidRaw(raw);
     }
   }
 
   /**
    * Check if the raw value is valid, as expected.
    * @param raw an Object which should be of correct type
    */
   private void doubleCheckValidRaw(Object raw) {
     try {
       assertValidRaw(raw);
     }
     catch (ValidationPoemException e) {
       throw new UnexpectedValidationPoemException(e);
     }
   }
 
   protected abstract T _getRaw(ResultSet rs, int col)
       throws SQLException;
 
   /**
    * {@inheritDoc}
    * @see org.melati.poem.SQLType#getRaw(java.sql.ResultSet, int)
    */
   public final T getRaw(ResultSet rs, int col)
       throws ValidationPoemException {
     T o;
     try {
       o = (T) _getRaw(rs, col);
     }
     catch (SQLException e) {
       throw new SQLSeriousPoemException(e);
     }
 
     assertValidRaw(o);
     return o;
   }
 
   protected abstract void _setRaw(PreparedStatement ps, int col,
                                   Object raw)
       throws SQLException;
 
   /**
    * {@inheritDoc}
    * @see org.melati.poem.SQLType#setRaw(java.sql.PreparedStatement, int, java.lang.Object)
    */
   public final void setRaw(PreparedStatement ps, int col, Object raw) {
     doubleCheckValidRaw(raw);
     try {
       if (raw == null)
         ps.setNull(col, sqlTypeCode());
       else
         _setRaw(ps, col, raw);
     }
     catch (SQLException e) {
       throw new SQLSeriousPoemException(e);
     }
   }
 
   protected Enumeration<T> _possibleRaws() {
     return null;
   }
   
   /**
    * {@inheritDoc}
    * @see org.melati.poem.PoemType#possibleRaws()
    */
   public Enumeration<T> possibleRaws() {
     Enumeration<T> them = _possibleRaws();
     return them == null ? null :
                    getNullable() ? new ConsEnumeration<T>(null, them) :
                    them;
   }
 
   protected abstract String _stringOfRaw(Object raw);
 
   /**
    * This <B>doesn't</B> do an explicit <TT>assertValidRaw</TT>.
       * {@inheritDoc}
    * @see org.melati.poem.PoemType#stringOfRaw(java.lang.Object)
    */
   public final String stringOfRaw(Object raw)
       throws ValidationPoemException {
     return raw == null ? null : _stringOfRaw(raw);
   }
 
   /**
    * Converts a non-null string to an appropriate value 
    * for insertion into the underlying DBMS.
    * @param string the String to parse
    * @return a converted type
    */
   protected abstract T _rawOfString(String string)
       throws ParsingPoemException;
 
   /**
    * Converts a possibly null <code>String</code> to a low level
    * representation of a valid database column value.
    * <p>
    * Null values are not changed.
    * <p>
    * This result is validated with {@link #assertValidRaw(Object)}
    * whereas {@link #stringOfRaw(Object)} assumes this is not
    * required.
    * {@inheritDoc}
    * @see org.melati.poem.PoemType#rawOfString(java.lang.String)
    */
   public final T rawOfString(String string)
       throws ParsingPoemException, ValidationPoemException {
     T raw = string == null ? null : _rawOfString(string);
     assertValidRaw(raw);
     return raw;
   }
 
   protected abstract void _assertValidCooked(Object cooked)
       throws ValidationPoemException;
 
   /**
    * {@inheritDoc}
    * @see org.melati.poem.PoemType#assertValidCooked(java.lang.Object)
    */
   public final void assertValidCooked(Object cooked)
       throws ValidationPoemException {
     if (cooked == null) {
       if (!nullable)
         throw new NullTypeMismatchPoemException(this);
     }
     else {
       _assertValidCooked(cooked);
       if (low != null || limit != null)
         assertRawInRange(_rawOfCooked(cooked));
     }
   }
 
   /**
    * Check that object is valid, as expected.
    * NOTE If it isn't valid then it isn't cooked.
    * @param cooked the cooked object
    */
   final void doubleCheckValidCooked(Object cooked) {
     try {
       assertValidCooked(cooked);
     }
     catch (ValidationPoemException e) {
       throw new UnexpectedValidationPoemException(e);
     }
   }
 
   /**
    * Converts a non-null low-level representation of a database
    * column value to the appropriate object.
    * <p>
    * For the base object types, (String, Integer etc) this involves no change. 
    * <p>
    * For types with an integer id, such as Poem internal types and user defined types, 
    * then the appropriate instantiated type is returned from its Integer id.
    * @param raw the base object or Integer object id
    * @return the unchanged base object or an instantiated type
    */
   protected abstract Object _cookedOfRaw(Object raw) throws PoemException;
 
   /**
    * Converts a possibly null low-level representation of a database
    * column value to its canonical form. 
    * Types represented as integers in the database are converted to 
    * corresponding objects .
    * <p>
    * The raw value is checked to ensure it is valid.
    * {@inheritDoc}
    * @see org.melati.poem.PoemType#cookedOfRaw(java.lang.Object)
    */
   public final Object cookedOfRaw(Object raw) throws PoemException {
     doubleCheckValidRaw(raw);
     return raw == null ? null : _cookedOfRaw(raw);
   }
 
   protected abstract T _rawOfCooked(Object raw) throws PoemException;
 
   /**
    * {@inheritDoc}
    * @see org.melati.poem.PoemType#rawOfCooked(java.lang.Object)
    */
   public final T rawOfCooked(Object cooked) {
     doubleCheckValidCooked(cooked);
     return cooked == null ? null : _rawOfCooked(cooked);
   }
 
   protected abstract String _stringOfCooked(Object cooked,
                                            PoemLocale locale, int style)
       throws PoemException;
 
   /**
    * {@inheritDoc}
    * @see org.melati.poem.PoemType#stringOfCooked(java.lang.Object, 
    *          org.melati.poem.PoemLocale, int)
    */
   public final String stringOfCooked(Object cooked,
                                     PoemLocale locale, int style)
       throws PoemException {
     doubleCheckValidCooked(cooked);
     return cooked == null ? "" : _stringOfCooked(cooked, locale, style);
   }
 
   /**
    * {@inheritDoc}
    * @see org.melati.poem.PoemType#getNullable()
    */
   public final boolean getNullable() {
     return nullable;
   }
 
   /**
    * {@inheritDoc}
    * @see org.melati.poem.SQLType#sqlTypeCode()
    */
   public final int sqlTypeCode() {
     return sqlTypeCode;
   }
 
   protected abstract String _sqlDefinition(Dbms dbms);
 
   /**
    * See http://dev.mysql.com/doc/refman/5.0/en/timestamp.html
    * The MySQL default for nullability of timestamps is not null, so need to 
    * make all fields explicitly nullable.
    * 
    * {@inheritDoc}
    * @see org.melati.poem.SQLType#sqlDefinition(org.melati.poem.dbms.Dbms)
    */
   public String sqlDefinition(Dbms dbms) {
     return sqlTypeDefinition(dbms) + (nullable ? " NULL" : " NOT NULL");
   }
   /**
    * {@inheritDoc}
    * @see org.melati.poem.SQLType#sqlTypeDefinition(org.melati.poem.dbms.Dbms)
    */
   public String sqlTypeDefinition(Dbms dbms) {
     return _sqlDefinition(dbms);
   }
   protected abstract boolean _canRepresent(SQLPoemType<?> other);
 
   /**
    * {@inheritDoc}
    * @see org.melati.poem.PoemType#canRepresent(org.melati.poem.PoemType)
    */
   public <O>PoemType<O> canRepresent(PoemType<O> other) {
     // FIXME takes no account of range---need to decide on semantics for this,
     // is it subset (inclusion) or some other notion of storability?
     if (!(other instanceof SQLPoemType)) 
       // NOTE Never happens as currently all PoemTypes are SQLPoemTypes
       return null;
     else {
       SQLPoemType<O> q = (SQLPoemType<O>)other;
       return
           !(!nullable && q.getNullable()) && // Nullable may represent not nullable
           _canRepresent(q) ?
               q : null;
     }
   }
 
   /**
    * {@inheritDoc}
    * @see org.melati.poem.PoemType#withNullable(boolean)
    */
   @SuppressWarnings("unchecked")
   public final PoemType<T> withNullable(boolean nullableP) {
     if (this.nullable == nullableP)
       return this;
     else {
       BasePoemType<T> it = (BasePoemType<T>)clone();
       it.nullable = nullableP;
       return it;
     }
   }
 
   protected abstract void _saveColumnInfo(ColumnInfo info)
       throws AccessPoemException;
 
   /**
    * {@inheritDoc}
    * @see org.melati.poem.PoemType#saveColumnInfo(org.melati.poem.ColumnInfo)
    */
   public void saveColumnInfo(ColumnInfo info) throws AccessPoemException {
     info.setNullable(nullable);
     info.setSize(0);
     info.setRangelow_string(
         getLowRaw() == null ? null : stringOfRaw(getLowRaw()));
     // this _won't_ throw an OutsideRangePoemException since it doesn't check
     info.setRangelimit_string(
         getLimitRaw() == null ? null : stringOfRaw(getLimitRaw()));
     _saveColumnInfo(info);
   }
 
   protected abstract String _quotedRaw(Object raw);
 
   /**
    * {@inheritDoc}
    * @see org.melati.poem.SQLType#quotedRaw(java.lang.Object)
    */
   public String quotedRaw(Object raw) throws ValidationPoemException {
     assertValidRaw(raw);
     return raw == null ? "NULL" : _quotedRaw(raw);
   }
 
   protected abstract String _toString();
 
   // 
   // --------
   //  Object
   // --------
   // 
 
   /**
    * {@inheritDoc}
    * @see java.lang.Object#toString()
    */
   public String toString() {
     return (nullable ? "nullable " : "") + _toString() + 
     " (" + this.getClass().getName() + ")";
   }
 
   /**
    * {@inheritDoc}
    * @see java.lang.Object#clone()
    */
   protected Object clone() {
     try {
       return super.clone();
     }
     catch (CloneNotSupportedException e) {
       throw new PoemBugPoemException();
     }
   }
 }

1		/*
2		* $Source$
3		* $Revision$
4		*
5		* Copyright (C) 2000 William Chesters
6		*
7		* Part of Melati (http://melati.org), a framework for the rapid
8		* development of clean, maintainable web applications.
9		*
10		* Melati is free software; Permission is granted to copy, distribute
11		* and/or modify this software under the terms either:
12		*
13		* a) the GNU General Public License as published by the Free Software
14		* Foundation; either version 2 of the License, or (at your option)
15		* any later version,
16		*
17		* or
18		*
19		* b) any version of the Melati Software License, as published
20		* at http://melati.org
21		*
22		* You should have received a copy of the GNU General Public License and
23		* the Melati Software License along with this program;
24		* if not, write to the Free Software Foundation, Inc.,
25		* 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA to obtain the
26		* GNU General Public License and visit http://melati.org to obtain the
27		* Melati Software License.
28		*
29		* Feel free to contact the Developers of Melati (http://melati.org),
30		* if you would like to work out a different arrangement than the options
31		* outlined here. It is our intention to allow Melati to be used by as
32		* wide an audience as possible.
33		*
34		* This program is distributed in the hope that it will be useful,
35		* but WITHOUT ANY WARRANTY; without even the implied warranty of
36		* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
37		* GNU General Public License for more details.
38		*
39		* Contact details for copyright holder:
40		*
41		* William Chesters <williamc At paneris.org>
42		* http://paneris.org/~williamc
43		* Obrechtstraat 114, 2517VX Den Haag, The Netherlands
44		*/
45
46		package org.melati.poem;
47
48		import java.sql.PreparedStatement;
49		import java.sql.ResultSet;
50		import java.sql.SQLException;
51		import java.util.Enumeration;
52
53		import org.melati.poem.dbms.Dbms;
54		import org.melati.poem.util.ConsEnumeration;
55
56		/**
57		* Base class of all fundamental types.
58		*/
59		public abstract class BasePoemType<T> implements SQLPoemType<T>, Cloneable {
60		private int sqlTypeCode;
61		protected boolean nullable;
62
63	10184	private Comparable<T> low = null, limit = null;
64
65	10184	BasePoemType(int sqlTypeCode, boolean nullable) {
66	10184	this.sqlTypeCode = sqlTypeCode;
67	10184	this.nullable = nullable;
68	10184	}
69
70		/**
71		* Set the limits, if applicable.
72		* @param low included lower limit
73		* @param limit excluded upper limit
74		*/
75		public void setRawRange(Comparable<T> low, Comparable<T> limit) {
76	9484	this.low = low;
77	9484	this.limit = limit;
78	9484	}
79
80		protected Comparable<T> getLowRaw() {
81	4743	return low;
82		}
83
84		protected Comparable<T> getLimitRaw() {
85	4743	return limit;
86		}
87
88		protected abstract void _assertValidRaw(Object raw)
89		throws ValidationPoemException;
90
91		@SuppressWarnings("unchecked")
92		private void assertRawInRange(Object raw) {
93		// Range check. Since we can't do this with multiple inheritance, we
94		// provide it as a facility even in types for which it is meaningless.
95
96		T asComparable;
97		try {
98		// Note that in java5 this will not throw until
99		// the cast object is accessed
100	10	asComparable = (T)raw;
101
102	10	if ((low != null && low.compareTo(asComparable) > 0) \|\|
103	8	(limit != null && limit.compareTo(asComparable) <= 0))
104	2	throw new ValidationPoemException(
105		this, raw, new OutsideRangePoemException(low, limit, raw));
106	1	} catch (ClassCastException e) {
107	1	throw new NotComparablePoemException(raw, this);
108	7	}
109	7	}
110
111		/**
112		* {@inheritDoc}
113		* @see org.melati.poem.PoemType#assertValidRaw(java.lang.Object)
114		*/
115		public final void assertValidRaw(Object raw)
116		throws ValidationPoemException {
117	314732	if (raw == null) {
118	58591	if (!nullable)
119	46	throw new NullTypeMismatchPoemException(this);
120		}
121		else {
122	256141	if (low != null \|\| limit != null)
123	9	assertRawInRange(raw);
124	256138	_assertValidRaw(raw);
125		}
126	314644	}
127
128		/**
129		* Check if the raw value is valid, as expected.
130		* @param raw an Object which should be of correct type
131		*/
132		private void doubleCheckValidRaw(Object raw) {
133		try {
134	139031	assertValidRaw(raw);
135		}
136	0	catch (ValidationPoemException e) {
137	0	throw new UnexpectedValidationPoemException(e);
138	139007	}
139	139007	}
140
141		protected abstract T _getRaw(ResultSet rs, int col)
142		throws SQLException;
143
144		/**
145		* {@inheritDoc}
146		* @see org.melati.poem.SQLType#getRaw(java.sql.ResultSet, int)
147		*/
148		public final T getRaw(ResultSet rs, int col)
149		throws ValidationPoemException {
150		T o;
151		try {
152	16210	o = (T) _getRaw(rs, col);
153		}
154	1	catch (SQLException e) {
155	1	throw new SQLSeriousPoemException(e);
156	16173	}
157
158	16173	assertValidRaw(o);
159	16173	return o;
160		}
161
162		protected abstract void _setRaw(PreparedStatement ps, int col,
163		Object raw)
164		throws SQLException;
165
166		/**
167		* {@inheritDoc}
168		* @see org.melati.poem.SQLType#setRaw(java.sql.PreparedStatement, int, java.lang.Object)
169		*/
170		public final void setRaw(PreparedStatement ps, int col, Object raw) {
171	138803	doubleCheckValidRaw(raw);
172		try {
173	138780	if (raw == null)
174	23501	ps.setNull(col, sqlTypeCode());
175		else
176	115279	_setRaw(ps, col, raw);
177		}
178	1	catch (SQLException e) {
179	1	throw new SQLSeriousPoemException(e);
180	138728	}
181	138728	}
182
183		protected Enumeration<T> _possibleRaws() {
184	2	return null;
185		}
186
187		/**
188		* {@inheritDoc}
189		* @see org.melati.poem.PoemType#possibleRaws()
190		*/
191		public Enumeration<T> possibleRaws() {
192	42	Enumeration<T> them = _possibleRaws();
193	42	return them == null ? null :
194	33	getNullable() ? new ConsEnumeration<T>(null, them) :
195		them;
196		}
197
198		protected abstract String _stringOfRaw(Object raw);
199
200		/**
201		* This <B>doesn't</B> do an explicit <TT>assertValidRaw</TT>.
202		* {@inheritDoc}
203		* @see org.melati.poem.PoemType#stringOfRaw(java.lang.Object)
204		*/
205		public final String stringOfRaw(Object raw)
206		throws ValidationPoemException {
207	9507	return raw == null ? null : _stringOfRaw(raw);
208		}
209
210		/**
211		* Converts a non-null string to an appropriate value
212		* for insertion into the underlying DBMS.
213		* @param string the String to parse
214		* @return a converted type
215		*/
216		protected abstract T _rawOfString(String string)
217		throws ParsingPoemException;
218
219		/**
220		* Converts a possibly null <code>String</code> to a low level
221		* representation of a valid database column value.
222		* <p>
223		* Null values are not changed.
224		* <p>
225		* This result is validated with {@link #assertValidRaw(Object)}
226		* whereas {@link #stringOfRaw(Object)} assumes this is not
227		* required.
228		* {@inheritDoc}
229		* @see org.melati.poem.PoemType#rawOfString(java.lang.String)
230		*/
231		public final T rawOfString(String string)
232		throws ParsingPoemException, ValidationPoemException {
233	9698	T raw = string == null ? null : _rawOfString(string);
234	9668	assertValidRaw(raw);
235	9668	return raw;
236		}
237
238		protected abstract void _assertValidCooked(Object cooked)
239		throws ValidationPoemException;
240
241		/**
242		* {@inheritDoc}
243		* @see org.melati.poem.PoemType#assertValidCooked(java.lang.Object)
244		*/
245		public final void assertValidCooked(Object cooked)
246		throws ValidationPoemException {
247	100524	if (cooked == null) {
248	19645	if (!nullable)
249	44	throw new NullTypeMismatchPoemException(this);
250		}
251		else {
252	80879	_assertValidCooked(cooked);
253	80831	if (low != null \|\| limit != null)
254	1	assertRawInRange(_rawOfCooked(cooked));
255		}
256	100432	}
257
258		/**
259		* Check that object is valid, as expected.
260		* NOTE If it isn't valid then it isn't cooked.
261		* @param cooked the cooked object
262		*/
263		final void doubleCheckValidCooked(Object cooked) {
264		try {
265	263	assertValidCooked(cooked);
266		}
267	0	catch (ValidationPoemException e) {
268	0	throw new UnexpectedValidationPoemException(e);
269	235	}
270	235	}
271
272		/**
273		* Converts a non-null low-level representation of a database
274		* column value to the appropriate object.
275		* <p>
276		* For the base object types, (String, Integer etc) this involves no change.
277		* <p>
278		* For types with an integer id, such as Poem internal types and user defined types,
279		* then the appropriate instantiated type is returned from its Integer id.
280		* @param raw the base object or Integer object id
281		* @return the unchanged base object or an instantiated type
282		*/
283		protected abstract Object _cookedOfRaw(Object raw) throws PoemException;
284
285		/**
286		* Converts a possibly null low-level representation of a database
287		* column value to its canonical form.
288		* Types represented as integers in the database are converted to
289		* corresponding objects .
290		* <p>
291		* The raw value is checked to ensure it is valid.
292		* {@inheritDoc}
293		* @see org.melati.poem.PoemType#cookedOfRaw(java.lang.Object)
294		*/
295		public final Object cookedOfRaw(Object raw) throws PoemException {
296	228	doubleCheckValidRaw(raw);
297	227	return raw == null ? null : _cookedOfRaw(raw);
298		}
299
300		protected abstract T _rawOfCooked(Object raw) throws PoemException;
301
302		/**
303		* {@inheritDoc}
304		* @see org.melati.poem.PoemType#rawOfCooked(java.lang.Object)
305		*/
306		public final T rawOfCooked(Object cooked) {
307	94	doubleCheckValidCooked(cooked);
308	66	return cooked == null ? null : _rawOfCooked(cooked);
309		}
310
311		protected abstract String _stringOfCooked(Object cooked,
312		PoemLocale locale, int style)
313		throws PoemException;
314
315		/**
316		* {@inheritDoc}
317		* @see org.melati.poem.PoemType#stringOfCooked(java.lang.Object,
318		* org.melati.poem.PoemLocale, int)
319		*/
320		public final String stringOfCooked(Object cooked,
321		PoemLocale locale, int style)
322		throws PoemException {
323	169	doubleCheckValidCooked(cooked);
324	169	return cooked == null ? "" : _stringOfCooked(cooked, locale, style);
325		}
326
327		/**
328		* {@inheritDoc}
329		* @see org.melati.poem.PoemType#getNullable()
330		*/
331		public final boolean getNullable() {
332	12216	return nullable;
333		}
334
335		/**
336		* {@inheritDoc}
337		* @see org.melati.poem.SQLType#sqlTypeCode()
338		*/
339		public final int sqlTypeCode() {
340	23801	return sqlTypeCode;
341		}
342
343		protected abstract String _sqlDefinition(Dbms dbms);
344
345		/**
346		* See http://dev.mysql.com/doc/refman/5.0/en/timestamp.html
347		* The MySQL default for nullability of timestamps is not null, so need to
348		* make all fields explicitly nullable.
349		*
350		* {@inheritDoc}
351		* @see org.melati.poem.SQLType#sqlDefinition(org.melati.poem.dbms.Dbms)
352		*/
353		public String sqlDefinition(Dbms dbms) {
354	2384	return sqlTypeDefinition(dbms) + (nullable ? " NULL" : " NOT NULL");
355		}
356		/**
357		* {@inheritDoc}
358		* @see org.melati.poem.SQLType#sqlTypeDefinition(org.melati.poem.dbms.Dbms)
359		*/
360		public String sqlTypeDefinition(Dbms dbms) {
361	2403	return _sqlDefinition(dbms);
362		}
363		protected abstract boolean _canRepresent(SQLPoemType<?> other);
364
365		/**
366		* {@inheritDoc}
367		* @see org.melati.poem.PoemType#canRepresent(org.melati.poem.PoemType)
368		*/
369		public <O>PoemType<O> canRepresent(PoemType<O> other) {
370		// FIXME takes no account of range---need to decide on semantics for this,
371		// is it subset (inclusion) or some other notion of storability?
372	4286	if (!(other instanceof SQLPoemType))
373		// NOTE Never happens as currently all PoemTypes are SQLPoemTypes
374	1	return null;
375		else {
376	4285	SQLPoemType<O> q = (SQLPoemType<O>)other;
377	4285	return
378	2262	!(!nullable && q.getNullable()) && // Nullable may represent not nullable
379	4245	_canRepresent(q) ?
380		q : null;
381		}
382		}
383
384		/**
385		* {@inheritDoc}
386		* @see org.melati.poem.PoemType#withNullable(boolean)
387		*/
388		@SuppressWarnings("unchecked")
389		public final PoemType<T> withNullable(boolean nullableP) {
390	9452	if (this.nullable == nullableP)
391	9446	return this;
392		else {
393	6	BasePoemType<T> it = (BasePoemType<T>)clone();
394	6	it.nullable = nullableP;
395	6	return it;
396		}
397		}
398
399		protected abstract void _saveColumnInfo(ColumnInfo info)
400		throws AccessPoemException;
401
402		/**
403		* {@inheritDoc}
404		* @see org.melati.poem.PoemType#saveColumnInfo(org.melati.poem.ColumnInfo)
405		*/
406		public void saveColumnInfo(ColumnInfo info) throws AccessPoemException {
407	4723	info.setNullable(nullable);
408	4723	info.setSize(0);
409	9446	info.setRangelow_string(
410	4723	getLowRaw() == null ? null : stringOfRaw(getLowRaw()));
411		// this _won't_ throw an OutsideRangePoemException since it doesn't check
412	9446	info.setRangelimit_string(
413	4723	getLimitRaw() == null ? null : stringOfRaw(getLimitRaw()));
414	4723	_saveColumnInfo(info);
415	4723	}
416
417		protected abstract String _quotedRaw(Object raw);
418
419		/**
420		* {@inheritDoc}
421		* @see org.melati.poem.SQLType#quotedRaw(java.lang.Object)
422		*/
423		public String quotedRaw(Object raw) throws ValidationPoemException {
424	255	assertValidRaw(raw);
425	255	return raw == null ? "NULL" : _quotedRaw(raw);
426		}
427
428		protected abstract String _toString();
429
430		//
431		// --------
432		// Object
433		// --------
434		//
435
436		/**
437		* {@inheritDoc}
438		* @see java.lang.Object#toString()
439		*/
440		public String toString() {
441	59	return (nullable ? "nullable " : "") + _toString() +
442	59	" (" + this.getClass().getName() + ")";
443		}
444
445		/**
446		* {@inheritDoc}
447		* @see java.lang.Object#clone()
448		*/
449		protected Object clone() {
450		try {
451	9460	return super.clone();
452		}
453	0	catch (CloneNotSupportedException e) {
454	0	throw new PoemBugPoemException();
455		}
456		}
457		}