View Javadoc
1 /*** 2 * Redistribution and use of this software and associated documentation 3 * ("Software"), with or without modification, are permitted provided 4 * that the following conditions are met: 5 * 6 * 1. Redistributions of source code must retain copyright 7 * statements and notices. Redistributions must also contain a 8 * copy of this document. 9 * 10 * 2. Redistributions in binary form must reproduce the 11 * above copyright notice, this list of conditions and the 12 * following disclaimer in the documentation and/or other 13 * materials provided with the distribution. 14 * 15 * 3. The name "Exolab" must not be used to endorse or promote 16 * products derived from this Software without prior written 17 * permission of Exoffice Technologies. For written permission, 18 * please contact info@exolab.org. 19 * 20 * 4. Products derived from this Software may not be called "Exolab" 21 * nor may "Exolab" appear in their names without prior written 22 * permission of Exoffice Technologies. Exolab is a registered 23 * trademark of Exoffice Technologies. 24 * 25 * 5. Due credit should be given to the Exolab Project 26 * (http://www.exolab.org/). 27 * 28 * THIS SOFTWARE IS PROVIDED BY EXOFFICE TECHNOLOGIES AND CONTRIBUTORS 29 * ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT 30 * NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND 31 * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL 32 * EXOFFICE TECHNOLOGIES OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 33 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 34 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 35 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 36 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 37 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 38 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED 39 * OF THE POSSIBILITY OF SUCH DAMAGE. 40 * 41 * Copyright 2001,2003 (C) Exoffice Technologies Inc. All Rights Reserved. 42 * 43 * $Id: Type.java,v 1.7 2003/08/17 01:32:27 tanderson Exp $ 44 */ 45 46 package org.exolab.jms.tools.db; 47 48 import org.exolab.jms.persistence.PersistenceException; 49 50 51 /*** 52 * This class is a helper class for converting from string values to their 53 * corresponding <code>java.sql.Types</code> 54 * 55 * @version $Revision: 1.7 $ $Date: 2003/08/17 01:32:27 $ 56 * @author <a href="mailto:tima@intalio.com">Tim Anderson</a> 57 */ 58 public class Type { 59 60 /*** 61 * The type descriptor 62 */ 63 private final Descriptor _descriptor; 64 65 /*** 66 * The type name 67 */ 68 private final String _name; 69 70 /*** 71 * The precision of the type 72 */ 73 private final long _precision; 74 75 /*** 76 * If true, denotes that the type takes parameters 77 */ 78 private final boolean _parameters; 79 80 /*** 81 * Construct an instance, using the default name for the type 82 * 83 * @param type a type corresponding to one in <code>java.sql.Types</code> 84 * @param precision the precision of the type. A precision <= 0 85 * indicates that the type has no precision 86 * @param parameters if true, denotes that the type takes parameters 87 * @throws IllegalArgumentException if type is invalid 88 */ 89 public Type(int type, long precision, boolean parameters) { 90 _descriptor = Descriptor.getDescriptor(type); 91 if (_descriptor == null) { 92 throw new IllegalArgumentException("Type id=" + type + 93 " is not a valid type"); 94 } 95 _name = _descriptor.getName(); 96 _precision = precision; 97 _parameters = parameters; 98 } 99 100 /*** 101 * Construct an instance specifying the database specific type name 102 * 103 * @param type a type corresponding to one in <code>java.sql.Types</code> 104 * @param name the RDBMS name of the type 105 * @param precision the precision of the type. A precision <= 0 106 * indicates that the type has no precision 107 * @param parameters if true, denotes that the type takes parameters 108 * @throws IllegalArgumentException if type is invalid 109 */ 110 public Type(int type, String name, long precision, boolean parameters) { 111 _descriptor = Descriptor.getDescriptor(type); 112 if (_descriptor == null) { 113 throw new IllegalArgumentException("Type id=" + type + 114 " is not a valid type"); 115 } 116 _name = name; 117 _precision = precision; 118 _parameters = parameters; 119 } 120 121 /*** 122 * Returns the type identifier 123 * 124 * @return the type identifier, corresponding to one in 125 * <code>java.sql.Types</code> 126 */ 127 public int getType() { 128 return _descriptor.getType(); 129 } 130 131 /*** 132 * Returns the name of the type 133 * 134 * @return the type name 135 */ 136 public String getName() { 137 return _name; 138 } 139 140 /*** 141 * Returns the precision of the type 142 * 143 * @return the type precision 144 */ 145 public long getPrecision() { 146 return _precision; 147 } 148 149 /*** 150 * Returns if the type takes parameters when created 151 * 152 * @return true if the type takes parameters when created, false otherwise 153 */ 154 public boolean getParameters() { 155 return _parameters; 156 } 157 158 /*** 159 * Returns a symbolic representation of the type 160 * 161 * @return a symbolic representation of the type 162 */ 163 public String getSymbolicType() { 164 String result = _descriptor.getName(); 165 if (_parameters && _precision > 0) { 166 result += "(" + _precision + ")"; 167 } 168 return result; 169 } 170 171 /*** 172 * Returns an SQL representation of the type 173 * 174 * @return an SQL string representation of the type 175 */ 176 public String getSQL() { 177 String result = _name; 178 if (_parameters && _precision > 0) { 179 result += "(" + _precision + ")"; 180 } 181 return result; 182 } 183 184 /*** 185 * Returns a string representation of the type, for debugging purposes 186 */ 187 public String toString() { 188 return "type=" + _descriptor.getName() + ", name=" + _name + 189 ", precision=" + _precision + ", parameters=" + 190 _parameters; 191 } 192 193 /*** 194 * Returns a new type corresponding to its string representation 195 * 196 * @param type the string representation of the type 197 * @return the type corresponding to the string 198 * @throws PersistenceException if the string is invalid 199 */ 200 public static Type getType(String type) throws PersistenceException { 201 int start = type.indexOf('('); 202 String name = type; 203 long precision = -1; 204 boolean parameters = false; 205 if (start != -1) { 206 name = type.substring(0, start); 207 int end = type.indexOf(')', start); 208 if (end == -1) { 209 throw new PersistenceException("Illegal type: " + type); 210 } 211 precision = Long.parseLong(type.substring(start + 1, end)); 212 parameters = true; 213 } 214 215 Descriptor descriptor = Descriptor.getDescriptor(name.trim()); 216 if (descriptor == null) { 217 throw new PersistenceException("Type name=" + type + 218 " is not a valid type"); 219 } 220 return new Type(descriptor.getType(), precision, parameters); 221 } 222 223 } //-- Type

This page was automatically generated by Maven