[hibernate-commits] Hibernate SVN: r11134 - in branches/HAN_SPLIT/HibernateExt/commons-annotations/src/java/org/hibernate/annotations/common: reflection/java and 1 other directories.
hibernate-commits at lists.jboss.org
hibernate-commits at lists.jboss.org
Thu Feb 1 17:42:23 EST 2007
Author: epbernard
Date: 2007-02-01 17:42:22 -0500 (Thu, 01 Feb 2007)
New Revision: 11134
Added:
branches/HAN_SPLIT/HibernateExt/commons-annotations/src/java/org/hibernate/annotations/common/AssertionFailure.java
branches/HAN_SPLIT/HibernateExt/commons-annotations/src/java/org/hibernate/annotations/common/util/
branches/HAN_SPLIT/HibernateExt/commons-annotations/src/java/org/hibernate/annotations/common/util/ReflectHelper.java
branches/HAN_SPLIT/HibernateExt/commons-annotations/src/java/org/hibernate/annotations/common/util/StringHelper.java
Modified:
branches/HAN_SPLIT/HibernateExt/commons-annotations/src/java/org/hibernate/annotations/common/reflection/java/JavaReflectionManager.java
Log:
Finish commons src independence
Added: branches/HAN_SPLIT/HibernateExt/commons-annotations/src/java/org/hibernate/annotations/common/AssertionFailure.java
===================================================================
--- branches/HAN_SPLIT/HibernateExt/commons-annotations/src/java/org/hibernate/annotations/common/AssertionFailure.java (rev 0)
+++ branches/HAN_SPLIT/HibernateExt/commons-annotations/src/java/org/hibernate/annotations/common/AssertionFailure.java 2007-02-01 22:42:22 UTC (rev 11134)
@@ -0,0 +1,30 @@
+//$Id: $
+package org.hibernate.annotations.common;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+
+/**
+ * Indicates failure of an assertion: a possible bug in Hibernate.
+ *
+ * @author Gavin King
+ * @auhor Emmanuel Bernard
+ */
+//TODO Copy from Hibernate Core, do some mutualization here?
+public class AssertionFailure extends RuntimeException {
+
+ private static final Log log = LogFactory.getLog(AssertionFailure.class);
+
+ private static final String MESSAGE = "an assertion failure occured (this may indicate a bug in Hibernate)";
+
+ public AssertionFailure(String s) {
+ super(s);
+ log.error(MESSAGE, this);
+ }
+
+ public AssertionFailure(String s, Throwable t) {
+ super(s, t);
+ log.error(MESSAGE, t);
+ }
+
+}
Modified: branches/HAN_SPLIT/HibernateExt/commons-annotations/src/java/org/hibernate/annotations/common/reflection/java/JavaReflectionManager.java
===================================================================
--- branches/HAN_SPLIT/HibernateExt/commons-annotations/src/java/org/hibernate/annotations/common/reflection/java/JavaReflectionManager.java 2007-02-01 21:48:09 UTC (rev 11133)
+++ branches/HAN_SPLIT/HibernateExt/commons-annotations/src/java/org/hibernate/annotations/common/reflection/java/JavaReflectionManager.java 2007-02-01 22:42:22 UTC (rev 11134)
@@ -19,7 +19,7 @@
import org.hibernate.annotations.common.reflection.java.generics.TypeEnvironmentFactory;
import org.hibernate.annotations.common.reflection.java.generics.TypeSwitch;
import org.hibernate.annotations.common.reflection.java.generics.TypeUtils;
-import org.hibernate.util.ReflectHelper;
+import org.hibernate.annotations.common.util.ReflectHelper;
/**
* The factory for all the objects in this package.
Added: branches/HAN_SPLIT/HibernateExt/commons-annotations/src/java/org/hibernate/annotations/common/util/ReflectHelper.java
===================================================================
--- branches/HAN_SPLIT/HibernateExt/commons-annotations/src/java/org/hibernate/annotations/common/util/ReflectHelper.java (rev 0)
+++ branches/HAN_SPLIT/HibernateExt/commons-annotations/src/java/org/hibernate/annotations/common/util/ReflectHelper.java 2007-02-01 22:42:22 UTC (rev 11134)
@@ -0,0 +1,122 @@
+//$Id: $
+package org.hibernate.annotations.common.util;
+
+import java.lang.reflect.Method;
+import java.lang.reflect.Member;
+import java.lang.reflect.Modifier;
+
+import org.hibernate.annotations.common.AssertionFailure;
+
+/**
+ * @author Emmanuel Bernard
+ */
+
+public final class ReflectHelper {
+
+ private static final Class[] OBJECT = new Class[] { Object.class };
+ private static final Method OBJECT_EQUALS;
+ private static final Class[] NO_PARAM = new Class[] { };
+
+ private static final Method OBJECT_HASHCODE;
+ static {
+ Method eq;
+ Method hash;
+ try {
+ eq = Object.class.getMethod("equals", OBJECT);
+ hash = Object.class.getMethod("hashCode", NO_PARAM);
+ }
+ catch (Exception e) {
+ throw new AssertionFailure("Could not find Object.equals() or Object.hashCode()", e);
+ }
+ OBJECT_EQUALS = eq;
+ OBJECT_HASHCODE = hash;
+ }
+
+ public static boolean overridesEquals(Class clazz) {
+ Method equals;
+ try {
+ equals = clazz.getMethod("equals", OBJECT);
+ }
+ catch (NoSuchMethodException nsme) {
+ return false; //its an interface so we can't really tell anything...
+ }
+ return !OBJECT_EQUALS.equals(equals);
+ }
+
+ public static boolean overridesHashCode(Class clazz) {
+ Method hashCode;
+ try {
+ hashCode = clazz.getMethod("hashCode", NO_PARAM);
+ }
+ catch (NoSuchMethodException nsme) {
+ return false; //its an interface so we can't really tell anything...
+ }
+ return !OBJECT_HASHCODE.equals(hashCode);
+ }
+
+ public static Class classForName(String name) throws ClassNotFoundException {
+ try {
+ ClassLoader contextClassLoader = Thread.currentThread().getContextClassLoader();
+ if ( contextClassLoader != null ) {
+ return contextClassLoader.loadClass(name);
+ }
+ }
+ catch ( Throwable t ) {
+ }
+ return Class.forName( name );
+ }
+
+ public static Class classForName(String name, Class caller) throws ClassNotFoundException {
+ try {
+ ClassLoader contextClassLoader = Thread.currentThread().getContextClassLoader();
+ if ( contextClassLoader != null ) {
+ return contextClassLoader.loadClass( name );
+ }
+ }
+ catch ( Throwable e ) {
+ }
+ return Class.forName( name, true, caller.getClassLoader() );
+ }
+
+ public static boolean isPublic(Class clazz, Member member) {
+ return Modifier.isPublic( member.getModifiers() ) && Modifier.isPublic( clazz.getModifiers() );
+ }
+
+ public static Object getConstantValue(String name) {
+ Class clazz;
+ try {
+ clazz = classForName( StringHelper.qualifier( name ) );
+ }
+ catch ( Throwable t ) {
+ return null;
+ }
+ try {
+ return clazz.getField( StringHelper.unqualify( name ) ).get(null);
+ }
+ catch ( Throwable t ) {
+ return null;
+ }
+ }
+
+ public static boolean isAbstractClass(Class clazz) {
+ int modifier = clazz.getModifiers();
+ return Modifier.isAbstract(modifier) || Modifier.isInterface(modifier);
+ }
+
+ public static boolean isFinalClass(Class clazz) {
+ return Modifier.isFinal( clazz.getModifiers() );
+ }
+
+ public static Method getMethod(Class clazz, Method method) {
+ try {
+ return clazz.getMethod( method.getName(), method.getParameterTypes() );
+ }
+ catch (Exception e) {
+ return null;
+ }
+ }
+
+ private ReflectHelper() {}
+
+}
+
Added: branches/HAN_SPLIT/HibernateExt/commons-annotations/src/java/org/hibernate/annotations/common/util/StringHelper.java
===================================================================
--- branches/HAN_SPLIT/HibernateExt/commons-annotations/src/java/org/hibernate/annotations/common/util/StringHelper.java (rev 0)
+++ branches/HAN_SPLIT/HibernateExt/commons-annotations/src/java/org/hibernate/annotations/common/util/StringHelper.java 2007-02-01 22:42:22 UTC (rev 11134)
@@ -0,0 +1,409 @@
+//$Id: $
+package org.hibernate.annotations.common.util;
+
+import java.util.Iterator;
+import java.util.StringTokenizer;
+import java.util.ArrayList;
+import java.util.Collection;
+
+/**
+ * @author Emmanuel Bernard
+ */
+//TODO copy from Hibernate Core, mutualization?
+public final class StringHelper {
+
+ private static final int ALIAS_TRUNCATE_LENGTH = 10;
+ public static final String WHITESPACE = " \n\r\f\t";
+
+ private StringHelper() { /* static methods only - hide constructor */
+ }
+
+ /*public static boolean containsDigits(String string) {
+ for ( int i=0; i<string.length(); i++ ) {
+ if ( Character.isDigit( string.charAt(i) ) ) return true;
+ }
+ return false;
+ }*/
+
+ public static int lastIndexOfLetter(String string) {
+ for ( int i=0; i<string.length(); i++ ) {
+ char character = string.charAt(i);
+ if ( !Character.isLetter(character) /*&& !('_'==character)*/ ) return i-1;
+ }
+ return string.length()-1;
+ }
+
+ public static String join(String seperator, String[] strings) {
+ int length = strings.length;
+ if ( length == 0 ) return "";
+ StringBuffer buf = new StringBuffer( length * strings[0].length() )
+ .append( strings[0] );
+ for ( int i = 1; i < length; i++ ) {
+ buf.append( seperator ).append( strings[i] );
+ }
+ return buf.toString();
+ }
+
+ public static String join(String seperator, Iterator objects) {
+ StringBuffer buf = new StringBuffer();
+ if ( objects.hasNext() ) buf.append( objects.next() );
+ while ( objects.hasNext() ) {
+ buf.append( seperator ).append( objects.next() );
+ }
+ return buf.toString();
+ }
+
+ public static String[] add(String[] x, String sep, String[] y) {
+ String[] result = new String[x.length];
+ for ( int i = 0; i < x.length; i++ ) {
+ result[i] = x[i] + sep + y[i];
+ }
+ return result;
+ }
+
+ public static String repeat(String string, int times) {
+ StringBuffer buf = new StringBuffer( string.length() * times );
+ for ( int i = 0; i < times; i++ ) buf.append( string );
+ return buf.toString();
+ }
+
+
+ public static String replace(String template, String placeholder, String replacement) {
+ return replace( template, placeholder, replacement, false );
+ }
+
+ public static String[] replace(String templates[], String placeholder, String replacement) {
+ String[] result = new String[templates.length];
+ for ( int i =0; i<templates.length; i++ ) {
+ result[i] = replace( templates[i], placeholder, replacement );;
+ }
+ return result;
+ }
+
+ public static String replace(String template, String placeholder, String replacement, boolean wholeWords) {
+ int loc = template == null ? -1 : template.indexOf( placeholder );
+ if ( loc < 0 ) {
+ return template;
+ }
+ else {
+ final boolean actuallyReplace = !wholeWords ||
+ loc + placeholder.length() == template.length() ||
+ !Character.isJavaIdentifierPart( template.charAt( loc + placeholder.length() ) );
+ String actualReplacement = actuallyReplace ? replacement : placeholder;
+ return new StringBuffer( template.substring( 0, loc ) )
+ .append( actualReplacement )
+ .append( replace( template.substring( loc + placeholder.length() ),
+ placeholder,
+ replacement,
+ wholeWords ) ).toString();
+ }
+ }
+
+
+ public static String replaceOnce(String template, String placeholder, String replacement) {
+ int loc = template == null ? -1 : template.indexOf( placeholder );
+ if ( loc < 0 ) {
+ return template;
+ }
+ else {
+ return new StringBuffer( template.substring( 0, loc ) )
+ .append( replacement )
+ .append( template.substring( loc + placeholder.length() ) )
+ .toString();
+ }
+ }
+
+
+ public static String[] split(String seperators, String list) {
+ return split( seperators, list, false );
+ }
+
+ public static String[] split(String seperators, String list, boolean include) {
+ StringTokenizer tokens = new StringTokenizer( list, seperators, include );
+ String[] result = new String[ tokens.countTokens() ];
+ int i = 0;
+ while ( tokens.hasMoreTokens() ) {
+ result[i++] = tokens.nextToken();
+ }
+ return result;
+ }
+
+ public static String unqualify(String qualifiedName) {
+ int loc = qualifiedName.lastIndexOf(".");
+ return ( loc < 0 ) ? qualifiedName : qualifiedName.substring( qualifiedName.lastIndexOf(".") + 1 );
+ }
+
+ public static String qualifier(String qualifiedName) {
+ int loc = qualifiedName.lastIndexOf(".");
+ return ( loc < 0 ) ? "" : qualifiedName.substring( 0, loc );
+ }
+
+ public static String[] suffix(String[] columns, String suffix) {
+ if ( suffix == null ) return columns;
+ String[] qualified = new String[columns.length];
+ for ( int i = 0; i < columns.length; i++ ) {
+ qualified[i] = suffix( columns[i], suffix );
+ }
+ return qualified;
+ }
+
+ private static String suffix(String name, String suffix) {
+ return ( suffix == null ) ? name : name + suffix;
+ }
+
+ public static String root(String qualifiedName) {
+ int loc = qualifiedName.indexOf( "." );
+ return ( loc < 0 ) ? qualifiedName : qualifiedName.substring( 0, loc );
+ }
+
+ public static String unroot(String qualifiedName) {
+ int loc = qualifiedName.indexOf( "." );
+ return ( loc < 0 ) ? qualifiedName : qualifiedName.substring( loc+1, qualifiedName.length() );
+ }
+
+ public static boolean booleanValue(String tfString) {
+ String trimmed = tfString.trim().toLowerCase();
+ return trimmed.equals( "true" ) || trimmed.equals( "t" );
+ }
+
+ public static String toString(Object[] array) {
+ int len = array.length;
+ if ( len == 0 ) return "";
+ StringBuffer buf = new StringBuffer( len * 12 );
+ for ( int i = 0; i < len - 1; i++ ) {
+ buf.append( array[i] ).append(", ");
+ }
+ return buf.append( array[len - 1] ).toString();
+ }
+
+ public static String[] multiply(String string, Iterator placeholders, Iterator replacements) {
+ String[] result = new String[]{string};
+ while ( placeholders.hasNext() ) {
+ result = multiply( result, ( String ) placeholders.next(), ( String[] ) replacements.next() );
+ }
+ return result;
+ }
+
+ private static String[] multiply(String[] strings, String placeholder, String[] replacements) {
+ String[] results = new String[replacements.length * strings.length];
+ int n = 0;
+ for ( int i = 0; i < replacements.length; i++ ) {
+ for ( int j = 0; j < strings.length; j++ ) {
+ results[n++] = replaceOnce( strings[j], placeholder, replacements[i] );
+ }
+ }
+ return results;
+ }
+
+ public static int countUnquoted(String string, char character) {
+ if ( '\'' == character ) {
+ throw new IllegalArgumentException( "Unquoted count of quotes is invalid" );
+ }
+ if (string == null)
+ return 0;
+ // Impl note: takes advantage of the fact that an escpaed single quote
+ // embedded within a quote-block can really be handled as two seperate
+ // quote-blocks for the purposes of this method...
+ int count = 0;
+ int stringLength = string.length();
+ boolean inQuote = false;
+ for ( int indx = 0; indx < stringLength; indx++ ) {
+ char c = string.charAt( indx );
+ if ( inQuote ) {
+ if ( '\'' == c ) {
+ inQuote = false;
+ }
+ }
+ else if ( '\'' == c ) {
+ inQuote = true;
+ }
+ else if ( c == character ) {
+ count++;
+ }
+ }
+ return count;
+ }
+
+ public static int[] locateUnquoted(String string, char character) {
+ if ( '\'' == character ) {
+ throw new IllegalArgumentException( "Unquoted count of quotes is invalid" );
+ }
+ if (string == null) {
+ return new int[0];
+ }
+
+ ArrayList locations = new ArrayList( 20 );
+
+ // Impl note: takes advantage of the fact that an escpaed single quote
+ // embedded within a quote-block can really be handled as two seperate
+ // quote-blocks for the purposes of this method...
+ int stringLength = string.length();
+ boolean inQuote = false;
+ for ( int indx = 0; indx < stringLength; indx++ ) {
+ char c = string.charAt( indx );
+ if ( inQuote ) {
+ if ( '\'' == c ) {
+ inQuote = false;
+ }
+ }
+ else if ( '\'' == c ) {
+ inQuote = true;
+ }
+ else if ( c == character ) {
+ locations.add( new Integer( indx ) );
+ }
+ }
+ return toIntArray( locations );
+ }
+
+ public static boolean isNotEmpty(String string) {
+ return string != null && string.length() > 0;
+ }
+
+ public static boolean isEmpty(String string) {
+ return string == null || string.length() == 0;
+ }
+
+ public static String qualify(String prefix, String name) {
+ if ( name == null || prefix == null ) {
+ throw new NullPointerException();
+ }
+ return new StringBuffer( prefix.length() + name.length() + 1 )
+ .append(prefix)
+ .append('.')
+ .append(name)
+ .toString();
+ }
+
+ public static String[] qualify(String prefix, String[] names) {
+ if ( prefix == null ) return names;
+ int len = names.length;
+ String[] qualified = new String[len];
+ for ( int i = 0; i < len; i++ ) {
+ qualified[i] = qualify( prefix, names[i] );
+ }
+ return qualified;
+ }
+
+ public static int firstIndexOfChar(String sqlString, String string, int startindex) {
+ int matchAt = -1;
+ for ( int i = 0; i < string.length(); i++ ) {
+ int curMatch = sqlString.indexOf( string.charAt( i ), startindex );
+ if ( curMatch >= 0 ) {
+ if ( matchAt == -1 ) { // first time we find match!
+ matchAt = curMatch;
+ }
+ else {
+ matchAt = Math.min( matchAt, curMatch );
+ }
+ }
+ }
+ return matchAt;
+ }
+
+ public static String truncate(String string, int length) {
+ if ( string.length() <= length ) {
+ return string;
+ }
+ else {
+ return string.substring( 0, length );
+ }
+ }
+
+ public static String generateAlias(String description) {
+ return generateAliasRoot(description) + '_';
+ }
+
+ /**
+ * Generate a nice alias for the given class name or collection role
+ * name and unique integer. Subclasses of Loader do <em>not</em> have
+ * to use aliases of this form.
+ * @return an alias of the form <tt>foo1_</tt>
+ */
+ public static String generateAlias(String description, int unique) {
+ return generateAliasRoot(description) +
+ Integer.toString(unique) +
+ '_';
+ }
+
+ /**
+ * Generates a root alias by truncating the "root name" defined by
+ * the incoming decription and removing/modifying any non-valid
+ * alias characters.
+ *
+ * @param description The root name from which to generate a root alias.
+ * @return The generated root alias.
+ */
+ private static String generateAliasRoot(String description) {
+ String result = truncate( unqualifyEntityName(description), ALIAS_TRUNCATE_LENGTH )
+ .toLowerCase()
+ .replace( '/', '_' ) // entityNames may now include slashes for the representations
+ .replace( '$', '_' ); //classname may be an inner class
+ result = cleanAlias( result );
+ if ( Character.isDigit( result.charAt(result.length()-1) ) ) {
+ return result + "x"; //ick!
+ }
+ else {
+ return result;
+ }
+ }
+
+ /**
+ * Clean the generated alias by removing any non-alpha characters from the
+ * beginning.
+ *
+ * @param alias The generated alias to be cleaned.
+ * @return The cleaned alias, stripped of any leading non-alpha characters.
+ */
+ private static String cleanAlias(String alias) {
+ char[] chars = alias.toCharArray();
+ // short cut check...
+ if ( !Character.isLetter( chars[0] ) ) {
+ for ( int i = 1; i < chars.length; i++ ) {
+ // as soon as we encounter our first letter, return the substring
+ // from that position
+ if ( Character.isLetter( chars[i] ) ) {
+ return alias.substring( i );
+ }
+ }
+ }
+ return alias;
+ }
+
+ public static String unqualifyEntityName(String entityName) {
+ String result = unqualify(entityName);
+ int slashPos = result.indexOf( '/' );
+ if ( slashPos > 0 ) {
+ result = result.substring( 0, slashPos - 1 );
+ }
+ return result;
+ }
+
+ public static String toUpperCase(String str) {
+ return str==null ? null : str.toUpperCase();
+ }
+
+ public static String toLowerCase(String str) {
+ return str==null ? null : str.toLowerCase();
+ }
+
+ public static String moveAndToBeginning(String filter) {
+ if ( filter.trim().length()>0 ){
+ filter += " and ";
+ if ( filter.startsWith(" and ") ) filter = filter.substring(4);
+ }
+ return filter;
+ }
+
+ //TODO Copy from ArrayHelper in Hibernate Core
+ public static int[] toIntArray(Collection coll) {
+ Iterator iter = coll.iterator();
+ int[] arr = new int[ coll.size() ];
+ int i=0;
+ while( iter.hasNext() ) {
+ arr[i++] = ( (Integer) iter.next() ).intValue();
+ }
+ return arr;
+ }
+
+}
More information about the hibernate-commits
mailing list